2647 lines
58 KiB
Plaintext
2647 lines
58 KiB
Plaintext
#TouhouDanmakufu[Single]
|
|
#ScriptVersion[3]
|
|
#Title["Winter Games"]
|
|
#Text["This bitch empty - would you like to yeet?"]
|
|
#System["script/KevinSystem/Kevin_System.txt"]
|
|
|
|
float rank = 1; // Increases through time
|
|
|
|
let RANK_PTR = LoadCommonDataValuePointer("Rank", 1);
|
|
|
|
let objScene = GetEnemyBossSceneObjectID();
|
|
let csd = GetCurrentScriptDirectory();
|
|
|
|
let bossObj;
|
|
|
|
float bossX = 0;
|
|
float bossY = 0;
|
|
float playerY = 0;
|
|
float playerX = 0;
|
|
|
|
bool bossIntro = false;
|
|
|
|
let spellsnd = ObjSound_Create();
|
|
let bossdiesnd = ObjSound_Create();
|
|
|
|
int[] enmFly = [];
|
|
int[] enmGround = [];
|
|
|
|
int[] rankAvg = [];
|
|
|
|
let POINTER_CHAIN = LoadAreaCommonDataValuePointer("PIV", "ChainAmount", 1);
|
|
|
|
//let SYSTEMID_PTR_2 = LoadAreaCommonDataValuePointer("ScriptID", "SystemID", 0);
|
|
|
|
// Includes ahoy
|
|
|
|
#include "script/KevinSystem/Universal_Lib.txt"
|
|
#include "script/Jam10/GunnerParade_EnmLib.dnh"
|
|
#include "script/Jam10/GunnerParade_ConstLib.dnh"
|
|
#include "script/KevinSystem/kevin_system/Lib_Const.dnh"
|
|
|
|
@Initialize {
|
|
|
|
//SetIntersectionVisualization(true);
|
|
|
|
SetAutoDeleteObject(true);
|
|
|
|
SetCommonData("Rank", clamp(GetCommonData("Rank", 1), RANK_MIN, RANK_MAX));
|
|
//difficultySelect = _InitDifficulty(difficultySelect);
|
|
|
|
//difficultySelect = 2; // debug
|
|
|
|
if(!IsCommonDataAreaExists("PIV")){
|
|
CreateCommonDataArea("PIV");
|
|
SetAreaCommonData("PIV", "currentvalue", 10000);
|
|
}
|
|
else{}
|
|
|
|
// Create the boss object itself
|
|
bossObj = ObjEnemy_Create(OBJ_ENEMY_BOSS);
|
|
ObjEnemy_Regist(bossObj);
|
|
|
|
ObjMove_SetPosition(bossObj, STG_WIDTH/2, -256);
|
|
|
|
ObjEnemy_SetDamageRate(bossObj, 0, 0);
|
|
|
|
_RenderBossFight(bossObj);
|
|
|
|
_MagicCircle(bossObj);
|
|
|
|
SetEnemyAutoDeleteClip(160, 160, 160, 160);
|
|
|
|
|
|
//testTask();
|
|
|
|
//groundTask();
|
|
flyingTask();
|
|
//UpdateDrops();
|
|
|
|
bossFight();
|
|
|
|
curEnmManage();
|
|
|
|
//SetCommonData("Rank", 9);
|
|
|
|
//_FadeInvincibility(bossObj, 150, 150, 1);
|
|
//endingnew();
|
|
}
|
|
|
|
@Event {
|
|
|
|
alternative(GetEventType())
|
|
|
|
case(EV_REQUEST_LIFE) {
|
|
SetScriptResult(HP_MAX);
|
|
}
|
|
|
|
case(EV_REQUEST_IS_DURABLE_SPELL) {
|
|
SetScriptResult(false);
|
|
}
|
|
|
|
case(EV_REQUEST_TIMER) {
|
|
SetScriptResult(STAGE_LENGTH);
|
|
//SetScriptResult(BOSS_LENGTH+5);
|
|
}
|
|
|
|
}
|
|
|
|
@MainLoop {
|
|
|
|
playerY = GetPlayerY();
|
|
playerX = GetPlayerX();
|
|
//The player position is ALWAYS UPDATED
|
|
|
|
bossX = ObjMove_GetX(bossObj);
|
|
bossY = ObjMove_GetY(bossObj);
|
|
|
|
ObjEnemy_SetIntersectionCircleToShot(bossObj, ObjMove_GetX(bossObj), ObjMove_GetY(bossObj), 192);
|
|
|
|
yield;
|
|
|
|
}
|
|
|
|
@Finalize {
|
|
|
|
}
|
|
|
|
|
|
// This array contains ONLY FLYING ENEMIES
|
|
|
|
|
|
task groundTask(){
|
|
|
|
wait(90);
|
|
|
|
while(ObjEnemyBossScene_GetInfo(objScene, INFO_TIMER) > BOSS_LENGTH){
|
|
|
|
WaveGround1();
|
|
wait(max(5, 15-rank));
|
|
if(ObjEnemyBossScene_GetInfo(objScene, INFO_TIMER) <= BOSS_LENGTH){break;}
|
|
|
|
if(GetCommonData("Ground Loops Cleared", 0) % 3 == 0 && rank > 3){
|
|
|
|
WaveGround2(playerX);
|
|
wait(max(5, 15-rank));
|
|
if(ObjEnemyBossScene_GetInfo(objScene, INFO_TIMER) <= BOSS_LENGTH){break;}
|
|
|
|
SetCommonData("Rank", clamp(GetCommonData("Rank", 1)+0.5, 1, RANK_MAX));
|
|
|
|
}
|
|
|
|
SetCommonData("Ground Loops Cleared", GetCommonData("Ground Loops Cleared", 0)+1);
|
|
|
|
yield;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
task flyingTask(){
|
|
|
|
wait(30);
|
|
|
|
// Stage 1
|
|
|
|
while(ObjEnemyBossScene_GetInfo(objScene, INFO_TIMER) > MIDBOSS_LENGTH){
|
|
|
|
Wave1();
|
|
wait(max(5, 20-4*rank));
|
|
if(ObjEnemyBossScene_GetInfo(objScene, INFO_TIMER) <= MIDBOSS_LENGTH){break;}
|
|
|
|
Wave2();
|
|
wait(max(5, 20-4*rank));
|
|
if(ObjEnemyBossScene_GetInfo(objScene, INFO_TIMER) <= MIDBOSS_LENGTH){break;}
|
|
|
|
if(rank > 4 || GetCommonData("Flying Loops Cleared", 0) > 3){
|
|
WaveGround1();
|
|
wait(max(5, 20-4*rank));
|
|
if(ObjEnemyBossScene_GetInfo(objScene, INFO_TIMER) <= MIDBOSS_LENGTH){break;}
|
|
}
|
|
|
|
Wave3();
|
|
wait(max(5, 20-4*rank));
|
|
if(ObjEnemyBossScene_GetInfo(objScene, INFO_TIMER) <= MIDBOSS_LENGTH){break;}
|
|
|
|
Wave5();
|
|
wait(max(5, 20-4*rank));
|
|
if(ObjEnemyBossScene_GetInfo(objScene, INFO_TIMER) <= MIDBOSS_LENGTH){break;}
|
|
|
|
SetCommonData("Rank", clamp(GetCommonData("Rank", 1)+0.5, 1, RANK_MAX));
|
|
|
|
Wave4();
|
|
wait(max(5, 20-4*rank));
|
|
if(ObjEnemyBossScene_GetInfo(objScene, INFO_TIMER) <= MIDBOSS_LENGTH){break;}
|
|
|
|
Wave1();
|
|
wait(max(5, 20-4*rank));
|
|
if(ObjEnemyBossScene_GetInfo(objScene, INFO_TIMER) <= MIDBOSS_LENGTH){break;}
|
|
|
|
SetCommonData("Flying Loops Cleared", GetCommonData("Flying Loops Cleared", 0)+1);
|
|
SetCommonData("Rank", clamp(GetCommonData("Rank", 1)+0.5, 1, RANK_MAX));
|
|
|
|
yield;
|
|
}
|
|
|
|
_MidbossFight();
|
|
|
|
// Stage 2
|
|
|
|
while(ObjEnemyBossScene_GetInfo(objScene, INFO_TIMER) > BOSS_LENGTH){
|
|
|
|
Wave9();
|
|
wait(max(5, 20-4*rank));
|
|
if(ObjEnemyBossScene_GetInfo(objScene, INFO_TIMER) <= BOSS_LENGTH){break;}
|
|
|
|
Wave2();
|
|
wait(max(5, 20-4*rank));
|
|
if(ObjEnemyBossScene_GetInfo(objScene, INFO_TIMER) <= BOSS_LENGTH){break;}
|
|
|
|
if(rank > 4 || GetCommonData("Flying Loops Cleared", 0) > 3){
|
|
WaveGround1();
|
|
wait(max(5, 20-4*rank));
|
|
if(ObjEnemyBossScene_GetInfo(objScene, INFO_TIMER) <= BOSS_LENGTH){break;}
|
|
}
|
|
|
|
Wave5();
|
|
wait(max(5, 20-4*rank));
|
|
if(ObjEnemyBossScene_GetInfo(objScene, INFO_TIMER) <= BOSS_LENGTH){break;}
|
|
|
|
Wave10();
|
|
wait(max(5, 20-4*rank));
|
|
if(ObjEnemyBossScene_GetInfo(objScene, INFO_TIMER) <= BOSS_LENGTH){break;}
|
|
|
|
SetCommonData("Rank", clamp(GetCommonData("Rank", 1)+0.5, 1, RANK_MAX));
|
|
|
|
Wave8();
|
|
wait(max(5, 20-4*rank));
|
|
if(ObjEnemyBossScene_GetInfo(objScene, INFO_TIMER) <= BOSS_LENGTH){break;}
|
|
|
|
Wave9();
|
|
wait(max(5, 20-4*rank));
|
|
if(ObjEnemyBossScene_GetInfo(objScene, INFO_TIMER) <= BOSS_LENGTH){break;}
|
|
|
|
if(rank > 7 || GetCommonData("Flying Loops Cleared", 0) > 4){
|
|
WaveGround2(playerX);
|
|
wait(max(5, 20-4*rank));
|
|
if(ObjEnemyBossScene_GetInfo(objScene, INFO_TIMER) <= BOSS_LENGTH){break;}
|
|
}
|
|
|
|
SetCommonData("Flying Loops Cleared", GetCommonData("Flying Loops Cleared", 0)+1);
|
|
SetCommonData("Rank", clamp(GetCommonData("Rank", 1)+0.5, 1, RANK_MAX));
|
|
|
|
yield;
|
|
}
|
|
|
|
}
|
|
|
|
task curEnmManage(){
|
|
|
|
SetCommonData("Flying Loops Cleared", 0);
|
|
SetCommonData("Ground Loops Cleared", 0);
|
|
|
|
RankManagement();
|
|
|
|
int[] allEnm = [];
|
|
|
|
while(true){
|
|
enmGround = [];
|
|
enmFly = [];
|
|
allEnm = GetIntersectionRegistedEnemyID();
|
|
for each (int enm in ref allEnm){
|
|
if(Obj_GetRenderPriorityI(enm) <= 37){enmGround ~= [enm];}
|
|
else if(Obj_GetRenderPriorityI(enm) >= 38 && Obj_GetRenderPriorityI(enm) < 41){enmFly ~= [enm];}
|
|
else{}
|
|
}
|
|
wait(10);
|
|
}
|
|
|
|
}
|
|
|
|
task _BossExplosion(){
|
|
|
|
float enmX = 0, enmY = 0;
|
|
|
|
while(ObjEnemy_GetInfo(bossObj, INFO_LIFE) > 0){
|
|
|
|
enmX = ObjMove_GetX(bossObj); enmY = ObjMove_GetY(bossObj);
|
|
|
|
yield;
|
|
|
|
}
|
|
|
|
//NotifyEventAll(EV_DROP_POINT_ENEMY, [enmX, enmY], timer, maxTimer, minPoint, maxPoint);
|
|
|
|
DeleteShotAll(TYPE_ALL, TYPE_ITEM);
|
|
SetPlayerInvincibilityFrame(300);
|
|
ObjSound_Play(bossBoom);
|
|
Obj_SetRenderPriorityI(bossObj, 30);
|
|
NotifyEvent(GetCommonDataPtr(SYSTEMID_PTR, 0), EV_EXPLODE, [enmX, enmY]);
|
|
|
|
_ObjShake(bossObj, 190, 60);
|
|
|
|
loop(30){
|
|
//LoadEx(bossBoom, "script/game/resourceLib/bigBoom.ogg", 30 * SFXVol);
|
|
ObjSound_Play(bossBoom);
|
|
NotifyEvent(GetCommonDataPtr(SYSTEMID_PTR, 0), EV_EXPLODE, [bossX+rand(-240, 240), bossY+rand(-150, 150)]);
|
|
wait(6);
|
|
}
|
|
|
|
ObjMove_SetDestAtFrame(bossObj, bossX, STG_HEIGHT+512, 120, LERP_ACCELERATE);
|
|
|
|
float ang = ObjRender_GetAngleZ(bossObj);
|
|
|
|
ascent(i in 0..120){
|
|
ObjRender_SetAngleZ(bossObj, Interpolate_Accelerate(ang, ang+180, i/120));
|
|
yield;
|
|
}
|
|
|
|
//wait();
|
|
|
|
_EndShake(120, 90);
|
|
|
|
loop(120){
|
|
NotifyEvent(GetCommonDataPtr(SYSTEMID_PTR, 0), EV_EXPLODE, [bossX+rand(-240, 240), STG_HEIGHT+rand(0, -150)]);
|
|
}
|
|
|
|
ObjSound_Play(bossBoom);
|
|
|
|
EndBonus();
|
|
|
|
//_ScorePopup(float enmX, float enmY, int pointNum, int pivNum);
|
|
|
|
// NotifyEvent is faster than NotifyEventAll, considering how the item event will be called many times.
|
|
|
|
}
|
|
|
|
function _MidbossExplosion(int enmID, float x, float y){
|
|
|
|
bool explosionEnd = false;
|
|
|
|
async{
|
|
|
|
int timer = ObjEnemyBossScene_GetInfo(objScene, INFO_TIMERF);
|
|
|
|
while(!explosionEnd){
|
|
|
|
ObjEnemyBossScene_SetSpellTimer(objScene, timer);
|
|
yield;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
//NotifyEventAll(EV_DROP_POINT_ENEMY, [enmX, enmY], timer, maxTimer, minPoint, maxPoint);
|
|
|
|
DeleteShotAll(TYPE_ALL, TYPE_ITEM);
|
|
SetPlayerInvincibilityFrame(90);
|
|
ObjSound_Play(bossBoom);
|
|
Obj_SetRenderPriorityI(enmID, 30);
|
|
NotifyEvent(GetCommonDataPtr(SYSTEMID_PTR, 0), EV_EXPLODE, [x, y]);
|
|
|
|
_ObjShake(enmID, 60, 45);
|
|
|
|
async{
|
|
|
|
loop(15){
|
|
//LoadEx(bossBoom, "script/game/resourceLib/bigBoom.ogg", 30 * SFXVol);
|
|
ObjSound_Play(bossBoom);
|
|
NotifyEvent(GetCommonDataPtr(SYSTEMID_PTR, 0), EV_EXPLODE, [x+rand(-90, 90), y+rand(-125, 125)]);
|
|
wait(4);
|
|
}
|
|
|
|
}
|
|
|
|
ObjMove_SetDestAtFrame(enmID, x, STG_HEIGHT+256, 60, LERP_ACCELERATE);
|
|
|
|
float ang = ObjRender_GetAngleZ(enmID);
|
|
|
|
ascent(i in 0..60){
|
|
ObjRender_SetAngleZ(enmID, Interpolate_Accelerate(ang, ang+180, i/60));
|
|
yield;
|
|
}
|
|
|
|
explosionEnd = true;
|
|
ObjSound_Play(bossBoom);
|
|
Obj_Delete(enmID);
|
|
|
|
return;
|
|
//_ScorePopup(float enmX, float enmY, int pointNum, int pivNum);
|
|
|
|
// NotifyEvent is faster than NotifyEventAll, considering how the item event will be called many times.
|
|
|
|
}
|
|
|
|
task EndBonus(){
|
|
|
|
while(ObjEnemy_GetInfo(bossObj, INFO_LIFE) > 0){
|
|
//WriteLog(ObjEnemyBossScene_GetInfo(objScene, INFO_TIMER));
|
|
//wait(30);
|
|
yield;
|
|
}
|
|
|
|
ObjEnemy_SetLife(bossObj, -1);
|
|
|
|
let timer = ObjEnemyBossScene_GetInfo(objScene, INFO_TIMERF);
|
|
//WriteLog(timer);
|
|
|
|
// Bonus Calculations:
|
|
|
|
// (Time Remaining + Ground Loops Cleared + Flying Loops Cleared + Average Rank) * 10000
|
|
|
|
function <void> _CreateBonusText(float x, y, fontSize, int colorBorder, string text){
|
|
|
|
int objText = CreateTextObject(
|
|
|
|
x, y, fontSize,
|
|
"", "GravityRegular5",
|
|
0xFFFFFF, 0xFFFFFF,
|
|
colorBorder, 4,
|
|
71
|
|
|
|
);
|
|
|
|
ObjText_SetHorizontalAlignment(objText, ALIGNMENT_CENTER);
|
|
|
|
TTextScroll(objText, text);
|
|
|
|
}
|
|
|
|
wait(120);
|
|
|
|
float rankAvgFinal = 0;
|
|
float rankSum = 0;
|
|
|
|
ascent(i in -1..length(rankAvg)-1){
|
|
rankSum += rankAvg[i];
|
|
}
|
|
|
|
rankAvgFinal = rankSum/length(rankAvg);
|
|
|
|
_CreateBonusText(STG_WIDTH/2, STG_HEIGHT/2-220, 30, 0xCF007A, "LIVES REMAINING: " ~ IntToString(GetPlayerLife()));
|
|
_CreateBonusText(STG_WIDTH/2, STG_HEIGHT/2-180, 30, 0x3500CF, "TIME REMAINING: " ~ vtos("5.2f", timer/60));
|
|
_CreateBonusText(STG_WIDTH/2, STG_HEIGHT/2-140, 30, 0xCF6100, "ENEMIES DEFEATED: " ~ IntToString(GetCommonDataPtr(GROUNDENM_PTR, 0) + GetCommonDataPtr(FLYINGENM_PTR, 0)));
|
|
_CreateBonusText(STG_WIDTH/2, STG_HEIGHT/2-100, 30, 0xCF0000, "AVERAGE RANK LV: " ~ vtos("5.2f", rankAvgFinal));
|
|
|
|
_CreateBonusText(STG_WIDTH/2, STG_HEIGHT/2, 30, 0xFFA300, "END BONUS:");
|
|
|
|
wait(120);
|
|
|
|
float multiplierBonus = (GetPlayerLife() + timer/60 + GetCommonDataPtr(GROUNDENM_PTR, 0)/5 + GetCommonDataPtr(FLYINGENM_PTR, 0)/5 + rankAvgFinal) * 30;
|
|
|
|
int scoreBonus = (trunc ( (multiplierBonus * 100000) / 100 ) * 10);
|
|
|
|
_CreateBonusText(STG_WIDTH/2, STG_HEIGHT/2+60, 60, 0xFFA300, DigitToCommaArray(scoreBonus));
|
|
AddScore(scoreBonus);
|
|
|
|
wait(60);
|
|
|
|
if(!IsReplay()){SetCommonData("Run Score", GetScore());}
|
|
else{SetCommonData("Run Score", 0);}
|
|
|
|
Obj_Delete(bossObj);
|
|
CloseScript(GetOwnScriptID());
|
|
|
|
}
|
|
|
|
task RankManagement(){
|
|
|
|
//SetCommonData("Rank", 9);
|
|
//SetCommonData("Rank", 10);
|
|
// Rank increase
|
|
let textRank = CreateTextObject(
|
|
STG_WIDTH-15, STG_HEIGHT/14, 24,
|
|
"RANK:", "GravityBold8",
|
|
0xFFFFFF, 0xFFFFFF,
|
|
0xAE22FF, 5,
|
|
71
|
|
);
|
|
|
|
ObjText_SetHorizontalAlignment(textRank, ALIGNMENT_RIGHT);
|
|
|
|
async{
|
|
while(true){
|
|
rank = trunc(GetCommonData("Rank", 1));
|
|
if(rank >= RANK_MAX){ObjText_SetText(textRank, "RANK LV [font sz=32 oc=(193, 0, 99)]MAX");}
|
|
else{ObjText_SetText(textRank, "RANK LV [font sz=45 oc=(193, 0, 99)]" ~ IntToString(rank));}
|
|
//SetCommonData("Rank", 9);
|
|
wait(45);
|
|
}
|
|
}
|
|
|
|
async{
|
|
while(true){
|
|
if(ObjMove_GetY(GetPlayerObjectID()) < GetStgFrameHeight()/6){
|
|
ObjRender_SetAlpha(textRank, 60);
|
|
}
|
|
else{
|
|
ObjRender_SetAlpha(textRank, 255);
|
|
}
|
|
yield;
|
|
}
|
|
}
|
|
|
|
async{
|
|
while(ObjEnemy_GetInfo(bossObj, INFO_LIFE) > 0){
|
|
rankAvg ~= [rank];
|
|
wait(60);
|
|
}
|
|
}
|
|
|
|
// Per frame rank increase. +1 rank per 10 seconds (+0.1 rank per second, +1/600 rank per frame), rank 10 at 100 seconds if no specials, bombs or deaths happen
|
|
|
|
async{
|
|
while(ObjEnemy_GetInfo(bossObj, INFO_LIFE) > 0){
|
|
SetCommonDataPtr(RANK_PTR, clamp(GetCommonDataPtr(RANK_PTR, 1)+1/600, RANK_MIN, RANK_MAX_TRUE));
|
|
yield;
|
|
}
|
|
}
|
|
|
|
// Rank on HUD
|
|
|
|
async{
|
|
let textRank = CreateTextObject(
|
|
1500, 660, 48,
|
|
"", "Origami Mommy",
|
|
0xFF9294, 0xFFFFFF,
|
|
0x8F0507, 8,
|
|
19
|
|
);
|
|
|
|
ObjText_SetHorizontalAlignment(textRank, ALIGNMENT_CENTER);
|
|
|
|
let textRankRange = CreateTextObject(
|
|
1820, 618, 24,
|
|
"", "Unispace",
|
|
0xA9FFD0, 0xFFFFFF,
|
|
0x8F0507, 2,
|
|
19
|
|
);
|
|
|
|
while(true){
|
|
ObjText_SetText(textRank, IntToString(rank));
|
|
ObjText_SetText(textRankRange, "LV." ~ IntToString(RANK_MIN) ~ "[r][font oy=4 tc=(255, 114, 189)]LV." ~ IntToString(RANK_MAX_TRUE) ~ "[r][font oy=8 tc=(255, 147, 138)]" ~ rtos("00.00", GetCommonData("Rank", 1)));
|
|
yield;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
task testTask(){
|
|
|
|
wait(15);
|
|
|
|
while(ObjEnemyBossScene_GetInfo(objScene, INFO_TIMER) > 20){
|
|
|
|
Wave8();
|
|
Wave9();
|
|
Wave10();
|
|
|
|
SetCommonData("Rank", clamp(GetCommonData("Rank", 1)+1, 1, RANK_MAX));
|
|
SetCommonData("Ground Loops Cleared", GetCommonData("Ground Loops Cleared", 0)+1);
|
|
SetCommonData("Flying Loops Cleared", GetCommonData("Flying Loops Cleared", 0)+1);
|
|
|
|
yield;
|
|
}
|
|
|
|
}
|
|
|
|
///////////// BOSS HANDLING /////////////
|
|
|
|
task bossFight(){
|
|
|
|
while(ObjEnemyBossScene_GetInfo(objScene, INFO_TIMERF) > BOSS_LENGTH*60){
|
|
|
|
yield;
|
|
|
|
}
|
|
|
|
NotifyEventAll(EV_BOSS_MUSIC, 1);
|
|
bossIntro = true;
|
|
|
|
BossIntro();
|
|
BossPhase1(); // Rings
|
|
BossPhase2();
|
|
//BossPhase3();
|
|
|
|
// Umbrella waves
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
function _MidbossFight(){
|
|
|
|
while(ObjEnemyBossScene_GetInfo(objScene, INFO_TIMERF) > MIDBOSS_LENGTH*60){
|
|
|
|
yield;
|
|
|
|
}
|
|
|
|
// Stacked rings (2 to 3)
|
|
// Every 2 ring waves, fire an aimed bullet ring (large fireballs)
|
|
|
|
int ringNum = FUNC_LERP_LINEAR(2, 4, rank/RANK_MAX);
|
|
int ringDense = FUNC_LERP_LINEAR(16, 21, rank/RANK_MAX);
|
|
int ringMaxSpd = FUNC_LERP_LINEAR(9, 11, rank/RANK_MAX);
|
|
int aimedRingStopTime = FUNC_LERP_LINEAR(45, 30, rank/RANK_MAX);
|
|
int aimedRingSpd = FUNC_LERP_LINEAR(11, 13, rank/RANK_MAX);
|
|
int ringDel = FUNC_LERP_LINEAR(70, 45, rank/RANK_MAX);
|
|
|
|
int waveNum = 0;
|
|
int timer = 20*60; // Boss auto-dies if not killed within 20 seconds.
|
|
|
|
int midbossObj =
|
|
|
|
_CreateEnemy(
|
|
STG_WIDTH+128, STG_HEIGHT/2, STG_WIDTH-128, STG_HEIGHT/2, 30,
|
|
1, 1,
|
|
MIDBOSS_HP, 64, 0,
|
|
texEnm,
|
|
192, 176*4, 96*4, 240*4);
|
|
|
|
_MagicCircle(midbossObj);
|
|
|
|
wait(60);
|
|
|
|
ObjEnemy_SetAutoDelete(midbossObj, false);
|
|
_FadeInvincibility(midbossObj, 90, 90, 0.5);
|
|
|
|
PhaseBonusCalculation(midbossObj, 0, "[font oc=(98, 0, 164) wg=800]Frozen Yogurt Toss");
|
|
|
|
async{
|
|
|
|
while(ObjEnemy_GetInfo(midbossObj, INFO_LIFE) > 0){
|
|
|
|
float baseAng = GetAngleToPlayer(midbossObj);
|
|
|
|
ascent(i in 0..ringNum){
|
|
|
|
float ang = baseAng + 24 * i;
|
|
|
|
Shoot2;
|
|
|
|
ascent(k in 0..ringDense){
|
|
int bullet = CreateShotA1(ObjMove_GetX(midbossObj), ObjMove_GetY(midbossObj), ringMaxSpd * (1-i/(ringNum*2)), ang + k * 360/ringDense, KEV_BALL_AQUA, 10);
|
|
_Delay(bullet, 10);
|
|
}
|
|
|
|
}
|
|
|
|
if (waveNum % 2 <= 0){
|
|
|
|
ascent(k in 0..ringDense*1.5){
|
|
int bullet = CreateShotA2(ObjMove_GetX(midbossObj), ObjMove_GetY(midbossObj), aimedRingSpd*2, k * 360/(ringDense*1.5), -aimedRingSpd*2/20, 0, 0, KEV_FIRELARGE_AQUA, 10);
|
|
ObjMove_AddPatternA4(bullet, ringDel, NO_CHANGE, 0, aimedRingSpd/30, aimedRingSpd, 0, NO_CHANGE, GetPlayerObjectID());
|
|
_Delay(bullet, 10);
|
|
}
|
|
|
|
}
|
|
|
|
waveNum++;
|
|
|
|
wait(ringDel-30);
|
|
|
|
ObjMove_SetDestAtFrame(midbossObj, STG_WIDTH*3/4 + rand(-64, 64), playerY, 30, LERP_DECELERATE);
|
|
|
|
wait(30);
|
|
|
|
}
|
|
|
|
DeleteShotAll(TYPE_ALL, TYPE_ITEM);
|
|
|
|
}
|
|
|
|
async{
|
|
while(timer > 0){
|
|
timer--;
|
|
yield;
|
|
}
|
|
ObjEnemy_SetLife(midbossObj, -1);
|
|
}
|
|
|
|
float x = 0, y = 0;
|
|
|
|
while(ObjEnemy_GetInfo(midbossObj, INFO_LIFE) > 0 && !Obj_IsDeleted(midbossObj)){
|
|
x = ObjMove_GetX(midbossObj);
|
|
y = ObjMove_GetY(midbossObj);
|
|
yield;
|
|
}
|
|
|
|
_MidbossExplosion(midbossObj, x, y);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
function <void> BossIntro(){
|
|
|
|
bool bossCurrentlyIntro = true;
|
|
|
|
ObjMove_SetDestAtFrame(bossObj, STG_WIDTH * 3/4, STG_HEIGHT/2, 60, LERP_DECELERATE);
|
|
|
|
async{
|
|
|
|
int timer = ObjEnemyBossScene_GetInfo(objScene, INFO_TIMERF);
|
|
|
|
while(bossCurrentlyIntro){
|
|
ObjEnemyBossScene_SetSpellTimer(objScene, timer);
|
|
SetForbidPlayerShot(true);
|
|
SetForbidPlayerSpell(true);
|
|
ObjEnemy_SetDamageRate(bossObj, 0, 0);
|
|
yield;
|
|
}
|
|
|
|
SetForbidPlayerShot(false);
|
|
SetForbidPlayerSpell(false);
|
|
ObjEnemy_SetDamageRate(bossObj, 0, 0);
|
|
|
|
}
|
|
|
|
wait(60);
|
|
|
|
bossCurrentlyIntro = false;
|
|
|
|
}
|
|
|
|
|
|
function <void> BossPhase1(){
|
|
|
|
ObjMove_SetDestAtFrame(bossObj, STG_WIDTH * 3/4, STG_HEIGHT/2, 60, LERP_DECELERATE);
|
|
wait(10);
|
|
|
|
_FadeInvincibility(bossObj, 90, 90, 0.5);
|
|
|
|
int dense = FUNC_LERP_LINEAR(18, 23, rank/RANK_MAX);
|
|
int del1 = FUNC_LERP_LINEAR(5, 3, rank/RANK_MAX);
|
|
int del2 = FUNC_LERP_LINEAR(60, 45, rank/RANK_MAX);
|
|
int ringNum = FUNC_LERP_LINEAR(6, 10, rank/RANK_MAX);
|
|
int accelTime = FUNC_LERP_LINEAR(30, 25, rank/RANK_MAX);
|
|
float spd = FUNC_LERP_ACCEL(10, 13, rank/RANK_MAX);
|
|
float range = FUNC_LERP_LINEAR(60, 100, rank/RANK_MAX);
|
|
float angStart = rand(0, 360);
|
|
|
|
PhaseBonusCalculation(bossObj, PHASE1_LIMIT, "[font oc=(98, 0, 164) wg=800]Withering Flower");
|
|
|
|
async{
|
|
|
|
while(ObjEnemy_GetInfo(bossObj, INFO_LIFE) > PHASE1_LIMIT){
|
|
|
|
float baseAng = rand(0, 360);
|
|
|
|
ascent(i in 0..ringNum){
|
|
|
|
float ang = baseAng + 180/ringNum * i;
|
|
float[] ringPos = [bossX + sin(ang) * range, bossY + cos(ang) * range];
|
|
|
|
Shoot2;
|
|
|
|
ascent(k in 0..dense){
|
|
int bullet = CreateShotA2(ringPos[0], ringPos[1], spd, k * 360/dense, -spd/accelTime, 0, KEV_LEAF_AQUA, 10);
|
|
ObjMove_AddPatternA2(bullet, accelTime*1.25, NO_CHANGE, NO_CHANGE, spd/accelTime, spd, 0);
|
|
_Delay(bullet, 10);
|
|
}
|
|
|
|
wait(del1);
|
|
|
|
}
|
|
|
|
wait(del2-30);
|
|
ObjMove_SetDestAtFrame(bossObj, STG_WIDTH*3/4 + rand(-128, 192), playerY, 30, LERP_DECELERATE);
|
|
wait(30);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
while(ObjEnemy_GetInfo(bossObj, INFO_LIFE) > PHASE1_LIMIT){
|
|
|
|
yield;
|
|
|
|
}
|
|
|
|
ObjEnemy_SetDamageRate(bossObj, 0, 0);
|
|
DeleteShotAll(TYPE_ALL, TYPE_ITEM);
|
|
|
|
wait(60);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
// Phase 2: Travelers Clad in White
|
|
function <void> BossPhase2(){
|
|
|
|
int fanDense = FUNC_LERP_LINEAR(3, 6, rank/RANK_MAX);
|
|
int fanStack = FUNC_LERP_LINEAR(1, 3, rank/RANK_MAX);
|
|
int fanRange = FUNC_LERP_LINEAR(3, 5, rank/RANK_MAX);
|
|
int del = FUNC_LERP_LINEAR(50, 65, rank/RANK_MAX);
|
|
float spd = FUNC_LERP_ACCEL(8, 11, rank/RANK_MAX);
|
|
float moveSpd = FUNC_LERP_ACCEL(1.5, 3, rank/RANK_MAX);
|
|
|
|
float ang = 180;
|
|
|
|
ObjMove_SetDestAtFrame(bossObj, STG_WIDTH * 5/6, STG_HEIGHT/2, 45, LERP_DECELERATE);
|
|
|
|
_FadeInvincibility(bossObj, 90, 90, 0.5);
|
|
|
|
PhaseBonusCalculation(bossObj, PHASE2_LIMIT, "[font oc=(98, 0, 164) wg=800]Travelers Clad in White");
|
|
|
|
async{
|
|
|
|
wait(45);
|
|
|
|
while(ObjEnemy_GetInfo(bossObj, INFO_LIFE) > PHASE2_LIMIT){
|
|
ObjMove_SetY(bossObj, STG_HEIGHT/2 + STG_HEIGHT/3 * sin(ang));
|
|
ang += moveSpd;
|
|
yield;
|
|
}
|
|
|
|
ObjEnemy_SetDamageRate(bossObj, 0, 0);
|
|
DeleteShotAll(TYPE_ALL, TYPE_ITEM);
|
|
|
|
_BossExplosion();
|
|
CollectAllItems();
|
|
|
|
}
|
|
|
|
async{
|
|
|
|
while(ObjEnemy_GetInfo(bossObj, INFO_LIFE) > PHASE2_LIMIT){
|
|
|
|
WaveGround2(playerX);
|
|
//wait(30);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
async{
|
|
|
|
while(ObjEnemy_GetInfo(bossObj, INFO_LIFE) > PHASE2_LIMIT){
|
|
|
|
CreateFan
|
|
(bossObj, fanDense, KEV_BALL_AQUA, fanStack,
|
|
0, fanRange, spd, spd/1.1, 1,
|
|
0, 0,
|
|
PATTERN_FAN_AIMED, false
|
|
);
|
|
|
|
wait(del);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
while(ObjEnemy_GetInfo(bossObj, INFO_LIFE) > PHASE2_LIMIT){
|
|
|
|
yield;
|
|
|
|
}
|
|
|
|
ObjEnemy_SetDamageRate(bossObj, 0, 0);
|
|
DeleteShotAll(TYPE_ALL, TYPE_ITEM);
|
|
|
|
wait(45);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
/*
|
|
function <void> BossPhase3(){
|
|
|
|
ObjMove_SetDestAtFrame(bossObj, STG_WIDTH/2, STG_HEIGHT/5, 60, LERP_DECELERATE);
|
|
|
|
PhaseBonusCalculation(PHASE3_LIMIT, "[font oc=(98, 0, 164) wg=800]Paving a Rainbow Sky");
|
|
|
|
_FadeInvincibility(bossObj, 90, 90, 0.25);
|
|
|
|
wait(30);
|
|
|
|
float numKilled = 0;
|
|
|
|
// BIRD
|
|
|
|
float bulletNum = FUNC_LERP_LINEAR(8, 12, rank/RANK_MAX);
|
|
float bulletSpd = FUNC_LERP_ACCEL(6.25, 7.25, rank/RANK_MAX);
|
|
float birdWvel = FUNC_LERP_ACCEL(1.2, 2, rank/RANK_MAX);
|
|
int bulletDel = FUNC_LERP_LINEAR(10, 5, rank/RANK_MAX);
|
|
int bulletWait = FUNC_LERP_LINEAR(45, 35, rank/RANK_MAX);
|
|
float birdSpd = FUNC_LERP_ACCEL(9, 11.2, rank/RANK_MAX);
|
|
float birdNum = FUNC_LERP_LINEAR(10, 15, rank/RANK_MAX);
|
|
int spawnDel = FUNC_LERP_ACCEL(80, 60, rank/RANK_MAX);
|
|
|
|
// Bullet lines
|
|
|
|
int linenum = FUNC_LERP_LINEAR(14, 17, rank/RANK_MAX);
|
|
int del = FUNC_LERP_ACCEL(4, 2, rank/RANK_MAX);
|
|
int del2 = FUNC_LERP_ACCEL(8, 5, rank/RANK_MAX);
|
|
float spd = FUNC_LERP_ACCEL(9, 11, rank/RANK_MAX);
|
|
float ang = rand(80, 100);
|
|
|
|
async{
|
|
|
|
while(ObjEnemy_GetInfo(bossObj, INFO_LIFE) > PHASE3_LIMIT){yield;}
|
|
|
|
ObjEnemy_SetDamageRate(bossObj, 0, 0);
|
|
DeleteShotAll(TYPE_ALL, TYPE_ITEM);
|
|
|
|
_BossExplosion();
|
|
|
|
}
|
|
|
|
task _SummonBirdEx(float startAng, float wvel, int num){
|
|
|
|
int umbrella = _SmallWitch(
|
|
41, bulletDel * bulletNum,
|
|
bossX, bossY
|
|
);
|
|
|
|
bool isFinishMove = false;
|
|
|
|
ObjMove_SetAngle(umbrella, startAng);
|
|
ObjRender_SetAngleZ(umbrella, startAng);
|
|
|
|
ObjMove_SetAngularVelocity(umbrella, wvel);
|
|
|
|
ObjMove_SetSpeed(umbrella, birdSpd);
|
|
|
|
ObjMove_AddPatternA2(umbrella, 60, NO_CHANGE, NO_CHANGE, NO_CHANGE, NO_CHANGE, wvel/10);
|
|
|
|
async{
|
|
while(!Obj_IsDeleted(umbrella)){
|
|
ObjRender_SetAngleZ(umbrella, ObjMove_GetAngle(umbrella));
|
|
yield;
|
|
}
|
|
numKilled++;
|
|
ObjEnemy_SetDamageRate(bossObj, numKilled * 2.5, numKilled * 2.5); // 33 enemies put dmg rate to 100
|
|
}
|
|
|
|
int num2 = 0;
|
|
|
|
ascent(i in 0..num){
|
|
|
|
float lerpNum1 = i;
|
|
float lerpNum2 = num;
|
|
|
|
ObjEnemy_SetDamageRate(umbrella, FUNC_LERP_LINEAR(10, 50, lerpNum1/lerpNum2), FUNC_LERP_LINEAR(10, 50, lerpNum1/lerpNum2));
|
|
|
|
int color = KEV_LEAF_RED + num2;
|
|
|
|
int bullet = CreateShotA1(ObjMove_GetX(umbrella), ObjMove_GetY(umbrella), 0, wvel < 0 ? ObjMove_GetAngle(umbrella) : ObjMove_GetAngle(umbrella), color, 5);
|
|
|
|
if(ObjEnemy_GetInfo(bossObj, INFO_LIFE) <= 0 || Obj_IsDeleted(umbrella)){Obj_Delete(bullet);}
|
|
else{
|
|
_Delay(bullet, 5);
|
|
_BulletRescale(bullet, 0.75, true, 0.25);
|
|
BulletAction(bullet, lerpNum1, lerpNum2);
|
|
Shoot1;
|
|
}
|
|
|
|
wait(bulletDel);
|
|
|
|
num2++;
|
|
if (num2 > (KEV_BALL_PINK - KEV_BALL_RED)){num2 = 0;}
|
|
}
|
|
|
|
task BulletAction(ID, lerpNum1, lerpNum2){
|
|
|
|
while(!isFinishMove){yield;}
|
|
|
|
if(Obj_IsDeleted(ID)){return;}
|
|
else{
|
|
ObjMove_AddPatternA2(ID, 0, NO_CHANGE, NO_CHANGE, FUNC_LERP_LINEAR(bulletSpd/1.5, bulletSpd, lerpNum1/lerpNum2)/FUNC_LERP_LINEAR(bulletWait, bulletWait/1.5, lerpNum1/lerpNum2), FUNC_LERP_LINEAR(bulletSpd/1.5, bulletSpd, lerpNum1/lerpNum2), 0);
|
|
}
|
|
|
|
}
|
|
|
|
isFinishMove = true;
|
|
|
|
ObjEnemy_SetDamageRate(umbrella, 100, 100);
|
|
|
|
}
|
|
|
|
while(ObjEnemy_GetInfo(bossObj, INFO_LIFE) > PHASE3_LIMIT){
|
|
|
|
float randAng = rand(0, 360);
|
|
|
|
ascent(i in 0..birdNum){
|
|
_SummonBirdEx(i * 360/birdNum + randAng, birdWvel, bulletNum);
|
|
}
|
|
|
|
wait(spawnDel);
|
|
|
|
randAng = rand(0, 360);
|
|
|
|
ascent(i in 0..birdNum){
|
|
_SummonBirdEx(i * 360/birdNum + randAng, -birdWvel, bulletNum);
|
|
}
|
|
|
|
wait(spawnDel);
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
*/
|
|
|
|
task PhaseBonusCalculation(int enm, int HPthreshold, string spellName){
|
|
|
|
int curRank = rank;
|
|
int scoreBase = 1000000 * curRank;
|
|
int scoreBonus = GetAreaCommonData("PIV", "currentvalue", 1000)*250;
|
|
int i = 0; // 20 seconds
|
|
|
|
function _CreateBonusText(float x, y, fontSize, int colorBorder, string text){
|
|
|
|
let objText = CreateTextObject(
|
|
|
|
x, y, fontSize,
|
|
text, "GravityBold8",
|
|
0xFFFFFF, 0xFFFFFF,
|
|
colorBorder, fontSize/10,
|
|
71
|
|
|
|
);
|
|
|
|
ObjText_SetHorizontalAlignment(objText, ALIGNMENT_RIGHT);
|
|
|
|
return objText;
|
|
|
|
}
|
|
|
|
let scoreText = _CreateBonusText(STG_WIDTH-12, STG_HEIGHT/9+36, 24, 0x000000, "");
|
|
|
|
while(ObjEnemy_GetInfo(enm, INFO_LIFE) > HPthreshold){
|
|
|
|
scoreBase = trunc(Interpolate_Smooth(1000000 * curRank, 100000 * curRank, i/1200)/10)*10;
|
|
i = min(1200, i+1);
|
|
|
|
scoreBonus = scoreBase * GetCommonDataPtr(POINTER_CHAIN, 1);
|
|
|
|
ObjText_SetText(scoreText, spellName ~ "[r][font sz=16]BONUS: [font oc=(255, 136, 0)]" ~ DigitToCommaArray(trunc(scoreBonus/10)*10));
|
|
|
|
yield;
|
|
|
|
}
|
|
|
|
AddScore(scoreBonus);
|
|
|
|
async{
|
|
|
|
ObjText_SetText(scoreText, "[font sz=32 oc=(164, 0, 90)]SCORE BONUS:[r][font sz=32 wg=800 oc=(255, 136, 0)]" ~ DigitToCommaArray(trunc(scoreBonus/10)*10));
|
|
|
|
ChargeBreakSFX;
|
|
|
|
wait(60);
|
|
|
|
Obj_Delete(scoreText);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
///////////// ENEMY HANDLING (NOT BOSS) /////////////
|
|
|
|
/*
|
|
function <void> WaveGround1(){
|
|
|
|
float speedMove = baseMoveSpeed1L * (1 + MoveSpeedRankMultiplierH * rank);
|
|
int invin = FUNC_LERP_DECEL(WG1_invinTimeMax, WG1_invinTimeMin, rank/RANK_MAX);
|
|
|
|
_SignPlatform1(
|
|
34, invin,
|
|
STG_WIDTH/4, -128, speedMove
|
|
);
|
|
|
|
wait(invin);
|
|
|
|
while(length(enmGround) > 1){yield;}
|
|
|
|
_SignPlatform1(
|
|
34, invin,
|
|
3*STG_WIDTH/4, -128, speedMove
|
|
);
|
|
|
|
wait(invin);
|
|
|
|
while(length(enmGround) > 1){yield;}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
function <void> WaveGround1A(){
|
|
|
|
float speedMove = baseMoveSpeed1L * (1 + MoveSpeedRankMultiplierL * rank);
|
|
int invin = FUNC_LERP_DECEL(WG1A_invinTimeMax, WG1A_invinTimeMin, rank/RANK_MAX);
|
|
int num = FUNC_LERP_DECEL(WG1A_bulletNumMin, WG1A_bulletNumMax, rank/RANK_MAX);
|
|
float spd = FUNC_LERP_DECEL(WG1A_bulletSpdMin, WG1A_bulletSpdMax, rank/RANK_MAX);
|
|
float del = FUNC_LERP_DECEL(WG1A_bulletDelayMin, WG1A_bulletDelayMax, rank/RANK_MAX);
|
|
|
|
int[] signs1 = _SignPlatform1A(
|
|
34, invin,
|
|
2*STG_WIDTH/7-64, -128, speedMove
|
|
);
|
|
|
|
for each (int sign in ref signs1){
|
|
Atk(sign);
|
|
}
|
|
|
|
int[] signs2 = _SignPlatform1A(
|
|
34, invin,
|
|
5*STG_WIDTH/7+64, -128, speedMove
|
|
);
|
|
|
|
for each (int sign in ref signs2){
|
|
Atk(sign);
|
|
}
|
|
|
|
task Atk(int ID){
|
|
|
|
async{
|
|
while(!Obj_IsDeleted(ID) && ObjMove_GetY(ID) <= STG_HEIGHT - 128 && GetObjectDistance(ID, GetPlayerObjectID()) > popcornHitbox * 2){
|
|
|
|
CreateFan(
|
|
ID, num, KEV_BALL_PINK, 1,
|
|
GetAngleToPlayer(ID), 2.25, spd, spd/1.5, 0.75,
|
|
ObjMove_GetX(ID), ObjMove_GetY(ID),
|
|
PATTERN_FAN, false
|
|
);
|
|
|
|
wait(del);
|
|
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
wait(invin);
|
|
|
|
while(length(enmGround) > 1){yield;}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
function <void> WaveGround2(){
|
|
|
|
float speedMove = baseMoveSpeedVL * (1 + MoveSpeedRankMultiplierL * rank);
|
|
int invin = FUNC_LERP_DECEL(WG2_invinTimeMax, WG2_invinTimeMin, rank/RANK_MAX);
|
|
|
|
int del = FUNC_LERP_DECEL(WG2_bulletDelayMax, WG2_bulletDelayMin, rank/RANK_MAX);
|
|
int num = FUNC_LERP_DECEL(WG2_bulletNumMin, WG2_bulletNumMax, rank/RANK_MAX);
|
|
float spd = FUNC_LERP_DECEL(WG2_bulletSpdMin, WG2_bulletSpdMax, rank/RANK_MAX);
|
|
float space = FUNC_LERP_DECEL(WG2_angRangeMin, WG2_angRangeMax, rank/RANK_MAX);
|
|
|
|
float aimAng = 0;
|
|
|
|
task Atk(int ID){
|
|
|
|
async{
|
|
while(!Obj_IsDeleted(ID) && ObjMove_GetY(ID) <= STG_HEIGHT * 6/7 && GetObjectDistance(ID, GetPlayerObjectID()) > popcornHitbox * 3){
|
|
|
|
float posX = 128 * cos(GetAngleToPlayer(ID));
|
|
float posY = 128 * sin(GetAngleToPlayer(ID));
|
|
|
|
CreateFan(
|
|
ID, num, KEV_FIRE_RED, 1,
|
|
GetAngleToPlayer(ID), space, spd, spd/1.5, 1,
|
|
posX, posY,
|
|
PATTERN_FAN, false
|
|
);
|
|
|
|
wait(del);
|
|
|
|
}
|
|
}
|
|
|
|
while(!Obj_IsDeleted(ID)){
|
|
ObjRender_SetAngleZ(ID, atan2(playerY - ObjMove_GetY(ID), playerX - ObjMove_GetX(ID)));
|
|
aimAng = atan2(playerY - ObjMove_GetY(ID), playerX - ObjMove_GetX(ID));
|
|
yield;
|
|
}
|
|
}
|
|
|
|
int[] enmArr = _CreateCannonBush(
|
|
35, invin,
|
|
2*STG_WIDTH/7, -128, speedMove
|
|
);
|
|
|
|
for each(int enm in ref enmArr){
|
|
Atk(enm);
|
|
}
|
|
|
|
wait(invin);
|
|
|
|
while(length(enmGround) > 0){yield;}
|
|
|
|
int[] enmArr2 = _CreateCannonBush(
|
|
34, invin,
|
|
5*STG_WIDTH/7, -128, speedMove
|
|
);
|
|
|
|
for each(int enm in ref enmArr2){
|
|
Atk(enm);
|
|
}
|
|
|
|
wait(invin);
|
|
|
|
while(length(enmGround) > 0){yield;}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
// Rybb
|
|
|
|
function <void> WaveGround3(){
|
|
|
|
float speedMove = baseMoveSpeedVL * (1 + MoveSpeedRankMultiplierVL * rank);
|
|
|
|
int dense = FUNC_LERP_DECEL(WG3_spiralDenseMin, WG3_spiralDenseMax, rank/RANK_MAX);
|
|
int num = FUNC_LERP_DECEL(WG3_spiralNumMin, WG3_spiralNumMax, rank/RANK_MAX);
|
|
int del = FUNC_LERP_DECEL(WG3_spiralDelayMax, WG3_spiralDelayMin, rank/RANK_MAX);
|
|
float spd = FUNC_LERP_DECEL(WG3_spiralSpdMin, WG3_spiralSpdMax, rank/RANK_MAX);
|
|
|
|
int ship = _CreateRybb(
|
|
36, del*3,
|
|
playerX, -180, speedMove
|
|
);
|
|
|
|
async{
|
|
|
|
while(!Obj_IsDeleted(ship)){
|
|
|
|
if (ObjMove_GetY(ship) <= 0) {ObjEnemy_SetDamageRate(ship, 0, 0);}
|
|
else if (ObjMove_GetY(ship) <= FUNC_LERP_LINEAR(180, 60, rank/RANK_MAX)) {ObjEnemy_SetDamageRate(ship, 25, 0);}
|
|
else {ObjEnemy_SetDamageRate(ship, 100, 100);}
|
|
|
|
yield;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
int i = 0;
|
|
float startAng = 0;
|
|
|
|
while(!Obj_IsDeleted(ship)){
|
|
|
|
int dir = i % 2 == 0 ? 1 : -1;
|
|
float startAng = i % 2 == 0 ? rand(-5, 0) : rand(0, 5);
|
|
|
|
ascent(i in 0..num){
|
|
ascent(k in 0..dense){
|
|
int bullet = CreateShotA1(ObjMove_GetX(ship), ObjMove_GetY(ship), FUNC_LERP_LINEAR(spd, spd, i/num), startAng + k * 360/dense + dir * i * 4, KEV_BALL_ORANGE, 5+i);
|
|
_BulletRescale(bullet, 0.6, true, 0.25);
|
|
_Delay(bullet, 5+i*2);
|
|
}
|
|
}
|
|
|
|
Shoot1;
|
|
wait(del);
|
|
i++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
function <void> WaveGround4(){
|
|
|
|
int del = FUNC_LERP_DECEL(WG4_bulletDelayMax, WG4_bulletDelayMin, rank/RANK_MAX);
|
|
int num = FUNC_LERP_DECEL(WG4_enmNumMin, WG4_enmNumMax, rank/RANK_MAX);
|
|
float enmspd = rand(baseMoveSpeedH * (1 + MoveSpeedRankMultiplierL*rank), baseMoveSpeedVH * (1 + MoveSpeedRankMultiplierL*rank));
|
|
float spd = FUNC_LERP_DECEL(WG4_bulletSpdMin, WG4_bulletSpdMax, rank/RANK_MAX);
|
|
int time = FUNC_LERP_DECEL(WG4_invinTimeMax, WG4_invinTimeMin, rank/RANK_MAX);
|
|
float bushspd = baseMoveSpeedVL * (1 + MoveSpeedRankMultiplierVL*rank);
|
|
|
|
float x = 0, y = 0;
|
|
|
|
int bussy = _CreateDangerBush(
|
|
34, time,
|
|
STG_WIDTH/2, -128, bushspd
|
|
);
|
|
|
|
async{
|
|
|
|
wait(time/2);
|
|
|
|
while(!Obj_IsDeleted(bussy)){
|
|
x = ObjMove_GetX(bussy);
|
|
y = ObjMove_GetY(bussy);
|
|
yield;
|
|
}
|
|
|
|
if(
|
|
(y > STG_HEIGHT+64)
|
|
)
|
|
{
|
|
return;
|
|
}
|
|
// Release bussy busses
|
|
|
|
loop(num){
|
|
|
|
int enm = _SmallFairy(
|
|
38, time/2,
|
|
x, y
|
|
);
|
|
|
|
int debris = _CreateBushRemnant(
|
|
35, time/2,
|
|
x, y
|
|
);
|
|
|
|
enmPattern(enm);
|
|
enmPattern2(debris);
|
|
|
|
}
|
|
|
|
task enmPattern(int ID){
|
|
|
|
float valueX = clamp([rand(-enmspd*1, -enmspd*0.25), rand(enmspd*0.25, enmspd*1)][rand_int(0, 1)], -12, 12);
|
|
float valueY = -enmspd * rand(1, 1.5);
|
|
|
|
ObjMove_AddPatternB2(ID, 0, valueX, valueY, -valueX/45, -valueY/45, valueX/20, -valueY/1.25);
|
|
|
|
while(!Obj_IsDeleted(ID) && ObjMove_GetY(ID) > 0 && ObjMove_GetY(ID) < STG_HEIGHT * 7/8){
|
|
|
|
if (ObjMove_GetSpeedY(ID) <= -valueY/24) {ObjEnemy_SetDamageRate(ID, 0, 0);}
|
|
else {ObjEnemy_SetDamageRate(ID, 100, 100);}
|
|
|
|
ObjMove_SetY(ID, clamp(ObjMove_GetY(ID), 0, STG_HEIGHT+99999999));
|
|
|
|
int bullet = CreateShotA1(ObjMove_GetX(ID), ObjMove_GetY(ID), spd, GetAngleToPlayer(ID), KEV_BALL_LAVENDER, 5);
|
|
|
|
_BulletRescale(bullet, 0.75, true, 0.25);
|
|
_Delay(bullet, 5);
|
|
Shoot1;
|
|
|
|
wait(del);
|
|
}
|
|
}
|
|
|
|
task enmPattern2(int ID){
|
|
|
|
float valueX = clamp([rand(-enmspd*1.25, -enmspd*0.75), rand(enmspd*1.25, enmspd*0.75)][rand_int(0, 1)], -12, 12);
|
|
float valueY = -enmspd * rand(1, 1.5);
|
|
|
|
ObjMove_AddPatternB2(ID, 0, valueX, valueY, -valueX/35, -valueY/35, valueX/12.5, -valueY);
|
|
//ObjRender_SetAlpha(ID, 160);
|
|
|
|
while(!Obj_IsDeleted(ID)){
|
|
|
|
if (ObjMove_GetSpeedY(ID) <= -valueY/24) {ObjEnemy_SetDamageRate(ID, 0, 0);}
|
|
else {ObjEnemy_SetDamageRate(ID, 100, 100);}
|
|
|
|
ObjMove_SetY(ID, clamp(ObjMove_GetY(ID), 0, STG_HEIGHT+99999999));
|
|
|
|
ObjRender_SetAngleZ(ID, ObjRender_GetAngleZ(ID)+3);
|
|
|
|
yield;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
wait(time/2);
|
|
|
|
while(length(enmGround) > 0){yield;}
|
|
|
|
return;
|
|
}
|
|
|
|
function <void> WaveGround5(){
|
|
|
|
float speedMove = baseMoveSpeedVL * (1 + MoveSpeedRankMultiplierVL * rank) * 0.5;
|
|
|
|
int num = FUNC_LERP_DECEL(WG5_bulletNumMin, WG5_bulletNumMax, rank/RANK_MAX);
|
|
int del = FUNC_LERP_DECEL(WG5_bulletDelayMax, WG5_bulletDelayMin, rank/RANK_MAX);
|
|
float spd = FUNC_LERP_DECEL(WG5_bulletSpdMin, WG5_bulletSpdMax, rank/RANK_MAX);
|
|
float[] moveX = [[180, -1.5], [0, 1.5]][GetCommonData("Flying Loops Cleared", 0) % 2];
|
|
|
|
int ship = _CreateDecker(
|
|
37, del*3,
|
|
playerX, -180, speedMove
|
|
);
|
|
|
|
async{
|
|
if(GetCommonData("Rush", false) == true){WaveGround3();}
|
|
else{}
|
|
}
|
|
|
|
async{
|
|
|
|
while(!Obj_IsDeleted(ship)){
|
|
|
|
ObjMove_SetSpeedY(ship, speedMove);
|
|
ObjMove_SetX(ship, STG_WIDTH/2 + STG_WIDTH/2 * cos(moveX[0]));
|
|
|
|
if (ObjMove_GetY(ship) <= 0) {ObjEnemy_SetDamageRate(ship, 0, 0);}
|
|
else if (ObjMove_GetY(ship) <= FUNC_LERP_LINEAR(180, 60, rank/RANK_MAX)) {ObjEnemy_SetDamageRate(ship, 25, 0);}
|
|
else {ObjEnemy_SetDamageRate(ship, 100, 100);}
|
|
|
|
moveX[0] += moveX[1];
|
|
|
|
yield;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
int i = 0;
|
|
float startAng = 0;
|
|
|
|
while(!Obj_IsDeleted(ship)){
|
|
|
|
int x = i % 2 == 0 ? 64 : -64;
|
|
|
|
ascent(i in 0..num){
|
|
int bullet = CreateShotA1(ObjMove_GetX(ship)+x, ObjMove_GetY(ship)+160, FUNC_LERP_LINEAR(spd, spd*1.5, i/num), 90, KEV_LEAF_ORANGE, 5);
|
|
_BulletRescale(bullet, 0.75, true, 0.25);
|
|
_Delay(bullet, 10);
|
|
ObjShot_SetDelayMotionEnable(bullet, true);
|
|
}
|
|
|
|
Shoot1;
|
|
wait(del);
|
|
i++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
function <void> WaveGround6(){
|
|
|
|
SetCommonData("Rush", true);
|
|
|
|
WaveGround5();
|
|
|
|
SetCommonData("Rush", false);
|
|
|
|
}
|
|
|
|
*/
|
|
|
|
function Wave1(){
|
|
|
|
int num = FUNC_LERP_ACCEL(W1_fairyNumMin, W1_fairyNumMax, rank/RANK_MAX);
|
|
int decel = FUNC_LERP_ACCEL(W1_decelTimeMax, W1_decelTimeMin, rank/RANK_MAX);
|
|
int del = FUNC_LERP_ACCEL(W1_bulletDelayMax, W1_bulletDelayMin, rank/RANK_MAX);
|
|
int spawndel = FUNC_LERP_ACCEL(W1_spawnDelayMax, W1_spawnDelayMin, rank/RANK_MAX);
|
|
float spd = FUNC_LERP_ACCEL(W1_bulletSpdMin, W1_bulletSpdMax, rank/RANK_MAX);
|
|
float movespd = baseMoveSpeedH * (1 + MoveSpeedRankMultiplierL*rank);
|
|
|
|
task CreateEnemyA(float startY){
|
|
|
|
int enm = _SmallFairy(
|
|
40, decel+del*2,
|
|
GetStgFrameWidth()+128, startY
|
|
);
|
|
|
|
ObjMove_AddPatternA2(enm, 0, movespd*2, 180, -movespd*2/decel, 0, 0);
|
|
ObjMove_AddPatternA2(enm, decel, NO_CHANGE, NO_CHANGE, movespd/decel, movespd, 0);
|
|
|
|
wait(decel);
|
|
|
|
while(!Obj_IsDeleted(enm) && ObjMove_GetX(enm) > STG_WIDTH * 1/8){
|
|
|
|
int bullet = CreateShotA1(ObjMove_GetX(enm), ObjMove_GetY(enm), spd, GetAngleToPlayer(enm), KEV_BALL_PURPLE, 5);
|
|
|
|
_Delay(bullet, 5);
|
|
Shoot1;
|
|
|
|
wait(del);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
ascent(i in 1..6){
|
|
|
|
CreateEnemyA(i * STG_HEIGHT/6);
|
|
|
|
if(i != 6){wait(spawndel);}
|
|
else{}
|
|
|
|
}
|
|
|
|
while(length(enmFly) > 1){yield;}
|
|
|
|
ascent(i in 1..6){
|
|
|
|
CreateEnemyA((6-i) * STG_HEIGHT/6);
|
|
|
|
if(i != 6){wait(spawndel);}
|
|
else{}
|
|
|
|
}
|
|
|
|
while(length(enmFly) > 1){yield;}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
function Wave2(){
|
|
|
|
int num = FUNC_LERP_ACCEL(W2_fairyNumMin, W2_fairyNumMax, rank/RANK_MAX);
|
|
int bulletnum = FUNC_LERP_ACCEL(W2_bulletfanNumMin, W2_bulletfanNumMax, rank/RANK_MAX);
|
|
int del = FUNC_LERP_ACCEL(W2_bulletDelayMax, W2_bulletDelayMin, rank/RANK_MAX);
|
|
int spawndel = FUNC_LERP_ACCEL(W2_spawnDelayMax, W2_spawnDelayMin, rank/RANK_MAX);
|
|
float spd = FUNC_LERP_ACCEL(W2_bulletSpdMin, W2_bulletSpdMax, rank/RANK_MAX);
|
|
float movespd = baseMoveSpeedM * (1 + MoveSpeedRankMultiplierL*rank);
|
|
float range = FUNC_LERP_ACCEL(W2_rangeMin, W2_rangeMax, rank/RANK_MAX);
|
|
float[] spdrange = [-4, 4];
|
|
|
|
task CreateEnemyA(float startX, float startY, float angMove){
|
|
|
|
float ang = 180;
|
|
|
|
int enm = _Spirit(
|
|
40, del, startX, startY
|
|
);
|
|
|
|
async{
|
|
|
|
while(!Obj_IsDeleted(enm)){
|
|
|
|
//ObjMove_SetSpeed(enm, )
|
|
ObjMove_AddPatternB1(enm, 0, -movespd, sin(ang) * spdrange[1]);
|
|
ang += 3.5;
|
|
yield;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
async{
|
|
|
|
wait(spawndel);
|
|
|
|
while(!Obj_IsDeleted(enm) & ObjMove_GetX(enm) > STG_WIDTH * 1/8){
|
|
|
|
int bullet = CreateFan
|
|
(
|
|
enm, bulletnum, KEV_FIRESMALL_AQUA, 1,
|
|
0, range, spd, spd/1.5, 1,
|
|
0, 0,
|
|
PATTERN_FAN_AIMED, false
|
|
);
|
|
|
|
//_Delay(bullet, 5);
|
|
Shoot1;
|
|
|
|
wait(del);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
ascent(i in 0..num){
|
|
|
|
float y = playerY;
|
|
|
|
y = clamp(y, STG_HEIGHT * 1/5, STG_HEIGHT * 4/5);
|
|
CreateEnemyA(STG_WIDTH+128, y, 0);
|
|
|
|
if(i != num){wait(spawndel);}
|
|
else{}
|
|
|
|
}
|
|
|
|
while(length(enmFly) > 1){yield;}
|
|
|
|
ascent(i in 0..num){
|
|
|
|
float y = playerY;
|
|
|
|
y = clamp(y, STG_HEIGHT * 1/5, STG_HEIGHT * 4/5);
|
|
CreateEnemyA(STG_WIDTH+128, y, 0);
|
|
|
|
if(i != num){wait(spawndel);}
|
|
else{}
|
|
|
|
}
|
|
|
|
while(length(enmFly) > 1){yield;}
|
|
|
|
return;
|
|
}
|
|
|
|
function Wave3(){
|
|
|
|
int num = FUNC_LERP_ACCEL(W3_fairyNumMin, W3_fairyNumMax, rank/RANK_MAX);
|
|
int del = FUNC_LERP_ACCEL(W3_bulletDelayMax, W3_bulletDelayMin, rank/RANK_MAX);
|
|
int bulletnum = FUNC_LERP_ACCEL(W3_bulletfanNumMin, W3_bulletfanNumMax, rank/RANK_MAX);
|
|
int spawndel = FUNC_LERP_ACCEL(W3_spawnDelayMax, W3_spawnDelayMin, rank/RANK_MAX);
|
|
float spd = FUNC_LERP_ACCEL(W3_bulletSpdMin, W3_bulletSpdMax, rank/RANK_MAX);
|
|
float movespd = baseMoveSpeedH * (1 + MoveSpeedRankMultiplierL*rank);
|
|
float range = FUNC_LERP_ACCEL(W3_rangeMin, W3_rangeMax, rank/RANK_MAX);
|
|
float[] rangemove = [2.5, 4];
|
|
int counter = 1;
|
|
|
|
task CreateEnemyA(float startX, float startY, float spd){
|
|
|
|
float ang = rand(0, 180);
|
|
float spdMax = rand(rangemove[0], rangemove[1]);
|
|
|
|
int enm = _MushroomFairy(
|
|
40, del*3,
|
|
startX, startY
|
|
);
|
|
|
|
async{
|
|
|
|
while(!Obj_IsDeleted(enm)){
|
|
|
|
//ObjMove_SetSpeed(enm, )
|
|
|
|
ObjMove_AddPatternB1(enm, 0, sin(ang) * spdMax, spd);
|
|
ang += 3;
|
|
yield;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
async{
|
|
|
|
while(!Obj_IsDeleted(enm)){
|
|
|
|
if(ObjMove_GetY(enm) > STG_HEIGHT+128 || ObjMove_GetY(enm) < -128){
|
|
Obj_Delete(enm);
|
|
break;
|
|
}
|
|
|
|
if(ObjMove_GetY(enm) < STG_HEIGHT && ObjMove_GetY(enm) > 0){
|
|
|
|
if (spd < 0){
|
|
|
|
int bullet = CreateShotA1(ObjMove_GetX(enm), ObjMove_GetY(enm), spd, GetAngleToPlayer(enm)+180, KEV_FIRELARGE_PURPLE, 10);
|
|
ObjRender_SetAngleZ(bullet, 180);
|
|
_Delay(bullet, 10);
|
|
|
|
}
|
|
|
|
else{
|
|
|
|
int bullet = CreateShotA1(ObjMove_GetX(enm), ObjMove_GetY(enm), spd, GetAngleToPlayer(enm), KEV_FIRELARGE_PURPLE, 10);
|
|
_Delay(bullet, 10);
|
|
|
|
}
|
|
//_Delay(bullet, 5);
|
|
Shoot1;
|
|
|
|
}
|
|
|
|
wait(del);
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
ascent(i in 0..num){
|
|
|
|
CreateEnemyA(rand(STG_WIDTH*6/8, STG_WIDTH*7/8), counter >= 1 ? -128 : STG_HEIGHT+128, movespd*counter);
|
|
|
|
counter *= -1;
|
|
|
|
if(i != num){wait(spawndel);}
|
|
else{}
|
|
|
|
}
|
|
|
|
while(length(enmFly) > 1){yield;}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
function Wave4(){
|
|
|
|
int num = FUNC_LERP_ACCEL(W4_fairyNumMin, W4_fairyNumMax, rank/RANK_MAX);
|
|
int del = FUNC_LERP_ACCEL(W4_bulletDelayMax, W4_bulletDelayMin, rank/RANK_MAX);
|
|
int bulletnum = FUNC_LERP_ACCEL(W4_bulletNumMin, W4_bulletNumMax, rank/RANK_MAX);
|
|
int spawndel = FUNC_LERP_ACCEL(W4_spawnDelayMax, W4_spawnDelayMin, rank/RANK_MAX);
|
|
float spd = FUNC_LERP_ACCEL(W4_bulletSpdMin, W4_bulletSpdMax, rank/RANK_MAX);
|
|
float movespd = baseMoveSpeedH * (1 + MoveSpeedRankMultiplierL*rank);
|
|
int stoptime = FUNC_LERP_LINEAR(W4_stopTimeMax, W4_stopTimeMin, rank/RANK_MAX);
|
|
|
|
int counter = 1;
|
|
|
|
task CreateEnemyA(float startX, float startY, float angle){
|
|
|
|
int enm = _MushroomFairyAlt(
|
|
40, del*3,
|
|
startX, startY
|
|
);
|
|
|
|
ObjMove_AddPatternA1(enm, 0, movespd, rand(angle-5, angle+5));
|
|
ObjMove_SetAngularVelocity(enm, rand(-0.1, 0.1));
|
|
|
|
async{
|
|
|
|
while(!Obj_IsDeleted(enm)){
|
|
|
|
if(ObjMove_GetY(enm) > STG_HEIGHT+128 || ObjMove_GetY(enm) < -128){
|
|
Obj_Delete(enm);
|
|
break;
|
|
}
|
|
|
|
yield;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
async{
|
|
|
|
while(!Obj_IsDeleted(enm)){
|
|
|
|
if(ObjMove_GetY(enm) < STG_HEIGHT && ObjMove_GetY(enm) > 0){
|
|
|
|
ascent(i in 0..bulletnum){
|
|
|
|
int bullet = CreateShotA1(ObjMove_GetX(enm), ObjMove_GetY(enm), 0, 180, KEV_FIRESMALL_AQUA, 10);
|
|
//ObjRender_SetAngleZ(bullet, 180);
|
|
_Delay(bullet, 10);
|
|
|
|
ObjMove_AddPatternA2(bullet, stoptime, NO_CHANGE, NO_CHANGE, spd/stoptime, spd, 0);
|
|
|
|
Shoot1;
|
|
wait(del);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
wait(del*bulletnum);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
ascent(i in 0..num){
|
|
|
|
CreateEnemyA(rand(STG_WIDTH*6.5/8, STG_WIDTH*7/8), counter >= 1 ? -128 : STG_HEIGHT+128, counter >= 1 ? 90 : 270);
|
|
|
|
counter *= -1;
|
|
|
|
if(i != num){wait(spawndel);}
|
|
else{}
|
|
|
|
}
|
|
|
|
while(length(enmFly) > 1){yield;}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
function Wave5(){
|
|
|
|
int num = FUNC_LERP_LINEAR(W5_fairyNumMin, W5_fairyNumMax, rank/RANK_MAX);
|
|
int spawndel = FUNC_LERP_ACCEL(W4_spawnDelayMax, W4_spawnDelayMin, rank/RANK_MAX);
|
|
float spd = FUNC_LERP_ACCEL(W4_bulletSpdMin, W4_bulletSpdMax, rank/RANK_MAX);
|
|
float movetime = FUNC_LERP_LINEAR(W5_moveTimeMin, W5_moveTimeMax, rank/RANK_MAX);
|
|
float movespeed = FUNC_LERP_LINEAR(16, 18, rank/RANK_MAX);
|
|
|
|
task CreateEnemyA(float startX, float startY, float movespeed){
|
|
|
|
int enm = _SmallFairy(
|
|
40, 30,
|
|
startX, startY
|
|
);
|
|
|
|
ObjEnemy_SetDamageRate(enm, 0, 0);
|
|
ObjMove_AddPatternB2(enm, 0, 0, movespeed, 0, -movespeed/movetime, 0, -movespeed);
|
|
|
|
async{
|
|
|
|
while(!Obj_IsDeleted(enm)){
|
|
|
|
if(ObjMove_GetY(enm) > STG_HEIGHT+128 || ObjMove_GetY(enm) < -128){
|
|
Obj_Delete(enm);
|
|
break;
|
|
}
|
|
|
|
yield;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
async{
|
|
|
|
wait(movetime);
|
|
ObjEnemy_SetDamageRate(enm, 100, 100);
|
|
|
|
if(!Obj_IsDeleted(enm)){
|
|
int bullet = CreateShotA1(ObjMove_GetX(enm), ObjMove_GetY(enm), spd, GetAngleToPlayer(enm), KEV_BALL_PURPLE, 5);
|
|
Shoot1;
|
|
_Delay(bullet, 5);
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
float x = rand(STG_WIDTH*4/7, STG_WIDTH*5.25/7);
|
|
|
|
ascent(k in 0..num){
|
|
CreateEnemyA(x + k * 84, -96, movespeed);
|
|
}
|
|
|
|
wait(spawndel);
|
|
|
|
x = rand(STG_WIDTH*4/7, STG_WIDTH*5/7);
|
|
|
|
ascent(k in 0..num){
|
|
CreateEnemyA(x + k * 84, STG_HEIGHT+96, -movespeed);
|
|
}
|
|
|
|
while(length(enmFly) > 1){yield;}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
function WaveGround1(){
|
|
|
|
int dense = FUNC_LERP_LINEAR(WG1_ringDenseMin, WG1_ringDenseMax, rank/RANK_MAX);
|
|
float spd = FUNC_LERP_LINEAR(WG1_bulletSpdMin, WG1_bulletSpdMax, rank/RANK_MAX);
|
|
int del = FUNC_LERP_ACCEL(WG1_bulletDelayMax, WG1_bulletDelayMin, rank/RANK_MAX);
|
|
float movespd = baseMoveSpeedM * (1 + MoveSpeedRankMultiplierL*rank);
|
|
|
|
task CreateEnemyA(float startX, float startY, float angle){
|
|
|
|
int enm = _MushroomFairyAlt(
|
|
39, del*3,
|
|
startX, startY
|
|
);
|
|
|
|
ObjMove_AddPatternA1(enm, 0, movespd, 180);
|
|
|
|
async{
|
|
|
|
while(!Obj_IsDeleted(enm)){
|
|
|
|
if(ObjMove_GetY(enm) > STG_HEIGHT+128 || ObjMove_GetY(enm) < -128 || ObjMove_GetX(enm) < -128 || ObjMove_GetX(enm) > STG_WIDTH+128){
|
|
Obj_Delete(enm);
|
|
break;
|
|
}
|
|
|
|
yield;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
async{
|
|
|
|
while(!Obj_IsDeleted(enm)){
|
|
|
|
float ang = rand(0, 360);
|
|
|
|
if(ObjMove_GetY(enm) < STG_HEIGHT && ObjMove_GetY(enm) > 0){
|
|
|
|
ascent(i in 0..dense){
|
|
|
|
int bullet = CreateShotA1(ObjMove_GetX(enm), ObjMove_GetY(enm), spd, ang + i * 360/dense, KEV_FIRESMALL_AQUA, 10);
|
|
//ObjRender_SetAngleZ(bullet, 180);
|
|
_Delay(bullet, 10);
|
|
|
|
Shoot2;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
wait(del);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if(rank <= 5){
|
|
CreateEnemyA(STG_WIDTH+128, STG_HEIGHT * 1/5, 180);
|
|
CreateEnemyA(STG_WIDTH+128, STG_HEIGHT * 4/5, 180);
|
|
}
|
|
|
|
else{
|
|
CreateEnemyA(STG_WIDTH+128, STG_HEIGHT * 1/5, 180);
|
|
CreateEnemyA(STG_WIDTH+128, STG_HEIGHT * 1/2, 180);
|
|
CreateEnemyA(STG_WIDTH+128, STG_HEIGHT * 4/5, 180);
|
|
}
|
|
|
|
while(length(enmFly) > 1){yield;}
|
|
|
|
}
|
|
|
|
function <void> WaveGround2(float pos){
|
|
|
|
float speedMove = baseMoveSpeed1L * (1 + MoveSpeedRankMultiplierL * rank);
|
|
|
|
int dense = FUNC_LERP_DECEL(WG2_spiralDenseMin, WG2_spiralDenseMax, rank/RANK_MAX);
|
|
int num = FUNC_LERP_DECEL(WG2_spiralNumMin, WG2_spiralNumMax, rank/RANK_MAX);
|
|
int del = FUNC_LERP_DECEL(WG2_spiralDelayMax, WG2_spiralDelayMin, rank/RANK_MAX);
|
|
float spd = FUNC_LERP_DECEL(WG2_spiralSpdMin, WG2_spiralSpdMax, rank/RANK_MAX);
|
|
float k = pos;
|
|
|
|
k = clamp(k, STG_HEIGHT * 1/5, STG_HEIGHT * 4/5);
|
|
|
|
int ship = _YukiOnna(
|
|
36, del*3,
|
|
STG_WIDTH+128, k
|
|
);
|
|
|
|
ObjMove_AddPatternA1(ship, 0, speedMove, 180);
|
|
|
|
async{
|
|
|
|
while(!Obj_IsDeleted(ship)){
|
|
|
|
if (ObjMove_GetX(ship) <= 0) {ObjEnemy_SetDamageRate(ship, 0, 0);}
|
|
else if (ObjMove_GetX(ship) <= FUNC_LERP_LINEAR(STG_WIDTH-240, STG_WIDTH-120, rank/RANK_MAX))
|
|
{ObjEnemy_SetDamageRate(ship, 40, 40);}
|
|
else {ObjEnemy_SetDamageRate(ship, 100, 100);}
|
|
|
|
yield;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
int i = 0;
|
|
float startAng = 0;
|
|
|
|
while(!Obj_IsDeleted(ship)){
|
|
|
|
int dir = i % 2 == 0 ? 1 : -1;
|
|
float startAng = i % 2 == 0 ? rand(-5, 0) : rand(0, 5);
|
|
|
|
ascent(i in 0..num){
|
|
ascent(k in 0..dense){
|
|
int bullet = CreateShotA1(ObjMove_GetX(ship), ObjMove_GetY(ship), FUNC_LERP_LINEAR(spd, spd, i/num), startAng + k * 360/dense + dir * i * 4, KEV_BALL_LAVENDER, 5+i);
|
|
_Delay(bullet, 5+i*2);
|
|
}
|
|
}
|
|
|
|
Shoot2;
|
|
wait(del);
|
|
i++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
function Wave8(){
|
|
|
|
int num = FUNC_LERP_ACCEL(W4_fairyNumMin, W4_fairyNumMax, rank/RANK_MAX);
|
|
int del = FUNC_LERP_ACCEL(W4_bulletDelayMax, W4_bulletDelayMin, rank/RANK_MAX);
|
|
int bulletnum = FUNC_LERP_ACCEL(W4_bulletNumMin, W4_bulletNumMax, rank/RANK_MAX) - 1;
|
|
int spawndel = FUNC_LERP_ACCEL(W4_spawnDelayMax, W4_spawnDelayMin, rank/RANK_MAX) * 1.1;
|
|
float spd = FUNC_LERP_ACCEL(W4_bulletSpdMin, W4_bulletSpdMax, rank/RANK_MAX);
|
|
float movespd = baseMoveSpeedH * (1 + MoveSpeedRankMultiplierL*rank);
|
|
int stoptime = FUNC_LERP_LINEAR(W4_stopTimeMax, W4_stopTimeMin, rank/RANK_MAX);
|
|
|
|
int counter = 1;
|
|
|
|
task CreateEnemyA(float startX, float startY, float angle){
|
|
|
|
int enm = _MushroomFairy(
|
|
40, del*3,
|
|
startX, startY
|
|
);
|
|
|
|
ObjMove_AddPatternA1(enm, 0, movespd, rand(angle-5, angle+5));
|
|
ObjMove_SetAngularVelocity(enm, [rand(-0.4, -0.25), rand(0.25, 0.4)][rand_int(0, 1)]);
|
|
|
|
async{
|
|
|
|
while(!Obj_IsDeleted(enm)){
|
|
|
|
if(ObjMove_GetY(enm) > STG_HEIGHT+128 || ObjMove_GetY(enm) < -128){
|
|
Obj_Delete(enm);
|
|
break;
|
|
}
|
|
|
|
yield;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
async{
|
|
|
|
while(!Obj_IsDeleted(enm)){
|
|
|
|
if(ObjMove_GetY(enm) < STG_HEIGHT && ObjMove_GetY(enm) > 0){
|
|
|
|
ascent(i in 0..bulletnum){
|
|
|
|
int bullet = CreateShotA1(ObjMove_GetX(enm), ObjMove_GetY(enm), 0, 180, KEV_FIRELARGE_PURPLE, 10);
|
|
//ObjRender_SetAngleZ(bullet, 180);
|
|
_Delay(bullet, 10);
|
|
|
|
ObjMove_AddPatternA2(bullet, stoptime, NO_CHANGE, NO_CHANGE, spd/stoptime, spd, 0);
|
|
|
|
Shoot1;
|
|
wait(del);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
wait(del*bulletnum);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
ascent(i in 0..num){
|
|
|
|
CreateEnemyA(rand(STG_WIDTH*6.5/8, STG_WIDTH*7/8), counter >= 1 ? -128 : STG_HEIGHT+128, counter >= 1 ? 90 : 270);
|
|
|
|
counter *= -1;
|
|
|
|
if(i != num){wait(spawndel);}
|
|
else{}
|
|
|
|
}
|
|
|
|
while(length(enmFly) > 1){yield;}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
function Wave9(){
|
|
|
|
int num = FUNC_LERP_ACCEL(W9_fairyNumMin, W9_fairyNumMax, rank/RANK_MAX);
|
|
int del = FUNC_LERP_ACCEL(W9_bulletDelayMax, W9_bulletDelayMin, rank/RANK_MAX);
|
|
int spawndel = FUNC_LERP_ACCEL(W9_spawnDelayMax, W9_spawnDelayMin, rank/RANK_MAX);
|
|
|
|
float spd = FUNC_LERP_ACCEL(W9_bulletSpdMin, W9_bulletSpdMax, rank/RANK_MAX);
|
|
float movespd = baseMoveSpeedH * (1 + MoveSpeedRankMultiplierVL*rank);
|
|
|
|
float[] rangemove = [3, 6];
|
|
|
|
int counter = 1;
|
|
|
|
task CreateEnemyA(float startX, float startY, float spd){
|
|
|
|
float ang = rand(0, 180);
|
|
float spdMax = rand(rangemove[0], rangemove[1]);
|
|
|
|
int enm = _SmallFairy(
|
|
40, del*3,
|
|
startX, startY
|
|
);
|
|
|
|
async{
|
|
|
|
while(!Obj_IsDeleted(enm)){
|
|
|
|
//ObjMove_SetSpeed(enm, )
|
|
|
|
ObjMove_AddPatternB1(enm, 0, sin(ang) * spdMax, spd);
|
|
ang += 3;
|
|
yield;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
async{
|
|
|
|
wait(spawndel);
|
|
|
|
while(!Obj_IsDeleted(enm)){
|
|
|
|
if(ObjMove_GetY(enm) > STG_HEIGHT+128 || ObjMove_GetY(enm) < -128){
|
|
Obj_Delete(enm);
|
|
break;
|
|
}
|
|
|
|
if(ObjMove_GetY(enm) < STG_HEIGHT && ObjMove_GetY(enm) > 0){
|
|
|
|
if (spd < 0){
|
|
|
|
ascent(i in 0..3){
|
|
int bullet = CreateShotA1(ObjMove_GetX(enm), ObjMove_GetY(enm), spd - i * spd/15, GetAngleToPlayer(enm)+180, KEV_BALL_PURPLE, 10);
|
|
ObjRender_SetAngleZ(bullet, 180);
|
|
_Delay(bullet, 10);
|
|
}
|
|
|
|
}
|
|
|
|
else{
|
|
|
|
ascent(i in 0..3){
|
|
int bullet = CreateShotA1(ObjMove_GetX(enm), ObjMove_GetY(enm), spd - i * spd/15, GetAngleToPlayer(enm), KEV_BALL_PURPLE, 10);
|
|
_Delay(bullet, 10);
|
|
}
|
|
|
|
}
|
|
//_Delay(bullet, 5);
|
|
Shoot1;
|
|
wait(del);
|
|
}
|
|
|
|
yield;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
ascent(i in 0..num){
|
|
|
|
CreateEnemyA(rand(STG_WIDTH*6.5/8, STG_WIDTH*6.75/8), counter >= 1 ? -128 : STG_HEIGHT+128, movespd*counter);
|
|
|
|
counter *= -1;
|
|
|
|
if(i != num){wait(spawndel);}
|
|
else{}
|
|
|
|
}
|
|
|
|
while(length(enmFly) > 1){yield;}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
function Wave10(){
|
|
|
|
int num = FUNC_LERP_LINEAR(W10_fairyNumMin, W10_fairyNumMax, rank/RANK_MAX);
|
|
int spawndel = FUNC_LERP_ACCEL(W10_spawnDelayMax, W10_spawnDelayMin, rank/RANK_MAX);
|
|
int bulletnum = FUNC_LERP_ACCEL(W10_bulletLineNumMin, W10_bulletLineNumMax, rank/RANK_MAX);
|
|
float spd = FUNC_LERP_ACCEL(W10_bulletSpdMin, W10_bulletSpdMax, rank/RANK_MAX);
|
|
float movetime = FUNC_LERP_LINEAR(W10_moveTimeMin, W10_moveTimeMax, rank/RANK_MAX);
|
|
float movespeed = FUNC_LERP_LINEAR(12, 15, rank/RANK_MAX);
|
|
|
|
task CreateEnemyA(float startX, float startY, float movespeed){
|
|
|
|
int enm = _MushroomFairyAlt(
|
|
40, 30,
|
|
startX, startY
|
|
);
|
|
|
|
ObjEnemy_SetDamageRate(enm, 0, 0);
|
|
ObjMove_AddPatternB2(enm, 0, movespeed, 0, -movespeed/movetime, 0, -movespeed, 0);
|
|
|
|
async{
|
|
|
|
while(!Obj_IsDeleted(enm)){
|
|
|
|
if(ObjMove_GetY(enm) > STG_HEIGHT+128 || ObjMove_GetY(enm) < -128){
|
|
Obj_Delete(enm);
|
|
break;
|
|
}
|
|
|
|
yield;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
async{
|
|
|
|
wait(movetime/2);
|
|
|
|
ObjEnemy_SetDamageRate(enm, 100, 100);
|
|
|
|
while(!Obj_IsDeleted(enm)){
|
|
|
|
ascent(i in 0..bulletnum){
|
|
int bullet = CreateShotA1(ObjMove_GetX(enm), ObjMove_GetY(enm), spd - i * (spd/(bulletnum*2)), GetAngleToPlayer(enm), KEV_LEAF_AQUA, 5);
|
|
Shoot1;
|
|
_Delay(bullet, 5);
|
|
}
|
|
|
|
wait(spawndel/2);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
ascent(k in 0..num){
|
|
CreateEnemyA(STG_WIDTH + 96, 96 + k * 84, -movespeed);
|
|
}
|
|
|
|
wait(spawndel);
|
|
|
|
ascent(k in 0..num){
|
|
CreateEnemyA(STG_WIDTH + 96, STG_HEIGHT - 96 - k * 84, -movespeed);
|
|
}
|
|
|
|
while(length(enmFly) > 1){yield;}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
function Wave3(){
|
|
|
|
int linenum = FUNC_LERP_LINEAR(W3_bulletLineNumMin, W3_bulletLineNumMax, rank/RANK_MAX);
|
|
int dense = FUNC_LERP_LINEAR(W3_bulletDenseMin, W3_bulletDenseMax, rank/RANK_MAX);
|
|
int del = FUNC_LERP_ACCEL(W3_bulletDelayMax, W3_bulletDelayMin, rank/RANK_MAX);
|
|
int zakodel = FUNC_LERP_ACCEL(W3_zakospawnDelayMax, W3_zakospawnDelayMin, rank/RANK_MAX);
|
|
float spd = FUNC_LERP_ACCEL(W3_bulletSpdMin, W3_bulletSpdMax, rank/RANK_MAX);
|
|
float movespd = baseMoveSpeed1L * (1 + MoveSpeedRankMultiplierL*rank);
|
|
float zakomovespd = baseMoveSpeedVH * (1 + MoveSpeedRankMultiplierL*rank);
|
|
float angmovespd =FUNC_LERP_ACCEL(W3_angleMoveSpdMin, W3_angleMoveSpdMax, rank/RANK_MAX);
|
|
float startX = [0, STG_WIDTH][GetCommonData("Flying Loops Cleared", 0) % 2];
|
|
float[] moveX = [[180, -angmovespd], [0, angmovespd]][GetCommonData("Flying Loops Cleared", 0) % 2];
|
|
float angStart = rand(0, 360);
|
|
int i = 0;
|
|
|
|
int enmLarge = _LargeDancer(
|
|
40, 90,
|
|
startX, -144
|
|
);
|
|
|
|
async{
|
|
|
|
while(!Obj_IsDeleted(enmLarge)){
|
|
|
|
ObjMove_SetSpeedY(enmLarge, movespd);
|
|
ObjMove_SetX(enmLarge, STG_WIDTH/2 + STG_WIDTH/2 * cos(moveX[0]));
|
|
|
|
if (ObjMove_GetY(enmLarge) <= FUNC_LERP_LINEAR(144, 48, rank/RANK_MAX)) {ObjEnemy_SetDamageRate(enmLarge, 0, 0);}
|
|
else {ObjEnemy_SetDamageRate(enmLarge, 100, 100);}
|
|
|
|
moveX[0] += moveX[1];
|
|
|
|
yield;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
while(!Obj_IsDeleted(enmLarge)){
|
|
|
|
int shot = CreateFan(enmLarge, 1, KEV_LEAF_LAVENDER, linenum,
|
|
angStart+i*1*360/dense, 0, spd/1.25, spd,
|
|
0.75,
|
|
0, 0,
|
|
PATTERN_FAN, false
|
|
);
|
|
int shot2 = CreateFan(enmLarge, 1, KEV_LEAF_LAVENDER, linenum,
|
|
angStart+(180+angStart)+i*(-1)*360/dense, 0, spd/1.25, spd,
|
|
0.75,
|
|
0, 0,
|
|
PATTERN_FAN, false
|
|
);
|
|
|
|
Shoot2;
|
|
|
|
i++;
|
|
wait(del);
|
|
|
|
}
|
|
|
|
// FUCK YOU HERE'S SOME ZAKO
|
|
|
|
task CreateEnemyA(float startX){
|
|
|
|
int enm = _SmallFairy(
|
|
39, zakomovespd*2,
|
|
startX, -64
|
|
);
|
|
|
|
ObjMove_AddPatternA1(enm, 0, zakomovespd*1.5, atan2(playerY - (-64), playerX - startX));
|
|
|
|
async{
|
|
while(!Obj_IsDeleted(enm)){
|
|
if (ObjMove_GetY(enm) <= 64) {ObjEnemy_SetDamageRate(enm, 0, 0);}
|
|
else {ObjEnemy_SetDamageRate(enm, 400, 400);}
|
|
yield;
|
|
}
|
|
}
|
|
|
|
while(!Obj_IsDeleted(enm) && ObjMove_GetY(enm) < STG_HEIGHT * 6/7){
|
|
|
|
int bullet = CreateShotA1(ObjMove_GetX(enm), ObjMove_GetY(enm), spd*1.2, GetAngleToPlayer(enm), KEV_BALL_LAVENDER, 5);
|
|
|
|
_BulletRescale(bullet, 0.75, true, 0.25);
|
|
_Delay(bullet, 5);
|
|
Shoot1;
|
|
|
|
wait(del*10);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
ascent(i in 1..7){
|
|
|
|
CreateEnemyA(i * STG_WIDTH/7);
|
|
|
|
if(i != 7){wait(zakodel);}
|
|
else{}
|
|
|
|
}
|
|
|
|
ascent(i in 1..7){
|
|
|
|
CreateEnemyA((7-i) * STG_WIDTH/7);
|
|
|
|
if(i != 7){wait(zakodel);}
|
|
else{}
|
|
|
|
}
|
|
|
|
while(length(enmFly) > 1){yield;}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
function Wave4(){
|
|
|
|
int del = FUNC_LERP_ACCEL(W4_bulletDelayMax, W4_bulletDelayMin, rank/RANK_MAX);
|
|
float spd = FUNC_LERP_ACCEL(W4_bulletSpdMin, W4_bulletSpdMax, rank/RANK_MAX);
|
|
int spawndel = FUNC_LERP_ACCEL(W4_spawnDelayMax, W4_spawnDelayMin, rank/RANK_MAX);
|
|
int invin = FUNC_LERP_ACCEL(W4_invinTimeMax, W4_invinTimeMin, rank/RANK_MAX);
|
|
float movespd = baseMoveSpeedH * (1 + MoveSpeedRankMultiplierVL*rank);
|
|
|
|
task CreateEnemyA(float startX){
|
|
|
|
int enm = _Oni(
|
|
41, invin,
|
|
startX, -128
|
|
);
|
|
|
|
ObjMove_AddPatternA1(enm, 0, movespd, 90);
|
|
|
|
while(!Obj_IsDeleted(enm) && ObjMove_GetY(enm) < STG_HEIGHT * 4/5){
|
|
|
|
if (ObjMove_GetY(enm) <= 128) {ObjEnemy_SetDamageRate(enm, 0, 0);}
|
|
else {ObjEnemy_SetDamageRate(enm, 100, 100);}
|
|
|
|
int bullet = CreateShotA1(ObjMove_GetX(enm), ObjMove_GetY(enm), spd, GetAngleToPlayer(enm), KEV_FIRE_PINK, 5);
|
|
|
|
_BulletRescale(bullet, 1, true, 1);
|
|
_Delay(bullet, 5);
|
|
Shoot2;
|
|
|
|
wait(del);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
ascent(i in 1..6){
|
|
|
|
CreateEnemyA(1.5*STG_WIDTH/8 + 96);
|
|
CreateEnemyA(1.5*STG_WIDTH/8 - 96);
|
|
|
|
if(i != 6){wait(spawndel);}
|
|
else{}
|
|
|
|
}
|
|
|
|
while(length(enmFly) > 1){yield;}
|
|
|
|
ascent(i in 1..6){
|
|
|
|
CreateEnemyA(6.5*STG_WIDTH/8 - 96);
|
|
CreateEnemyA(6.5*STG_WIDTH/8 + 96);
|
|
|
|
if(i != 6){wait(spawndel);}
|
|
else{}
|
|
|
|
}
|
|
|
|
while(length(enmFly) > 1){yield;}
|
|
|
|
return;
|
|
|
|
|
|
}
|
|
|
|
function Wave5(){
|
|
|
|
float acceltime = FUNC_LERP_ACCEL(W5_accelTimeMax, W5_accelTimeMin, rank/RANK_MAX);
|
|
float bulletwait = FUNC_LERP_ACCEL(W5_bulletWaitTimeMax, W5_bulletWaitTimeMin, rank/RANK_MAX);
|
|
float spd = FUNC_LERP_ACCEL(W5_bulletSpdMin, W5_bulletSpdMax, rank/RANK_MAX);
|
|
float angrange = FUNC_LERP_ACCEL(W5_angRangeMin, W5_angRangeMax, rank/RANK_MAX);
|
|
float del = FUNC_LERP_ACCEL(W5_bulletDelayMax, W5_bulletDelayMin, rank/RANK_MAX);
|
|
float spawndel = FUNC_LERP_ACCEL(W4_spawnDelayMax, W4_spawnDelayMin, rank/RANK_MAX);
|
|
float movespd = min(baseMoveSpeedVH * (1 + MoveSpeedRankMultiplierH * rank) * 1.2, 18);
|
|
|
|
task CreateEnemyA(float startX){
|
|
|
|
float angMove = atan2(playerY - (-96), playerX - startX);
|
|
|
|
int enm = _SmallWitch(
|
|
40, del*20,
|
|
startX, -96
|
|
);
|
|
|
|
ObjMove_AddPatternA1(enm, 0, movespd, angMove);
|
|
ObjRender_SetAngleZ(enm, angMove);
|
|
|
|
while(!Obj_IsDeleted(enm) && ObjMove_GetY(enm) < STG_HEIGHT * 1/2){
|
|
|
|
if (ObjMove_GetY(enm) <= 128) {ObjEnemy_SetDamageRate(enm, 0, 0);}
|
|
else {ObjEnemy_SetDamageRate(enm, 100, 100);}
|
|
|
|
int bullet = CreateShotA1(ObjMove_GetX(enm), ObjMove_GetY(enm), 0, angMove+rand(-angrange, angrange), KEV_LEAF_PINK, 5);
|
|
|
|
_BulletRescale(bullet, 0.75, true, 1);
|
|
_Delay(bullet, 5);
|
|
|
|
ObjMove_AddPatternA2(bullet, bulletwait, NO_CHANGE, NO_CHANGE, spd/acceltime, spd, 0);
|
|
|
|
wait(del);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
ChargeSFX;
|
|
|
|
ascent(i in 1..7){
|
|
|
|
CreateEnemyA(i * STG_WIDTH/7);
|
|
|
|
if(i != 7){wait(spawndel);}
|
|
else{}
|
|
|
|
}
|
|
|
|
while(length(enmFly) > 1){yield;}
|
|
|
|
ChargeSFX;
|
|
|
|
ascent(i in 1..7){
|
|
|
|
CreateEnemyA((7-i) * STG_WIDTH/7);
|
|
|
|
if(i != 7){wait(spawndel);}
|
|
else{}
|
|
|
|
}
|
|
|
|
while(length(enmFly) > 1){yield;}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
function Wave6(){
|
|
|
|
int dense = FUNC_LERP_LINEAR(W6_spiralDenseMin, W6_spiralDenseMax, rank/RANK_MAX);
|
|
int del = FUNC_LERP_ACCEL(W6_bulletDelayMax, W6_bulletDelayMin, rank/RANK_MAX);
|
|
int zakodel = FUNC_LERP_ACCEL(W6_zakospawnDelayMax, W6_zakospawnDelayMin, rank/RANK_MAX);
|
|
int waittime = FUNC_LERP_ACCEL(W6_bulletWaitTimeMax, W6_bulletWaitTimeMin, rank/RANK_MAX);
|
|
float spd = FUNC_LERP_ACCEL(W6_bulletSpdMin, W6_bulletSpdMax, rank/RANK_MAX);
|
|
float angoff = FUNC_LERP_ACCEL(W6_spiralAngOffsetMax, W6_spiralAngOffsetMin, rank/RANK_MAX);
|
|
float movespd = baseMoveSpeedM * (1 + MoveSpeedRankMultiplierL*rank);
|
|
float zakomovespd = baseMoveSpeedVH * (1 + MoveSpeedRankMultiplierL*rank);
|
|
float space = FUNC_LERP_ACCEL(W6_angRangeMin, W6_angRangeMax, rank/RANK_MAX);
|
|
int bulletnum = FUNC_LERP_LINEAR(W6_bulletNumMin, W6_bulletNumMax, rank/RANK_MAX);
|
|
float angStart = rand(0, 360);
|
|
int i = 0;
|
|
|
|
int enmLarge = _LargeWitch(
|
|
40, 90,
|
|
playerX, -144
|
|
);
|
|
|
|
async{
|
|
|
|
ObjMove_AddPatternA1(enmLarge, 0, movespd, 90);
|
|
|
|
while(!Obj_IsDeleted(enmLarge)){
|
|
|
|
if (ObjMove_GetY(enmLarge) <= FUNC_LERP_LINEAR(144, 48, rank/RANK_MAX)) {ObjEnemy_SetDamageRate(enmLarge, 15, 15);}
|
|
else {ObjEnemy_SetDamageRate(enmLarge, 100, 100);}
|
|
|
|
yield;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
while(!Obj_IsDeleted(enmLarge) && ObjMove_GetY(enmLarge) <= STG_HEIGHT * 7/8){
|
|
|
|
ascent(i in 0..dense){
|
|
|
|
int bullet = CreateShotA1(ObjMove_GetX(enmLarge) + 64 * cos(angStart + i * 360/dense), ObjMove_GetY(enmLarge) + 64 * sin(angStart + i * 360/dense), 0, angStart + i * 360/dense, KEV_LEAF_PINK, 5);
|
|
|
|
_BulletRescale(bullet, 0.75, true, 0.25);
|
|
_Delay(bullet, 5);
|
|
ObjMove_AddPatternA2(bullet, waittime, NO_CHANGE, NO_CHANGE, spd/waittime, spd, 0);
|
|
|
|
}
|
|
|
|
angStart += angoff;
|
|
|
|
Shoot2;
|
|
|
|
wait(del);
|
|
|
|
}
|
|
|
|
task CreateEnemyA(float startX){
|
|
|
|
float time = waittime/2;
|
|
|
|
int enm = _Oni(
|
|
39, waittime*1.5,
|
|
startX, -64
|
|
);
|
|
|
|
ObjEnemy_SetDamageRate(enm, 0, 0);
|
|
ObjMove_SetDestAtFrame(enm, startX, STG_HEIGHT * 1/8, time, LERP_DECELERATE);
|
|
|
|
wait(time-1);
|
|
|
|
ObjMove_AddPatternA2(enm, time, NO_CHANGE, 90, zakomovespd/waittime, zakomovespd, 0);
|
|
|
|
async{
|
|
while(!Obj_IsDeleted(enm)){
|
|
if (ObjMove_GetY(enm) <= 0) {ObjEnemy_SetDamageRate(enm, 0, 0);}
|
|
else {ObjEnemy_SetDamageRate(enm, 200, 200);}
|
|
yield;
|
|
}
|
|
}
|
|
|
|
while(!Obj_IsDeleted(enm) && ObjMove_GetY(enm) < STG_HEIGHT * 6/7){
|
|
|
|
CreateFan(
|
|
enm, bulletnum, KEV_FIRE_PINK, 1,
|
|
GetAngleToPlayer(enm), space, spd*1.25, spd*1.25/1.5, 1,
|
|
0, 0,
|
|
PATTERN_FAN, false
|
|
);
|
|
|
|
wait(del*999);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
ascent(i in 1..8){
|
|
|
|
CreateEnemyA(i * STG_WIDTH/8);
|
|
|
|
}
|
|
|
|
wait(waittime/2);
|
|
|
|
while(length(enmFly) > 1){yield;}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
*/
|
|
task _EndShake(shaketime, intensity){
|
|
|
|
float baseintensity = intensity;
|
|
float shakeno = shaketime;
|
|
|
|
ascent(i in 0..shakeno){
|
|
Set2DCameraFocusX(GetStgFrameWidth/2 + rand(-intensity, intensity));
|
|
Set2DCameraFocusY(GetStgFrameHeight/2 + rand(-intensity, intensity));
|
|
intensity = Interpolate_Decelerate(0, baseintensity, 1-i/shakeno);
|
|
shaketime--;
|
|
yield;
|
|
}
|
|
|
|
while(shaketime > 0){yield;}
|
|
|
|
Set2DCameraFocusX(GetStgFrameWidth/2);
|
|
Set2DCameraFocusY(GetStgFrameHeight/2);
|
|
yield;
|
|
}
|
|
|
|
task _ObjShake(objID, shaketime, intensity){
|
|
|
|
float baseX = ObjMove_GetX(objID);
|
|
float baseY = ObjMove_GetY(objID);
|
|
float baseintensity = intensity;
|
|
float shakeno = shaketime;
|
|
|
|
ascent(i in 0..shakeno){
|
|
ObjMove_SetPosition(objID, baseX + rand(-intensity, intensity), baseY + rand(-intensity, intensity)/2);
|
|
intensity = Interpolate_Decelerate(0, baseintensity, 1-i/shakeno);
|
|
shaketime--;
|
|
yield;
|
|
}
|
|
|
|
while(shaketime > 0){yield;}
|
|
|
|
ObjMove_SetPosition(objID, baseX, baseY);
|
|
|
|
yield;
|
|
}
|
|
|
|
task _MagicCircle(int enmID){
|
|
|
|
int circle = _Create2DImage(texEnm, [96*4, 112*4, 176*4, 192*4]);
|
|
Obj_SetRenderPriorityI(circle, 39);
|
|
ObjRender_SetScaleXYZ(circle, 2);
|
|
|
|
while(ObjEnemy_GetInfo(enmID, INFO_LIFE) > 0){
|
|
|
|
ObjRender_SetPosition(circle, ObjRender_GetX(enmID), ObjRender_GetY(enmID), 1);
|
|
ObjRender_SetAngleZ(circle, ObjRender_GetAngleZ(circle)+3);
|
|
|
|
yield;
|
|
|
|
}
|
|
|
|
Obj_Delete(circle);
|
|
}
|
|
|