1618 lines
32 KiB
Plaintext
1618 lines
32 KiB
Plaintext
let texEnm = "script/Jam10/resourceLib/Jam10.png";
|
|
#include "script/Jam10/GunnerParade_ConstLib.dnh"
|
|
|
|
float deadZone = STG_WIDTH - 32;
|
|
float deadZoneB = STG_HEIGHT - 16;
|
|
|
|
LoadTextureEx(texEnm, true, true);
|
|
|
|
task _RenderBossFight(int enemy){
|
|
|
|
int aniidle = 0;
|
|
|
|
//LoadTextureEx(tex, true, true);
|
|
|
|
ObjPrim_SetTexture(enemy, texEnm);
|
|
ObjSprite2D_SetSourceRect(enemy, bossRect[0], bossRect[1], bossRect[2], bossRect[3]);
|
|
ObjSprite2D_SetDestCenter(enemy);
|
|
ObjRender_SetScaleXYZ(enemy, 1);
|
|
|
|
/*
|
|
int nameText = CreateTextObject(
|
|
GetStgFrameWidth()*0.3, 200, 25,
|
|
"REMILIA SCARLET", "Origami Mommy",
|
|
0xFF5A5A, 0xFFFFFF,
|
|
0x791D1D, 3,
|
|
1
|
|
);
|
|
|
|
ObjRender_SetAngleZ(nameText, -90);
|
|
ObjText_SetFontBold(nameText, true);
|
|
*/
|
|
|
|
//_BossMarker(enemy, tex, 512, 0, 768, 256, 0.45, 30);
|
|
|
|
}
|
|
|
|
function <int> CreateUmbrellaEnemy(
|
|
int renderPriority, int[] rect,
|
|
float enmX, enmY, scale, hitbox,
|
|
int invinTime, int killTime, int enmHealth, int itemDropPoint, int itemDropChain
|
|
){
|
|
|
|
// Spawns enemy.
|
|
|
|
int enm = _CreateEnemy(
|
|
enmX, enmY, enmX, enmY, 5,
|
|
scale, scale,
|
|
enmHealth, hitbox, 0,
|
|
texEnm,
|
|
rect[0], rect[1], rect[2], rect[3]);
|
|
|
|
Obj_SetRenderPriorityI(enm, renderPriority);
|
|
|
|
async{
|
|
while(!Obj_IsDeleted(enm)){
|
|
ObjRender_SetAngleZ(enm, ObjRender_GetAngleZ(enm)+1.5);
|
|
yield;
|
|
}
|
|
}
|
|
|
|
async{
|
|
|
|
ObjEnemy_SetDamageRate(enm, 0, 0);
|
|
|
|
wait(invinTime);
|
|
|
|
ObjEnemy_SetAutoDelete(enm, true);
|
|
|
|
}
|
|
|
|
_EnemyItemDrop(
|
|
enm, true,
|
|
itemDropPoint, itemDropChain,
|
|
itemDropPoint*2+(GetCommonDataPtr(RANK_PTR, 1)-1)*2, itemDropChain*2+(GetCommonDataPtr(RANK_PTR, 1)-1)*2,
|
|
killTime, hitbox*2.5
|
|
);
|
|
|
|
return enm;
|
|
|
|
}
|
|
|
|
function <int> CreateFan (int parent, int way, int graphic, int stack,
|
|
float ang, float angspace, float spd1, float spd2, float scaleBullet,
|
|
int type, bool reflect){
|
|
|
|
int objPattern = ObjPatternShot_Create();
|
|
|
|
ObjPatternShot_SetParentObject(objPattern, parent);
|
|
|
|
//if(ObjEnemyBossScene_GetInfo(GetEnemyBossSceneObjectID(), INFO_CURRENT_LIFE) == 0){Obj_Delete(objPattern); return;}
|
|
|
|
ObjPatternShot_SetPatternType(objPattern, type); // PATTERN_FAN or PATTERN_FAN_AIMED
|
|
ObjPatternShot_SetShotType(objPattern, OBJ_SHOT);
|
|
ObjPatternShot_SetInitialBlendMode(objPattern, BLEND_ALPHA);
|
|
|
|
ObjPatternShot_SetShotCount(objPattern, way, stack);
|
|
ObjPatternShot_SetSpeed(objPattern, spd1, spd2);
|
|
ObjPatternShot_SetAngle(objPattern, ang, angspace);
|
|
|
|
ObjPatternShot_SetBasePointOffset(objPattern, 0, 0);
|
|
//ObjPatternShot_SetDelay(objPattern, 15);
|
|
ObjPatternShot_SetGraphic(objPattern, graphic);
|
|
|
|
//Shoot2;
|
|
let arrayPattern = ObjPatternShot_FireReturn(objPattern);
|
|
|
|
ascent(i in -1..length(arrayPattern)-1){
|
|
_BulletRescale(arrayPattern[i], scaleBullet, true, 0.25);
|
|
_Delay(arrayPattern[i], 5);
|
|
//Obj_SetRenderPriorityI(arrayPattern[i], 51);
|
|
}
|
|
|
|
async{
|
|
wait(300);
|
|
Obj_Delete(objPattern);
|
|
return;
|
|
}
|
|
|
|
return objPattern;
|
|
|
|
}
|
|
|
|
// Overload
|
|
|
|
function <int> CreateFan (int parent, int way, int graphic, int stack,
|
|
float ang, float angspace, float spd1, float spd2, float scaleBullet,
|
|
float xOffset, float yOffset,
|
|
int type, bool reflect){
|
|
|
|
int objPattern = ObjPatternShot_Create();
|
|
|
|
ObjPatternShot_SetParentObject(objPattern, parent);
|
|
|
|
//if(ObjEnemyBossScene_GetInfo(GetEnemyBossSceneObjectID(), INFO_CURRENT_LIFE) == 0){Obj_Delete(objPattern); return;}
|
|
|
|
ObjPatternShot_SetPatternType(objPattern, type); // PATTERN_FAN or PATTERN_FAN_AIMED
|
|
ObjPatternShot_SetShotType(objPattern, OBJ_SHOT);
|
|
ObjPatternShot_SetInitialBlendMode(objPattern, BLEND_ALPHA);
|
|
|
|
ObjPatternShot_SetShotCount(objPattern, way, stack);
|
|
ObjPatternShot_SetSpeed(objPattern, spd1, spd2);
|
|
ObjPatternShot_SetAngle(objPattern, ang, angspace);
|
|
|
|
ObjPatternShot_SetBasePointOffset(objPattern, xOffset, yOffset);
|
|
//ObjPatternShot_SetDelay(objPattern, 15);
|
|
ObjPatternShot_SetGraphic(objPattern, graphic);
|
|
|
|
//Shoot2;
|
|
let arrayPattern = ObjPatternShot_FireReturn(objPattern);
|
|
|
|
ascent(i in -1..length(arrayPattern)-1){
|
|
_BulletRescale(arrayPattern[i], scaleBullet, true, 0.25);
|
|
_Delay(arrayPattern[i], 5);
|
|
//Obj_SetRenderPriorityI(arrayPattern[i], 51);
|
|
}
|
|
|
|
async{
|
|
wait(300);
|
|
Obj_Delete(objPattern);
|
|
return;
|
|
}
|
|
|
|
return objPattern;
|
|
|
|
}
|
|
|
|
// Enemy Type 1: Fairy (Wave 1, 2)
|
|
|
|
function <int> _SmallFairy(
|
|
int renderPriority, invinTime,
|
|
float enmX, float enmY
|
|
){
|
|
|
|
// Spawns enemy.
|
|
|
|
int enm = _CreateEnemy(
|
|
enmX, enmY, enmX, enmY, 5,
|
|
smallEnemyScale, smallEnemyScale,
|
|
popcornHP, smallEnemyHitbox, 0,
|
|
texEnm,
|
|
smallfairyRect[0], smallfairyRect[1], smallfairyRect[2], smallfairyRect[3]);
|
|
|
|
Obj_SetRenderPriorityI(enm, renderPriority);
|
|
|
|
int frame = 0;
|
|
|
|
async{
|
|
|
|
while(!Obj_IsDeleted(enm)){
|
|
|
|
ObjSprite2D_SetSourceRect(enm, smallfairyRect[0]+128*floor(frame/6), smallfairyRect[1], smallfairyRect[2]+128*floor(frame/6), smallfairyRect[3]);
|
|
|
|
frame++;
|
|
|
|
if (frame >= (2*6-1)){frame = 0;}
|
|
|
|
yield;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
async{
|
|
|
|
while(!Obj_IsDeleted(enm)){
|
|
|
|
if(ObjMove_GetX(enm) > deadZone){ObjEnemy_SetDamageRate(enm, 0, 0);}
|
|
else{ObjEnemy_SetDamageRate(enm, 100, 100);}
|
|
|
|
yield;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
_EnemyItemDrop(
|
|
enm, true,
|
|
smallFlyingEnm_itemPointMin, smallEnm_itemChainMin,
|
|
smallFlyingEnm_itemPointMax, smallEnm_itemChainMax,
|
|
invinTime*4, smallEnemyHitbox*2
|
|
);
|
|
|
|
return enm;
|
|
|
|
}
|
|
|
|
function <int> _MushroomFairy(
|
|
int renderPriority, invinTime,
|
|
float enmX, float enmY
|
|
){
|
|
|
|
// Spawns enemy.
|
|
|
|
int enm = _CreateEnemy(
|
|
enmX, enmY, enmX, enmY, 5,
|
|
smallEnemyScale, smallEnemyScale,
|
|
mediumEnemyHP, medEnemyHitbox, 0,
|
|
texEnm,
|
|
mushroomfairyRect[0], mushroomfairyRect[1], mushroomfairyRect[2], mushroomfairyRect[3]);
|
|
|
|
Obj_SetRenderPriorityI(enm, renderPriority);
|
|
|
|
int frame = 0;
|
|
|
|
async{
|
|
|
|
while(!Obj_IsDeleted(enm)){
|
|
|
|
ObjSprite2D_SetSourceRect(enm, mushroomfairyRect[0]+192*floor(frame/6), mushroomfairyRect[1], mushroomfairyRect[2]+192*floor(frame/6), mushroomfairyRect[3]);
|
|
|
|
frame++;
|
|
|
|
if (frame >= (2*6-1)){frame = 0;}
|
|
|
|
yield;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
async{
|
|
|
|
while(!Obj_IsDeleted(enm)){
|
|
|
|
if(ObjMove_GetX(enm) > deadZone){ObjEnemy_SetDamageRate(enm, 0, 0);}
|
|
else{ObjEnemy_SetDamageRate(enm, 100, 100);}
|
|
|
|
yield;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
_EnemyItemDrop(
|
|
enm, true,
|
|
smallFlyingEnm_itemPointMin, smallEnm_itemChainMin,
|
|
smallFlyingEnm_itemPointMax, smallEnm_itemChainMax,
|
|
invinTime*5, smallEnemyHitbox*2
|
|
);
|
|
|
|
return enm;
|
|
}
|
|
|
|
function <int> _MushroomFairyAlt(
|
|
int renderPriority, invinTime,
|
|
float enmX, float enmY
|
|
){
|
|
|
|
// Spawns enemy.
|
|
|
|
int enm = _CreateEnemy(
|
|
enmX, enmY, enmX, enmY, 5,
|
|
smallEnemyScale, smallEnemyScale,
|
|
mediumEnemyHP, medEnemyHitbox, 0,
|
|
texEnm,
|
|
mushroomfairyRect[0]+384, mushroomfairyRect[1], mushroomfairyRect[2]+384, mushroomfairyRect[3]);
|
|
|
|
Obj_SetRenderPriorityI(enm, renderPriority);
|
|
|
|
int frame = 0;
|
|
|
|
async{
|
|
|
|
while(!Obj_IsDeleted(enm)){
|
|
|
|
ObjSprite2D_SetSourceRect(enm, mushroomfairyRect[0]+192*floor(frame/6)+384, mushroomfairyRect[1], mushroomfairyRect[2]+192*floor(frame/6)+384, mushroomfairyRect[3]);
|
|
|
|
frame++;
|
|
|
|
if (frame >= (2*6-1)){frame = 0;}
|
|
|
|
yield;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
async{
|
|
|
|
while(!Obj_IsDeleted(enm)){
|
|
|
|
if(ObjMove_GetX(enm) > deadZone){ObjEnemy_SetDamageRate(enm, 0, 0);}
|
|
else{ObjEnemy_SetDamageRate(enm, 100, 100);}
|
|
|
|
yield;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
_EnemyItemDrop(
|
|
enm, true,
|
|
medFlyingEnm_itemPointMin, smallEnm_itemChainMin,
|
|
medFlyingEnm_itemPointMax, smallEnm_itemChainMax,
|
|
invinTime*5, smallEnemyHitbox*2
|
|
);
|
|
|
|
return enm;
|
|
}
|
|
|
|
function <int> _YukiOnna(
|
|
int renderPriority, invinTime,
|
|
float enmX, float enmY
|
|
){
|
|
|
|
// Spawns enemy.
|
|
|
|
int enm = _CreateEnemy(
|
|
enmX, enmY, enmX, enmY, 5,
|
|
smallEnemyScale, smallEnemyScale,
|
|
largeEnemyHP, largeEnemyHitbox, 0,
|
|
texEnm,
|
|
yukionnaRect[0], yukionnaRect[1], yukionnaRect[2], yukionnaRect[3]);
|
|
|
|
Obj_SetRenderPriorityI(enm, renderPriority);
|
|
|
|
async{
|
|
|
|
while(!Obj_IsDeleted(enm)){
|
|
|
|
if(ObjMove_GetX(enm) > deadZone){ObjEnemy_SetDamageRate(enm, 0, 0);}
|
|
else{ObjEnemy_SetDamageRate(enm, 100, 100);}
|
|
|
|
yield;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
_EnemyItemDrop(
|
|
enm, true,
|
|
largeFlyingEnm_itemPointMin, smallEnm_itemChainMin,
|
|
largeFlyingEnm_itemPointMax, smallEnm_itemChainMax,
|
|
invinTime*6, largeEnemyHitbox*2
|
|
);
|
|
|
|
return enm;
|
|
}
|
|
|
|
// Enemy Type 2: Oni/Bird (Wave 4)
|
|
|
|
function <int> _Spirit(
|
|
int renderPriority, invinTime,
|
|
float enmX, float enmY
|
|
){
|
|
|
|
// Spawns enemy.
|
|
|
|
int enm = _CreateEnemy(
|
|
enmX, enmY, enmX, enmY, 5,
|
|
smallEnemyScale, smallEnemyScale,
|
|
smallEnemyHP, spiritHitbox, 0,
|
|
texEnm,
|
|
spiritRect[0], spiritRect[1], spiritRect[2], spiritRect[3]);
|
|
|
|
Obj_SetRenderPriorityI(enm, renderPriority);
|
|
|
|
int frame = 0;
|
|
|
|
async{
|
|
|
|
while(!Obj_IsDeleted(enm)){
|
|
|
|
ObjSprite2D_SetSourceRect(enm, spiritRect[0]+128*floor(frame/6), spiritRect[1], spiritRect[2]+128*floor(frame/6), spiritRect[3]);
|
|
|
|
frame++;
|
|
|
|
if (frame >= (2*6-1)){frame = 0;}
|
|
|
|
yield;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
async{
|
|
|
|
while(!Obj_IsDeleted(enm)){
|
|
|
|
if(ObjMove_GetX(enm) > deadZone){ObjEnemy_SetDamageRate(enm, 0, 0);}
|
|
else{ObjEnemy_SetDamageRate(enm, 100, 100);}
|
|
|
|
yield;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
_EnemyItemDrop(
|
|
enm, true,
|
|
smallFlyingEnm_itemPointMin, smallEnm_itemChainMin,
|
|
smallFlyingEnm_itemPointMax, smallEnm_itemChainMax,
|
|
invinTime*4, smallEnemyHitbox*2
|
|
);
|
|
|
|
return enm;
|
|
|
|
}
|
|
|
|
// Enemy Type 3: Witch/Dancer (Wave 5)
|
|
|
|
/*
|
|
function <int> _SmallWitch(
|
|
int renderPriority, invinTime,
|
|
float enmX, float enmY
|
|
){
|
|
|
|
// Spawns enemy.
|
|
|
|
int enm = _CreateEnemy(
|
|
enmX, enmY, enmX, enmY, 5,
|
|
smallEnemyScale, smallEnemyScale*1.5,
|
|
smallEnemyHP, smallEnemyHitbox, 0,
|
|
texEnm,
|
|
smallwitchRect[0], smallwitchRect[1], smallwitchRect[2], smallwitchRect[3]);
|
|
|
|
Obj_SetRenderPriorityI(enm, renderPriority);
|
|
|
|
async{
|
|
|
|
ObjEnemy_SetDamageRate(enm, 0, 0);
|
|
wait(5);
|
|
ObjEnemy_SetAutoDelete(enm, true);
|
|
wait(invinTime-5);
|
|
ObjEnemy_SetDamageRate(enm, 100, 100);
|
|
|
|
}
|
|
|
|
_EnemyItemDrop(
|
|
enm, true,
|
|
smallFlyingEnm_itemPointMin, smallEnm_itemChainMin,
|
|
smallFlyingEnm_itemPointMax, smallEnm_itemChainMax,
|
|
invinTime*2, smallEnemyHitbox*2
|
|
);
|
|
|
|
return enm;
|
|
|
|
}
|
|
|
|
function <int> _LargeWitch(
|
|
int renderPriority, invinTime,
|
|
float enmX, float enmY
|
|
){
|
|
|
|
// Spawns enemy.
|
|
|
|
int enm = _CreateEnemy(
|
|
enmX, enmY, enmX, enmY, 5,
|
|
largeEnemyScale, largeEnemyScale,
|
|
largeEnemyHP, largeEnemyHitbox, 0,
|
|
texEnm,
|
|
largewitchRect[0], largewitchRect[1], largewitchRect[2], largewitchRect[3]);
|
|
|
|
Obj_SetRenderPriorityI(enm, renderPriority);
|
|
|
|
async{
|
|
|
|
ObjEnemy_SetDamageRate(enm, 0, 0);
|
|
wait(5);
|
|
ObjEnemy_SetAutoDelete(enm, true);
|
|
wait(invinTime-5);
|
|
ObjEnemy_SetDamageRate(enm, 100, 100);
|
|
|
|
}
|
|
|
|
_EnemyItemDrop(
|
|
enm, true,
|
|
largeFlyingEnm_itemPointMin, largeEnm_itemChainMin,
|
|
largeFlyingEnm_itemPointMax, largeEnm_itemChainMax,
|
|
invinTime*2, largeEnemyHitbox*2
|
|
);
|
|
|
|
return enm;
|
|
|
|
}
|
|
|
|
function <int> _LargeDancer(
|
|
int renderPriority, invinTime,
|
|
float enmX, float enmY
|
|
){
|
|
|
|
// Spawns enemy.
|
|
|
|
int enm = _CreateEnemy(
|
|
enmX, enmY, enmX, enmY, 5,
|
|
largeEnemyScale, largeEnemyScale,
|
|
largeEnemyHP, largeEnemyHitbox, 0,
|
|
texEnm,
|
|
largedancerRect[0], largedancerRect[1], largedancerRect[2], largedancerRect[3]);
|
|
|
|
Obj_SetRenderPriorityI(enm, renderPriority);
|
|
|
|
async{
|
|
|
|
ObjEnemy_SetDamageRate(enm, 0, 0);
|
|
wait(5);
|
|
ObjEnemy_SetAutoDelete(enm, true);
|
|
wait(invinTime-5);
|
|
ObjEnemy_SetDamageRate(enm, 100, 100);
|
|
|
|
}
|
|
|
|
_EnemyItemDrop(
|
|
enm, true,
|
|
largeFlyingEnm_itemPointMin, largeEnm_itemChainMin,
|
|
largeFlyingEnm_itemPointMax, largeEnm_itemChainMax,
|
|
invinTime*2, largeEnemyHitbox*2
|
|
);
|
|
|
|
return enm;
|
|
|
|
}
|
|
|
|
function <int> _Fish(
|
|
int renderPriority, invinTime,
|
|
float enmX, float enmY
|
|
){
|
|
|
|
// Spawns enemy.
|
|
|
|
int enm = _CreateEnemy(
|
|
enmX, enmY, enmX, enmY, 5,
|
|
smallEnemyScale, smallEnemyScale,
|
|
smallEnemyHP, smallEnemyHitbox, 0,
|
|
texEnm,
|
|
1280, 768, 1280+256, 768+256);
|
|
|
|
Obj_SetRenderPriorityI(enm, renderPriority);
|
|
|
|
async{
|
|
|
|
ObjEnemy_SetDamageRate(enm, 0, 0);
|
|
wait(5);
|
|
ObjEnemy_SetAutoDelete(enm, true);
|
|
wait(invinTime-5);
|
|
ObjEnemy_SetDamageRate(enm, 100, 100);
|
|
|
|
}
|
|
|
|
_EnemyItemDrop(
|
|
enm, true,
|
|
smallFlyingEnm_itemPointMin, smallEnm_itemChainMin,
|
|
smallFlyingEnm_itemPointMax, smallEnm_itemChainMax,
|
|
invinTime*2, smallEnemyHitbox*2
|
|
);
|
|
|
|
return enm;
|
|
|
|
}
|
|
|
|
// Ground Enemy 1
|
|
|
|
task _CreateSign1(
|
|
int renderPriority, invinTime,
|
|
float enmX, float enmY, float movespd
|
|
){
|
|
|
|
int enm = _CreateEnemy(
|
|
enmX, enmY, enmX, enmY, 5,
|
|
popcornScale, popcornScale,
|
|
popcornHP, popcornHitbox, 0,
|
|
texEnm,
|
|
sign1Rect[0], sign1Rect[1], sign1Rect[2], sign1Rect[3]);
|
|
|
|
Obj_SetRenderPriorityI(enm, renderPriority);
|
|
|
|
ObjMove_SetSpeed(enm, movespd);
|
|
ObjMove_SetAngle(enm, 90);
|
|
|
|
async{
|
|
|
|
ObjEnemy_SetDamageRate(enm, 0, 0);
|
|
|
|
wait(invinTime);
|
|
|
|
ObjEnemy_SetAutoDelete(enm, true);
|
|
|
|
}
|
|
|
|
_EnemyItemDrop(
|
|
enm, false,
|
|
1, smallEnm_itemChainMin, smallGroundEnm_itemAmmoMin,
|
|
smallFlyingEnm_itemPointMax/2, smallEnm_itemChainMax, smallGroundEnm_itemAmmoMax,
|
|
invinTime*2, popcornHitbox*2
|
|
);
|
|
|
|
}
|
|
|
|
function <int> _CreateSign1A(
|
|
int renderPriority, invinTime,
|
|
float enmX, float enmY, float movespd
|
|
){
|
|
|
|
int enm = _CreateEnemy(
|
|
enmX, enmY, enmX, enmY, 5,
|
|
popcornScale, popcornScale,
|
|
popcornHP, popcornHitbox, 0,
|
|
texEnm,
|
|
sign2Rect[0], sign2Rect[1], sign2Rect[2], sign2Rect[3]);
|
|
|
|
Obj_SetRenderPriorityI(enm, renderPriority);
|
|
|
|
ObjMove_SetSpeed(enm, movespd);
|
|
ObjMove_SetAngle(enm, 90);
|
|
|
|
async{
|
|
|
|
ObjEnemy_SetDamageRate(enm, 0, 0);
|
|
|
|
wait(invinTime);
|
|
|
|
ObjEnemy_SetAutoDelete(enm, true);
|
|
|
|
}
|
|
|
|
_EnemyItemDrop(
|
|
enm, false,
|
|
smallFlyingEnm_itemPointMin, smallEnm_itemChainMin, smallGroundEnm_itemAmmoMin,
|
|
smallFlyingEnm_itemPointMax, smallEnm_itemChainMax, smallGroundEnm_itemAmmoMax,
|
|
invinTime*2, popcornHitbox*2
|
|
);
|
|
|
|
return enm;
|
|
}
|
|
|
|
// Ground Enemy 2
|
|
|
|
function <int> _CreateCannon1(
|
|
int renderPriority, invinTime,
|
|
float enmX, float enmY, float movespd
|
|
){
|
|
|
|
int enm = _CreateEnemy(
|
|
enmX, enmY, enmX, enmY, 5,
|
|
1, 1,
|
|
mediumEnemyHP, largeEnemyHitbox, 0,
|
|
texEnm,
|
|
cannonRect[0], cannonRect[1], cannonRect[2], cannonRect[3]);
|
|
|
|
Obj_SetRenderPriorityI(enm, renderPriority);
|
|
|
|
ObjMove_SetSpeed(enm, movespd);
|
|
ObjMove_SetAngle(enm, 90);
|
|
|
|
async{
|
|
|
|
ObjEnemy_SetDamageRate(enm, 0, 0);
|
|
|
|
wait(invinTime);
|
|
|
|
ObjEnemy_SetAutoDelete(enm, true);
|
|
|
|
}
|
|
|
|
_EnemyItemDrop(
|
|
enm, false,
|
|
smallFlyingEnm_itemPointMin, mediumEnm_itemChainMin, medGroundEnm_itemAmmoMin,
|
|
smallFlyingEnm_itemPointMax, mediumEnm_itemChainMax, medGroundEnm_itemAmmoMax,
|
|
invinTime*3, largeEnemyHitbox*2
|
|
);
|
|
|
|
return enm;
|
|
|
|
}
|
|
|
|
// 6 signs
|
|
|
|
task _SignPlatform1(
|
|
int renderPriority, invinTime,
|
|
float platformX, float platformY, float movespd
|
|
){
|
|
|
|
int enmPad = _CreateEnemy(
|
|
false,
|
|
platformX, platformY, platformX, platformY, 5,
|
|
0.6, 0.6,
|
|
999, 0, 0,
|
|
texEnm,
|
|
platformRect[0], platformRect[1], platformRect[2], platformRect[3]);
|
|
|
|
float offsetX = 128, offsetY = 64;
|
|
|
|
Obj_SetRenderPriorityI(enmPad, renderPriority);
|
|
|
|
ObjMove_SetSpeed(enmPad, movespd);
|
|
ObjMove_SetAngle(enmPad, 90);
|
|
|
|
ObjEnemy_SetDamageRate(enmPad, 0, 0);
|
|
|
|
async{
|
|
|
|
ascent(i in 0..3){
|
|
|
|
_CreateSign1(
|
|
renderPriority+1, invinTime,
|
|
platformX-128+(offsetX*2)-(offsetX*i), platformY-offsetY-offsetY*0.5, movespd
|
|
);
|
|
|
|
}
|
|
|
|
ascent(i in 0..3){
|
|
|
|
_CreateSign1(
|
|
renderPriority+2, invinTime,
|
|
platformX-128+(offsetX*2)-(offsetX*i), platformY+offsetY-offsetY*0.5, movespd
|
|
);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
wait(invinTime);
|
|
|
|
ObjEnemy_SetAutoDelete(enmPad, true);
|
|
|
|
}
|
|
|
|
// 3 signs per platform, straight line
|
|
|
|
function <int[]> _SignPlatform1A(
|
|
int renderPriority, invinTime,
|
|
float platformX, float platformY, float movespd
|
|
){
|
|
|
|
int[] signs = [];
|
|
|
|
int enmPad = _CreateEnemy(
|
|
false,
|
|
platformX, platformY, platformX, platformY, 5,
|
|
0.8, 0.8,
|
|
999, 0, 0,
|
|
texEnm,
|
|
platformRect[0], platformRect[1], platformRect[2], platformRect[3]);
|
|
|
|
float offsetX = 128, offsetY = 64;
|
|
|
|
Obj_SetRenderPriorityI(enmPad, renderPriority);
|
|
|
|
ObjMove_SetSpeed(enmPad, movespd);
|
|
ObjMove_SetAngle(enmPad, 90);
|
|
|
|
ObjEnemy_SetDamageRate(enmPad, 0, 0);
|
|
|
|
async{
|
|
|
|
ascent(i in 0..3){
|
|
|
|
int sign = _CreateSign1A(
|
|
renderPriority+1, invinTime,
|
|
platformX-128+(offsetX*2)-(offsetX*i), platformY-offsetY-offsetY*0.5, movespd
|
|
);
|
|
|
|
signs ~= [sign];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
async{
|
|
wait(invinTime);
|
|
|
|
ObjEnemy_SetAutoDelete(enmPad, true);
|
|
}
|
|
|
|
return signs;
|
|
|
|
}
|
|
|
|
// A Bussy
|
|
|
|
function <int[]> _CreateCannonBush(
|
|
int renderPriority, invinTime,
|
|
float platformX, float platformY, float movespd
|
|
){
|
|
|
|
int[] signs = [];
|
|
|
|
int enmPad = _CreateEnemy(
|
|
false,
|
|
platformX, platformY, platformX, platformY, 5,
|
|
1.2, 1.2,
|
|
999, 0, 0,
|
|
texEnm,
|
|
bushRect[0], bushRect[1], bushRect[2], bushRect[3]);
|
|
|
|
float offsetX = 280, offsetY = 64;
|
|
|
|
Obj_SetRenderPriorityI(enmPad, renderPriority);
|
|
|
|
ObjMove_SetSpeed(enmPad, movespd);
|
|
ObjMove_SetAngle(enmPad, 90);
|
|
|
|
ObjEnemy_SetDamageRate(enmPad, 0, 0);
|
|
|
|
async{
|
|
|
|
ascent(i in -1..1){
|
|
|
|
int enm = _CreateCannon1(
|
|
renderPriority+1, invinTime,
|
|
platformX-[135, -135][i], platformY, movespd
|
|
);
|
|
|
|
signs ~= [enm];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
async{
|
|
|
|
wait(invinTime);
|
|
|
|
ObjEnemy_SetAutoDelete(enmPad, true);
|
|
|
|
}
|
|
|
|
return signs;
|
|
|
|
}
|
|
|
|
// A Bussy for Only The BIGGEST BITCHES IN TOWN (additional zako not included)
|
|
|
|
function <int> _CreateDangerBush(
|
|
int renderPriority, invinTime,
|
|
float platformX, float platformY, float movespd
|
|
){
|
|
|
|
int enmPad = _CreateEnemy(
|
|
true,
|
|
platformX, platformY, platformX, platformY, 5,
|
|
1, 1,
|
|
largeEnemyHP, largeEnemyHitbox*2.5, 0,
|
|
texEnm,
|
|
bush2Rect[0], bush2Rect[1], bush2Rect[2], bush2Rect[3]);
|
|
|
|
float offsetX = 280, offsetY = 64;
|
|
float x = 0, y = 0;
|
|
|
|
Obj_SetRenderPriorityI(enmPad, renderPriority);
|
|
|
|
ObjMove_SetSpeed(enmPad, movespd);
|
|
ObjMove_SetAngle(enmPad, 90);
|
|
|
|
ObjEnemy_SetDamageRate(enmPad, 0, 0);
|
|
|
|
// Sigil
|
|
async{
|
|
|
|
if(GetCommonData("Ground Loops Cleared", 0) % 2 == 0 && GetCommonData("Ground Loops Cleared", 0) != 0 && GetCommonData("Difficulty", "Standard") != "Extra"){
|
|
|
|
int sigil = _Create2DImage(texEnm, [0, 1024, 512, 1536]);
|
|
ObjRender_SetAlpha(sigil, 180);
|
|
Obj_SetRenderPriorityI(sigil, Obj_GetRenderPriorityI(enmPad)+1);
|
|
|
|
while(ObjEnemy_GetInfo(enmPad, INFO_LIFE) > 0){
|
|
ObjRender_SetPosition(sigil, ObjMove_GetX(enmPad), ObjMove_GetY(enmPad), 1);
|
|
ObjRender_SetAngleZ(sigil, ObjRender_GetAngleZ(sigil)+1.5);
|
|
yield;
|
|
}
|
|
|
|
Obj_Delete(sigil);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// Drops
|
|
async{
|
|
|
|
while(!Obj_IsDeleted(enmPad)){
|
|
|
|
x = ObjMove_GetX(enmPad);
|
|
y = ObjMove_GetY(enmPad);
|
|
|
|
if (y < STG_HEIGHT/8) {ObjEnemy_SetDamageRate(enmPad, 0, 0);}
|
|
else {ObjEnemy_SetDamageRate(enmPad, 100, 100);}
|
|
|
|
yield;
|
|
}
|
|
|
|
if(
|
|
(-128 < x && x < STG_WIDTH+128)
|
|
&&
|
|
(y < STG_HEIGHT+128)
|
|
)
|
|
{
|
|
DeleteShotInCircle(TYPE_SHOT, TYPE_ITEM, x, y, 256);
|
|
ObjSound_Play(bossBoom);
|
|
if(GetCommonData("Ground Loops Cleared", 0) % 2 == 0 && GetCommonData("Ground Loops Cleared", 0) != 0 && GetCommonData("Difficulty", "Standard") != "Extra"){CreateExtendItem(EXTEND_SPELL, x, y);}
|
|
TExplosionA(x, y, 10, 0.5);
|
|
}
|
|
|
|
}
|
|
|
|
// Shake
|
|
async{
|
|
|
|
while(!Obj_IsDeleted(enmPad)){
|
|
float value = rand(-4, 4);
|
|
ObjMove_SetPosition(enmPad, x + value, y + value);
|
|
yield;
|
|
}
|
|
|
|
}
|
|
|
|
async{
|
|
|
|
wait(invinTime);
|
|
|
|
ObjEnemy_SetAutoDelete(enmPad, true);
|
|
ObjEnemy_SetDamageRate(enmPad, 100, 100);
|
|
|
|
}
|
|
|
|
_EnemyItemDrop(
|
|
enmPad, false,
|
|
medFlyingEnm_itemPointMin, mediumEnm_itemChainMin, verylargeGroundEnm_itemAmmoMin,
|
|
medFlyingEnm_itemPointMax, mediumEnm_itemChainMax, verylargeGroundEnm_itemAmmoMax,
|
|
invinTime*3, largeEnemyHitbox*3.5
|
|
);
|
|
|
|
return enmPad;
|
|
|
|
}
|
|
|
|
function <int> _CreateBushRemnant(
|
|
int renderPriority, invinTime,
|
|
float enmX, float enmY
|
|
){
|
|
|
|
// Spawns enemy.
|
|
|
|
int enm = _CreateEnemy(
|
|
enmX, enmY, enmX, enmY, 5,
|
|
smallEnemyScale, smallEnemyScale,
|
|
smallEnemyHP, smallEnemyHitbox, 0,
|
|
texEnm,
|
|
bush2ARect[0], bush2ARect[1], bush2ARect[2], bush2ARect[3]);
|
|
|
|
Obj_SetRenderPriorityI(enm, renderPriority);
|
|
|
|
async{
|
|
|
|
ObjEnemy_SetDamageRate(enm, 0, 0);
|
|
wait(5);
|
|
ObjEnemy_SetAutoDelete(enm, true);
|
|
wait(invinTime-5);
|
|
ObjEnemy_SetDamageRate(enm, 100, 100);
|
|
|
|
}
|
|
|
|
_EnemyItemDrop(
|
|
enm, true,
|
|
smallFlyingEnm_itemPointMin/2, smallEnm_itemChainMin/2, smallGroundEnm_itemAmmoMin,
|
|
smallFlyingEnm_itemPointMax/2, smallEnm_itemChainMax/2, smallGroundEnm_itemAmmoMax,
|
|
invinTime*2, smallEnemyHitbox*2
|
|
);
|
|
|
|
return enm;
|
|
|
|
}
|
|
|
|
// Ships
|
|
|
|
function <int> _CreateRybb(
|
|
int renderPriority, invinTime,
|
|
float enmX, float enmY, float moveSpd
|
|
){
|
|
|
|
int enm = _CreateEnemy(
|
|
enmX, enmY, enmX, enmY, 5,
|
|
1.5, 1.5,
|
|
largeEnemyAltHP, largeEnemyHitbox*2, 0,
|
|
texEnm,
|
|
rybbRect[0], rybbRect[1], rybbRect[2], rybbRect[3]);
|
|
|
|
Obj_SetRenderPriorityI(enm, renderPriority);
|
|
|
|
ObjMove_SetSpeed(enm, moveSpd);
|
|
ObjMove_SetAngle(enm, 90);
|
|
ObjRender_SetAngleZ(enm, 180);
|
|
|
|
float x = 0, y = 0;
|
|
|
|
async{
|
|
|
|
ObjEnemy_SetDamageRate(enm, 0, 0);
|
|
|
|
wait(invinTime);
|
|
|
|
ObjEnemy_SetDamageRate(enm, 100, 100);
|
|
ObjEnemy_SetAutoDelete(enm, true);
|
|
|
|
}
|
|
|
|
async{
|
|
|
|
while(!Obj_IsDeleted(enm)){
|
|
|
|
x = ObjMove_GetX(enm);
|
|
y = ObjMove_GetY(enm);
|
|
|
|
yield;
|
|
}
|
|
|
|
if(
|
|
(-128 < x && x < STG_WIDTH+128)
|
|
&&
|
|
(y < STG_HEIGHT+128)
|
|
)
|
|
{
|
|
DeleteShotInCircle(TYPE_SHOT, TYPE_ITEM, x, y, 256);
|
|
ObjSound_Play(bossBoom);
|
|
TExplosionA(x, y, 10, 0.5);
|
|
}
|
|
|
|
}
|
|
|
|
_EnemyItemDrop(
|
|
enm, false,
|
|
verylargeFlyingEnm_itemPointMin, largeEnm_itemChainMin, verylargeGroundEnm_itemAmmoMin,
|
|
verylargeFlyingEnm_itemPointMax, largeEnm_itemChainMax, verylargeGroundEnm_itemAmmoMax,
|
|
invinTime*2, largeEnemyHitbox*4
|
|
);
|
|
|
|
return enm;
|
|
|
|
}
|
|
|
|
function <int> _CreateDecker(
|
|
int renderPriority, invinTime,
|
|
float enmX, float enmY, float moveSpd
|
|
){
|
|
|
|
int enm = _CreateEnemy(
|
|
enmX, enmY, enmX, enmY, 5,
|
|
1.5, 1.5,
|
|
largeEnemyAltHP, largeEnemyHitbox*2, 0,
|
|
texEnm,
|
|
deckerRect[0], deckerRect[1], deckerRect[2], deckerRect[3]);
|
|
|
|
Obj_SetRenderPriorityI(enm, renderPriority);
|
|
|
|
ObjRender_SetAngleZ(enm, 180);
|
|
|
|
float x = 0, y = 0;
|
|
|
|
async{
|
|
|
|
while(!Obj_IsDeleted(enm)){
|
|
|
|
x = ObjMove_GetX(enm);
|
|
y = ObjMove_GetY(enm);
|
|
|
|
yield;
|
|
}
|
|
|
|
if(
|
|
(-128 < x && x < STG_WIDTH+128)
|
|
&&
|
|
(y < STG_HEIGHT+128)
|
|
)
|
|
{
|
|
DeleteShotInCircle(TYPE_SHOT, TYPE_ITEM, x, y, 256);
|
|
ObjSound_Play(bossBoom);
|
|
TExplosionA(x, y, 10, 0.5);
|
|
}
|
|
|
|
}
|
|
|
|
async{
|
|
|
|
ObjEnemy_SetDamageRate(enm, 0, 0);
|
|
|
|
wait(invinTime);
|
|
|
|
ObjEnemy_SetDamageRate(enm, 100, 100);
|
|
ObjEnemy_SetAutoDelete(enm, true);
|
|
|
|
}
|
|
|
|
_EnemyItemDrop(
|
|
enm, false,
|
|
verylargeFlyingEnm_itemPointMin, largeEnm_itemChainMin, verylargeGroundEnm_itemAmmoMin,
|
|
verylargeFlyingEnm_itemPointMax, largeEnm_itemChainMax, verylargeGroundEnm_itemAmmoMax,
|
|
invinTime*2, largeEnemyHitbox*4
|
|
);
|
|
|
|
return enm;
|
|
|
|
}
|
|
|
|
// Formation 2
|
|
|
|
task _SmallFairyRing(
|
|
int renderPriority, int graphicBullet,
|
|
float enmX, enmY,
|
|
int denseRing, float delayRing, float speedRing,
|
|
float spdMove, angMove, scaleBullet
|
|
){
|
|
|
|
// Spawns enemy.
|
|
|
|
int enm = _CreateEnemy(
|
|
enmX, enmY, enmX, enmY, 5,
|
|
smallEnemyScale, smallEnemyScale,
|
|
smallEnemyHP, smallEnemyHitbox, 0,
|
|
texEnm,
|
|
768, 0, 1024, 256);
|
|
|
|
Obj_SetRenderPriorityI(enm, renderPriority);
|
|
|
|
ObjMove_SetSpeed(enm, spdMove);
|
|
ObjMove_SetAngle(enm, angMove);
|
|
|
|
ObjEnemy_SetDamageRate(enm, 0, 0);
|
|
|
|
wait(5);
|
|
|
|
ObjEnemy_SetAutoDelete(enm, true);
|
|
|
|
async{
|
|
|
|
wait(5);
|
|
|
|
while(ObjEnemy_GetInfo(enm, INFO_LIFE) > 0){
|
|
|
|
if(ObjMove_GetX(enm) < STG_WIDTH && ObjMove_GetX(enm) > 0){
|
|
|
|
ascent(i in -1..denseRing){
|
|
|
|
int bullet = CreateShotA1(ObjMove_GetX(enm), ObjMove_GetY(enm), speedRing, GetAngleToPlayer(enm)+i*360/denseRing, graphicBullet, 10);
|
|
|
|
_BulletRescale(bullet, scaleBullet, true, 1);
|
|
_Delay(bullet, 10);
|
|
|
|
if(ObjEnemy_GetInfo(enm, INFO_LIFE) <= 0){Obj_Delete(bullet);}
|
|
else{
|
|
Shoot1;
|
|
}
|
|
|
|
}
|
|
|
|
wait(delayRing);
|
|
|
|
}
|
|
|
|
else{yield;}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
_EnemyItemDrop(
|
|
enm, true,
|
|
5, 3,
|
|
10+(GetCommonDataPtr(RANK_PTR, 1)-1)*2, 6+(GetCommonDataPtr(RANK_PTR, 1)-1)*1,
|
|
120, smallEnemyHitbox*2
|
|
);
|
|
|
|
}
|
|
|
|
// Enemy Type 2 : Jack o Lanterns (ground enemies)
|
|
|
|
// Formation 1: Groups of 8 mini-lanterns. Does nothing.
|
|
// Formation 2: Groups of 4 midsize-lanterns. Fires aimed fans.
|
|
|
|
task _CreateLanternSmall(
|
|
int renderPriority, int graphicBullet,
|
|
float angspaceFan, float speedFan1, float speedFan2, int widthFan, int stackFan, int delayFan,
|
|
float enmX, enmY, speedMove, scaleBullet
|
|
){
|
|
|
|
int enm = _CreateEnemy(
|
|
enmX, enmY, enmX, enmY, 5,
|
|
popcornScale, popcornScale,
|
|
popcornHP, popcornHitbox, 0,
|
|
texEnm,
|
|
1024, 512, 1280, 768);
|
|
|
|
Obj_SetRenderPriorityI(enm, renderPriority);
|
|
|
|
ObjMove_SetSpeed(enm, speedMove);
|
|
ObjMove_SetAngle(enm, 90);
|
|
|
|
async{
|
|
|
|
ObjEnemy_SetDamageRate(enm, 0, 0);
|
|
|
|
wait(15);
|
|
|
|
ObjEnemy_SetAutoDelete(enm, true);
|
|
|
|
}
|
|
|
|
_EnemyItemDrop(
|
|
enm, false,
|
|
6, 8,
|
|
10+round((GetCommonDataPtr(RANK_PTR, 1)-1)*1.5), 12+(GetCommonDataPtr(RANK_PTR, 1)-1)*1.5,
|
|
120, popcornHitbox*2
|
|
);
|
|
|
|
}
|
|
|
|
task _CreateLanternMid(
|
|
int renderPriority, int graphicBullet,
|
|
float angspaceFan, float speedFan1, float speedFan2, int widthFan, int stackFan, int delayFan,
|
|
float enmX, enmY, speedMove, scaleBullet
|
|
){
|
|
|
|
int enm = _CreateEnemy(
|
|
enmX, enmY, enmX, enmY, 5,
|
|
smallEnemyScale, smallEnemyScale,
|
|
smallEnemyHP, smallEnemyHitbox, 0,
|
|
texEnm,
|
|
1280, 768, 1536, 1024);
|
|
|
|
Obj_SetRenderPriorityI(enm, renderPriority);
|
|
|
|
ObjMove_SetSpeed(enm, speedMove);
|
|
ObjMove_SetAngle(enm, 90);
|
|
|
|
async{
|
|
|
|
ObjEnemy_SetDamageRate(enm, 0, 0);
|
|
|
|
wait(15);
|
|
|
|
ObjEnemy_SetAutoDelete(enm, true);
|
|
|
|
}
|
|
|
|
async{
|
|
|
|
wait(speedMove*2);
|
|
|
|
while(ObjEnemy_GetInfo(enm, INFO_LIFE) > 0){
|
|
|
|
if(ObjMove_GetY(enm) < 10*STG_HEIGHT/12-100 && ObjMove_GetY(enm) > STG_HEIGHT/9){
|
|
|
|
int bullet = CreateFan(enm, widthFan, graphicBullet, stackFan,
|
|
0, angspaceFan, speedFan1, speedFan2, scaleBullet,
|
|
PATTERN_FAN_AIMED, false);
|
|
|
|
if(ObjEnemy_GetInfo(enm, INFO_LIFE) <= 0){Obj_Delete(bullet);}
|
|
else{
|
|
Shoot1;
|
|
}
|
|
|
|
wait(delayFan);
|
|
|
|
}
|
|
|
|
else{yield;}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
_EnemyItemDrop(
|
|
enm, false,
|
|
12, 10,
|
|
20+round((GetCommonDataPtr(RANK_PTR, 1)-1)*1.5), 16+(GetCommonDataPtr(RANK_PTR, 1)-1)*2,
|
|
120, smallEnemyHitbox*2
|
|
);
|
|
|
|
}
|
|
|
|
task _SmallLanternFormation(
|
|
int renderEnm, int graphicBullet,
|
|
float padX, float padY,
|
|
float angspaceFan, float speedFan1, float speedFan2, int widthFan, int stackFan, int delayFan, float scaleBullet,
|
|
float speedMove
|
|
){
|
|
|
|
float offsetX = 80;
|
|
float offsetY = 70;
|
|
|
|
int enmPad = _CreateEnemy(
|
|
false,
|
|
padX, padY, padX, padY, 5,
|
|
1, 1,
|
|
999, 0, 0,
|
|
texEnm,
|
|
1536, 256, 2048, 768);
|
|
|
|
Obj_SetRenderPriorityI(enmPad, renderEnm-4);
|
|
|
|
ObjMove_SetSpeed(enmPad, speedMove);
|
|
ObjMove_SetAngle(enmPad, 90);
|
|
|
|
ObjEnemy_SetDamageRate(enmPad, 0, 0);
|
|
|
|
wait(5);
|
|
|
|
ObjEnemy_SetAutoDelete(enmPad, true);
|
|
|
|
async{
|
|
|
|
_CreateLanternSmall(
|
|
renderEnm, graphicBullet,
|
|
angspaceFan, speedFan1, speedFan2, widthFan, stackFan, delayFan,
|
|
padX+offsetX, padY+offsetY, speedMove, scaleBullet
|
|
);
|
|
_CreateLanternSmall(
|
|
renderEnm, graphicBullet,
|
|
angspaceFan, speedFan1, speedFan2, widthFan, stackFan, delayFan,
|
|
padX-offsetX, padY+offsetY, speedMove, scaleBullet
|
|
);
|
|
|
|
_CreateLanternSmall(
|
|
renderEnm-1, graphicBullet,
|
|
angspaceFan, speedFan1, speedFan2, widthFan, stackFan, delayFan,
|
|
padX+offsetX, padY-offsetY, speedMove, scaleBullet
|
|
);
|
|
_CreateLanternSmall(
|
|
renderEnm-1, graphicBullet,
|
|
angspaceFan, speedFan1, speedFan2, widthFan, stackFan, delayFan,
|
|
padX-offsetX, padY-offsetY, speedMove, scaleBullet
|
|
);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
task _MidLanternFormation(
|
|
int renderEnm, int graphicBullet,
|
|
float padX, float padY,
|
|
float angspaceFan, float speedFan1, float speedFan2, int widthFan, int stackFan, int delayFan, float scaleBullet,
|
|
float speedMove
|
|
){
|
|
|
|
int enmPad = _CreateEnemy(
|
|
false,
|
|
padX, padY, padX, padY, 5,
|
|
0.75, 0.75,
|
|
999, 0, 0,
|
|
texEnm,
|
|
1536, 256, 2048, 768);
|
|
|
|
Obj_SetRenderPriorityI(enmPad, renderEnm-4);
|
|
|
|
ObjMove_SetSpeed(enmPad, speedMove);
|
|
ObjMove_SetAngle(enmPad, 90);
|
|
|
|
ObjEnemy_SetDamageRate(enmPad, 0, 0);
|
|
|
|
wait(5);
|
|
|
|
ObjEnemy_SetAutoDelete(enmPad, true);
|
|
|
|
async{
|
|
|
|
_CreateLanternMid(
|
|
renderEnm, graphicBullet,
|
|
angspaceFan, speedFan1, speedFan2, widthFan, stackFan, delayFan,
|
|
padX-90, padY, speedMove, scaleBullet
|
|
);
|
|
_CreateLanternMid(
|
|
renderEnm, graphicBullet,
|
|
angspaceFan, speedFan1, speedFan2, widthFan, stackFan, delayFan,
|
|
padX+90, padY, speedMove, scaleBullet
|
|
);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// Enemy Type 3: Will o the Wisps
|
|
|
|
// Formation 1: Appears randomly on the top of the screen, slowly moving down while firing slow aimed bullets.
|
|
// Formation 2: Flies from either side, moving horizontally. Fires bullets aimed straight down.
|
|
|
|
function <int> _SmallWisp(
|
|
int renderPriority, spawnTime, invinTime,
|
|
float enmX, enmY, spdMove, angMove, int graphicBullet,
|
|
int delayBullet, int bulletAccelTime, float maxspeedBullet, float bulletAng, float scaleBullet
|
|
){
|
|
|
|
// Spawns enemy.
|
|
|
|
int enm = _CreateEnemy(
|
|
enmX, enmY, enmX, enmY, spawnTime,
|
|
smallEnemyScale*0.5, smallEnemyScale,
|
|
smallEnemyHP, smallEnemyHitbox, 0,
|
|
texEnm,
|
|
768, 0, 1024, 256);
|
|
|
|
Obj_SetRenderPriorityI(enm, renderPriority);
|
|
|
|
ObjMove_SetSpeed(enm, 0);
|
|
ObjMove_SetAngle(enm, angMove);
|
|
|
|
async{
|
|
|
|
ObjEnemy_SetDamageRate(enm, 0, 0);
|
|
|
|
wait(spawnTime);
|
|
|
|
ObjEnemy_SetAutoDelete(enm, true);
|
|
|
|
wait(invinTime - spawnTime);
|
|
|
|
ObjEnemy_SetDamageRate(enm, 100, 100);
|
|
|
|
}
|
|
|
|
async{
|
|
|
|
wait(spawnTime);
|
|
|
|
ObjMove_SetSpeed(enm, spdMove);
|
|
|
|
while(ObjEnemy_GetInfo(enm, INFO_LIFE) > 0){
|
|
|
|
if(ObjMove_GetX(enm) < STG_WIDTH && ObjMove_GetX(enm) > 0){
|
|
|
|
int bullet = CreateShotA2(ObjMove_GetX(enm) + rand(-30, 30), ObjMove_GetY(enm) + rand(-30, 30), 0, bulletAng, maxspeedBullet/bulletAccelTime, maxspeedBullet, graphicBullet, 10);
|
|
|
|
_BulletRescale(bullet, scaleBullet, true, 1);
|
|
_Delay(bullet, 10);
|
|
|
|
if(ObjEnemy_GetInfo(enm, INFO_LIFE) <= 0){Obj_Delete(bullet);}
|
|
else{
|
|
Shoot1;
|
|
}
|
|
|
|
wait(delayBullet);
|
|
|
|
}
|
|
|
|
else{yield;}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
_EnemyItemDrop(
|
|
enm, true,
|
|
5, 5,
|
|
10+(GetCommonDataPtr(RANK_PTR, 1)-1)*2, 10+(GetCommonDataPtr(RANK_PTR, 1)-1)*1,
|
|
120, smallEnemyHitbox*2
|
|
);
|
|
|
|
return enm;
|
|
|
|
}
|
|
|
|
// Enemy Type 4: Oni
|
|
|
|
function _CreateOni(
|
|
int renderPriority, int graphicBullet, bool bombdrop,
|
|
float delayBullet, float speedBullet, float acceltimeBullet,
|
|
float enmX, enmY, speedMoveEnm, scaleBullet
|
|
){
|
|
|
|
// Enemy has NO GRAPHIC
|
|
|
|
int enm = _CreateEnemy(
|
|
enmX, enmY, enmX, enmY, 5,
|
|
largeEnemyScale, largeEnemyScale,
|
|
largeEnemyHP, largeEnemyHitbox, 0,
|
|
texEnm,
|
|
0, 256, 256, 512);
|
|
|
|
Obj_SetRenderPriorityI(enm, renderPriority);
|
|
|
|
ObjMove_SetSpeed(enm, speedMoveEnm);
|
|
ObjMove_SetAngle(enm, 90);
|
|
|
|
ObjEnemy_SetDamageRate(enm, 0, 0);
|
|
|
|
async{
|
|
|
|
if(GetCommonData("Flying Loops Cleared", 0) % 2 == 0 && GetCommonData("Flying Loops Cleared", 0) != 0 && bombdrop){
|
|
|
|
int sigil = _Create2DImage(texEnm, [0, 1024, 512, 1536]);
|
|
ObjRender_SetAlpha(sigil, 180);
|
|
Obj_SetRenderPriorityI(sigil, Obj_GetRenderPriorityI(enm)-1);
|
|
|
|
while(ObjEnemy_GetInfo(enm, INFO_LIFE) > 0){
|
|
ObjRender_SetPosition(sigil, ObjMove_GetX(enm), ObjMove_GetY(enm), 1);
|
|
ObjRender_SetAngleZ(sigil, ObjRender_GetAngleZ(sigil)+3);
|
|
yield;
|
|
}
|
|
|
|
Obj_Delete(sigil);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
async{
|
|
|
|
async{
|
|
|
|
float x = 0, y = 0;
|
|
|
|
async{
|
|
wait(max(5, 10-GetCommonData("Rank", 0)*5));
|
|
while(ObjEnemy_GetInfo(enm, INFO_LIFE) > 0){
|
|
x = ObjMove_GetX(enm);
|
|
y = ObjMove_GetY(enm);
|
|
yield;
|
|
}
|
|
}
|
|
|
|
wait(max(25, 60-GetCommonData("Rank", 1)*5));
|
|
|
|
while(ObjEnemy_GetInfo(enm, INFO_LIFE) > 0){yield;}
|
|
|
|
if(
|
|
(-128 < x && x < STG_WIDTH+128)
|
|
&&
|
|
(y < STG_HEIGHT+128)
|
|
)
|
|
{
|
|
//DeleteShotInCircle(TYPE_SHOT, TYPE_ITEM, x, y, 384);
|
|
//ObjSound_Play(bossBoom);
|
|
if(GetCommonData("Flying Loops Cleared", 0) % 2 == 0 && GetCommonData("Flying Loops Cleared", 0) != 0 && bombdrop){CreateExtendItem(EXTEND_SPELL, x, y);}
|
|
TExplosionA(x, y, 10, 0.5);
|
|
}
|
|
|
|
}
|
|
|
|
wait(max(10, 20-GetCommonData("Rank", 1)*2));
|
|
|
|
ObjEnemy_SetAutoDelete(enm, true);
|
|
|
|
async{
|
|
|
|
wait(5);
|
|
|
|
while(ObjEnemy_GetInfo(enm, INFO_LIFE) > 0){
|
|
|
|
if(ObjMove_GetY(enm) < 11*STG_HEIGHT/12 && ObjMove_GetY(enm) > STG_HEIGHT/12){
|
|
|
|
float xspd = rand(-(2+GetCommonDataPtr(RANK_PTR, 1)*0.25), 2+GetCommonDataPtr(RANK_PTR, 1)*0.25);
|
|
int bullet = CreateShotB2(ObjMove_GetX(enm), ObjMove_GetY(enm), xspd, -speedBullet, 0, speedBullet/(acceltimeBullet/2), xspd, speedBullet*1.5, graphicBullet, 10);
|
|
|
|
if(Obj_IsDeleted(enm)){Obj_Delete(bullet); break;}
|
|
|
|
else{
|
|
|
|
Shoot1;
|
|
_BulletRescale(bullet, scaleBullet, true, 1);
|
|
_Delay(bullet, 10);
|
|
|
|
}
|
|
|
|
wait(delayBullet);
|
|
|
|
}
|
|
|
|
else{yield;}
|
|
|
|
yield;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
_EnemyItemDrop(
|
|
enm, false,
|
|
18, 15,
|
|
round(30+(GetCommonDataPtr(RANK_PTR, 1)-1)*1.5), round(24+(GetCommonDataPtr(RANK_PTR, 1)-1)*1.5),
|
|
180, largeEnemyHitbox*2.5
|
|
);
|
|
|
|
}
|
|
|
|
return enm;
|
|
//ObjEnemy_SetDamageRate(enm, 100, 150);
|
|
|
|
}
|
|
|
|
*/ |