zdoom/raze
0
0
Fork 0
mirror of https://github.com/ZDoom/Raze.git synced 2025-04-18 22:02:12 +00:00
Code Issues Projects Releases Packages Wiki Activity

- SW: refactored states to use a Doom-like state model.

Browse source
This commit is contained in:
Christoph Oelckers 2023-05-25 16:53:29 +02:00
parent 24a3d91d0d
commit 031fb2ea4e
37 changed files with 2801 additions and 7653 deletions

7
source/core/states.cpp
View file

@ -83,6 +83,13 @@ void InitSpriteDefs(const char** names, size_t count)
texs[k] = TexMan.CheckForTexture(work.Data(), ETextureType::Any);
if (texs[k].isValid()) bits |= (1 << k);
}
// use the base name without frame extensions if no frame found.
if (bits == 0)
{
texs[0] = TexMan.CheckForTexture(names[i], ETextureType::Any);
if (texs[0].isValid()) bits = 1;
else continue;
}
if (bits == 1)
{
swork[j].Texture[0] = texs[0];

1
source/core/states.h
View file

@ -191,6 +191,7 @@ extern FStateLabelStorage StateLabels;
int GetSpriteIndex(const char * spritename, bool add = true);
TArray<FName> &MakeStateNameList(const char * fname);
void AddStateLight(FState *state, const char *lname);
void InitSpriteDefs(const char** names, size_t count);
//==========================================================================

4
source/games/sw/src/actor.cpp
View file

@ -181,7 +181,7 @@ int DoActorDie(DSWActor* actor, DSWActor* weapActor, int meansofdeath)
DoActorBeginJump(actor);
}
actor->user.__legacyState.RotNum = 0;
actor->clearActionFunc();
if (!sw_ninjahack)
@ -957,8 +957,6 @@ int DoFall(DSWActor* actor)
void DSWActor::ChangeStateEnd()
{
ChangeState(this, user.__legacyState.StateEnd);
user.__legacyState.RotNum = 0;
}
Personality* DSWActor::getPersonality()

2
source/games/sw/src/break.cpp
View file

@ -397,7 +397,7 @@ BREAK_INFO SpriteBreakInfo[] =
{ NINJA_DEAD1 , -1, SHRAP_GIBS, BF_KILL | BF_TOUGH, 0 },
{ NINJA_DEAD_SLICED, -1, SHRAP_GIBS, BF_KILL | BF_TOUGH, 0 }, // Evil Ninja cut in half
{ PLAYER_NINJA_DEAD ,-1, SHRAP_GIBS, BF_KILL | BF_TOUGH, 0 },
{ NINJA_HeadFly , -1, SHRAP_GIBS, BF_KILL | BF_TOUGH, 0 },
{ Player_HeadFly , -1, SHRAP_GIBS, BF_KILL | BF_TOUGH, 0 },
{ RIPPER_DEAD , -1, SHRAP_GIBS, BF_KILL | BF_TOUGH, 0 },
{ RIPPER2_DEAD , -1, SHRAP_GIBS, BF_KILL | BF_TOUGH, 0 }, // Dead Big Ripper

316
source/games/sw/src/bunny.cpp
View file

@ -156,58 +156,22 @@ ATTRIBUTE WhiteBunnyAttrib =
#define BUNNY_RUN_RATE 10
STATE s_BunnyRun[5][6] =
STATE s_BunnyRun[][6] =
{
{
{BUNNY_RUN_R0 + 0, BUNNY_RUN_RATE | SF_TIC_ADJUST, &AF(DoBunnyMove), &s_BunnyRun[0][1]},
{BUNNY_RUN_R0 + 1, BUNNY_RUN_RATE | SF_TIC_ADJUST, &AF(DoBunnyMove), &s_BunnyRun[0][2]},
{BUNNY_RUN_R0 + 2, BUNNY_RUN_RATE | SF_TIC_ADJUST, &AF(DoBunnyMove), &s_BunnyRun[0][3]},
{BUNNY_RUN_R0 + 3, BUNNY_RUN_RATE | SF_TIC_ADJUST, &AF(DoBunnyMove), &s_BunnyRun[0][4]},
{BUNNY_RUN_R0 + 4, SF_QUICK_CALL, &AF(DoBunnyGrowUp), &s_BunnyRun[0][5]},
{BUNNY_RUN_R0 + 4, BUNNY_RUN_RATE | SF_TIC_ADJUST, &AF(DoBunnyMove), &s_BunnyRun[0][0]},
{SPR_BUNNY_RUN, 'A', BUNNY_RUN_RATE | SF_TIC_ADJUST, &AF(DoBunnyMove), &s_BunnyRun[0][1]},
{SPR_BUNNY_RUN, 'B', BUNNY_RUN_RATE | SF_TIC_ADJUST, &AF(DoBunnyMove), &s_BunnyRun[0][2]},
{SPR_BUNNY_RUN, 'C', BUNNY_RUN_RATE | SF_TIC_ADJUST, &AF(DoBunnyMove), &s_BunnyRun[0][3]},
{SPR_BUNNY_RUN, 'D', BUNNY_RUN_RATE | SF_TIC_ADJUST, &AF(DoBunnyMove), &s_BunnyRun[0][4]},
{SPR_BUNNY_RUN, 'E', SF_QUICK_CALL, &AF(DoBunnyGrowUp), &s_BunnyRun[0][5]},
{SPR_BUNNY_RUN, 'F', BUNNY_RUN_RATE | SF_TIC_ADJUST, &AF(DoBunnyMove), &s_BunnyRun[0][0]},
},
{
{BUNNY_RUN_R1 + 0, BUNNY_RUN_RATE | SF_TIC_ADJUST, &AF(DoBunnyMove), &s_BunnyRun[1][1]},
{BUNNY_RUN_R1 + 1, BUNNY_RUN_RATE | SF_TIC_ADJUST, &AF(DoBunnyMove), &s_BunnyRun[1][2]},
{BUNNY_RUN_R1 + 2, BUNNY_RUN_RATE | SF_TIC_ADJUST, &AF(DoBunnyMove), &s_BunnyRun[1][3]},
{BUNNY_RUN_R1 + 3, BUNNY_RUN_RATE | SF_TIC_ADJUST, &AF(DoBunnyMove), &s_BunnyRun[1][4]},
{BUNNY_RUN_R1 + 4, SF_QUICK_CALL, &AF(DoBunnyGrowUp), &s_BunnyRun[1][5]},
{BUNNY_RUN_R1 + 4, BUNNY_RUN_RATE | SF_TIC_ADJUST, &AF(DoBunnyMove), &s_BunnyRun[1][0]},
},
{
{BUNNY_RUN_R2 + 0, BUNNY_RUN_RATE | SF_TIC_ADJUST, &AF(DoBunnyMove), &s_BunnyRun[2][1]},
{BUNNY_RUN_R2 + 1, BUNNY_RUN_RATE | SF_TIC_ADJUST, &AF(DoBunnyMove), &s_BunnyRun[2][2]},
{BUNNY_RUN_R2 + 2, BUNNY_RUN_RATE | SF_TIC_ADJUST, &AF(DoBunnyMove), &s_BunnyRun[2][3]},
{BUNNY_RUN_R2 + 3, BUNNY_RUN_RATE | SF_TIC_ADJUST, &AF(DoBunnyMove), &s_BunnyRun[2][4]},
{BUNNY_RUN_R2 + 4, SF_QUICK_CALL, &AF(DoBunnyGrowUp), &s_BunnyRun[2][5]},
{BUNNY_RUN_R2 + 4, BUNNY_RUN_RATE | SF_TIC_ADJUST, &AF(DoBunnyMove), &s_BunnyRun[2][0]},
},
{
{BUNNY_RUN_R3 + 0, BUNNY_RUN_RATE | SF_TIC_ADJUST, &AF(DoBunnyMove), &s_BunnyRun[3][1]},
{BUNNY_RUN_R3 + 1, BUNNY_RUN_RATE | SF_TIC_ADJUST, &AF(DoBunnyMove), &s_BunnyRun[3][2]},
{BUNNY_RUN_R3 + 2, BUNNY_RUN_RATE | SF_TIC_ADJUST, &AF(DoBunnyMove), &s_BunnyRun[3][3]},
{BUNNY_RUN_R3 + 3, BUNNY_RUN_RATE | SF_TIC_ADJUST, &AF(DoBunnyMove), &s_BunnyRun[3][4]},
{BUNNY_RUN_R3 + 4, SF_QUICK_CALL, &AF(DoBunnyGrowUp), &s_BunnyRun[3][5]},
{BUNNY_RUN_R3 + 4, BUNNY_RUN_RATE | SF_TIC_ADJUST, &AF(DoBunnyMove), &s_BunnyRun[3][0]},
},
{
{BUNNY_RUN_R4 + 0, BUNNY_RUN_RATE | SF_TIC_ADJUST, &AF(DoBunnyMove), &s_BunnyRun[4][1]},
{BUNNY_RUN_R4 + 1, BUNNY_RUN_RATE | SF_TIC_ADJUST, &AF(DoBunnyMove), &s_BunnyRun[4][2]},
{BUNNY_RUN_R4 + 2, BUNNY_RUN_RATE | SF_TIC_ADJUST, &AF(DoBunnyMove), &s_BunnyRun[4][3]},
{BUNNY_RUN_R4 + 3, BUNNY_RUN_RATE | SF_TIC_ADJUST, &AF(DoBunnyMove), &s_BunnyRun[4][4]},
{BUNNY_RUN_R4 + 4, SF_QUICK_CALL, &AF(DoBunnyGrowUp), &s_BunnyRun[4][5]},
{BUNNY_RUN_R4 + 4, BUNNY_RUN_RATE | SF_TIC_ADJUST, &AF(DoBunnyMove), &s_BunnyRun[4][0]},
}
};
STATE* sg_BunnyRun[] =
{
&s_BunnyRun[0][0],
&s_BunnyRun[1][0],
&s_BunnyRun[2][0],
&s_BunnyRun[3][0],
&s_BunnyRun[4][0]
};
//////////////////////
@ -218,32 +182,12 @@ STATE* sg_BunnyRun[] =
#define BUNNY_STAND_RATE 12
STATE s_BunnyStand[5][3] =
STATE s_BunnyStand[][3] =
{
{
{BUNNY_STAND_R0 + 0, BUNNY_STAND_RATE, &AF(DoBunnyEat), &s_BunnyStand[0][1]},
{BUNNY_STAND_R0 + 4, SF_QUICK_CALL, &AF(DoBunnyGrowUp), &s_BunnyStand[0][2]},
{BUNNY_STAND_R0 + 4, BUNNY_STAND_RATE, &AF(DoBunnyEat), &s_BunnyStand[0][0]},
},
{
{BUNNY_STAND_R1 + 0, BUNNY_STAND_RATE, &AF(DoBunnyEat), &s_BunnyStand[1][1]},
{BUNNY_STAND_R1 + 4, SF_QUICK_CALL, &AF(DoBunnyGrowUp), &s_BunnyStand[1][2]},
{BUNNY_STAND_R1 + 4, BUNNY_STAND_RATE, &AF(DoBunnyEat), &s_BunnyStand[1][0]},
},
{
{BUNNY_STAND_R2 + 0, BUNNY_STAND_RATE, &AF(DoBunnyEat), &s_BunnyStand[2][1]},
{BUNNY_STAND_R2 + 4, SF_QUICK_CALL, &AF(DoBunnyGrowUp), &s_BunnyStand[2][2]},
{BUNNY_STAND_R2 + 4, BUNNY_STAND_RATE, &AF(DoBunnyEat), &s_BunnyStand[2][0]},
},
{
{BUNNY_STAND_R3 + 0, BUNNY_STAND_RATE, &AF(DoBunnyEat), &s_BunnyStand[3][1]},
{BUNNY_STAND_R3 + 4, SF_QUICK_CALL, &AF(DoBunnyGrowUp), &s_BunnyStand[3][2]},
{BUNNY_STAND_R3 + 4, BUNNY_STAND_RATE, &AF(DoBunnyEat), &s_BunnyStand[3][0]},
},
{
{BUNNY_STAND_R4 + 0, BUNNY_STAND_RATE, &AF(DoBunnyEat), &s_BunnyStand[4][1]},
{BUNNY_STAND_R4 + 4, SF_QUICK_CALL, &AF(DoBunnyGrowUp), &s_BunnyStand[4][2]},
{BUNNY_STAND_R4 + 4, BUNNY_STAND_RATE, &AF(DoBunnyEat), &s_BunnyStand[4][0]},
{SPR_BUNNY_RUN, 'A', BUNNY_STAND_RATE, &AF(DoBunnyEat), &s_BunnyStand[0][1]},
{SPR_BUNNY_RUN, 'E', SF_QUICK_CALL, &AF(DoBunnyGrowUp), &s_BunnyStand[0][2]},
{SPR_BUNNY_RUN, 'E', BUNNY_STAND_RATE, &AF(DoBunnyEat), &s_BunnyStand[0][0]},
},
};
@ -251,10 +195,6 @@ STATE s_BunnyStand[5][3] =
STATE* sg_BunnyStand[] =
{
s_BunnyStand[0],
s_BunnyStand[1],
s_BunnyStand[2],
s_BunnyStand[3],
s_BunnyStand[4]
};
//////////////////////
@ -265,27 +205,11 @@ STATE* sg_BunnyStand[] =
#define BUNNY_SCREW_RATE 16
STATE s_BunnyScrew[5][2] =
STATE s_BunnyScrew[][2] =
{
{
{BUNNY_STAND_R0 + 0, BUNNY_SCREW_RATE, &AF(DoBunnyScrew), &s_BunnyScrew[0][1]},
{BUNNY_STAND_R0 + 2, BUNNY_SCREW_RATE, &AF(DoBunnyScrew), &s_BunnyScrew[0][0]},
},
{
{BUNNY_STAND_R1 + 0, BUNNY_SCREW_RATE, &AF(DoBunnyScrew), &s_BunnyScrew[1][1]},
{BUNNY_STAND_R1 + 2, BUNNY_SCREW_RATE, &AF(DoBunnyScrew), &s_BunnyScrew[1][0]},
},
{
{BUNNY_STAND_R2 + 0, BUNNY_SCREW_RATE, &AF(DoBunnyScrew), &s_BunnyScrew[2][1]},
{BUNNY_STAND_R2 + 2, BUNNY_SCREW_RATE, &AF(DoBunnyScrew), &s_BunnyScrew[2][0]},
},
{
{BUNNY_STAND_R3 + 0, BUNNY_SCREW_RATE, &AF(DoBunnyScrew), &s_BunnyScrew[3][1]},
{BUNNY_STAND_R3 + 2, BUNNY_SCREW_RATE, &AF(DoBunnyScrew), &s_BunnyScrew[3][0]},
},
{
{BUNNY_STAND_R4 + 0, BUNNY_SCREW_RATE, &AF(DoBunnyScrew), &s_BunnyScrew[4][1]},
{BUNNY_STAND_R4 + 2, BUNNY_SCREW_RATE, &AF(DoBunnyScrew), &s_BunnyScrew[4][0]},
{SPR_BUNNY_RUN, 'A', BUNNY_SCREW_RATE, &AF(DoBunnyScrew), &s_BunnyScrew[0][1]},
{SPR_BUNNY_RUN, 'C', BUNNY_SCREW_RATE, &AF(DoBunnyScrew), &s_BunnyScrew[0][0]},
},
};
@ -293,10 +217,6 @@ STATE s_BunnyScrew[5][2] =
STATE* sg_BunnyScrew[] =
{
s_BunnyScrew[0],
s_BunnyScrew[1],
s_BunnyScrew[2],
s_BunnyScrew[3],
s_BunnyScrew[4]
};
//////////////////////
@ -307,68 +227,24 @@ STATE* sg_BunnyScrew[] =
#define BUNNY_SWIPE_RATE 8
STATE s_BunnySwipe[5][8] =
STATE s_BunnySwipe[][8] =
{
{
{BUNNY_SWIPE_R0 + 0, BUNNY_SWIPE_RATE, &AF(NullBunny), &s_BunnySwipe[0][1]},
{BUNNY_SWIPE_R0 + 1, BUNNY_SWIPE_RATE, &AF(NullBunny), &s_BunnySwipe[0][2]},
{BUNNY_SWIPE_R0 + 1, 0 | SF_QUICK_CALL, &AF(InitBunnySlash), &s_BunnySwipe[0][3]},
{BUNNY_SWIPE_R0 + 2, BUNNY_SWIPE_RATE, &AF(NullBunny), &s_BunnySwipe[0][4]},
{BUNNY_SWIPE_R0 + 3, BUNNY_SWIPE_RATE, &AF(NullBunny), &s_BunnySwipe[0][5]},
{BUNNY_SWIPE_R0 + 3, 0 | SF_QUICK_CALL, &AF(InitBunnySlash), &s_BunnySwipe[0][6]},
{BUNNY_SWIPE_R0 + 3, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_BunnySwipe[0][7]},
{BUNNY_SWIPE_R0 + 3, BUNNY_SWIPE_RATE, &AF(DoBunnyMove), &s_BunnySwipe[0][7]},
{SPR_BUNNY_SWIPE, 'A', BUNNY_SWIPE_RATE, &AF(NullBunny), &s_BunnySwipe[0][1]},
{SPR_BUNNY_SWIPE, 'B', BUNNY_SWIPE_RATE, &AF(NullBunny), &s_BunnySwipe[0][2]},
{SPR_BUNNY_SWIPE, 'B', 0 | SF_QUICK_CALL, &AF(InitBunnySlash), &s_BunnySwipe[0][3]},
{SPR_BUNNY_SWIPE, 'C', BUNNY_SWIPE_RATE, &AF(NullBunny), &s_BunnySwipe[0][4]},
{SPR_BUNNY_SWIPE, 'D', BUNNY_SWIPE_RATE, &AF(NullBunny), &s_BunnySwipe[0][5]},
{SPR_BUNNY_SWIPE, 'D', 0 | SF_QUICK_CALL, &AF(InitBunnySlash), &s_BunnySwipe[0][6]},
{SPR_BUNNY_SWIPE, 'D', 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_BunnySwipe[0][7]},
{SPR_BUNNY_SWIPE, 'D', BUNNY_SWIPE_RATE, &AF(DoBunnyMove), &s_BunnySwipe[0][7]},
},
{
{BUNNY_SWIPE_R1 + 0, BUNNY_SWIPE_RATE, &AF(NullBunny), &s_BunnySwipe[1][1]},
{BUNNY_SWIPE_R1 + 1, BUNNY_SWIPE_RATE, &AF(NullBunny), &s_BunnySwipe[1][2]},
{BUNNY_SWIPE_R1 + 1, 0 | SF_QUICK_CALL, &AF(InitBunnySlash), &s_BunnySwipe[1][3]},
{BUNNY_SWIPE_R1 + 2, BUNNY_SWIPE_RATE, &AF(NullBunny), &s_BunnySwipe[1][4]},
{BUNNY_SWIPE_R1 + 3, BUNNY_SWIPE_RATE, &AF(NullBunny), &s_BunnySwipe[1][5]},
{BUNNY_SWIPE_R1 + 3, 0 | SF_QUICK_CALL, &AF(InitBunnySlash), &s_BunnySwipe[1][6]},
{BUNNY_SWIPE_R1 + 3, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_BunnySwipe[1][7]},
{BUNNY_SWIPE_R1 + 3, BUNNY_SWIPE_RATE, &AF(DoBunnyMove), &s_BunnySwipe[1][7]},
},
{
{BUNNY_SWIPE_R2 + 0, BUNNY_SWIPE_RATE, &AF(NullBunny), &s_BunnySwipe[2][1]},
{BUNNY_SWIPE_R2 + 1, BUNNY_SWIPE_RATE, &AF(NullBunny), &s_BunnySwipe[2][2]},
{BUNNY_SWIPE_R2 + 1, 0 | SF_QUICK_CALL, &AF(InitBunnySlash), &s_BunnySwipe[2][3]},
{BUNNY_SWIPE_R2 + 2, BUNNY_SWIPE_RATE, &AF(NullBunny), &s_BunnySwipe[2][4]},
{BUNNY_SWIPE_R2 + 3, BUNNY_SWIPE_RATE, &AF(NullBunny), &s_BunnySwipe[2][5]},
{BUNNY_SWIPE_R2 + 3, 0 | SF_QUICK_CALL, &AF(InitBunnySlash), &s_BunnySwipe[2][6]},
{BUNNY_SWIPE_R2 + 3, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_BunnySwipe[2][7]},
{BUNNY_SWIPE_R2 + 3, BUNNY_SWIPE_RATE, &AF(DoBunnyMove), &s_BunnySwipe[2][7]},
},
{
{BUNNY_SWIPE_R3 + 0, BUNNY_SWIPE_RATE, &AF(NullBunny), &s_BunnySwipe[3][1]},
{BUNNY_SWIPE_R3 + 1, BUNNY_SWIPE_RATE, &AF(NullBunny), &s_BunnySwipe[3][2]},
{BUNNY_SWIPE_R3 + 1, 0 | SF_QUICK_CALL, &AF(InitBunnySlash), &s_BunnySwipe[3][3]},
{BUNNY_SWIPE_R3 + 2, BUNNY_SWIPE_RATE, &AF(NullBunny), &s_BunnySwipe[3][4]},
{BUNNY_SWIPE_R3 + 3, BUNNY_SWIPE_RATE, &AF(NullBunny), &s_BunnySwipe[3][5]},
{BUNNY_SWIPE_R3 + 3, 0 | SF_QUICK_CALL, &AF(InitBunnySlash), &s_BunnySwipe[3][6]},
{BUNNY_SWIPE_R3 + 3, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_BunnySwipe[3][7]},
{BUNNY_SWIPE_R3 + 3, BUNNY_SWIPE_RATE, &AF(DoBunnyMove), &s_BunnySwipe[3][7]},
},
{
{BUNNY_SWIPE_R4 + 0, BUNNY_SWIPE_RATE, &AF(NullBunny), &s_BunnySwipe[4][1]},
{BUNNY_SWIPE_R4 + 1, BUNNY_SWIPE_RATE, &AF(NullBunny), &s_BunnySwipe[4][2]},
{BUNNY_SWIPE_R4 + 1, 0 | SF_QUICK_CALL, &AF(InitBunnySlash), &s_BunnySwipe[4][3]},
{BUNNY_SWIPE_R4 + 2, BUNNY_SWIPE_RATE, &AF(NullBunny), &s_BunnySwipe[4][4]},
{BUNNY_SWIPE_R4 + 3, BUNNY_SWIPE_RATE, &AF(NullBunny), &s_BunnySwipe[4][5]},
{BUNNY_SWIPE_R4 + 3, 0 | SF_QUICK_CALL, &AF(InitBunnySlash), &s_BunnySwipe[4][6]},
{BUNNY_SWIPE_R4 + 3, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_BunnySwipe[4][7]},
{BUNNY_SWIPE_R4 + 3, BUNNY_SWIPE_RATE, &AF(DoBunnyMove), &s_BunnySwipe[4][7]},
}
};
STATE* sg_BunnySwipe[] =
{
&s_BunnySwipe[0][0],
&s_BunnySwipe[1][0],
&s_BunnySwipe[2][0],
&s_BunnySwipe[3][0],
&s_BunnySwipe[4][0]
};
@ -380,33 +256,17 @@ STATE* sg_BunnySwipe[] =
#define BUNNY_HEART_RATE 14
STATE s_BunnyHeart[5][4] =
STATE s_BunnyHeart[][4] =
{
{
{BUNNY_SWIPE_R0 + 0, BUNNY_HEART_RATE, &AF(DoBunnyStandKill), &s_BunnyHeart[0][0]},
{SPR_BUNNY_SWIPE, 'A', BUNNY_HEART_RATE, &AF(DoBunnyStandKill), &s_BunnyHeart[0][0]},
},
{
{BUNNY_SWIPE_R1 + 0, BUNNY_HEART_RATE, &AF(DoBunnyStandKill), &s_BunnyHeart[1][0]},
},
{
{BUNNY_SWIPE_R2 + 0, BUNNY_HEART_RATE, &AF(DoBunnyStandKill), &s_BunnyHeart[2][0]},
},
{
{BUNNY_SWIPE_R3 + 0, BUNNY_HEART_RATE, &AF(DoBunnyStandKill), &s_BunnyHeart[3][0]},
},
{
{BUNNY_SWIPE_R4 + 0, BUNNY_HEART_RATE, &AF(DoBunnyStandKill), &s_BunnyHeart[4][0]},
}
};
STATE* sg_BunnyHeart[] =
{
&s_BunnyHeart[0][0],
&s_BunnyHeart[1][0],
&s_BunnyHeart[2][0],
&s_BunnyHeart[3][0],
&s_BunnyHeart[4][0]
};
//////////////////////
@ -417,32 +277,16 @@ STATE* sg_BunnyHeart[] =
#define BUNNY_PAIN_RATE 38
STATE s_BunnyPain[5][1] =
STATE s_BunnyPain[][1] =
{
{
{BUNNY_SWIPE_R0 + 0, BUNNY_PAIN_RATE, &AF(DoBunnyPain), &s_BunnyPain[0][0]},
{SPR_BUNNY_SWIPE, 'A', BUNNY_PAIN_RATE, &AF(DoBunnyPain), &s_BunnyPain[0][0]},
},
{
{BUNNY_SWIPE_R0 + 0, BUNNY_PAIN_RATE, &AF(DoBunnyPain), &s_BunnyPain[1][0]},
},
{
{BUNNY_SWIPE_R0 + 0, BUNNY_PAIN_RATE, &AF(DoBunnyPain), &s_BunnyPain[2][0]},
},
{
{BUNNY_SWIPE_R0 + 0, BUNNY_PAIN_RATE, &AF(DoBunnyPain), &s_BunnyPain[3][0]},
},
{
{BUNNY_SWIPE_R0 + 0, BUNNY_PAIN_RATE, &AF(DoBunnyPain), &s_BunnyPain[4][0]},
}
};
STATE* sg_BunnyPain[] =
{
&s_BunnyPain[0][0],
&s_BunnyPain[1][0],
&s_BunnyPain[2][0],
&s_BunnyPain[3][0],
&s_BunnyPain[4][0]
};
//////////////////////
@ -453,38 +297,18 @@ STATE* sg_BunnyPain[] =
#define BUNNY_JUMP_RATE 25
STATE s_BunnyJump[5][6] =
STATE s_BunnyJump[][6] =
{
{
{BUNNY_RUN_R0 + 1, BUNNY_JUMP_RATE, &AF(DoBunnyMoveJump), &s_BunnyJump[0][1]},
{BUNNY_RUN_R0 + 2, BUNNY_JUMP_RATE, &AF(DoBunnyMoveJump), &s_BunnyJump[0][1]},
{SPR_BUNNY_RUN, 'B', BUNNY_JUMP_RATE, &AF(DoBunnyMoveJump), &s_BunnyJump[0][1]},
{SPR_BUNNY_RUN, 'C', BUNNY_JUMP_RATE, &AF(DoBunnyMoveJump), &s_BunnyJump[0][1]},
},
{
{BUNNY_RUN_R1 + 1, BUNNY_JUMP_RATE, &AF(DoBunnyMoveJump), &s_BunnyJump[1][1]},
{BUNNY_RUN_R1 + 2, BUNNY_JUMP_RATE, &AF(DoBunnyMoveJump), &s_BunnyJump[1][1]},
},
{
{BUNNY_RUN_R2 + 1, BUNNY_JUMP_RATE, &AF(DoBunnyMoveJump), &s_BunnyJump[2][1]},
{BUNNY_RUN_R2 + 2, BUNNY_JUMP_RATE, &AF(DoBunnyMoveJump), &s_BunnyJump[2][1]},
},
{
{BUNNY_RUN_R3 + 1, BUNNY_JUMP_RATE, &AF(DoBunnyMoveJump), &s_BunnyJump[3][1]},
{BUNNY_RUN_R3 + 2, BUNNY_JUMP_RATE, &AF(DoBunnyMoveJump), &s_BunnyJump[3][1]},
},
{
{BUNNY_RUN_R4 + 1, BUNNY_JUMP_RATE, &AF(DoBunnyMoveJump), &s_BunnyJump[4][1]},
{BUNNY_RUN_R4 + 2, BUNNY_JUMP_RATE, &AF(DoBunnyMoveJump), &s_BunnyJump[4][1]},
}
};
STATE* sg_BunnyJump[] =
{
&s_BunnyJump[0][0],
&s_BunnyJump[1][0],
&s_BunnyJump[2][0],
&s_BunnyJump[3][0],
&s_BunnyJump[4][0]
};
@ -496,33 +320,17 @@ STATE* sg_BunnyJump[] =
#define BUNNY_FALL_RATE 25
STATE s_BunnyFall[5][6] =
STATE s_BunnyFall[][6] =
{
{
{BUNNY_RUN_R0 + 3, BUNNY_FALL_RATE, &AF(DoBunnyMoveJump), &s_BunnyFall[0][0]},
{SPR_BUNNY_RUN, 'D', BUNNY_FALL_RATE, &AF(DoBunnyMoveJump), &s_BunnyFall[0][0]},
},
{
{BUNNY_RUN_R1 + 3, BUNNY_FALL_RATE, &AF(DoBunnyMoveJump), &s_BunnyFall[1][0]},
},
{
{BUNNY_RUN_R2 + 3, BUNNY_FALL_RATE, &AF(DoBunnyMoveJump), &s_BunnyFall[2][0]},
},
{
{BUNNY_RUN_R3 + 3, BUNNY_FALL_RATE, &AF(DoBunnyMoveJump), &s_BunnyFall[3][0]},
},
{
{BUNNY_RUN_R4 + 3, BUNNY_FALL_RATE, &AF(DoBunnyMoveJump), &s_BunnyFall[4][0]},
}
};
STATE* sg_BunnyFall[] =
{
&s_BunnyFall[0][0],
&s_BunnyFall[1][0],
&s_BunnyFall[2][0],
&s_BunnyFall[3][0],
&s_BunnyFall[4][0]
};
@ -535,43 +343,19 @@ STATE* sg_BunnyFall[] =
#define BUNNY_JUMP_ATTACK_RATE 35
int DoBunnyBeginJumpAttack(DSWActor* actor);
STATE s_BunnyJumpAttack[5][6] =
STATE s_BunnyJumpAttack[][6] =
{
{
{BUNNY_RUN_R0 + 1, BUNNY_JUMP_ATTACK_RATE, &AF(NullBunny), &s_BunnyJumpAttack[0][1]},
{BUNNY_RUN_R0 + 1, 0 | SF_QUICK_CALL, &AF(DoBunnyBeginJumpAttack), &s_BunnyJumpAttack[0][2]},
{BUNNY_RUN_R0 + 2, BUNNY_JUMP_ATTACK_RATE, &AF(DoBunnyMoveJump), &s_BunnyJumpAttack[0][2]},
{SPR_BUNNY_RUN, 'B', BUNNY_JUMP_ATTACK_RATE, &AF(NullBunny), &s_BunnyJumpAttack[0][1]},
{SPR_BUNNY_RUN, 'B', 0 | SF_QUICK_CALL, &AF(DoBunnyBeginJumpAttack), &s_BunnyJumpAttack[0][2]},
{SPR_BUNNY_RUN, 'C', BUNNY_JUMP_ATTACK_RATE, &AF(DoBunnyMoveJump), &s_BunnyJumpAttack[0][2]},
},
{
{BUNNY_RUN_R1 + 1, BUNNY_JUMP_ATTACK_RATE, &AF(NullBunny), &s_BunnyJumpAttack[1][1]},
{BUNNY_RUN_R1 + 1, 0 | SF_QUICK_CALL, &AF(DoBunnyBeginJumpAttack), &s_BunnyJumpAttack[1][2]},
{BUNNY_RUN_R1 + 2, BUNNY_JUMP_ATTACK_RATE, &AF(DoBunnyMoveJump), &s_BunnyJumpAttack[1][2]},
},
{
{BUNNY_RUN_R2 + 1, BUNNY_JUMP_ATTACK_RATE, &AF(NullBunny), &s_BunnyJumpAttack[2][1]},
{BUNNY_RUN_R2 + 1, 0 | SF_QUICK_CALL, &AF(DoBunnyBeginJumpAttack), &s_BunnyJumpAttack[2][2]},
{BUNNY_RUN_R2 + 2, BUNNY_JUMP_ATTACK_RATE, &AF(DoBunnyMoveJump), &s_BunnyJumpAttack[2][2]},
},
{
{BUNNY_RUN_R3 + 1, BUNNY_JUMP_ATTACK_RATE, &AF(NullBunny), &s_BunnyJumpAttack[3][1]},
{BUNNY_RUN_R3 + 1, 0 | SF_QUICK_CALL, &AF(DoBunnyBeginJumpAttack), &s_BunnyJumpAttack[3][2]},
{BUNNY_RUN_R3 + 2, BUNNY_JUMP_ATTACK_RATE, &AF(DoBunnyMoveJump), &s_BunnyJumpAttack[3][2]},
},
{
{BUNNY_RUN_R4 + 1, BUNNY_JUMP_ATTACK_RATE, &AF(NullBunny), &s_BunnyJumpAttack[4][1]},
{BUNNY_RUN_R4 + 1, 0 | SF_QUICK_CALL, &AF(DoBunnyBeginJumpAttack), &s_BunnyJumpAttack[4][2]},
{BUNNY_RUN_R4 + 2, BUNNY_JUMP_ATTACK_RATE, &AF(DoBunnyMoveJump), &s_BunnyJumpAttack[4][2]},
}
};
STATE* sg_BunnyJumpAttack[] =
{
&s_BunnyJumpAttack[0][0],
&s_BunnyJumpAttack[1][0],
&s_BunnyJumpAttack[2][0],
&s_BunnyJumpAttack[3][0],
&s_BunnyJumpAttack[4][0]
};
@ -585,24 +369,24 @@ STATE* sg_BunnyJumpAttack[] =
STATE s_BunnyDie[] =
{
{BUNNY_DIE + 0, BUNNY_DIE_RATE, &AF(NullBunny), &s_BunnyDie[1]},
{BUNNY_DIE + 0, SF_QUICK_CALL, &AF(BunnySpew), &s_BunnyDie[2]},
{BUNNY_DIE + 1, BUNNY_DIE_RATE, &AF(NullBunny), &s_BunnyDie[3]},
{BUNNY_DIE + 2, BUNNY_DIE_RATE, &AF(NullBunny), &s_BunnyDie[4]},
{BUNNY_DIE + 2, BUNNY_DIE_RATE, &AF(NullBunny), &s_BunnyDie[5]},
{BUNNY_DEAD, BUNNY_DIE_RATE, &AF(DoActorDebris), &s_BunnyDie[5]},
{SPR_BUNNY_DIE, 'A', BUNNY_DIE_RATE, &AF(NullBunny), &s_BunnyDie[1]},
{SPR_BUNNY_DIE, 'A', SF_QUICK_CALL, &AF(BunnySpew), &s_BunnyDie[2]},
{SPR_BUNNY_DIE, 'B', BUNNY_DIE_RATE, &AF(NullBunny), &s_BunnyDie[3]},
{SPR_BUNNY_DIE, 'C', BUNNY_DIE_RATE, &AF(NullBunny), &s_BunnyDie[4]},
{SPR_BUNNY_DIE, 'C', BUNNY_DIE_RATE, &AF(NullBunny), &s_BunnyDie[5]},
{SPR_BUNNY_DEAD, 'A', BUNNY_DIE_RATE, &AF(DoActorDebris), &s_BunnyDie[5]},
};
#define BUNNY_DEAD_RATE 8
STATE s_BunnyDead[] =
{
{BUNNY_DIE + 0, BUNNY_DEAD_RATE, nullptr, &s_BunnyDie[1]},
{BUNNY_DIE + 0, SF_QUICK_CALL, &AF(BunnySpew), &s_BunnyDie[2]},
{BUNNY_DIE + 1, BUNNY_DEAD_RATE, nullptr, &s_BunnyDead[3]},
{BUNNY_DIE + 2, BUNNY_DEAD_RATE, nullptr, &s_BunnyDead[4]},
{BUNNY_DEAD, SF_QUICK_CALL, &AF(QueueFloorBlood), &s_BunnyDead[5]},
{BUNNY_DEAD, BUNNY_DEAD_RATE, &AF(DoActorDebris), &s_BunnyDead[5]},
{SPR_BUNNY_DIE, 'A', BUNNY_DEAD_RATE, nullptr, &s_BunnyDie[1]},
{SPR_BUNNY_DIE, 'A', SF_QUICK_CALL, &AF(BunnySpew), &s_BunnyDie[2]},
{SPR_BUNNY_DIE, 'B', BUNNY_DEAD_RATE, nullptr, &s_BunnyDead[3]},
{SPR_BUNNY_DIE, 'C', BUNNY_DEAD_RATE, nullptr, &s_BunnyDead[4]},
{SPR_BUNNY_DEAD, 'A', SF_QUICK_CALL, &AF(QueueFloorBlood), &s_BunnyDead[5]},
{SPR_BUNNY_DEAD, 'A', BUNNY_DEAD_RATE, &AF(DoActorDebris), &s_BunnyDead[5]},
};
STATE* sg_BunnyDie[] =
@ -617,12 +401,12 @@ STATE* sg_BunnyDead[] =
STATE s_BunnyDeathJump[] =
{
{BUNNY_DIE + 0, BUNNY_DIE_RATE, &AF(DoActorDeathMove), &s_BunnyDeathJump[0]}
{SPR_BUNNY_DIE, 'A', BUNNY_DIE_RATE, &AF(DoActorDeathMove), &s_BunnyDeathJump[0]}
};
STATE s_BunnyDeathFall[] =
{
{BUNNY_DIE + 1, BUNNY_DIE_RATE, &AF(DoActorDeathMove), &s_BunnyDeathFall[0]}
{SPR_BUNNY_DIE, 'B', BUNNY_DIE_RATE, &AF(DoActorDeathMove), &s_BunnyDeathFall[0]}
};
STATE* sg_BunnyDeathJump[] =

231
source/games/sw/src/coolg.cpp
View file

@ -120,47 +120,19 @@ ATTRIBUTE CoolgAttrib =
#define COOLG_RUN_RATE 40
STATE s_CoolgRun[5][4] =
STATE s_CoolgRun[][4] =
{
{
{COOLG_RUN_R0 + 0, COOLG_RUN_RATE, &AF(DoCoolgMove), &s_CoolgRun[0][1]},
{COOLG_RUN_R0 + 1, COOLG_RUN_RATE, &AF(DoCoolgMove), &s_CoolgRun[0][2]},
{COOLG_RUN_R0 + 2, COOLG_RUN_RATE, &AF(DoCoolgMove), &s_CoolgRun[0][3]},
{COOLG_RUN_R0 + 3, COOLG_RUN_RATE, &AF(DoCoolgMove), &s_CoolgRun[0][0]},
{SPR_COOLG_RUN, 'A', COOLG_RUN_RATE, &AF(DoCoolgMove), &s_CoolgRun[0][1]},
{SPR_COOLG_RUN, 'B', COOLG_RUN_RATE, &AF(DoCoolgMove), &s_CoolgRun[0][2]},
{SPR_COOLG_RUN, 'C', COOLG_RUN_RATE, &AF(DoCoolgMove), &s_CoolgRun[0][3]},
{SPR_COOLG_RUN, 'D', COOLG_RUN_RATE, &AF(DoCoolgMove), &s_CoolgRun[0][0]},
},
{
{COOLG_RUN_R1 + 0, COOLG_RUN_RATE, &AF(DoCoolgMove), &s_CoolgRun[1][1]},
{COOLG_RUN_R1 + 1, COOLG_RUN_RATE, &AF(DoCoolgMove), &s_CoolgRun[1][2]},
{COOLG_RUN_R1 + 2, COOLG_RUN_RATE, &AF(DoCoolgMove), &s_CoolgRun[1][3]},
{COOLG_RUN_R1 + 3, COOLG_RUN_RATE, &AF(DoCoolgMove), &s_CoolgRun[1][0]},
},
{
{COOLG_RUN_R2 + 0, COOLG_RUN_RATE, &AF(DoCoolgMove), &s_CoolgRun[2][1]},
{COOLG_RUN_R2 + 1, COOLG_RUN_RATE, &AF(DoCoolgMove), &s_CoolgRun[2][2]},
{COOLG_RUN_R2 + 2, COOLG_RUN_RATE, &AF(DoCoolgMove), &s_CoolgRun[2][3]},
{COOLG_RUN_R2 + 3, COOLG_RUN_RATE, &AF(DoCoolgMove), &s_CoolgRun[2][0]},
},
{
{COOLG_RUN_R3 + 0, COOLG_RUN_RATE, &AF(DoCoolgMove), &s_CoolgRun[3][1]},
{COOLG_RUN_R3 + 1, COOLG_RUN_RATE, &AF(DoCoolgMove), &s_CoolgRun[3][2]},
{COOLG_RUN_R3 + 2, COOLG_RUN_RATE, &AF(DoCoolgMove), &s_CoolgRun[3][3]},
{COOLG_RUN_R3 + 3, COOLG_RUN_RATE, &AF(DoCoolgMove), &s_CoolgRun[3][0]},
},
{
{COOLG_RUN_R4 + 0, COOLG_RUN_RATE, &AF(DoCoolgMove), &s_CoolgRun[4][1]},
{COOLG_RUN_R4 + 1, COOLG_RUN_RATE, &AF(DoCoolgMove), &s_CoolgRun[4][2]},
{COOLG_RUN_R4 + 2, COOLG_RUN_RATE, &AF(DoCoolgMove), &s_CoolgRun[4][3]},
{COOLG_RUN_R4 + 3, COOLG_RUN_RATE, &AF(DoCoolgMove), &s_CoolgRun[4][0]},
}
};
STATE* sg_CoolgRun[] =
{
&s_CoolgRun[0][0],
&s_CoolgRun[1][0],
&s_CoolgRun[2][0],
&s_CoolgRun[3][0],
&s_CoolgRun[4][0]
};
//////////////////////
@ -170,32 +142,16 @@ STATE* sg_CoolgRun[] =
//////////////////////
STATE s_CoolgStand[5][1] =
STATE s_CoolgStand[][1] =
{
{
{COOLG_RUN_R0 + 0, COOLG_RUN_RATE, &AF(DoCoolgMove), &s_CoolgStand[0][0]},
{SPR_COOLG_RUN, 'A', COOLG_RUN_RATE, &AF(DoCoolgMove), &s_CoolgStand[0][0]},
},
{
{COOLG_RUN_R1 + 0, COOLG_RUN_RATE, &AF(DoCoolgMove), &s_CoolgStand[1][0]},
},
{
{COOLG_RUN_R2 + 0, COOLG_RUN_RATE, &AF(DoCoolgMove), &s_CoolgStand[2][0]},
},
{
{COOLG_RUN_R3 + 0, COOLG_RUN_RATE, &AF(DoCoolgMove), &s_CoolgStand[3][0]},
},
{
{COOLG_RUN_R4 + 0, COOLG_RUN_RATE, &AF(DoCoolgMove), &s_CoolgStand[4][0]},
}
};
STATE* sg_CoolgStand[] =
{
&s_CoolgStand[0][0],
&s_CoolgStand[1][0],
&s_CoolgStand[2][0],
&s_CoolgStand[3][0],
&s_CoolgStand[4][0]
};
//////////////////////
@ -206,57 +162,21 @@ STATE* sg_CoolgStand[] =
#define COOLG_RATE 16
STATE s_CoolgClub[5][6] =
STATE s_CoolgClub[][6] =
{
{
{COOLG_CLUB_R0 + 0, COOLG_RATE, &AF(NullCoolg), &s_CoolgClub[0][1]},
{COOLG_RUN_R0 + 0, COOLG_RATE, &AF(NullCoolg), &s_CoolgClub[0][2]},
{COOLG_CLUB_R0 + 1, 0|SF_QUICK_CALL, &AF(InitCoolgBash), &s_CoolgClub[0][3]},
{COOLG_CLUB_R0 + 1, COOLG_RATE, &AF(NullCoolg), &s_CoolgClub[0][4]},
{COOLG_CLUB_R0 + 1, 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_CoolgClub[0][5]},
{COOLG_CLUB_R0 + 1, COOLG_RATE, &AF(DoCoolgMove), &s_CoolgClub[0][5]}
{SPR_COOLG_CLUB, 'A', COOLG_RATE, &AF(NullCoolg), &s_CoolgClub[0][1]},
{SPR_COOLG_RUN, 'A', COOLG_RATE, &AF(NullCoolg), &s_CoolgClub[0][2]},
{SPR_COOLG_CLUB, 'B', 0|SF_QUICK_CALL, &AF(InitCoolgBash), &s_CoolgClub[0][3]},
{SPR_COOLG_CLUB, 'B', COOLG_RATE, &AF(NullCoolg), &s_CoolgClub[0][4]},
{SPR_COOLG_CLUB, 'B', 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_CoolgClub[0][5]},
{SPR_COOLG_CLUB, 'B', COOLG_RATE, &AF(DoCoolgMove), &s_CoolgClub[0][5]}
},
{
{COOLG_CLUB_R1 + 0, COOLG_RATE, &AF(NullCoolg), &s_CoolgClub[1][1]},
{COOLG_RUN_R1 + 0, COOLG_RATE, &AF(NullCoolg), &s_CoolgClub[1][2]},
{COOLG_CLUB_R1 + 1, 0|SF_QUICK_CALL, &AF(InitCoolgBash), &s_CoolgClub[1][3]},
{COOLG_CLUB_R1 + 1, COOLG_RATE, &AF(NullCoolg), &s_CoolgClub[1][4]},
{COOLG_CLUB_R1 + 1, 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_CoolgClub[1][5]},
{COOLG_CLUB_R1 + 1, COOLG_RATE, &AF(DoCoolgMove), &s_CoolgClub[1][5]}
},
{
{COOLG_CLUB_R2 + 0, COOLG_RATE, &AF(NullCoolg), &s_CoolgClub[2][1]},
{COOLG_RUN_R2 + 0, COOLG_RATE, &AF(NullCoolg), &s_CoolgClub[2][2]},
{COOLG_CLUB_R2 + 1, 0|SF_QUICK_CALL, &AF(InitCoolgBash), &s_CoolgClub[2][3]},
{COOLG_CLUB_R2 + 1, COOLG_RATE, &AF(NullCoolg), &s_CoolgClub[2][4]},
{COOLG_CLUB_R2 + 1, 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_CoolgClub[2][5]},
{COOLG_CLUB_R2 + 1, COOLG_RATE, &AF(DoCoolgMove), &s_CoolgClub[2][5]}
},
{
{COOLG_CLUB_R3 + 0, COOLG_RATE, &AF(NullCoolg), &s_CoolgClub[3][1]},
{COOLG_RUN_R3 + 0, COOLG_RATE, &AF(NullCoolg), &s_CoolgClub[3][2]},
{COOLG_CLUB_R3 + 1, 0|SF_QUICK_CALL, &AF(InitCoolgBash), &s_CoolgClub[3][3]},
{COOLG_CLUB_R3 + 1, COOLG_RATE, &AF(NullCoolg), &s_CoolgClub[3][4]},
{COOLG_CLUB_R3 + 1, 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_CoolgClub[3][5]},
{COOLG_CLUB_R3 + 1, COOLG_RATE, &AF(DoCoolgMove), &s_CoolgClub[3][5]}
},
{
{COOLG_CLUB_R4 + 0, COOLG_RATE, &AF(NullCoolg), &s_CoolgClub[4][1]},
{COOLG_RUN_R4 + 0, COOLG_RATE, &AF(NullCoolg), &s_CoolgClub[4][2]},
{COOLG_CLUB_R4 + 1, 0|SF_QUICK_CALL, &AF(InitCoolgBash), &s_CoolgClub[4][3]},
{COOLG_CLUB_R4 + 1, COOLG_RATE, &AF(NullCoolg), &s_CoolgClub[4][4]},
{COOLG_CLUB_R4 + 1, 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_CoolgClub[4][5]},
{COOLG_CLUB_R4 + 1, COOLG_RATE, &AF(DoCoolgMove), &s_CoolgClub[4][5]}
}
};
STATE* sg_CoolgClub[] =
{
&s_CoolgClub[0][0],
&s_CoolgClub[1][0],
&s_CoolgClub[2][0],
&s_CoolgClub[3][0],
&s_CoolgClub[4][0]
};
//////////////////////
@ -267,62 +187,22 @@ STATE* sg_CoolgClub[] =
#define COOLG_FIRE_RATE 12
STATE s_CoolgAttack[5][7] =
STATE s_CoolgAttack[][7] =
{
{
{COOLG_FIRE_R0 + 0, COOLG_FIRE_RATE*2, &AF(NullCoolg), &s_CoolgAttack[0][1]},
{COOLG_FIRE_R0 + 1, COOLG_FIRE_RATE*2, &AF(NullCoolg), &s_CoolgAttack[0][2]},
{COOLG_FIRE_R0 + 2, COOLG_FIRE_RATE*2, &AF(NullCoolg), &s_CoolgAttack[0][3]},
{COOLG_FIRE_R0 + 2, 0|SF_QUICK_CALL, &AF(InitCoolgFire), &s_CoolgAttack[0][4]},
{COOLG_FIRE_R0 + 2, COOLG_FIRE_RATE, &AF(NullCoolg), &s_CoolgAttack[0][5]},
{COOLG_FIRE_R0 + 2, 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_CoolgAttack[0][6]},
{COOLG_RUN_R0 + 2, COOLG_FIRE_RATE, &AF(DoCoolgMove), &s_CoolgAttack[0][6]}
{SPR_COOLG_FIRE, 'A', COOLG_FIRE_RATE*2, &AF(NullCoolg), &s_CoolgAttack[0][1]},
{SPR_COOLG_FIRE, 'B', COOLG_FIRE_RATE*2, &AF(NullCoolg), &s_CoolgAttack[0][2]},
{SPR_COOLG_FIRE, 'C', COOLG_FIRE_RATE*2, &AF(NullCoolg), &s_CoolgAttack[0][3]},
{SPR_COOLG_FIRE, 'C', 0|SF_QUICK_CALL, &AF(InitCoolgFire), &s_CoolgAttack[0][4]},
{SPR_COOLG_FIRE, 'C', COOLG_FIRE_RATE, &AF(NullCoolg), &s_CoolgAttack[0][5]},
{SPR_COOLG_FIRE, 'C', 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_CoolgAttack[0][6]},
{SPR_COOLG_RUN, 'C', COOLG_FIRE_RATE, &AF(DoCoolgMove), &s_CoolgAttack[0][6]}
},
{
{COOLG_FIRE_R1 + 0, COOLG_FIRE_RATE*2, &AF(NullCoolg), &s_CoolgAttack[1][1]},
{COOLG_FIRE_R1 + 1, COOLG_FIRE_RATE*2, &AF(NullCoolg), &s_CoolgAttack[1][2]},
{COOLG_FIRE_R1 + 2, COOLG_FIRE_RATE*2, &AF(NullCoolg), &s_CoolgAttack[1][3]},
{COOLG_FIRE_R1 + 2, 0|SF_QUICK_CALL, &AF(InitCoolgFire), &s_CoolgAttack[1][4]},
{COOLG_FIRE_R1 + 2, COOLG_FIRE_RATE, &AF(NullCoolg), &s_CoolgAttack[1][5]},
{COOLG_FIRE_R1 + 2, 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_CoolgAttack[1][6]},
{COOLG_RUN_R0 + 2, COOLG_FIRE_RATE, &AF(DoCoolgMove), &s_CoolgAttack[1][6]}
},
{
{COOLG_FIRE_R2 + 0, COOLG_FIRE_RATE*2, &AF(NullCoolg), &s_CoolgAttack[2][1]},
{COOLG_FIRE_R2 + 1, COOLG_FIRE_RATE*2, &AF(NullCoolg), &s_CoolgAttack[2][2]},
{COOLG_FIRE_R2 + 2, COOLG_FIRE_RATE*2, &AF(NullCoolg), &s_CoolgAttack[2][3]},
{COOLG_FIRE_R2 + 2, 0|SF_QUICK_CALL, &AF(InitCoolgFire), &s_CoolgAttack[2][4]},
{COOLG_FIRE_R2 + 2, COOLG_FIRE_RATE, &AF(NullCoolg), &s_CoolgAttack[2][5]},
{COOLG_FIRE_R2 + 2, 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_CoolgAttack[2][6]},
{COOLG_RUN_R0 + 2, COOLG_FIRE_RATE, &AF(DoCoolgMove), &s_CoolgAttack[2][6]}
},
{
{COOLG_RUN_R3 + 0, COOLG_FIRE_RATE*2, &AF(NullCoolg), &s_CoolgAttack[3][1]},
{COOLG_RUN_R3 + 1, COOLG_FIRE_RATE*2, &AF(NullCoolg), &s_CoolgAttack[3][2]},
{COOLG_RUN_R3 + 2, COOLG_FIRE_RATE*2, &AF(NullCoolg), &s_CoolgAttack[3][3]},
{COOLG_RUN_R3 + 2, 0|SF_QUICK_CALL, &AF(InitCoolgFire), &s_CoolgAttack[3][4]},
{COOLG_RUN_R3 + 2, COOLG_FIRE_RATE, &AF(NullCoolg), &s_CoolgAttack[3][5]},
{COOLG_RUN_R3 + 2, 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_CoolgAttack[3][6]},
{COOLG_RUN_R0 + 2, COOLG_FIRE_RATE, &AF(DoCoolgMove), &s_CoolgAttack[3][6]}
},
{
{COOLG_RUN_R4 + 0, COOLG_FIRE_RATE*2, &AF(NullCoolg), &s_CoolgAttack[4][1]},
{COOLG_RUN_R4 + 1, COOLG_FIRE_RATE*2, &AF(NullCoolg), &s_CoolgAttack[4][2]},
{COOLG_RUN_R4 + 2, COOLG_FIRE_RATE*2, &AF(NullCoolg), &s_CoolgAttack[4][3]},
{COOLG_RUN_R4 + 2, 0|SF_QUICK_CALL, &AF(InitCoolgFire), &s_CoolgAttack[4][4]},
{COOLG_RUN_R4 + 2, COOLG_FIRE_RATE, &AF(NullCoolg), &s_CoolgAttack[4][5]},
{COOLG_RUN_R4 + 2, 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_CoolgAttack[4][6]},
{COOLG_RUN_R0 + 2, COOLG_FIRE_RATE, &AF(DoCoolgMove), &s_CoolgAttack[4][6]}
}
};
STATE* sg_CoolgAttack[] =
{
&s_CoolgAttack[0][0],
&s_CoolgAttack[1][0],
&s_CoolgAttack[2][0],
&s_CoolgAttack[3][0],
&s_CoolgAttack[4][0]
};
//////////////////////
@ -333,37 +213,17 @@ STATE* sg_CoolgAttack[] =
#define COOLG_PAIN_RATE 15
STATE s_CoolgPain[5][2] =
STATE s_CoolgPain[][2] =
{
{
{COOLG_PAIN_R0 + 0, COOLG_PAIN_RATE, &AF(DoCoolgPain), &s_CoolgPain[0][1]},
{COOLG_PAIN_R0 + 0, COOLG_PAIN_RATE, &AF(DoCoolgPain), &s_CoolgPain[0][1]},
},
{
{COOLG_RUN_R1 + 0, COOLG_PAIN_RATE, &AF(DoCoolgPain), &s_CoolgPain[1][1]},
{COOLG_RUN_R1 + 0, COOLG_PAIN_RATE, &AF(DoCoolgPain), &s_CoolgPain[1][1]},
},
{
{COOLG_RUN_R2 + 0, COOLG_PAIN_RATE, &AF(DoCoolgPain), &s_CoolgPain[2][1]},
{COOLG_RUN_R2 + 0, COOLG_PAIN_RATE, &AF(DoCoolgPain), &s_CoolgPain[2][1]},
},
{
{COOLG_RUN_R3 + 0, COOLG_PAIN_RATE, &AF(DoCoolgPain), &s_CoolgPain[3][1]},
{COOLG_RUN_R3 + 0, COOLG_PAIN_RATE, &AF(DoCoolgPain), &s_CoolgPain[3][1]},
},
{
{COOLG_RUN_R4 + 0, COOLG_PAIN_RATE, &AF(DoCoolgPain), &s_CoolgPain[4][1]},
{COOLG_RUN_R4 + 0, COOLG_PAIN_RATE, &AF(DoCoolgPain), &s_CoolgPain[4][1]},
{SPR_COOLG_PAIN, 'A', COOLG_PAIN_RATE, &AF(DoCoolgPain), &s_CoolgPain[0][1]},
{SPR_COOLG_PAIN, 'A', COOLG_PAIN_RATE, &AF(DoCoolgPain), &s_CoolgPain[0][1]},
},
};
STATE* sg_CoolgPain[] =
{
s_CoolgPain[0],
s_CoolgPain[1],
s_CoolgPain[2],
s_CoolgPain[3],
s_CoolgPain[4]
};
@ -375,16 +235,14 @@ STATE* sg_CoolgPain[] =
#define COOLG_DIE_RATE 20
#define COOLG_DIE 4307
#define COOLG_DEAD 4307+5
STATE s_CoolgDie[] =
{
{COOLG_DIE + 0, COOLG_DIE_RATE, &AF(DoCoolgDeath), &s_CoolgDie[1]},
{COOLG_DIE + 1, COOLG_DIE_RATE, &AF(DoCoolgDeath), &s_CoolgDie[2]},
{COOLG_DIE + 2, COOLG_DIE_RATE, &AF(DoCoolgDeath), &s_CoolgDie[3]},
{COOLG_DIE + 3, COOLG_DIE_RATE, &AF(DoCoolgDeath), &s_CoolgDie[4]},
{COOLG_DIE + 4, COOLG_DIE_RATE, &AF(DoCoolgDeath), &s_CoolgDie[5]},
{COOLG_DIE + 5, COOLG_DIE_RATE, &AF(DoCoolgDeath), &s_CoolgDie[5]},
{SPR_COOLG_DIE, 'A', COOLG_DIE_RATE, &AF(DoCoolgDeath), &s_CoolgDie[1]},
{SPR_COOLG_DIE, 'B', COOLG_DIE_RATE, &AF(DoCoolgDeath), &s_CoolgDie[2]},
{SPR_COOLG_DIE, 'C', COOLG_DIE_RATE, &AF(DoCoolgDeath), &s_CoolgDie[3]},
{SPR_COOLG_DIE, 'D', COOLG_DIE_RATE, &AF(DoCoolgDeath), &s_CoolgDie[4]},
{SPR_COOLG_DIE, 'E', COOLG_DIE_RATE, &AF(DoCoolgDeath), &s_CoolgDie[5]},
{SPR_COOLG_DIE, 'F', COOLG_DIE_RATE, &AF(DoCoolgDeath), &s_CoolgDie[5]},
};
STATE* sg_CoolgDie[] =
@ -394,8 +252,8 @@ STATE* sg_CoolgDie[] =
STATE s_CoolgDead[] =
{
{COOLG_DEAD, SF_QUICK_CALL, &AF(QueueFloorBlood), &s_CoolgDead[1]},
{COOLG_DEAD, COOLG_DIE_RATE, &AF(DoActorDebris), &s_CoolgDead[1]},
{SPR_COOLG_DEAD, 'A', SF_QUICK_CALL, &AF(QueueFloorBlood), &s_CoolgDead[1]},
{SPR_COOLG_DEAD, 'A', COOLG_DIE_RATE, &AF(DoActorDebris), &s_CoolgDead[1]},
};
STATE* sg_CoolgDead[] =
@ -410,21 +268,20 @@ STATE* sg_CoolgDead[] =
//////////////////////
#define COOLG_BIRTH_RATE 20
#define COOLG_BIRTH 4268
STATE s_CoolgBirth[] =
{
{COOLG_BIRTH + 0, COOLG_BIRTH_RATE, nullptr, &s_CoolgBirth[1]},
{COOLG_BIRTH + 1, COOLG_BIRTH_RATE, nullptr, &s_CoolgBirth[2]},
{COOLG_BIRTH + 2, COOLG_BIRTH_RATE, nullptr, &s_CoolgBirth[3]},
{COOLG_BIRTH + 3, COOLG_BIRTH_RATE, nullptr, &s_CoolgBirth[4]},
{COOLG_BIRTH + 4, COOLG_BIRTH_RATE, nullptr, &s_CoolgBirth[5]},
{COOLG_BIRTH + 5, COOLG_BIRTH_RATE, nullptr, &s_CoolgBirth[6]},
{COOLG_BIRTH + 6, COOLG_BIRTH_RATE, nullptr, &s_CoolgBirth[7]},
{COOLG_BIRTH + 7, COOLG_BIRTH_RATE, nullptr, &s_CoolgBirth[8]},
{COOLG_BIRTH + 8, COOLG_BIRTH_RATE, nullptr, &s_CoolgBirth[9]},
{COOLG_BIRTH + 8, COOLG_BIRTH_RATE, nullptr, &s_CoolgBirth[10]},
{COOLG_BIRTH + 8, 0|SF_QUICK_CALL, &AF(DoCoolgBirth), &s_CoolgBirth[10]}
{SPR_COOLG_BIRTH, 'A', COOLG_BIRTH_RATE, nullptr, &s_CoolgBirth[1]},
{SPR_COOLG_BIRTH, 'B', COOLG_BIRTH_RATE, nullptr, &s_CoolgBirth[2]},
{SPR_COOLG_BIRTH, 'C', COOLG_BIRTH_RATE, nullptr, &s_CoolgBirth[3]},
{SPR_COOLG_BIRTH, 'D', COOLG_BIRTH_RATE, nullptr, &s_CoolgBirth[4]},
{SPR_COOLG_BIRTH, 'E', COOLG_BIRTH_RATE, nullptr, &s_CoolgBirth[5]},
{SPR_COOLG_BIRTH, 'F', COOLG_BIRTH_RATE, nullptr, &s_CoolgBirth[6]},
{SPR_COOLG_BIRTH, 'G', COOLG_BIRTH_RATE, nullptr, &s_CoolgBirth[7]},
{SPR_COOLG_BIRTH, 'H', COOLG_BIRTH_RATE, nullptr, &s_CoolgBirth[8]},
{SPR_COOLG_BIRTH, 'I', COOLG_BIRTH_RATE, nullptr, &s_CoolgBirth[9]},
{SPR_COOLG_BIRTH, 'I', COOLG_BIRTH_RATE, nullptr, &s_CoolgBirth[10]},
{SPR_COOLG_BIRTH, 'I', 0 | SF_QUICK_CALL, &AF(DoCoolgBirth), &s_CoolgBirth[10]}
};
STATE* sg_CoolgBirth[] =

147
source/games/sw/src/coolie.cpp
View file

@ -116,47 +116,19 @@ ATTRIBUTE CoolieAttrib =
#define COOLIE_RATE 12
STATE s_CoolieRun[5][4] =
STATE s_CoolieRun[][4] =
{
{
{COOLIE_RUN_R0 + 0, COOLIE_RATE, &AF(DoCoolieMove), &s_CoolieRun[0][1]},
{COOLIE_RUN_R0 + 1, COOLIE_RATE, &AF(DoCoolieMove), &s_CoolieRun[0][2]},
{COOLIE_RUN_R0 + 2, COOLIE_RATE, &AF(DoCoolieMove), &s_CoolieRun[0][3]},
{COOLIE_RUN_R0 + 3, COOLIE_RATE, &AF(DoCoolieMove), &s_CoolieRun[0][0]}
{SPR_COOLIE_RUN, 'A', COOLIE_RATE, &AF(DoCoolieMove), &s_CoolieRun[0][1]},
{SPR_COOLIE_RUN, 'B', COOLIE_RATE, &AF(DoCoolieMove), &s_CoolieRun[0][2]},
{SPR_COOLIE_RUN, 'C', COOLIE_RATE, &AF(DoCoolieMove), &s_CoolieRun[0][3]},
{SPR_COOLIE_RUN, 'D', COOLIE_RATE, &AF(DoCoolieMove), &s_CoolieRun[0][0]}
},
{
{COOLIE_RUN_R1 + 0, COOLIE_RATE, &AF(DoCoolieMove), &s_CoolieRun[1][1]},
{COOLIE_RUN_R1 + 1, COOLIE_RATE, &AF(DoCoolieMove), &s_CoolieRun[1][2]},
{COOLIE_RUN_R1 + 2, COOLIE_RATE, &AF(DoCoolieMove), &s_CoolieRun[1][3]},
{COOLIE_RUN_R1 + 3, COOLIE_RATE, &AF(DoCoolieMove), &s_CoolieRun[1][0]}
},
{
{COOLIE_RUN_R2 + 0, COOLIE_RATE, &AF(DoCoolieMove), &s_CoolieRun[2][1]},
{COOLIE_RUN_R2 + 1, COOLIE_RATE, &AF(DoCoolieMove), &s_CoolieRun[2][2]},
{COOLIE_RUN_R2 + 2, COOLIE_RATE, &AF(DoCoolieMove), &s_CoolieRun[2][3]},
{COOLIE_RUN_R2 + 3, COOLIE_RATE, &AF(DoCoolieMove), &s_CoolieRun[2][0]}
},
{
{COOLIE_RUN_R3 + 0, COOLIE_RATE, &AF(DoCoolieMove), &s_CoolieRun[3][1]},
{COOLIE_RUN_R3 + 1, COOLIE_RATE, &AF(DoCoolieMove), &s_CoolieRun[3][2]},
{COOLIE_RUN_R3 + 2, COOLIE_RATE, &AF(DoCoolieMove), &s_CoolieRun[3][3]},
{COOLIE_RUN_R3 + 3, COOLIE_RATE, &AF(DoCoolieMove), &s_CoolieRun[3][0]}
},
{
{COOLIE_RUN_R4 + 0, COOLIE_RATE, &AF(DoCoolieMove), &s_CoolieRun[4][1]},
{COOLIE_RUN_R4 + 1, COOLIE_RATE, &AF(DoCoolieMove), &s_CoolieRun[4][2]},
{COOLIE_RUN_R4 + 2, COOLIE_RATE, &AF(DoCoolieMove), &s_CoolieRun[4][3]},
{COOLIE_RUN_R4 + 3, COOLIE_RATE, &AF(DoCoolieMove), &s_CoolieRun[4][0]},
}
};
STATE* sg_CoolieRun[] =
{
&s_CoolieRun[0][0],
&s_CoolieRun[1][0],
&s_CoolieRun[2][0],
&s_CoolieRun[3][0],
&s_CoolieRun[4][0]
};
//////////////////////
@ -167,47 +139,19 @@ STATE* sg_CoolieRun[] =
#define COOLIE_RATE 12
STATE s_CoolieCharge[5][4] =
STATE s_CoolieCharge[][4] =
{
{
{COOLIE_CHARGE_R0 + 0, COOLIE_RATE, &AF(DoCoolieMove), &s_CoolieCharge[0][1]},
{COOLIE_CHARGE_R0 + 1, COOLIE_RATE, &AF(DoCoolieMove), &s_CoolieCharge[0][2]},
{COOLIE_CHARGE_R0 + 2, COOLIE_RATE, &AF(DoCoolieMove), &s_CoolieCharge[0][3]},
{COOLIE_CHARGE_R0 + 3, COOLIE_RATE, &AF(DoCoolieMove), &s_CoolieCharge[0][0]}
{SPR_COOLIE_CHARGE, 'A', COOLIE_RATE, &AF(DoCoolieMove), &s_CoolieCharge[0][1]},
{SPR_COOLIE_CHARGE, 'B', COOLIE_RATE, &AF(DoCoolieMove), &s_CoolieCharge[0][2]},
{SPR_COOLIE_CHARGE, 'C', COOLIE_RATE, &AF(DoCoolieMove), &s_CoolieCharge[0][3]},
{SPR_COOLIE_CHARGE, 'D', COOLIE_RATE, &AF(DoCoolieMove), &s_CoolieCharge[0][0]}
},
{
{COOLIE_CHARGE_R1 + 0, COOLIE_RATE, &AF(DoCoolieMove), &s_CoolieCharge[1][1]},
{COOLIE_CHARGE_R1 + 1, COOLIE_RATE, &AF(DoCoolieMove), &s_CoolieCharge[1][2]},
{COOLIE_CHARGE_R1 + 2, COOLIE_RATE, &AF(DoCoolieMove), &s_CoolieCharge[1][3]},
{COOLIE_CHARGE_R1 + 3, COOLIE_RATE, &AF(DoCoolieMove), &s_CoolieCharge[1][0]}
},
{
{COOLIE_CHARGE_R2 + 0, COOLIE_RATE, &AF(DoCoolieMove), &s_CoolieCharge[2][1]},
{COOLIE_CHARGE_R2 + 1, COOLIE_RATE, &AF(DoCoolieMove), &s_CoolieCharge[2][2]},
{COOLIE_CHARGE_R2 + 2, COOLIE_RATE, &AF(DoCoolieMove), &s_CoolieCharge[2][3]},
{COOLIE_CHARGE_R2 + 3, COOLIE_RATE, &AF(DoCoolieMove), &s_CoolieCharge[2][0]}
},
{
{COOLIE_CHARGE_R3 + 0, COOLIE_RATE, &AF(DoCoolieMove), &s_CoolieCharge[3][1]},
{COOLIE_CHARGE_R3 + 1, COOLIE_RATE, &AF(DoCoolieMove), &s_CoolieCharge[3][2]},
{COOLIE_CHARGE_R3 + 2, COOLIE_RATE, &AF(DoCoolieMove), &s_CoolieCharge[3][3]},
{COOLIE_CHARGE_R3 + 3, COOLIE_RATE, &AF(DoCoolieMove), &s_CoolieCharge[3][0]}
},
{
{COOLIE_CHARGE_R4 + 0, COOLIE_RATE, &AF(DoCoolieMove), &s_CoolieCharge[4][1]},
{COOLIE_CHARGE_R4 + 1, COOLIE_RATE, &AF(DoCoolieMove), &s_CoolieCharge[4][2]},
{COOLIE_CHARGE_R4 + 2, COOLIE_RATE, &AF(DoCoolieMove), &s_CoolieCharge[4][3]},
{COOLIE_CHARGE_R4 + 3, COOLIE_RATE, &AF(DoCoolieMove), &s_CoolieCharge[4][0]},
}
};
STATE* sg_CoolieCharge[] =
{
&s_CoolieCharge[0][0],
&s_CoolieCharge[1][0],
&s_CoolieCharge[2][0],
&s_CoolieCharge[3][0],
&s_CoolieCharge[4][0]
};
//////////////////////
@ -216,32 +160,16 @@ STATE* sg_CoolieCharge[] =
//
//////////////////////
STATE s_CoolieStand[5][6] =
STATE s_CoolieStand[][6] =
{
{
{COOLIE_RUN_R0 + 0, COOLIE_RATE, &AF(DoCoolieMove), &s_CoolieStand[0][0]}
{SPR_COOLIE_RUN, 'A', COOLIE_RATE, &AF(DoCoolieMove), &s_CoolieStand[0][0]}
},
{
{COOLIE_RUN_R1 + 0, COOLIE_RATE, &AF(DoCoolieMove), &s_CoolieStand[1][0]}
},
{
{COOLIE_RUN_R2 + 0, COOLIE_RATE, &AF(DoCoolieMove), &s_CoolieStand[2][0]}
},
{
{COOLIE_RUN_R3 + 0, COOLIE_RATE, &AF(DoCoolieMove), &s_CoolieStand[3][0]}
},
{
{COOLIE_RUN_R4 + 0, COOLIE_RATE, &AF(DoCoolieMove), &s_CoolieStand[4][0]}
}
};
STATE* sg_CoolieStand[] =
{
&s_CoolieStand[0][0],
&s_CoolieStand[1][0],
&s_CoolieStand[2][0],
&s_CoolieStand[3][0],
&s_CoolieStand[4][0]
};
//////////////////////
@ -252,32 +180,16 @@ STATE* sg_CoolieStand[] =
#define COOLIE_PAIN_RATE 60
STATE s_CooliePain[5][1] =
STATE s_CooliePain[][1] =
{
{
{COOLIE_PAIN_R0 + 0, COOLIE_PAIN_RATE, &AF(CooliePain), &s_CooliePain[0][0]},
{SPR_COOLIE_PAIN, 'A', COOLIE_PAIN_RATE, &AF(CooliePain), &s_CooliePain[0][0]},
},
{
{COOLIE_PAIN_R1 + 0, COOLIE_PAIN_RATE, &AF(CooliePain), &s_CooliePain[1][0]},
},
{
{COOLIE_PAIN_R2 + 0, COOLIE_PAIN_RATE, &AF(CooliePain), &s_CooliePain[2][0]},
},
{
{COOLIE_PAIN_R3 + 0, COOLIE_PAIN_RATE, &AF(CooliePain), &s_CooliePain[3][0]},
},
{
{COOLIE_PAIN_R4 + 0, COOLIE_PAIN_RATE, &AF(CooliePain), &s_CooliePain[4][0]},
}
};
STATE* sg_CooliePain[] =
{
&s_CooliePain[0][0],
&s_CooliePain[1][0],
&s_CooliePain[2][0],
&s_CooliePain[3][0],
&s_CooliePain[4][0]
};
//////////////////////
@ -290,22 +202,22 @@ STATE* sg_CooliePain[] =
STATE s_CoolieDie[] =
{
{COOLIE_DIE + 0, COOLIE_DIE_RATE, &AF(NullCoolie), &s_CoolieDie[1]},
{SPR_COOLIE_DIE, 'A', COOLIE_DIE_RATE, &AF(NullCoolie), &s_CoolieDie[1]},
{COOLIE_DIE + 0, 0|SF_QUICK_CALL, &AF(SpawnCoolieExp), &s_CoolieDie[2]},
{SPR_COOLIE_DIE, 'A', 0|SF_QUICK_CALL, &AF(SpawnCoolieExp), &s_CoolieDie[2]},
{COOLIE_DIE + 1, COOLIE_DIE_RATE, &AF(NullCoolie), &s_CoolieDie[3]},
{COOLIE_DIE + 2, COOLIE_DIE_RATE, &AF(NullCoolie), &s_CoolieDie[4]},
{COOLIE_DIE + 3, COOLIE_DIE_RATE, &AF(NullCoolie), &s_CoolieDie[5]},
{COOLIE_DIE + 4, COOLIE_DIE_RATE, &AF(NullCoolie), &s_CoolieDie[6]},
{COOLIE_DIE + 5, COOLIE_DIE_RATE, &AF(NullCoolie), &s_CoolieDie[7]},
{COOLIE_DIE + 6, COOLIE_DIE_RATE, &AF(NullCoolie), &s_CoolieDie[8]},
{COOLIE_DIE + 7, COOLIE_DIE_RATE, &AF(DoCoolieWaitBirth), &s_CoolieDie[8]},
{SPR_COOLIE_DIE, 'B', COOLIE_DIE_RATE, &AF(NullCoolie), &s_CoolieDie[3]},
{SPR_COOLIE_DIE, 'C', COOLIE_DIE_RATE, &AF(NullCoolie), &s_CoolieDie[4]},
{SPR_COOLIE_DIE, 'D', COOLIE_DIE_RATE, &AF(NullCoolie), &s_CoolieDie[5]},
{SPR_COOLIE_DIE, 'E', COOLIE_DIE_RATE, &AF(NullCoolie), &s_CoolieDie[6]},
{SPR_COOLIE_DIE, 'F', COOLIE_DIE_RATE, &AF(NullCoolie), &s_CoolieDie[7]},
{SPR_COOLIE_DIE, 'G', COOLIE_DIE_RATE, &AF(NullCoolie), &s_CoolieDie[8]},
{SPR_COOLIE_DIE, 'H', COOLIE_DIE_RATE, &AF(DoCoolieWaitBirth), &s_CoolieDie[8]},
{COOLIE_DIE + 7, COOLIE_DIE_RATE*5, &AF(DoActorDebris), &s_CoolieDie[10]},
{COOLIE_DIE + 7, 0|SF_QUICK_CALL, &AF(SpawnCoolg), &s_CoolieDie[11]},
{COOLIE_DEAD_NOHEAD, SF_QUICK_CALL, &AF(QueueFloorBlood), &s_CoolieDie[12]},
{COOLIE_DEAD_NOHEAD, COOLIE_DIE_RATE, &AF(DoActorDebris), &s_CoolieDie[12]}
{SPR_COOLIE_DIE, 'H', COOLIE_DIE_RATE*5, &AF(DoActorDebris), &s_CoolieDie[10]},
{SPR_COOLIE_DIE, 'H', 0|SF_QUICK_CALL, &AF(SpawnCoolg), &s_CoolieDie[11]},
{SPR_COOLIE_DEAD_NOHEAD, 'A', SF_QUICK_CALL, &AF(QueueFloorBlood), &s_CoolieDie[12]},
{SPR_COOLIE_DEAD_NOHEAD, 'A', COOLIE_DIE_RATE, &AF(DoActorDebris), &s_CoolieDie[12]}
};
STATE* sg_CoolieDie[] =
@ -315,7 +227,7 @@ STATE* sg_CoolieDie[] =
STATE s_CoolieDead[] =
{
{COOLIE_DEAD, COOLIE_DIE_RATE, &AF(DoActorDebris), &s_CoolieDead[0]},
{SPR_COOLIE_DEAD, 'A', COOLIE_DIE_RATE, &AF(DoActorDebris), &s_CoolieDead[0]},
};
STATE* sg_CoolieDead[] =
@ -391,7 +303,6 @@ void EnemyDefaults(DSWActor* actor, ACTOR_ACTION_SET* action, PERSONALITY* perso
actor->user.spal = actor->spr.pal;
actor->user.__legacyState.RotNum = 5;
actor->clipdist = 16;
actor->user.zclip = 48;
@ -409,7 +320,7 @@ void EnemyDefaults(DSWActor* actor, ACTOR_ACTION_SET* action, PERSONALITY* perso
actor->spr.cstat |= (CSTAT_SPRITE_BLOCK|CSTAT_SPRITE_BLOCK_HITSCAN);
actor->spr.extra |= (SPRX_PLAYER_OR_ENEMY);
actor->spr.picnum = actor->user.__legacyState.State->Pic;
actor->setPicFromState();
change_actor_stat(actor, STAT_ENEMY);
actor->user.Personality = person;

89
source/games/sw/src/draw.cpp
View file

@ -98,8 +98,7 @@ void ShadeSprite(tspritetype* tsp)
//
//
//---------------------------------------------------------------------------
int GetRotation(tspriteArray& tsprites, int tSpriteNum, const DVector2& view)
int SetActorRotation(tspriteArray& tsprites, int tSpriteNum, const DVector2& viewpos)
{
static const uint8_t RotTable8[] = {0, 7, 6, 5, 4, 3, 2, 1};
static const uint8_t RotTable5[] = {0, 1, 2, 3, 4, 3, 2, 1};
@ -108,16 +107,33 @@ int GetRotation(tspriteArray& tsprites, int tSpriteNum, const DVector2& view)
tspritetype* tsp = tsprites.get(tSpriteNum);
auto ownerActor = static_cast<DSWActor*>(tsp->ownerActor);
if (!ownerActor->hasU() || ownerActor->user.__legacyState.RotNum == 0)
if (!ownerActor->hasU() || ownerActor->user.__legacyState.State == nullptr)
return 0;
unsigned sprite = ownerActor->user.__legacyState.State->Sprite;
unsigned frame = ownerActor->user.__legacyState.State->Frame - 'A';
if (SpriteDefs.Size() <= sprite) return 0;
auto spdef = &SpriteDefs[sprite];
if (SpriteFrames.Size() <= spdef->numframes) return 0;
auto spframe = &SpriteFrames[spdef->spriteframes + frame];
if (spframe->RotMode == 0) return 0;
if (spframe->RotMode == 1)
{
tsp->setspritetexture(spframe->Texture[0]);
return 0;
}
if (spframe->RotMode != 5 && spframe->RotMode != 8) return 0;
// Get which of the 8 angles of the sprite to draw (0-7)
// rotation ranges from 0-7
DAngle angle2 = (tsp->pos - view).Angle();
DAngle angle2 = (tsp->pos - viewpos).Angle();
rotation = (tsp->Angles.Yaw + DAngle180 + DAngle22_5 * 0.5 - angle2).Buildang() & 2047;
rotation = (rotation >> 8) & 7;
if (ownerActor->user.__legacyState.RotNum == 5)
if (spframe->RotMode == 5)
{
if ((ownerActor->user.Flags & SPR_XFLIP_TOGGLE))
{
@ -153,60 +169,11 @@ int GetRotation(tspriteArray& tsprites, int tSpriteNum, const DVector2& view)
ID == SAILORGIRL_R0)
tsp->cstat &= ~(CSTAT_SPRITE_XFLIP); // clear x-flipping bit
return RotTable5[rotation];
tsp->setspritetexture(spframe->Texture[RotTable5[rotation]]);
return 0;
}
return RotTable8[rotation];
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
/*
!AIC - At draw time this is called for actor rotation. GetRotation() is more
complex than needs to be in part because importing of actor rotations and x-flip
directions was not standardized.
*/
int SetActorRotation(tspriteArray& tsprites, int tSpriteNum, const DVector2& viewpos)
{
tspritetype* tsp = tsprites.get(tSpriteNum);
auto ownerActor = static_cast<DSWActor*>(tsp->ownerActor);
int StateOffset, Rotation;
if (!ownerActor->hasU()) return 0;
// don't modify ANY tu vars - back them up!
STATE* State = ownerActor->user.__legacyState.State;
STATE* StateStart = ownerActor->user.__legacyState.StateStart;
if (ownerActor->user.__legacyState.RotNum == 0)
return 0;
// Get the offset into the State animation
StateOffset = int(State - StateStart);
// Get the rotation angle
Rotation = GetRotation(tsprites, tSpriteNum, viewpos);
ASSERT(Rotation < 5);
// Reset the State animation start based on the Rotation
StateStart = ownerActor->user.__legacyState.Rot[Rotation];
// Set the sprites state
State = StateStart + StateOffset;
// set the picnum here - may be redundant, but we just changed states and
// thats a big deal
tsp->picnum = State->Pic;
tsp->setspritetexture(spframe->Texture[RotTable8[rotation]]);
return 0;
}
@ -512,9 +479,9 @@ void DoStarView(tspritetype* tsp, DSWActor* tActor, double viewz)
if (abs(zdiff) > 24)
{
if (tActor->user.__legacyState.StateStart == s_StarStuck)
tsp->picnum = s_StarDownStuck[tActor->user.__legacyState.State - s_StarStuck].Pic;
tsp->setspritetexture(picFromState(&s_StarDownStuck[tActor->user.__legacyState.State - s_StarStuck]));
else
tsp->picnum = s_StarDown[tActor->user.__legacyState.State - s_Star].Pic;
tsp->setspritetexture(picFromState(&s_StarDown[tActor->user.__legacyState.State - s_Star]));
if (zdiff > 0)
tsp->cstat |= (CSTAT_SPRITE_YFLIP);
@ -702,8 +669,7 @@ static void analyzesprites(tspriteArray& tsprites, const DVector3& viewpos, doub
}
// rotation
if (tActor->user.__legacyState.RotNum > 0)
SetActorRotation(tsprites, tSpriteNum, viewpos.XY());
SetActorRotation(tsprites, tSpriteNum, viewpos.XY());
if (tActor->user.motion_blur_num)
{
@ -1099,7 +1065,6 @@ void PreDrawStackedWater(void)
actorNew->user.__legacyState.StateEnd = itActor2->user.__legacyState.StateEnd;
actorNew->user.Flags = itActor2->user.Flags;
actorNew->user.Flags2 = itActor2->user.Flags2;
actorNew->user.__legacyState.RotNum = itActor2->user.__legacyState.RotNum;
actorNew->user.ID = itActor2->user.ID;
actorNew->user.PlayerP = itActor2->user.PlayerP;

128
source/games/sw/src/eel.cpp
View file

@ -116,47 +116,19 @@ ATTRIBUTE EelAttrib =
#define EEL_RUN_RATE 20
STATE s_EelRun[5][4] =
STATE s_EelRun[][4] =
{
{
{EEL_RUN_R0 + 0, EEL_RUN_RATE, &AF(DoEelMove), &s_EelRun[0][1]},
{EEL_RUN_R0 + 1, EEL_RUN_RATE, &AF(DoEelMove), &s_EelRun[0][2]},
{EEL_RUN_R0 + 2, EEL_RUN_RATE, &AF(DoEelMove), &s_EelRun[0][3]},
{EEL_RUN_R0 + 1, EEL_RUN_RATE, &AF(DoEelMove), &s_EelRun[0][0]},
{SPR_EEL_RUN, 'A', EEL_RUN_RATE, &AF(DoEelMove), &s_EelRun[0][1]},
{SPR_EEL_RUN, 'B', EEL_RUN_RATE, &AF(DoEelMove), &s_EelRun[0][2]},
{SPR_EEL_RUN, 'C', EEL_RUN_RATE, &AF(DoEelMove), &s_EelRun[0][3]},
{SPR_EEL_RUN, 'B', EEL_RUN_RATE, &AF(DoEelMove), &s_EelRun[0][0]},
},
{
{EEL_RUN_R1 + 0, EEL_RUN_RATE, &AF(DoEelMove), &s_EelRun[1][1]},
{EEL_RUN_R1 + 1, EEL_RUN_RATE, &AF(DoEelMove), &s_EelRun[1][2]},
{EEL_RUN_R1 + 2, EEL_RUN_RATE, &AF(DoEelMove), &s_EelRun[1][3]},
{EEL_RUN_R1 + 1, EEL_RUN_RATE, &AF(DoEelMove), &s_EelRun[1][0]},
},
{
{EEL_RUN_R2 + 0, EEL_RUN_RATE, &AF(DoEelMove), &s_EelRun[2][1]},
{EEL_RUN_R2 + 1, EEL_RUN_RATE, &AF(DoEelMove), &s_EelRun[2][2]},
{EEL_RUN_R2 + 2, EEL_RUN_RATE, &AF(DoEelMove), &s_EelRun[2][3]},
{EEL_RUN_R2 + 1, EEL_RUN_RATE, &AF(DoEelMove), &s_EelRun[2][0]},
},
{
{EEL_RUN_R3 + 0, EEL_RUN_RATE, &AF(DoEelMove), &s_EelRun[3][1]},
{EEL_RUN_R3 + 1, EEL_RUN_RATE, &AF(DoEelMove), &s_EelRun[3][2]},
{EEL_RUN_R3 + 2, EEL_RUN_RATE, &AF(DoEelMove), &s_EelRun[3][3]},
{EEL_RUN_R3 + 1, EEL_RUN_RATE, &AF(DoEelMove), &s_EelRun[3][0]},
},
{
{EEL_RUN_R4 + 0, EEL_RUN_RATE, &AF(DoEelMove), &s_EelRun[4][1]},
{EEL_RUN_R4 + 1, EEL_RUN_RATE, &AF(DoEelMove), &s_EelRun[4][2]},
{EEL_RUN_R4 + 2, EEL_RUN_RATE, &AF(DoEelMove), &s_EelRun[4][3]},
{EEL_RUN_R4 + 1, EEL_RUN_RATE, &AF(DoEelMove), &s_EelRun[4][0]},
}
};
STATE* sg_EelRun[] =
{
&s_EelRun[0][0],
&s_EelRun[1][0],
&s_EelRun[2][0],
&s_EelRun[3][0],
&s_EelRun[4][0]
};
//////////////////////
@ -166,32 +138,16 @@ STATE* sg_EelRun[] =
//////////////////////
STATE s_EelStand[5][1] =
STATE s_EelStand[][1] =
{
{
{EEL_RUN_R0 + 0, EEL_RUN_RATE, &AF(DoEelMove), &s_EelStand[0][0]},
{SPR_EEL_RUN, 'A', EEL_RUN_RATE, &AF(DoEelMove), &s_EelStand[0][0]},
},
{
{EEL_RUN_R1 + 0, EEL_RUN_RATE, &AF(DoEelMove), &s_EelStand[1][0]},
},
{
{EEL_RUN_R2 + 0, EEL_RUN_RATE, &AF(DoEelMove), &s_EelStand[2][0]},
},
{
{EEL_RUN_R3 + 0, EEL_RUN_RATE, &AF(DoEelMove), &s_EelStand[3][0]},
},
{
{EEL_RUN_R4 + 0, EEL_RUN_RATE, &AF(DoEelMove), &s_EelStand[4][0]},
}
};
STATE* sg_EelStand[] =
{
&s_EelStand[0][0],
&s_EelStand[1][0],
&s_EelStand[2][0],
&s_EelStand[3][0],
&s_EelStand[4][0]
};
//////////////////////
@ -202,62 +158,22 @@ STATE* sg_EelStand[] =
#define EEL_FIRE_RATE 12
STATE s_EelAttack[5][7] =
STATE s_EelAttack[][7] =
{
{
{EEL_FIRE_R0 + 0, EEL_FIRE_RATE*2, &AF(NullEel), &s_EelAttack[0][1]},
{EEL_FIRE_R0 + 1, EEL_FIRE_RATE*2, &AF(NullEel), &s_EelAttack[0][2]},
{EEL_FIRE_R0 + 2, EEL_FIRE_RATE*2, &AF(NullEel), &s_EelAttack[0][3]},
{EEL_FIRE_R0 + 2, 0|SF_QUICK_CALL, &AF(InitEelFire), &s_EelAttack[0][4]},
{EEL_FIRE_R0 + 2, EEL_FIRE_RATE, &AF(NullEel), &s_EelAttack[0][5]},
{EEL_FIRE_R0 + 3, 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_EelAttack[0][6]},
{EEL_RUN_R0 + 3, EEL_FIRE_RATE, &AF(DoEelMove), &s_EelAttack[0][6]}
{SPR_EEL_FIRE, 'A', EEL_FIRE_RATE*2, &AF(NullEel), &s_EelAttack[0][1]},
{SPR_EEL_FIRE, 'B', EEL_FIRE_RATE*2, &AF(NullEel), &s_EelAttack[0][2]},
{SPR_EEL_FIRE, 'C', EEL_FIRE_RATE*2, &AF(NullEel), &s_EelAttack[0][3]},
{SPR_EEL_FIRE, 'C', 0|SF_QUICK_CALL, &AF(InitEelFire), &s_EelAttack[0][4]},
{SPR_EEL_FIRE, 'C', EEL_FIRE_RATE, &AF(NullEel), &s_EelAttack[0][5]},
{SPR_EEL_FIRE, 'D', 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_EelAttack[0][6]},
{SPR_EEL_RUN, 'D', EEL_FIRE_RATE, &AF(DoEelMove), &s_EelAttack[0][6]}
},
{
{EEL_FIRE_R1 + 0, EEL_FIRE_RATE*2, &AF(NullEel), &s_EelAttack[1][1]},
{EEL_FIRE_R1 + 1, EEL_FIRE_RATE*2, &AF(NullEel), &s_EelAttack[1][2]},
{EEL_FIRE_R1 + 2, EEL_FIRE_RATE*2, &AF(NullEel), &s_EelAttack[1][3]},
{EEL_FIRE_R1 + 2, 0|SF_QUICK_CALL, &AF(InitEelFire), &s_EelAttack[1][5]},
{EEL_FIRE_R1 + 2, EEL_FIRE_RATE, &AF(NullEel), &s_EelAttack[1][6]},
{EEL_FIRE_R1 + 3, 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_EelAttack[1][7]},
{EEL_RUN_R0 + 3, EEL_FIRE_RATE, &AF(DoEelMove), &s_EelAttack[1][7]}
},
{
{EEL_FIRE_R2 + 0, EEL_FIRE_RATE*2, &AF(NullEel), &s_EelAttack[2][1]},
{EEL_FIRE_R2 + 1, EEL_FIRE_RATE*2, &AF(NullEel), &s_EelAttack[2][2]},
{EEL_FIRE_R2 + 2, EEL_FIRE_RATE*2, &AF(NullEel), &s_EelAttack[2][3]},
{EEL_FIRE_R2 + 2, 0|SF_QUICK_CALL, &AF(InitEelFire), &s_EelAttack[2][4]},
{EEL_FIRE_R2 + 2, EEL_FIRE_RATE, &AF(NullEel), &s_EelAttack[2][5]},
{EEL_FIRE_R2 + 3, 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_EelAttack[2][6]},
{EEL_RUN_R0 + 3, EEL_FIRE_RATE, &AF(DoEelMove), &s_EelAttack[2][6]}
},
{
{EEL_RUN_R3 + 0, EEL_FIRE_RATE*2, &AF(NullEel), &s_EelAttack[3][1]},
{EEL_RUN_R3 + 1, EEL_FIRE_RATE*2, &AF(NullEel), &s_EelAttack[3][2]},
{EEL_RUN_R3 + 2, EEL_FIRE_RATE*2, &AF(NullEel), &s_EelAttack[3][3]},
{EEL_RUN_R3 + 2, 0|SF_QUICK_CALL, &AF(InitEelFire), &s_EelAttack[3][4]},
{EEL_RUN_R3 + 2, EEL_FIRE_RATE, &AF(NullEel), &s_EelAttack[3][5]},
{EEL_RUN_R3 + 3, 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_EelAttack[3][6]},
{EEL_RUN_R0 + 3, EEL_FIRE_RATE, &AF(DoEelMove), &s_EelAttack[3][6]}
},
{
{EEL_RUN_R4 + 0, EEL_FIRE_RATE*2, &AF(NullEel), &s_EelAttack[4][1]},
{EEL_RUN_R4 + 1, EEL_FIRE_RATE*2, &AF(NullEel), &s_EelAttack[4][2]},
{EEL_RUN_R4 + 2, EEL_FIRE_RATE*2, &AF(NullEel), &s_EelAttack[4][3]},
{EEL_RUN_R4 + 2, 0|SF_QUICK_CALL, &AF(InitEelFire), &s_EelAttack[4][4]},
{EEL_RUN_R4 + 2, EEL_FIRE_RATE, &AF(NullEel), &s_EelAttack[4][5]},
{EEL_RUN_R4 + 3, 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_EelAttack[4][6]},
{EEL_RUN_R0 + 3, EEL_FIRE_RATE, &AF(DoEelMove), &s_EelAttack[4][6]}
}
};
STATE* sg_EelAttack[] =
{
&s_EelAttack[0][0],
&s_EelAttack[1][0],
&s_EelAttack[2][0],
&s_EelAttack[3][0],
&s_EelAttack[4][0]
};
@ -271,12 +187,12 @@ STATE* sg_EelAttack[] =
STATE s_EelDie[] =
{
{EEL_DIE + 0, EEL_DIE_RATE, &AF(DoEelDeath), &s_EelDie[1]},
{EEL_DIE + 0, EEL_DIE_RATE, &AF(DoEelDeath), &s_EelDie[2]},
{EEL_DIE + 0, EEL_DIE_RATE, &AF(DoEelDeath), &s_EelDie[3]},
{EEL_DIE + 0, EEL_DIE_RATE, &AF(DoEelDeath), &s_EelDie[4]},
{EEL_DIE + 0, EEL_DIE_RATE, &AF(DoEelDeath), &s_EelDie[5]},
{EEL_DIE + 0, EEL_DIE_RATE, &AF(DoEelDeath), &s_EelDie[5]},
{SPR_EEL_DIE, 'A', EEL_DIE_RATE, &AF(DoEelDeath), &s_EelDie[1]},
{SPR_EEL_DIE, 'A', EEL_DIE_RATE, &AF(DoEelDeath), &s_EelDie[2]},
{SPR_EEL_DIE, 'A', EEL_DIE_RATE, &AF(DoEelDeath), &s_EelDie[3]},
{SPR_EEL_DIE, 'A', EEL_DIE_RATE, &AF(DoEelDeath), &s_EelDie[4]},
{SPR_EEL_DIE, 'A', EEL_DIE_RATE, &AF(DoEelDeath), &s_EelDie[5]},
{SPR_EEL_DIE, 'A', EEL_DIE_RATE, &AF(DoEelDeath), &s_EelDie[5]},
};
STATE* sg_EelDie[] =
@ -286,7 +202,7 @@ STATE* sg_EelDie[] =
STATE s_EelDead[] =
{
{EEL_DEAD, EEL_DIE_RATE, &AF(DoActorDebris), &s_EelDead[0]},
{SPR_EEL_DEAD, 'A', EEL_DIE_RATE, &AF(DoActorDebris), &s_EelDead[0]},
};
STATE* sg_EelDead[] =

6
source/games/sw/src/game.cpp
View file

@ -246,6 +246,11 @@ static void SetTileNames(TilesetBuildInfo& info)
}
#undef x
#define x(a) #a,
static const char* spritenames[] = {
#include "spritenames.h"
};
void GameInterface::LoadTextureInfo(TilesetBuildInfo& info)
{
LoadKVXFromScript(info, "swvoxfil.txt"); // Load voxels from script file
@ -337,6 +342,7 @@ void GameInterface::app_init()
userConfig.AddDefs.reset();
S_CacheAllSounds();
InitSpriteDefs(spritenames, countof(spritenames));
}
//---------------------------------------------------------------------------

15
source/games/sw/src/game.h
View file

@ -348,9 +348,22 @@ typedef void (*soANIMATORp) (SECTOR_OBJECT*);
}
#define AF(func) DSWActor_##func##_VMPtr
#define x(a) SPR_##a,
enum spriteindex_t
{
SPR_NULL = 0,
#include "spritenames.h"
SPR_MAX,
};
#undef x
struct STATE
{
short Pic;
spriteindex_t Sprite;
char Frame;
int Tics;
VMNativeFunction** Animator; // go through the scripting interface

345
source/games/sw/src/girlninj.cpp
View file

@ -120,50 +120,21 @@ ATTRIBUTE GirlNinjaAttrib =
#define GIRLNINJA_RATE 18
STATE s_GirlNinjaRun[5][4] =
STATE s_GirlNinjaRun[1][4] =
{
{
{GIRLNINJA_RUN_R0 + 0, GIRLNINJA_RATE | SF_TIC_ADJUST, &AF(DoGirlNinjaMove), &s_GirlNinjaRun[0][1]},
{GIRLNINJA_RUN_R0 + 1, GIRLNINJA_RATE | SF_TIC_ADJUST, &AF(DoGirlNinjaMove), &s_GirlNinjaRun[0][2]},
{GIRLNINJA_RUN_R0 + 2, GIRLNINJA_RATE | SF_TIC_ADJUST, &AF(DoGirlNinjaMove), &s_GirlNinjaRun[0][3]},
{GIRLNINJA_RUN_R0 + 3, GIRLNINJA_RATE | SF_TIC_ADJUST, &AF(DoGirlNinjaMove), &s_GirlNinjaRun[0][0]},
{SPR_GIRLNINJA_RUN, 'A', GIRLNINJA_RATE | SF_TIC_ADJUST, &AF(DoGirlNinjaMove), &s_GirlNinjaRun[0][1]},
{SPR_GIRLNINJA_RUN, 'B', GIRLNINJA_RATE | SF_TIC_ADJUST, &AF(DoGirlNinjaMove), &s_GirlNinjaRun[0][2]},
{SPR_GIRLNINJA_RUN, 'C', GIRLNINJA_RATE | SF_TIC_ADJUST, &AF(DoGirlNinjaMove), &s_GirlNinjaRun[0][3]},
{SPR_GIRLNINJA_RUN, 'D', GIRLNINJA_RATE | SF_TIC_ADJUST, &AF(DoGirlNinjaMove), &s_GirlNinjaRun[0][0]},
},
{
{GIRLNINJA_RUN_R1 + 0, GIRLNINJA_RATE | SF_TIC_ADJUST, &AF(DoGirlNinjaMove), &s_GirlNinjaRun[1][1]},
{GIRLNINJA_RUN_R1 + 1, GIRLNINJA_RATE | SF_TIC_ADJUST, &AF(DoGirlNinjaMove), &s_GirlNinjaRun[1][2]},
{GIRLNINJA_RUN_R1 + 2, GIRLNINJA_RATE | SF_TIC_ADJUST, &AF(DoGirlNinjaMove), &s_GirlNinjaRun[1][3]},
{GIRLNINJA_RUN_R1 + 3, GIRLNINJA_RATE | SF_TIC_ADJUST, &AF(DoGirlNinjaMove), &s_GirlNinjaRun[1][0]},
},
{
{GIRLNINJA_RUN_R2 + 0, GIRLNINJA_RATE | SF_TIC_ADJUST, &AF(DoGirlNinjaMove), &s_GirlNinjaRun[2][1]},
{GIRLNINJA_RUN_R2 + 1, GIRLNINJA_RATE | SF_TIC_ADJUST, &AF(DoGirlNinjaMove), &s_GirlNinjaRun[2][2]},
{GIRLNINJA_RUN_R2 + 2, GIRLNINJA_RATE | SF_TIC_ADJUST, &AF(DoGirlNinjaMove), &s_GirlNinjaRun[2][3]},
{GIRLNINJA_RUN_R2 + 3, GIRLNINJA_RATE | SF_TIC_ADJUST, &AF(DoGirlNinjaMove), &s_GirlNinjaRun[2][0]},
},
{
{GIRLNINJA_RUN_R3 + 0, GIRLNINJA_RATE | SF_TIC_ADJUST, &AF(DoGirlNinjaMove), &s_GirlNinjaRun[3][1]},
{GIRLNINJA_RUN_R3 + 1, GIRLNINJA_RATE | SF_TIC_ADJUST, &AF(DoGirlNinjaMove), &s_GirlNinjaRun[3][2]},
{GIRLNINJA_RUN_R3 + 2, GIRLNINJA_RATE | SF_TIC_ADJUST, &AF(DoGirlNinjaMove), &s_GirlNinjaRun[3][3]},
{GIRLNINJA_RUN_R3 + 3, GIRLNINJA_RATE | SF_TIC_ADJUST, &AF(DoGirlNinjaMove), &s_GirlNinjaRun[3][0]},
},
{
{GIRLNINJA_RUN_R4 + 0, GIRLNINJA_RATE | SF_TIC_ADJUST, &AF(DoGirlNinjaMove), &s_GirlNinjaRun[4][1]},
{GIRLNINJA_RUN_R4 + 1, GIRLNINJA_RATE | SF_TIC_ADJUST, &AF(DoGirlNinjaMove), &s_GirlNinjaRun[4][2]},
{GIRLNINJA_RUN_R4 + 2, GIRLNINJA_RATE | SF_TIC_ADJUST, &AF(DoGirlNinjaMove), &s_GirlNinjaRun[4][3]},
{GIRLNINJA_RUN_R4 + 3, GIRLNINJA_RATE | SF_TIC_ADJUST, &AF(DoGirlNinjaMove), &s_GirlNinjaRun[4][0]},
},
};
STATE* sg_GirlNinjaRun[] =
{
s_GirlNinjaRun[0],
s_GirlNinjaRun[1],
s_GirlNinjaRun[2],
s_GirlNinjaRun[3],
s_GirlNinjaRun[4]
};
//////////////////////
@ -174,22 +145,10 @@ STATE* sg_GirlNinjaRun[] =
#define GIRLNINJA_STAND_RATE 10
STATE s_GirlNinjaStand[5][1] =
STATE s_GirlNinjaStand[1][1] =
{
{
{GIRLNINJA_STAND_R0 + 0, GIRLNINJA_STAND_RATE, &AF(DoGirlNinjaMove), &s_GirlNinjaStand[0][0]},
},
{
{GIRLNINJA_STAND_R1 + 0, GIRLNINJA_STAND_RATE, &AF(DoGirlNinjaMove), &s_GirlNinjaStand[1][0]},
},
{
{GIRLNINJA_STAND_R2 + 0, GIRLNINJA_STAND_RATE, &AF(DoGirlNinjaMove), &s_GirlNinjaStand[2][0]},
},
{
{GIRLNINJA_STAND_R3 + 0, GIRLNINJA_STAND_RATE, &AF(DoGirlNinjaMove), &s_GirlNinjaStand[3][0]},
},
{
{GIRLNINJA_STAND_R4 + 0, GIRLNINJA_STAND_RATE, &AF(DoGirlNinjaMove), &s_GirlNinjaStand[4][0]},
{SPR_GIRLNINJA_STAND, 'A', GIRLNINJA_STAND_RATE, &AF(DoGirlNinjaMove), &s_GirlNinjaStand[0][0]},
},
};
@ -197,10 +156,6 @@ STATE s_GirlNinjaStand[5][1] =
STATE* sg_GirlNinjaStand[] =
{
s_GirlNinjaStand[0],
s_GirlNinjaStand[1],
s_GirlNinjaStand[2],
s_GirlNinjaStand[3],
s_GirlNinjaStand[4]
};
//////////////////////
@ -211,45 +166,21 @@ STATE* sg_GirlNinjaStand[] =
#define GIRLNINJA_RISE_RATE 10
STATE s_GirlNinjaRise[5][3] =
STATE s_GirlNinjaRise[1][3] =
{
{
{GIRLNINJA_KNEEL_R0 + 0, GIRLNINJA_RISE_RATE, &AF(NullGirlNinja), &s_GirlNinjaRise[0][1]},
{GIRLNINJA_STAND_R0 + 0, GIRLNINJA_STAND_RATE, &AF(NullGirlNinja), &s_GirlNinjaRise[0][2]},
{0, 0, nullptr, (STATE*)sg_GirlNinjaRun}, // JBF: sg_GirlNinjaRun really is supposed to be the
{SPR_GIRLNINJA_KNEEL, 'A', GIRLNINJA_RISE_RATE, &AF(NullGirlNinja), &s_GirlNinjaRise[0][1]},
{SPR_GIRLNINJA_STAND, 'A', GIRLNINJA_STAND_RATE, &AF(NullGirlNinja), &s_GirlNinjaRise[0][2]},
{SPR_NULL, 0, 0, nullptr, (STATE*)sg_GirlNinjaRun}, // JBF: sg_GirlNinjaRun really is supposed to be the
// pointer to the state group. See StateControl() where
// it says "if (!actor->user.__legacyState.State->Pic)".
},
{
{GIRLNINJA_KNEEL_R1 + 0, GIRLNINJA_RISE_RATE, &AF(NullGirlNinja), &s_GirlNinjaRise[1][1]},
{GIRLNINJA_STAND_R1 + 0, GIRLNINJA_STAND_RATE, &AF(NullGirlNinja), &s_GirlNinjaRise[1][2]},
{0, 0, nullptr, (STATE*)sg_GirlNinjaRun},
},
{
{GIRLNINJA_KNEEL_R2 + 0, GIRLNINJA_RISE_RATE, &AF(NullGirlNinja), &s_GirlNinjaRise[2][1]},
{GIRLNINJA_STAND_R2 + 0, GIRLNINJA_STAND_RATE, &AF(NullGirlNinja), &s_GirlNinjaRise[2][2]},
{0, 0, nullptr, (STATE*)sg_GirlNinjaRun},
},
{
{GIRLNINJA_KNEEL_R3 + 0, GIRLNINJA_RISE_RATE, &AF(NullGirlNinja), &s_GirlNinjaRise[3][1]},
{GIRLNINJA_STAND_R3 + 0, GIRLNINJA_STAND_RATE, &AF(NullGirlNinja), &s_GirlNinjaRise[3][2]},
{0, 0, nullptr, (STATE*)sg_GirlNinjaRun},
},
{
{GIRLNINJA_KNEEL_R4 + 0, GIRLNINJA_RISE_RATE, &AF(NullGirlNinja), &s_GirlNinjaRise[4][1]},
{GIRLNINJA_STAND_R4 + 0, GIRLNINJA_STAND_RATE, &AF(NullGirlNinja), &s_GirlNinjaRise[4][2]},
{0, 0, nullptr, (STATE*)sg_GirlNinjaRun},
},
};
STATE* sg_GirlNinjaRise[] =
{
s_GirlNinjaRise[0],
s_GirlNinjaRise[1],
s_GirlNinjaRise[2],
s_GirlNinjaRise[3],
s_GirlNinjaRise[4]
};
//////////////////////
@ -261,27 +192,11 @@ STATE* sg_GirlNinjaRise[] =
#define GIRLNINJA_DUCK_RATE 10
#define GIRLNINJA_CRAWL_RATE 14
STATE s_GirlNinjaDuck[5][2] =
STATE s_GirlNinjaDuck[1][2] =
{
{
{GIRLNINJA_KNEEL_R0 + 0, GIRLNINJA_DUCK_RATE, &AF(NullGirlNinja), &s_GirlNinjaDuck[0][1]},
{GIRLNINJA_CRAWL_R0 + 0, GIRLNINJA_CRAWL_RATE, &AF(DoGirlNinjaMove), &s_GirlNinjaDuck[0][1]},
},
{
{GIRLNINJA_KNEEL_R1 + 0, GIRLNINJA_DUCK_RATE, &AF(NullGirlNinja), &s_GirlNinjaDuck[1][1]},
{GIRLNINJA_CRAWL_R1 + 0, GIRLNINJA_CRAWL_RATE, &AF(DoGirlNinjaMove), &s_GirlNinjaDuck[1][1]},
},
{
{GIRLNINJA_KNEEL_R2 + 0, GIRLNINJA_DUCK_RATE, &AF(NullGirlNinja), &s_GirlNinjaDuck[2][1]},
{GIRLNINJA_CRAWL_R2 + 0, GIRLNINJA_CRAWL_RATE, &AF(DoGirlNinjaMove), &s_GirlNinjaDuck[2][1]},
},
{
{GIRLNINJA_KNEEL_R3 + 0, GIRLNINJA_DUCK_RATE, &AF(NullGirlNinja), &s_GirlNinjaDuck[3][1]},
{GIRLNINJA_CRAWL_R3 + 0, GIRLNINJA_CRAWL_RATE, &AF(DoGirlNinjaMove), &s_GirlNinjaDuck[3][1]},
},
{
{GIRLNINJA_KNEEL_R4 + 0, GIRLNINJA_DUCK_RATE, &AF(NullGirlNinja), &s_GirlNinjaDuck[4][1]},
{GIRLNINJA_CRAWL_R4 + 0, GIRLNINJA_CRAWL_RATE, &AF(DoGirlNinjaMove), &s_GirlNinjaDuck[4][1]},
{SPR_GIRLNINJA_KNEEL, 'A', GIRLNINJA_DUCK_RATE, &AF(NullGirlNinja), &s_GirlNinjaDuck[0][1]},
{SPR_GIRLNINJA_CRAWL, 'A', GIRLNINJA_CRAWL_RATE, &AF(DoGirlNinjaMove), &s_GirlNinjaDuck[0][1]},
},
};
@ -289,10 +204,6 @@ STATE s_GirlNinjaDuck[5][2] =
STATE* sg_GirlNinjaDuck[] =
{
s_GirlNinjaDuck[0],
s_GirlNinjaDuck[1],
s_GirlNinjaDuck[2],
s_GirlNinjaDuck[3],
s_GirlNinjaDuck[4]
};
@ -302,22 +213,10 @@ STATE* sg_GirlNinjaDuck[] =
//
//////////////////////
STATE s_GirlNinjaSit[5][1] =
STATE s_GirlNinjaSit[1][1] =
{
{
{GIRLNINJA_KNEEL_R0 + 0, GIRLNINJA_RISE_RATE, &AF(DoGirlNinjaMove), &s_GirlNinjaSit[0][0]},
},
{
{GIRLNINJA_KNEEL_R1 + 0, GIRLNINJA_RISE_RATE, &AF(DoGirlNinjaMove), &s_GirlNinjaSit[1][0]},
},
{
{GIRLNINJA_KNEEL_R2 + 0, GIRLNINJA_RISE_RATE, &AF(DoGirlNinjaMove), &s_GirlNinjaSit[2][0]},
},
{
{GIRLNINJA_KNEEL_R3 + 0, GIRLNINJA_RISE_RATE, &AF(DoGirlNinjaMove), &s_GirlNinjaSit[3][0]},
},
{
{GIRLNINJA_KNEEL_R4 + 0, GIRLNINJA_RISE_RATE, &AF(DoGirlNinjaMove), &s_GirlNinjaSit[4][0]},
{SPR_GIRLNINJA_KNEEL, 'A', GIRLNINJA_RISE_RATE, &AF(DoGirlNinjaMove), &s_GirlNinjaSit[0][0]},
},
};
@ -325,10 +224,6 @@ STATE s_GirlNinjaSit[5][1] =
STATE* sg_GirlNinjaSit[] =
{
s_GirlNinjaSit[0],
s_GirlNinjaSit[1],
s_GirlNinjaSit[2],
s_GirlNinjaSit[3],
s_GirlNinjaSit[4]
};
@ -340,27 +235,11 @@ STATE* sg_GirlNinjaSit[] =
#define GIRLNINJA_JUMP_RATE 24
STATE s_GirlNinjaJump[5][2] =
STATE s_GirlNinjaJump[1][2] =
{
{
{GIRLNINJA_JUMP_R0 + 0, GIRLNINJA_JUMP_RATE, &AF(DoGirlNinjaMove), &s_GirlNinjaJump[0][1]},
{GIRLNINJA_JUMP_R0 + 1, GIRLNINJA_JUMP_RATE, &AF(DoGirlNinjaMove), &s_GirlNinjaJump[0][1]},
},
{
{GIRLNINJA_JUMP_R1 + 0, GIRLNINJA_JUMP_RATE, &AF(DoGirlNinjaMove), &s_GirlNinjaJump[1][1]},
{GIRLNINJA_JUMP_R1 + 1, GIRLNINJA_JUMP_RATE, &AF(DoGirlNinjaMove), &s_GirlNinjaJump[1][1]},
},
{
{GIRLNINJA_JUMP_R2 + 0, GIRLNINJA_JUMP_RATE, &AF(DoGirlNinjaMove), &s_GirlNinjaJump[2][1]},
{GIRLNINJA_JUMP_R2 + 1, GIRLNINJA_JUMP_RATE, &AF(DoGirlNinjaMove), &s_GirlNinjaJump[2][1]},
},
{
{GIRLNINJA_JUMP_R3 + 0, GIRLNINJA_JUMP_RATE, &AF(DoGirlNinjaMove), &s_GirlNinjaJump[3][1]},
{GIRLNINJA_JUMP_R3 + 1, GIRLNINJA_JUMP_RATE, &AF(DoGirlNinjaMove), &s_GirlNinjaJump[3][1]},
},
{
{GIRLNINJA_JUMP_R4 + 0, GIRLNINJA_JUMP_RATE, &AF(DoGirlNinjaMove), &s_GirlNinjaJump[4][1]},
{GIRLNINJA_JUMP_R4 + 1, GIRLNINJA_JUMP_RATE, &AF(DoGirlNinjaMove), &s_GirlNinjaJump[4][1]},
{SPR_GIRLNINJA_JUMP, 'A', GIRLNINJA_JUMP_RATE, &AF(DoGirlNinjaMove), &s_GirlNinjaJump[0][1]},
{SPR_GIRLNINJA_JUMP, 'B', GIRLNINJA_JUMP_RATE, &AF(DoGirlNinjaMove), &s_GirlNinjaJump[0][1]},
},
};
@ -368,10 +247,6 @@ STATE s_GirlNinjaJump[5][2] =
STATE* sg_GirlNinjaJump[] =
{
s_GirlNinjaJump[0],
s_GirlNinjaJump[1],
s_GirlNinjaJump[2],
s_GirlNinjaJump[3],
s_GirlNinjaJump[4]
};
@ -383,27 +258,11 @@ STATE* sg_GirlNinjaJump[] =
#define GIRLNINJA_FALL_RATE 16
STATE s_GirlNinjaFall[5][2] =
STATE s_GirlNinjaFall[1][2] =
{
{
{GIRLNINJA_JUMP_R0 + 1, GIRLNINJA_FALL_RATE, &AF(DoGirlNinjaMove), &s_GirlNinjaFall[0][1]},
{GIRLNINJA_JUMP_R0 + 2, GIRLNINJA_FALL_RATE, &AF(DoGirlNinjaMove), &s_GirlNinjaFall[0][1]},
},
{
{GIRLNINJA_JUMP_R1 + 1, GIRLNINJA_FALL_RATE, &AF(DoGirlNinjaMove), &s_GirlNinjaFall[1][1]},
{GIRLNINJA_JUMP_R1 + 2, GIRLNINJA_FALL_RATE, &AF(DoGirlNinjaMove), &s_GirlNinjaFall[1][1]},
},
{
{GIRLNINJA_JUMP_R2 + 1, GIRLNINJA_FALL_RATE, &AF(DoGirlNinjaMove), &s_GirlNinjaFall[2][1]},
{GIRLNINJA_JUMP_R2 + 2, GIRLNINJA_FALL_RATE, &AF(DoGirlNinjaMove), &s_GirlNinjaFall[2][1]},
},
{
{GIRLNINJA_JUMP_R3 + 1, GIRLNINJA_FALL_RATE, &AF(DoGirlNinjaMove), &s_GirlNinjaFall[3][1]},
{GIRLNINJA_JUMP_R3 + 2, GIRLNINJA_FALL_RATE, &AF(DoGirlNinjaMove), &s_GirlNinjaFall[3][1]},
},
{
{GIRLNINJA_JUMP_R4 + 1, GIRLNINJA_FALL_RATE, &AF(DoGirlNinjaMove), &s_GirlNinjaFall[4][1]},
{GIRLNINJA_JUMP_R4 + 2, GIRLNINJA_FALL_RATE, &AF(DoGirlNinjaMove), &s_GirlNinjaFall[4][1]},
{SPR_GIRLNINJA_JUMP, 'B', GIRLNINJA_FALL_RATE, &AF(DoGirlNinjaMove), &s_GirlNinjaFall[0][1]},
{SPR_GIRLNINJA_JUMP, 'C', GIRLNINJA_FALL_RATE, &AF(DoGirlNinjaMove), &s_GirlNinjaFall[0][1]},
},
};
@ -411,10 +270,6 @@ STATE s_GirlNinjaFall[5][2] =
STATE* sg_GirlNinjaFall[] =
{
s_GirlNinjaFall[0],
s_GirlNinjaFall[1],
s_GirlNinjaFall[2],
s_GirlNinjaFall[3],
s_GirlNinjaFall[4]
};
//////////////////////
@ -425,32 +280,16 @@ STATE* sg_GirlNinjaFall[] =
#define GIRLNINJA_PAIN_RATE 15
STATE s_GirlNinjaPain[5][1] =
STATE s_GirlNinjaPain[1][1] =
{
{
{GIRLNINJA_PAIN_R0 + 0, GIRLNINJA_PAIN_RATE, &AF(DoGirlNinjaPain), &s_GirlNinjaPain[0][0]},
},
{
{GIRLNINJA_PAIN_R1 + 0, GIRLNINJA_PAIN_RATE, &AF(DoGirlNinjaPain), &s_GirlNinjaPain[1][0]},
},
{
{GIRLNINJA_PAIN_R2 + 0, GIRLNINJA_PAIN_RATE, &AF(DoGirlNinjaPain), &s_GirlNinjaPain[2][0]},
},
{
{GIRLNINJA_PAIN_R3 + 0, GIRLNINJA_PAIN_RATE, &AF(DoGirlNinjaPain), &s_GirlNinjaPain[3][0]},
},
{
{GIRLNINJA_PAIN_R4 + 0, GIRLNINJA_PAIN_RATE, &AF(DoGirlNinjaPain), &s_GirlNinjaPain[4][0]},
{SPR_GIRLNINJA_PAIN, 'A', GIRLNINJA_PAIN_RATE, &AF(DoGirlNinjaPain), &s_GirlNinjaPain[0][0]},
},
};
STATE* sg_GirlNinjaPain[] =
{
s_GirlNinjaPain[0],
s_GirlNinjaPain[1],
s_GirlNinjaPain[2],
s_GirlNinjaPain[3],
s_GirlNinjaPain[4]
};
//////////////////////
@ -461,57 +300,21 @@ STATE* sg_GirlNinjaPain[] =
#define GIRLNINJA_STICKY_RATE 32
STATE s_GirlNinjaSticky[5][6] =
STATE s_GirlNinjaSticky[1][6] =
{
{
{GIRLNINJA_THROW_R0 + 0, GIRLNINJA_STICKY_RATE * 2, &AF(NullGirlNinja), &s_GirlNinjaSticky[0][1]},
{GIRLNINJA_THROW_R0 + 0, GIRLNINJA_STICKY_RATE, &AF(NullGirlNinja), &s_GirlNinjaSticky[0][2]},
{GIRLNINJA_THROW_R0 + 1, 0 | SF_QUICK_CALL, &AF(InitEnemyMine), &s_GirlNinjaSticky[0][3]},
{GIRLNINJA_THROW_R0 + 1, GIRLNINJA_STICKY_RATE * 2, &AF(NullGirlNinja), &s_GirlNinjaSticky[0][4]},
{GIRLNINJA_THROW_R0 + 2, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_GirlNinjaSticky[0][5]},
{GIRLNINJA_THROW_R0 + 2, GIRLNINJA_STICKY_RATE, &AF(DoGirlNinjaMove), &s_GirlNinjaSticky[0][5]},
},
{
{GIRLNINJA_THROW_R1 + 0, GIRLNINJA_STICKY_RATE * 2, &AF(NullGirlNinja), &s_GirlNinjaSticky[1][1]},
{GIRLNINJA_THROW_R1 + 0, GIRLNINJA_STICKY_RATE, &AF(NullGirlNinja), &s_GirlNinjaSticky[1][2]},
{GIRLNINJA_THROW_R1 + 1, 0 | SF_QUICK_CALL, &AF(InitEnemyMine), &s_GirlNinjaSticky[1][3]},
{GIRLNINJA_THROW_R1 + 1, GIRLNINJA_STICKY_RATE * 2, &AF(NullGirlNinja), &s_GirlNinjaSticky[1][4]},
{GIRLNINJA_THROW_R1 + 2, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_GirlNinjaSticky[1][5]},
{GIRLNINJA_THROW_R1 + 2, GIRLNINJA_STICKY_RATE, &AF(DoGirlNinjaMove), &s_GirlNinjaSticky[1][5]},
},
{
{GIRLNINJA_THROW_R2 + 0, GIRLNINJA_STICKY_RATE * 2, &AF(NullGirlNinja), &s_GirlNinjaSticky[2][1]},
{GIRLNINJA_THROW_R2 + 0, GIRLNINJA_STICKY_RATE, &AF(NullGirlNinja), &s_GirlNinjaSticky[2][2]},
{GIRLNINJA_THROW_R2 + 1, 0 | SF_QUICK_CALL, &AF(InitEnemyMine), &s_GirlNinjaSticky[2][3]},
{GIRLNINJA_THROW_R2 + 1, GIRLNINJA_STICKY_RATE * 2, &AF(NullGirlNinja), &s_GirlNinjaSticky[2][4]},
{GIRLNINJA_THROW_R2 + 2, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_GirlNinjaSticky[2][5]},
{GIRLNINJA_THROW_R2 + 2, GIRLNINJA_STICKY_RATE, &AF(DoGirlNinjaMove), &s_GirlNinjaSticky[2][5]},
},
{
{GIRLNINJA_THROW_R2 + 0, GIRLNINJA_STICKY_RATE * 2, &AF(NullGirlNinja), &s_GirlNinjaSticky[3][1]},
{GIRLNINJA_THROW_R2 + 0, GIRLNINJA_STICKY_RATE, &AF(NullGirlNinja), &s_GirlNinjaSticky[3][2]},
{GIRLNINJA_THROW_R2 + 1, 0 | SF_QUICK_CALL, &AF(InitEnemyMine), &s_GirlNinjaSticky[3][3]},
{GIRLNINJA_THROW_R2 + 1, GIRLNINJA_STICKY_RATE * 2, &AF(NullGirlNinja), &s_GirlNinjaSticky[3][4]},
{GIRLNINJA_THROW_R2 + 2, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_GirlNinjaSticky[3][5]},
{GIRLNINJA_THROW_R2 + 2, GIRLNINJA_STICKY_RATE, &AF(DoGirlNinjaMove), &s_GirlNinjaSticky[3][5]},
},
{
{GIRLNINJA_THROW_R2 + 0, GIRLNINJA_STICKY_RATE * 2, &AF(NullGirlNinja), &s_GirlNinjaSticky[4][1]},
{GIRLNINJA_THROW_R2 + 0, GIRLNINJA_STICKY_RATE, &AF(NullGirlNinja), &s_GirlNinjaSticky[4][2]},
{GIRLNINJA_THROW_R2 + 1, 0 | SF_QUICK_CALL, &AF(InitEnemyMine), &s_GirlNinjaSticky[4][3]},
{GIRLNINJA_THROW_R2 + 1, GIRLNINJA_STICKY_RATE * 2, &AF(NullGirlNinja), &s_GirlNinjaSticky[4][4]},
{GIRLNINJA_THROW_R2 + 2, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_GirlNinjaSticky[4][5]},
{GIRLNINJA_THROW_R2 + 2, GIRLNINJA_STICKY_RATE, &AF(DoGirlNinjaMove), &s_GirlNinjaSticky[4][5]},
{SPR_GIRLNINJA_THROW, 'A', GIRLNINJA_STICKY_RATE * 2, &AF(NullGirlNinja), &s_GirlNinjaSticky[0][1]},
{SPR_GIRLNINJA_THROW, 'A', GIRLNINJA_STICKY_RATE, &AF(NullGirlNinja), &s_GirlNinjaSticky[0][2]},
{SPR_GIRLNINJA_THROW, 'B', 0 | SF_QUICK_CALL, &AF(InitEnemyMine), &s_GirlNinjaSticky[0][3]},
{SPR_GIRLNINJA_THROW, 'B', GIRLNINJA_STICKY_RATE * 2, &AF(NullGirlNinja), &s_GirlNinjaSticky[0][4]},
{SPR_GIRLNINJA_THROW, 'C', 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_GirlNinjaSticky[0][5]},
{SPR_GIRLNINJA_THROW, 'C', GIRLNINJA_STICKY_RATE, &AF(DoGirlNinjaMove), &s_GirlNinjaSticky[0][5]},
},
};
STATE* sg_GirlNinjaSticky[] =
{
s_GirlNinjaSticky[0],
s_GirlNinjaSticky[1],
s_GirlNinjaSticky[2],
s_GirlNinjaSticky[3],
s_GirlNinjaSticky[4]
};
@ -523,42 +326,14 @@ STATE* sg_GirlNinjaSticky[] =
#define GIRLNINJA_CROSSBOW_RATE 14
STATE s_GirlNinjaCrossbow[5][5] =
STATE s_GirlNinjaCrossbow[1][5] =
{
{
{GIRLNINJA_FIRE_R0 + 0, GIRLNINJA_CROSSBOW_RATE * 2, &AF(NullGirlNinja), &s_GirlNinjaCrossbow[0][1]},
{GIRLNINJA_FIRE_R0 + 1, 0 | SF_QUICK_CALL, &AF(InitEnemyCrossbow), &s_GirlNinjaCrossbow[0][2]},
{GIRLNINJA_FIRE_R0 + 1, GIRLNINJA_CROSSBOW_RATE, &AF(NullGirlNinja), &s_GirlNinjaCrossbow[0][3]},
{GIRLNINJA_FIRE_R0 + 1, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_GirlNinjaCrossbow[0][4]},
{GIRLNINJA_FIRE_R0 + 1, GIRLNINJA_CROSSBOW_RATE, &AF(DoGirlNinjaMove), &s_GirlNinjaCrossbow[0][4]},
},
{
{GIRLNINJA_FIRE_R1 + 0, GIRLNINJA_CROSSBOW_RATE * 2, &AF(NullGirlNinja), &s_GirlNinjaCrossbow[1][1]},
{GIRLNINJA_FIRE_R1 + 1, 0 | SF_QUICK_CALL, &AF(InitEnemyCrossbow), &s_GirlNinjaCrossbow[1][2]},
{GIRLNINJA_FIRE_R1 + 1, GIRLNINJA_CROSSBOW_RATE, &AF(NullGirlNinja), &s_GirlNinjaCrossbow[1][3]},
{GIRLNINJA_FIRE_R1 + 1, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_GirlNinjaCrossbow[1][4]},
{GIRLNINJA_FIRE_R1 + 1, GIRLNINJA_CROSSBOW_RATE, &AF(DoGirlNinjaMove), &s_GirlNinjaCrossbow[1][4]},
},
{
{GIRLNINJA_FIRE_R2 + 0, GIRLNINJA_CROSSBOW_RATE * 2, &AF(NullGirlNinja), &s_GirlNinjaCrossbow[2][1]},
{GIRLNINJA_FIRE_R2 + 1, 0 | SF_QUICK_CALL, &AF(InitEnemyCrossbow), &s_GirlNinjaCrossbow[2][2]},
{GIRLNINJA_FIRE_R2 + 1, GIRLNINJA_CROSSBOW_RATE, &AF(NullGirlNinja), &s_GirlNinjaCrossbow[2][3]},
{GIRLNINJA_FIRE_R2 + 1, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_GirlNinjaCrossbow[2][4]},
{GIRLNINJA_FIRE_R2 + 1, GIRLNINJA_CROSSBOW_RATE, &AF(DoGirlNinjaMove), &s_GirlNinjaCrossbow[2][4]},
},
{
{GIRLNINJA_FIRE_R3 + 0, GIRLNINJA_CROSSBOW_RATE * 2, &AF(NullGirlNinja), &s_GirlNinjaCrossbow[3][1]},
{GIRLNINJA_FIRE_R3 + 1, 0 | SF_QUICK_CALL, &AF(InitEnemyCrossbow), &s_GirlNinjaCrossbow[3][2]},
{GIRLNINJA_FIRE_R3 + 1, GIRLNINJA_CROSSBOW_RATE, &AF(NullGirlNinja), &s_GirlNinjaCrossbow[3][3]},
{GIRLNINJA_FIRE_R3 + 1, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_GirlNinjaCrossbow[3][4]},
{GIRLNINJA_FIRE_R3 + 1, GIRLNINJA_CROSSBOW_RATE, &AF(DoGirlNinjaMove), &s_GirlNinjaCrossbow[3][4]},
},
{
{GIRLNINJA_FIRE_R4 + 0, GIRLNINJA_CROSSBOW_RATE * 2, &AF(NullGirlNinja), &s_GirlNinjaCrossbow[4][1]},
{GIRLNINJA_FIRE_R4 + 1, 0 | SF_QUICK_CALL, &AF(InitEnemyCrossbow), &s_GirlNinjaCrossbow[4][2]},
{GIRLNINJA_FIRE_R4 + 1, GIRLNINJA_CROSSBOW_RATE, &AF(NullGirlNinja), &s_GirlNinjaCrossbow[4][3]},
{GIRLNINJA_FIRE_R4 + 1, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_GirlNinjaCrossbow[4][4]},
{GIRLNINJA_FIRE_R4 + 1, GIRLNINJA_CROSSBOW_RATE, &AF(DoGirlNinjaMove), &s_GirlNinjaCrossbow[4][4]},
{SPR_GIRLNINJA_FIRE, 'A', GIRLNINJA_CROSSBOW_RATE * 2, &AF(NullGirlNinja), &s_GirlNinjaCrossbow[0][1]},
{SPR_GIRLNINJA_FIRE, 'B', 0 | SF_QUICK_CALL, &AF(InitEnemyCrossbow), &s_GirlNinjaCrossbow[0][2]},
{SPR_GIRLNINJA_FIRE, 'B', GIRLNINJA_CROSSBOW_RATE, &AF(NullGirlNinja), &s_GirlNinjaCrossbow[0][3]},
{SPR_GIRLNINJA_FIRE, 'B', 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_GirlNinjaCrossbow[0][4]},
{SPR_GIRLNINJA_FIRE, 'B', GIRLNINJA_CROSSBOW_RATE, &AF(DoGirlNinjaMove), &s_GirlNinjaCrossbow[0][4]},
},
};
@ -566,10 +341,6 @@ STATE s_GirlNinjaCrossbow[5][5] =
STATE* sg_GirlNinjaCrossbow[] =
{
s_GirlNinjaCrossbow[0],
s_GirlNinjaCrossbow[1],
s_GirlNinjaCrossbow[2],
s_GirlNinjaCrossbow[3],
s_GirlNinjaCrossbow[4]
};
@ -584,40 +355,40 @@ STATE* sg_GirlNinjaCrossbow[] =
STATE s_GirlNinjaDie[] =
{
{GIRLNINJA_DIE + 0, GIRLNINJA_DIE_RATE*2, &AF(NullGirlNinja), &s_GirlNinjaDie[1]},
{GIRLNINJA_DIE + 1, GIRLNINJA_DIE_RATE, &AF(NullGirlNinja), &s_GirlNinjaDie[2]},
{GIRLNINJA_DIE + 2, GIRLNINJA_DIE_RATE, &AF(NullGirlNinja), &s_GirlNinjaDie[3]},
{GIRLNINJA_DIE + 3, GIRLNINJA_DIE_RATE, &AF(NullGirlNinja), &s_GirlNinjaDie[4]},
{GIRLNINJA_DIE + 4, GIRLNINJA_DIE_RATE, &AF(NullGirlNinja), &s_GirlNinjaDie[5]},
{GIRLNINJA_DIE + 5, GIRLNINJA_DIE_RATE, &AF(NullGirlNinja), &s_GirlNinjaDie[6]},
{GIRLNINJA_DIE + 6, GIRLNINJA_DIE_RATE, &AF(NullGirlNinja), &s_GirlNinjaDie[7]},
{GIRLNINJA_DIE + 6, SF_QUICK_CALL, &AF(DoGirlNinjaSpecial), &s_GirlNinjaDie[8]},
{GIRLNINJA_DIE + 7, GIRLNINJA_DIE_RATE, &AF(NullGirlNinja), &s_GirlNinjaDie[9]},
{GIRLNINJA_DIE + 8, SF_QUICK_CALL, &AF(QueueFloorBlood), &s_GirlNinjaDie[10]},
{GIRLNINJA_DIE + 8, GIRLNINJA_DIE_RATE, &AF(DoActorDebris), &s_GirlNinjaDie[10]},
{SPR_GIRLNINJA_DIE, 'A', GIRLNINJA_DIE_RATE*2, &AF(NullGirlNinja), &s_GirlNinjaDie[1]},
{SPR_GIRLNINJA_DIE, 'B', GIRLNINJA_DIE_RATE, &AF(NullGirlNinja), &s_GirlNinjaDie[2]},
{SPR_GIRLNINJA_DIE, 'C', GIRLNINJA_DIE_RATE, &AF(NullGirlNinja), &s_GirlNinjaDie[3]},
{SPR_GIRLNINJA_DIE, 'D', GIRLNINJA_DIE_RATE, &AF(NullGirlNinja), &s_GirlNinjaDie[4]},
{SPR_GIRLNINJA_DIE, 'E', GIRLNINJA_DIE_RATE, &AF(NullGirlNinja), &s_GirlNinjaDie[5]},
{SPR_GIRLNINJA_DIE, 'F', GIRLNINJA_DIE_RATE, &AF(NullGirlNinja), &s_GirlNinjaDie[6]},
{SPR_GIRLNINJA_DIE, 'G', GIRLNINJA_DIE_RATE, &AF(NullGirlNinja), &s_GirlNinjaDie[7]},
{SPR_GIRLNINJA_DIE, 'G', SF_QUICK_CALL, &AF(DoGirlNinjaSpecial), &s_GirlNinjaDie[8]},
{SPR_GIRLNINJA_DIE, 'H', GIRLNINJA_DIE_RATE, &AF(NullGirlNinja), &s_GirlNinjaDie[9]},
{SPR_GIRLNINJA_DIE, 'I', SF_QUICK_CALL, &AF(QueueFloorBlood), &s_GirlNinjaDie[10]},
{SPR_GIRLNINJA_DIE, 'I', GIRLNINJA_DIE_RATE, &AF(DoActorDebris), &s_GirlNinjaDie[10]},
};
STATE s_GirlNinjaDead[] =
{
{GIRLNINJA_DIE + 6, GIRLNINJA_DIE_RATE, &AF(DoActorDebris), &s_GirlNinjaDead[1]},
{GIRLNINJA_DIE + 7, SF_QUICK_CALL, &AF(DoGirlNinjaSpecial), &s_GirlNinjaDead[2]},
{GIRLNINJA_DIE + 7, GIRLNINJA_DIE_RATE, &AF(DoActorDebris), &s_GirlNinjaDead[3]},
{GIRLNINJA_DIE + 8, SF_QUICK_CALL, &AF(QueueFloorBlood),&s_GirlNinjaDead[4]},
{GIRLNINJA_DIE + 8, GIRLNINJA_DIE_RATE, &AF(DoActorDebris), &s_GirlNinjaDead[4]},
{SPR_GIRLNINJA_DIE, 'G', GIRLNINJA_DIE_RATE, &AF(DoActorDebris), &s_GirlNinjaDead[1]},
{SPR_GIRLNINJA_DIE, 'H', SF_QUICK_CALL, &AF(DoGirlNinjaSpecial), &s_GirlNinjaDead[2]},
{SPR_GIRLNINJA_DIE, 'H', GIRLNINJA_DIE_RATE, &AF(DoActorDebris), &s_GirlNinjaDead[3]},
{SPR_GIRLNINJA_DIE, 'I', SF_QUICK_CALL, &AF(QueueFloorBlood),&s_GirlNinjaDead[4]},
{SPR_GIRLNINJA_DIE, 'I', GIRLNINJA_DIE_RATE, &AF(DoActorDebris), &s_GirlNinjaDead[4]},
};
STATE s_GirlNinjaDeathJump[] =
{
{GIRLNINJA_DIE + 0, GIRLNINJA_DIE_RATE, &AF(DoActorDeathMove), &s_GirlNinjaDeathJump[1]},
{GIRLNINJA_DIE + 1, GIRLNINJA_DIE_RATE, &AF(DoActorDeathMove), &s_GirlNinjaDeathJump[2]},
{GIRLNINJA_DIE + 2, GIRLNINJA_DIE_RATE, &AF(DoActorDeathMove), &s_GirlNinjaDeathJump[2]},
{SPR_GIRLNINJA_DIE, 'A', GIRLNINJA_DIE_RATE, &AF(DoActorDeathMove), &s_GirlNinjaDeathJump[1]},
{SPR_GIRLNINJA_DIE, 'B', GIRLNINJA_DIE_RATE, &AF(DoActorDeathMove), &s_GirlNinjaDeathJump[2]},
{SPR_GIRLNINJA_DIE, 'C', GIRLNINJA_DIE_RATE, &AF(DoActorDeathMove), &s_GirlNinjaDeathJump[2]},
};
STATE s_GirlNinjaDeathFall[] =
{
{GIRLNINJA_DIE + 3, GIRLNINJA_DIE_RATE, &AF(DoActorDeathMove), &s_GirlNinjaDeathFall[1]},
{GIRLNINJA_DIE + 4, GIRLNINJA_DIE_RATE, &AF(DoActorDeathMove), &s_GirlNinjaDeathFall[1]},
{SPR_GIRLNINJA_DIE, 'D', GIRLNINJA_DIE_RATE, &AF(DoActorDeathMove), &s_GirlNinjaDeathFall[1]},
{SPR_GIRLNINJA_DIE, 'E', GIRLNINJA_DIE_RATE, &AF(DoActorDeathMove), &s_GirlNinjaDeathFall[1]},
};
/*

234
source/games/sw/src/goro.cpp
View file

@ -35,12 +35,6 @@ Prepared for public release: 03/28/2005 - Charlie Wiederhold, 3D Realms
BEGIN_SW_NS
#define GORO_PAIN_R0 GORO_STAND_R0
#define GORO_PAIN_R1 GORO_STAND_R1
#define GORO_PAIN_R2 GORO_STAND_R2
#define GORO_PAIN_R3 GORO_STAND_R3
#define GORO_PAIN_R4 GORO_STAND_R4
DECISION GoroBattle[] =
{
{697, &AF(InitActorMoveCloser ) },
@ -118,48 +112,20 @@ ATTRIBUTE GoroAttrib =
#define GORO_RUN_RATE 18
STATE s_GoroRun[5][4] =
STATE s_GoroRun[1][4] =
{
{
{GORO_RUN_R0 + 0, GORO_RUN_RATE|SF_TIC_ADJUST, &AF(DoGoroMove), &s_GoroRun[0][1]},
{GORO_RUN_R0 + 1, GORO_RUN_RATE|SF_TIC_ADJUST, &AF(DoGoroMove), &s_GoroRun[0][2]},
{GORO_RUN_R0 + 2, GORO_RUN_RATE|SF_TIC_ADJUST, &AF(DoGoroMove), &s_GoroRun[0][3]},
{GORO_RUN_R0 + 3, GORO_RUN_RATE|SF_TIC_ADJUST, &AF(DoGoroMove), &s_GoroRun[0][0]},
{SPR_GORO_RUN, 'A', GORO_RUN_RATE|SF_TIC_ADJUST, &AF(DoGoroMove), &s_GoroRun[0][1]},
{SPR_GORO_RUN, 'B', GORO_RUN_RATE|SF_TIC_ADJUST, &AF(DoGoroMove), &s_GoroRun[0][2]},
{SPR_GORO_RUN, 'C', GORO_RUN_RATE|SF_TIC_ADJUST, &AF(DoGoroMove), &s_GoroRun[0][3]},
{SPR_GORO_RUN, 'D', GORO_RUN_RATE|SF_TIC_ADJUST, &AF(DoGoroMove), &s_GoroRun[0][0]},
},
{
{GORO_RUN_R1 + 0, GORO_RUN_RATE|SF_TIC_ADJUST, &AF(DoGoroMove), &s_GoroRun[1][1]},
{GORO_RUN_R1 + 1, GORO_RUN_RATE|SF_TIC_ADJUST, &AF(DoGoroMove), &s_GoroRun[1][2]},
{GORO_RUN_R1 + 2, GORO_RUN_RATE|SF_TIC_ADJUST, &AF(DoGoroMove), &s_GoroRun[1][3]},
{GORO_RUN_R1 + 3, GORO_RUN_RATE|SF_TIC_ADJUST, &AF(DoGoroMove), &s_GoroRun[1][0]},
},
{
{GORO_RUN_R2 + 0, GORO_RUN_RATE|SF_TIC_ADJUST, &AF(DoGoroMove), &s_GoroRun[2][1]},
{GORO_RUN_R2 + 1, GORO_RUN_RATE|SF_TIC_ADJUST, &AF(DoGoroMove), &s_GoroRun[2][2]},
{GORO_RUN_R2 + 2, GORO_RUN_RATE|SF_TIC_ADJUST, &AF(DoGoroMove), &s_GoroRun[2][3]},
{GORO_RUN_R2 + 3, GORO_RUN_RATE|SF_TIC_ADJUST, &AF(DoGoroMove), &s_GoroRun[2][0]},
},
{
{GORO_RUN_R3 + 0, GORO_RUN_RATE|SF_TIC_ADJUST, &AF(DoGoroMove), &s_GoroRun[3][1]},
{GORO_RUN_R3 + 1, GORO_RUN_RATE|SF_TIC_ADJUST, &AF(DoGoroMove), &s_GoroRun[3][2]},
{GORO_RUN_R3 + 2, GORO_RUN_RATE|SF_TIC_ADJUST, &AF(DoGoroMove), &s_GoroRun[3][3]},
{GORO_RUN_R3 + 3, GORO_RUN_RATE|SF_TIC_ADJUST, &AF(DoGoroMove), &s_GoroRun[3][0]},
},
{
{GORO_RUN_R4 + 0, GORO_RUN_RATE|SF_TIC_ADJUST, &AF(DoGoroMove), &s_GoroRun[4][1]},
{GORO_RUN_R4 + 1, GORO_RUN_RATE|SF_TIC_ADJUST, &AF(DoGoroMove), &s_GoroRun[4][2]},
{GORO_RUN_R4 + 2, GORO_RUN_RATE|SF_TIC_ADJUST, &AF(DoGoroMove), &s_GoroRun[4][3]},
{GORO_RUN_R4 + 3, GORO_RUN_RATE|SF_TIC_ADJUST, &AF(DoGoroMove), &s_GoroRun[4][0]},
}
};
STATE* sg_GoroRun[] =
{
&s_GoroRun[0][0],
&s_GoroRun[1][0],
&s_GoroRun[2][0],
&s_GoroRun[3][0],
&s_GoroRun[4][0]
};
//////////////////////
@ -170,53 +136,17 @@ STATE* sg_GoroRun[] =
#define GORO_CHOP_RATE 14
STATE s_GoroChop[5][7] =
STATE s_GoroChop[1][7] =
{
{
{GORO_CHOP_R0 + 0, GORO_CHOP_RATE, &AF(NullGoro), &s_GoroChop[0][1]},
{GORO_CHOP_R0 + 1, GORO_CHOP_RATE, &AF(NullGoro), &s_GoroChop[0][2]},
{GORO_CHOP_R0 + 2, GORO_CHOP_RATE, &AF(NullGoro), &s_GoroChop[0][3]},
{GORO_CHOP_R0 + 2, 0|SF_QUICK_CALL, &AF(InitGoroChop), &s_GoroChop[0][4]},
{GORO_CHOP_R0 + 2, GORO_CHOP_RATE, &AF(NullGoro), &s_GoroChop[0][5]},
{GORO_CHOP_R0 + 2, 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_GoroChop[0][6]},
{GORO_CHOP_R0 + 2, GORO_CHOP_RATE, &AF(DoGoroMove), &s_GoroChop[0][6]},
{SPR_GORO_CHOP, 'A', GORO_CHOP_RATE, &AF(NullGoro), &s_GoroChop[0][1]},
{SPR_GORO_CHOP, 'B', GORO_CHOP_RATE, &AF(NullGoro), &s_GoroChop[0][2]},
{SPR_GORO_CHOP, 'C', GORO_CHOP_RATE, &AF(NullGoro), &s_GoroChop[0][3]},
{SPR_GORO_CHOP, 'C', 0|SF_QUICK_CALL, &AF(InitGoroChop), &s_GoroChop[0][4]},
{SPR_GORO_CHOP, 'C', GORO_CHOP_RATE, &AF(NullGoro), &s_GoroChop[0][5]},
{SPR_GORO_CHOP, 'C', 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_GoroChop[0][6]},
{SPR_GORO_CHOP, 'C', GORO_CHOP_RATE, &AF(DoGoroMove), &s_GoroChop[0][6]},
},
{
{GORO_CHOP_R1 + 0, GORO_CHOP_RATE, &AF(NullGoro), &s_GoroChop[1][1]},
{GORO_CHOP_R1 + 1, GORO_CHOP_RATE, &AF(NullGoro), &s_GoroChop[1][2]},
{GORO_CHOP_R1 + 2, GORO_CHOP_RATE, &AF(NullGoro), &s_GoroChop[1][3]},
{GORO_CHOP_R1 + 2, 0|SF_QUICK_CALL, &AF(InitGoroChop), &s_GoroChop[1][4]},
{GORO_CHOP_R1 + 2, GORO_CHOP_RATE, &AF(NullGoro), &s_GoroChop[1][5]},
{GORO_CHOP_R1 + 2, 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_GoroChop[1][6]},
{GORO_CHOP_R1 + 2, GORO_CHOP_RATE, &AF(DoGoroMove), &s_GoroChop[1][6]},
},
{
{GORO_CHOP_R2 + 0, GORO_CHOP_RATE, &AF(NullGoro), &s_GoroChop[2][1]},
{GORO_CHOP_R2 + 1, GORO_CHOP_RATE, &AF(NullGoro), &s_GoroChop[2][2]},
{GORO_CHOP_R2 + 2, GORO_CHOP_RATE, &AF(NullGoro), &s_GoroChop[2][3]},
{GORO_CHOP_R2 + 2, 0|SF_QUICK_CALL, &AF(InitGoroChop), &s_GoroChop[2][4]},
{GORO_CHOP_R2 + 2, GORO_CHOP_RATE, &AF(NullGoro), &s_GoroChop[2][5]},
{GORO_CHOP_R2 + 2, 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_GoroChop[2][6]},
{GORO_CHOP_R2 + 2, GORO_CHOP_RATE, &AF(DoGoroMove), &s_GoroChop[2][6]},
},
{
{GORO_CHOP_R3 + 0, GORO_CHOP_RATE, &AF(NullGoro), &s_GoroChop[3][1]},
{GORO_CHOP_R3 + 1, GORO_CHOP_RATE, &AF(NullGoro), &s_GoroChop[3][2]},
{GORO_CHOP_R3 + 2, GORO_CHOP_RATE, &AF(NullGoro), &s_GoroChop[3][3]},
{GORO_CHOP_R3 + 2, 0|SF_QUICK_CALL, &AF(InitGoroChop), &s_GoroChop[3][4]},
{GORO_CHOP_R3 + 2, GORO_CHOP_RATE, &AF(NullGoro), &s_GoroChop[3][5]},
{GORO_CHOP_R3 + 2, 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_GoroChop[3][6]},
{GORO_CHOP_R3 + 2, GORO_CHOP_RATE, &AF(DoGoroMove), &s_GoroChop[3][6]},
},
{
{GORO_CHOP_R4 + 0, GORO_CHOP_RATE, &AF(NullGoro), &s_GoroChop[4][1]},
{GORO_CHOP_R4 + 1, GORO_CHOP_RATE, &AF(NullGoro), &s_GoroChop[4][2]},
{GORO_CHOP_R4 + 2, GORO_CHOP_RATE, &AF(NullGoro), &s_GoroChop[4][3]},
{GORO_CHOP_R4 + 2, 0|SF_QUICK_CALL, &AF(InitGoroChop), &s_GoroChop[4][4]},
{GORO_CHOP_R4 + 2, GORO_CHOP_RATE, &AF(NullGoro), &s_GoroChop[4][5]},
{GORO_CHOP_R4 + 2, 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_GoroChop[4][6]},
{GORO_CHOP_R4 + 2, GORO_CHOP_RATE, &AF(DoGoroMove), &s_GoroChop[4][6]},
}
};
@ -239,78 +169,26 @@ STATE* sg_GoroChop[] =
#define GORO_SPELL_RATE 6
#define GORO_SPELL_PAUSE 30
STATE s_GoroSpell[5][10] =
STATE s_GoroSpell[1][10] =
{
{
{GORO_SPELL_R0 + 0, GORO_SPELL_PAUSE, &AF(NullGoro), &s_GoroSpell[0][1]},
{GORO_SPELL_R0 + 1, GORO_SPELL_PAUSE, &AF(NullGoro), &s_GoroSpell[0][2]},
{GORO_SPELL_R0 + 1, GORO_SPELL_RATE, &AF(InitEnemyFireball), &s_GoroSpell[0][3]},
{GORO_SPELL_R0 + 1, GORO_SPELL_RATE, &AF(NullGoro), &s_GoroSpell[0][4]},
{GORO_SPELL_R0 + 1, GORO_SPELL_RATE, &AF(InitEnemyFireball), &s_GoroSpell[0][5]},
{GORO_SPELL_R0 + 1, GORO_SPELL_RATE, &AF(NullGoro), &s_GoroSpell[0][6]},
{GORO_SPELL_R0 + 1, GORO_SPELL_RATE, &AF(InitEnemyFireball), &s_GoroSpell[0][7]},
{GORO_SPELL_R0 + 1, GORO_SPELL_PAUSE, &AF(NullGoro), &s_GoroSpell[0][8]},
{GORO_SPELL_R0 + 1, 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_GoroSpell[0][9]},
{GORO_SPELL_R0 + 1, GORO_SPELL_RATE, &AF(DoGoroMove), &s_GoroSpell[0][9]},
{SPR_GORO_SPELL, 'A', GORO_SPELL_PAUSE, &AF(NullGoro), &s_GoroSpell[0][1]},
{SPR_GORO_SPELL, 'B', GORO_SPELL_PAUSE, &AF(NullGoro), &s_GoroSpell[0][2]},
{SPR_GORO_SPELL, 'B', GORO_SPELL_RATE, &AF(InitEnemyFireball), &s_GoroSpell[0][3]},
{SPR_GORO_SPELL, 'B', GORO_SPELL_RATE, &AF(NullGoro), &s_GoroSpell[0][4]},
{SPR_GORO_SPELL, 'B', GORO_SPELL_RATE, &AF(InitEnemyFireball), &s_GoroSpell[0][5]},
{SPR_GORO_SPELL, 'B', GORO_SPELL_RATE, &AF(NullGoro), &s_GoroSpell[0][6]},
{SPR_GORO_SPELL, 'B', GORO_SPELL_RATE, &AF(InitEnemyFireball), &s_GoroSpell[0][7]},
{SPR_GORO_SPELL, 'B', GORO_SPELL_PAUSE, &AF(NullGoro), &s_GoroSpell[0][8]},
{SPR_GORO_SPELL, 'B', 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_GoroSpell[0][9]},
{SPR_GORO_SPELL, 'B', GORO_SPELL_RATE, &AF(DoGoroMove), &s_GoroSpell[0][9]},
},
{
{GORO_SPELL_R1 + 0, GORO_SPELL_PAUSE, &AF(NullGoro), &s_GoroSpell[1][1]},
{GORO_SPELL_R1 + 1, GORO_SPELL_PAUSE, &AF(NullGoro), &s_GoroSpell[1][2]},
{GORO_SPELL_R1 + 1, GORO_SPELL_RATE, &AF(InitEnemyFireball), &s_GoroSpell[1][3]},
{GORO_SPELL_R1 + 1, GORO_SPELL_RATE, &AF(NullGoro), &s_GoroSpell[1][4]},
{GORO_SPELL_R1 + 1, GORO_SPELL_RATE, &AF(InitEnemyFireball), &s_GoroSpell[1][5]},
{GORO_SPELL_R1 + 1, GORO_SPELL_RATE, &AF(NullGoro), &s_GoroSpell[1][6]},
{GORO_SPELL_R1 + 1, GORO_SPELL_RATE, &AF(InitEnemyFireball), &s_GoroSpell[1][7]},
{GORO_SPELL_R1 + 1, GORO_SPELL_PAUSE, &AF(NullGoro), &s_GoroSpell[1][8]},
{GORO_SPELL_R1 + 1, 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_GoroSpell[1][9]},
{GORO_SPELL_R1 + 1, GORO_SPELL_RATE, &AF(DoGoroMove), &s_GoroSpell[1][9]},
},
{
{GORO_SPELL_R2 + 0, GORO_SPELL_PAUSE, &AF(NullGoro), &s_GoroSpell[2][1]},
{GORO_SPELL_R2 + 1, GORO_SPELL_PAUSE, &AF(NullGoro), &s_GoroSpell[2][2]},
{GORO_SPELL_R2 + 1, GORO_SPELL_RATE, &AF(InitEnemyFireball), &s_GoroSpell[2][3]},
{GORO_SPELL_R2 + 1, GORO_SPELL_RATE, &AF(NullGoro), &s_GoroSpell[2][4]},
{GORO_SPELL_R2 + 1, GORO_SPELL_RATE, &AF(InitEnemyFireball), &s_GoroSpell[2][5]},
{GORO_SPELL_R2 + 1, GORO_SPELL_RATE, &AF(NullGoro), &s_GoroSpell[2][6]},
{GORO_SPELL_R2 + 1, GORO_SPELL_RATE, &AF(InitEnemyFireball), &s_GoroSpell[2][7]},
{GORO_SPELL_R2 + 1, GORO_SPELL_PAUSE, &AF(NullGoro), &s_GoroSpell[2][8]},
{GORO_SPELL_R2 + 1, 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_GoroSpell[2][9]},
{GORO_SPELL_R2 + 1, GORO_SPELL_RATE, &AF(DoGoroMove), &s_GoroSpell[2][9]},
},
{
{GORO_SPELL_R3 + 0, GORO_SPELL_PAUSE, &AF(NullGoro), &s_GoroSpell[3][1]},
{GORO_SPELL_R3 + 1, GORO_SPELL_PAUSE, &AF(NullGoro), &s_GoroSpell[3][2]},
{GORO_SPELL_R3 + 1, GORO_SPELL_RATE, &AF(InitEnemyFireball), &s_GoroSpell[3][3]},
{GORO_SPELL_R3 + 1, GORO_SPELL_RATE, &AF(NullGoro), &s_GoroSpell[3][4]},
{GORO_SPELL_R3 + 1, GORO_SPELL_RATE, &AF(InitEnemyFireball), &s_GoroSpell[3][5]},
{GORO_SPELL_R3 + 1, GORO_SPELL_RATE, &AF(NullGoro), &s_GoroSpell[3][6]},
{GORO_SPELL_R3 + 1, GORO_SPELL_RATE, &AF(InitEnemyFireball), &s_GoroSpell[3][7]},
{GORO_SPELL_R3 + 1, GORO_SPELL_PAUSE, &AF(NullGoro), &s_GoroSpell[3][8]},
{GORO_SPELL_R3 + 1, 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_GoroSpell[3][9]},
{GORO_SPELL_R3 + 1, GORO_SPELL_RATE, &AF(DoGoroMove), &s_GoroSpell[3][9]},
},
{
{GORO_SPELL_R4 + 0, GORO_SPELL_PAUSE, &AF(NullGoro), &s_GoroSpell[4][1]},
{GORO_SPELL_R4 + 1, GORO_SPELL_PAUSE, &AF(NullGoro), &s_GoroSpell[4][2]},
{GORO_SPELL_R4 + 1, GORO_SPELL_RATE, &AF(InitEnemyFireball), &s_GoroSpell[4][3]},
{GORO_SPELL_R4 + 1, GORO_SPELL_RATE, &AF(NullGoro), &s_GoroSpell[4][4]},
{GORO_SPELL_R4 + 1, GORO_SPELL_RATE, &AF(InitEnemyFireball), &s_GoroSpell[4][5]},
{GORO_SPELL_R4 + 1, GORO_SPELL_RATE, &AF(NullGoro), &s_GoroSpell[4][6]},
{GORO_SPELL_R4 + 1, GORO_SPELL_RATE, &AF(InitEnemyFireball), &s_GoroSpell[4][7]},
{GORO_SPELL_R4 + 1, GORO_SPELL_PAUSE, &AF(NullGoro), &s_GoroSpell[4][8]},
{GORO_SPELL_R4 + 1, 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_GoroSpell[4][9]},
{GORO_SPELL_R4 + 1, GORO_SPELL_RATE, &AF(DoGoroMove), &s_GoroSpell[4][9]},
}
};
STATE* sg_GoroSpell[] =
{
&s_GoroSpell[0][0],
&s_GoroSpell[1][0],
&s_GoroSpell[2][0],
&s_GoroSpell[3][0],
&s_GoroSpell[4][0]
};
//////////////////////
@ -321,22 +199,10 @@ STATE* sg_GoroSpell[] =
#define GORO_STAND_RATE 12
STATE s_GoroStand[5][1] =
STATE s_GoroStand[1][1] =
{
{
{GORO_STAND_R0 + 0, GORO_STAND_RATE, &AF(DoGoroMove), &s_GoroStand[0][0]},
},
{
{GORO_STAND_R1 + 0, GORO_STAND_RATE, &AF(DoGoroMove), &s_GoroStand[1][0]},
},
{
{GORO_STAND_R2 + 0, GORO_STAND_RATE, &AF(DoGoroMove), &s_GoroStand[2][0]},
},
{
{GORO_STAND_R3 + 0, GORO_STAND_RATE, &AF(DoGoroMove), &s_GoroStand[3][0]},
},
{
{GORO_STAND_R4 + 0, GORO_STAND_RATE, &AF(DoGoroMove), &s_GoroStand[4][0]},
{SPR_GORO_STAND, 'A', GORO_STAND_RATE, &AF(DoGoroMove), &s_GoroStand[0][0]},
},
};
@ -344,10 +210,6 @@ STATE s_GoroStand[5][1] =
STATE* sg_GoroStand[] =
{
s_GoroStand[0],
s_GoroStand[1],
s_GoroStand[2],
s_GoroStand[3],
s_GoroStand[4]
};
//////////////////////
@ -358,22 +220,10 @@ STATE* sg_GoroStand[] =
#define GORO_PAIN_RATE 12
STATE s_GoroPain[5][1] =
STATE s_GoroPain[1][1] =
{
{
{GORO_PAIN_R0 + 0, GORO_PAIN_RATE, &AF(DoGoroPain), &s_GoroPain[0][0]},
},
{
{GORO_PAIN_R1 + 0, GORO_PAIN_RATE, &AF(DoGoroPain), &s_GoroPain[1][0]},
},
{
{GORO_PAIN_R2 + 0, GORO_PAIN_RATE, &AF(DoGoroPain), &s_GoroPain[2][0]},
},
{
{GORO_PAIN_R3 + 0, GORO_PAIN_RATE, &AF(DoGoroPain), &s_GoroPain[3][0]},
},
{
{GORO_PAIN_R4 + 0, GORO_PAIN_RATE, &AF(DoGoroPain), &s_GoroPain[4][0]},
{SPR_GORO_STAND, 'A', GORO_PAIN_RATE, &AF(DoGoroPain), &s_GoroPain[0][0]},
},
};
@ -381,10 +231,6 @@ STATE s_GoroPain[5][1] =
STATE* sg_GoroPain[] =
{
s_GoroPain[0],
s_GoroPain[1],
s_GoroPain[2],
s_GoroPain[3],
s_GoroPain[4]
};
//////////////////////
@ -397,22 +243,22 @@ STATE* sg_GoroPain[] =
STATE s_GoroDie[] =
{
{GORO_DIE + 0, GORO_DIE_RATE, &AF(NullGoro), &s_GoroDie[1]},
{GORO_DIE + 1, GORO_DIE_RATE, &AF(NullGoro), &s_GoroDie[2]},
{GORO_DIE + 2, GORO_DIE_RATE, &AF(NullGoro), &s_GoroDie[3]},
{GORO_DIE + 3, GORO_DIE_RATE, &AF(NullGoro), &s_GoroDie[4]},
{GORO_DIE + 4, GORO_DIE_RATE, &AF(NullGoro), &s_GoroDie[5]},
{GORO_DIE + 5, GORO_DIE_RATE, &AF(NullGoro), &s_GoroDie[6]},
{GORO_DIE + 6, GORO_DIE_RATE, &AF(NullGoro), &s_GoroDie[7]},
{GORO_DIE + 7, GORO_DIE_RATE, &AF(NullGoro), &s_GoroDie[8]},
{GORO_DIE + 8, GORO_DIE_RATE, &AF(NullGoro), &s_GoroDie[9]},
{GORO_DEAD, SF_QUICK_CALL, &AF(QueueFloorBlood), &s_GoroDie[10]},
{GORO_DEAD, GORO_DIE_RATE, &AF(DoActorDebris), &s_GoroDie[10]},
{SPR_GORO_DIE, 'A', GORO_DIE_RATE, &AF(NullGoro), &s_GoroDie[1]},
{SPR_GORO_DIE, 'B', GORO_DIE_RATE, &AF(NullGoro), &s_GoroDie[2]},
{SPR_GORO_DIE, 'C', GORO_DIE_RATE, &AF(NullGoro), &s_GoroDie[3]},
{SPR_GORO_DIE, 'D', GORO_DIE_RATE, &AF(NullGoro), &s_GoroDie[4]},
{SPR_GORO_DIE, 'E', GORO_DIE_RATE, &AF(NullGoro), &s_GoroDie[5]},
{SPR_GORO_DIE, 'F', GORO_DIE_RATE, &AF(NullGoro), &s_GoroDie[6]},
{SPR_GORO_DIE, 'G', GORO_DIE_RATE, &AF(NullGoro), &s_GoroDie[7]},
{SPR_GORO_DIE, 'H', GORO_DIE_RATE, &AF(NullGoro), &s_GoroDie[8]},
{SPR_GORO_DIE, 'I', GORO_DIE_RATE, &AF(NullGoro), &s_GoroDie[9]},
{SPR_GORO_DEAD, 'A', SF_QUICK_CALL, &AF(QueueFloorBlood), &s_GoroDie[10]},
{SPR_GORO_DEAD, 'A', GORO_DIE_RATE, &AF(DoActorDebris), &s_GoroDie[10]},
};
STATE s_GoroDead[] =
{
{GORO_DEAD, GORO_DIE_RATE, &AF(DoActorDebris), &s_GoroDead[0]},
{SPR_GORO_DEAD, 'A', GORO_DIE_RATE, &AF(DoActorDebris), &s_GoroDead[0]},
};
STATE* sg_GoroDie[] =

56
source/games/sw/src/hornet.cpp
View file

@ -119,37 +119,17 @@ ATTRIBUTE HornetAttrib =
#define HORNET_RUN_RATE 7
STATE s_HornetRun[5][2] =
STATE s_HornetRun[1][2] =
{
{
{HORNET_RUN_R0 + 0, HORNET_RUN_RATE, &AF(DoHornetMove), &s_HornetRun[0][1]},
{HORNET_RUN_R0 + 1, HORNET_RUN_RATE, &AF(DoHornetMove), &s_HornetRun[0][0]},
{SPR_HORNET_RUN, 'A', HORNET_RUN_RATE, &AF(DoHornetMove), &s_HornetRun[0][1]},
{SPR_HORNET_RUN, 'B', HORNET_RUN_RATE, &AF(DoHornetMove), &s_HornetRun[0][0]},
},
{
{HORNET_RUN_R1 + 0, HORNET_RUN_RATE, &AF(DoHornetMove), &s_HornetRun[1][1]},
{HORNET_RUN_R1 + 1, HORNET_RUN_RATE, &AF(DoHornetMove), &s_HornetRun[1][0]},
},
{
{HORNET_RUN_R2 + 0, HORNET_RUN_RATE, &AF(DoHornetMove), &s_HornetRun[2][1]},
{HORNET_RUN_R2 + 1, HORNET_RUN_RATE, &AF(DoHornetMove), &s_HornetRun[2][0]},
},
{
{HORNET_RUN_R3 + 0, HORNET_RUN_RATE, &AF(DoHornetMove), &s_HornetRun[3][1]},
{HORNET_RUN_R3 + 1, HORNET_RUN_RATE, &AF(DoHornetMove), &s_HornetRun[3][0]},
},
{
{HORNET_RUN_R4 + 0, HORNET_RUN_RATE, &AF(DoHornetMove), &s_HornetRun[4][1]},
{HORNET_RUN_R4 + 1, HORNET_RUN_RATE, &AF(DoHornetMove), &s_HornetRun[4][0]},
}
};
STATE* sg_HornetRun[] =
{
&s_HornetRun[0][0],
&s_HornetRun[1][0],
&s_HornetRun[2][0],
&s_HornetRun[3][0],
&s_HornetRun[4][0]
};
//////////////////////
@ -160,37 +140,17 @@ STATE* sg_HornetRun[] =
#define HORNET_STAND_RATE (HORNET_RUN_RATE + 5)
STATE s_HornetStand[5][2] =
STATE s_HornetStand[1][2] =
{
{
{HORNET_RUN_R0 + 0, HORNET_STAND_RATE, &AF(DoHornetMove), &s_HornetStand[0][1]},
{HORNET_RUN_R0 + 1, HORNET_STAND_RATE, &AF(DoHornetMove), &s_HornetStand[0][0]}
{SPR_HORNET_RUN, 'A', HORNET_STAND_RATE, &AF(DoHornetMove), &s_HornetStand[0][1]},
{SPR_HORNET_RUN, 'B', HORNET_STAND_RATE, &AF(DoHornetMove), &s_HornetStand[0][0]}
},
{
{HORNET_RUN_R1 + 0, HORNET_STAND_RATE, &AF(DoHornetMove), &s_HornetStand[1][1]},
{HORNET_RUN_R1 + 1, HORNET_STAND_RATE, &AF(DoHornetMove), &s_HornetStand[1][0]}
},
{
{HORNET_RUN_R2 + 0, HORNET_STAND_RATE, &AF(DoHornetMove), &s_HornetStand[2][1]},
{HORNET_RUN_R2 + 1, HORNET_STAND_RATE, &AF(DoHornetMove), &s_HornetStand[2][0]}
},
{
{HORNET_RUN_R3 + 0, HORNET_STAND_RATE, &AF(DoHornetMove), &s_HornetStand[3][1]},
{HORNET_RUN_R3 + 1, HORNET_STAND_RATE, &AF(DoHornetMove), &s_HornetStand[3][0]}
},
{
{HORNET_RUN_R4 + 0, HORNET_STAND_RATE, &AF(DoHornetMove), &s_HornetStand[4][1]},
{HORNET_RUN_R4 + 1, HORNET_STAND_RATE, &AF(DoHornetMove), &s_HornetStand[4][0]}
}
};
STATE* sg_HornetStand[] =
{
&s_HornetStand[0][0],
&s_HornetStand[1][0],
&s_HornetStand[2][0],
&s_HornetStand[3][0],
&s_HornetStand[4][0]
};
//////////////////////
@ -202,7 +162,7 @@ STATE* sg_HornetStand[] =
#define HORNET_DIE_RATE 20
STATE s_HornetDie[] =
{
{HORNET_DIE + 0, HORNET_DIE_RATE, &AF(DoHornetDeath), &s_HornetDie[0]},
{SPR_HORNET_DIE, 'A', HORNET_DIE_RATE, &AF(DoHornetDeath), &s_HornetDie[0]},
};
STATE* sg_HornetDie[] =
@ -212,7 +172,7 @@ STATE* sg_HornetDie[] =
STATE s_HornetDead[] =
{
{HORNET_DEAD, HORNET_DIE_RATE, &AF(DoActorDebris), &s_HornetDead[0]},
{SPR_HORNET_DEAD, 'A', HORNET_DIE_RATE, &AF(DoActorDebris), &s_HornetDead[0]},
};
STATE* sg_HornetDead[] =

1
source/games/sw/src/jsector.cpp
View file

@ -178,7 +178,6 @@ void JS_SpriteSetup(void)
{
SpawnUser(itActor, 0, nullptr);
itActor->user.__legacyState.RotNum = 0;
itActor->user.WaitTics = itActor->spr.lotag * 120;
itActor->user.ActorActionFunc = AF(GenerateDrips);

206
source/games/sw/src/jweapon.cpp
View file

@ -58,127 +58,113 @@ extern bool GlobalSkipZrange;
STATE s_BloodSpray[] =
{
{GOREDrip + 0, BLOODSPRAY_RATE, &AF(BloodSprayFall), &s_BloodSpray[1]},
{GOREDrip + 1, BLOODSPRAY_RATE, &AF(BloodSprayFall), &s_BloodSpray[2]},
{GOREDrip + 2, BLOODSPRAY_RATE, &AF(BloodSprayFall), &s_BloodSpray[3]},
{GOREDrip + 3, BLOODSPRAY_RATE, &AF(BloodSprayFall), &s_BloodSpray[4]},
{GOREDrip + 3, 100, &AF(DoSuicide), &s_BloodSpray[0]}
{SPR_GOREDrip, 'A', BLOODSPRAY_RATE, &AF(BloodSprayFall), &s_BloodSpray[1]},
{SPR_GOREDrip, 'B', BLOODSPRAY_RATE, &AF(BloodSprayFall), &s_BloodSpray[2]},
{SPR_GOREDrip, 'C', BLOODSPRAY_RATE, &AF(BloodSprayFall), &s_BloodSpray[3]},
{SPR_GOREDrip, 'D', BLOODSPRAY_RATE, &AF(BloodSprayFall), &s_BloodSpray[4]},
{SPR_GOREDrip, 'E', 100, &AF(DoSuicide), &s_BloodSpray[0]}
};
#define EXP_RATE 2
STATE s_PhosphorExp[] =
{
{EXP + 0, EXP_RATE, nullptr, &s_PhosphorExp[1]},
{EXP + 1, EXP_RATE, nullptr, &s_PhosphorExp[2]},
{EXP + 2, EXP_RATE, nullptr, &s_PhosphorExp[3]},
{EXP + 3, EXP_RATE, nullptr, &s_PhosphorExp[4]},
{EXP + 4, EXP_RATE, nullptr, &s_PhosphorExp[5]},
{EXP + 5, EXP_RATE, nullptr, &s_PhosphorExp[6]},
{EXP + 6, EXP_RATE, nullptr, &s_PhosphorExp[7]},
{EXP + 7, EXP_RATE, nullptr, &s_PhosphorExp[8]},
{EXP + 8, EXP_RATE, nullptr, &s_PhosphorExp[9]},
{EXP + 9, EXP_RATE, nullptr, &s_PhosphorExp[10]},
{EXP + 10, EXP_RATE, nullptr, &s_PhosphorExp[11]},
{EXP + 11, EXP_RATE, nullptr, &s_PhosphorExp[12]},
{EXP + 12, EXP_RATE, nullptr, &s_PhosphorExp[13]},
{EXP + 13, EXP_RATE, nullptr, &s_PhosphorExp[14]},
{EXP + 14, EXP_RATE, nullptr, &s_PhosphorExp[15]},
{EXP + 15, EXP_RATE, nullptr, &s_PhosphorExp[16]},
{EXP + 16, EXP_RATE, nullptr, &s_PhosphorExp[17]},
{EXP + 17, EXP_RATE, nullptr, &s_PhosphorExp[18]},
{EXP + 18, EXP_RATE, nullptr, &s_PhosphorExp[19]},
{EXP + 19, EXP_RATE, nullptr, &s_PhosphorExp[20]},
{EXP + 20, 100, &AF(DoSuicide), &s_PhosphorExp[0]}
{SPR_EXP, 'A', EXP_RATE, nullptr, &s_PhosphorExp[1]},
{SPR_EXP, 'B', EXP_RATE, nullptr, &s_PhosphorExp[2]},
{SPR_EXP, 'C', EXP_RATE, nullptr, &s_PhosphorExp[3]},
{SPR_EXP, 'D', EXP_RATE, nullptr, &s_PhosphorExp[4]},
{SPR_EXP, 'E', EXP_RATE, nullptr, &s_PhosphorExp[5]},
{SPR_EXP, 'F', EXP_RATE, nullptr, &s_PhosphorExp[6]},
{SPR_EXP, 'G', EXP_RATE, nullptr, &s_PhosphorExp[7]},
{SPR_EXP, 'H', EXP_RATE, nullptr, &s_PhosphorExp[8]},
{SPR_EXP, 'I', EXP_RATE, nullptr, &s_PhosphorExp[9]},
{SPR_EXP, 'J', EXP_RATE, nullptr, &s_PhosphorExp[10]},
{SPR_EXP, 'K', EXP_RATE, nullptr, &s_PhosphorExp[11]},
{SPR_EXP, 'L', EXP_RATE, nullptr, &s_PhosphorExp[12]},
{SPR_EXP, 'M', EXP_RATE, nullptr, &s_PhosphorExp[13]},
{SPR_EXP, 'N', EXP_RATE, nullptr, &s_PhosphorExp[14]},
{SPR_EXP, 'O', EXP_RATE, nullptr, &s_PhosphorExp[15]},
{SPR_EXP, 'P', EXP_RATE, nullptr, &s_PhosphorExp[16]},
{SPR_EXP, 'Q', EXP_RATE, nullptr, &s_PhosphorExp[17]},
{SPR_EXP, 'R', EXP_RATE, nullptr, &s_PhosphorExp[18]},
{SPR_EXP, 'S', EXP_RATE, nullptr, &s_PhosphorExp[19]},
{SPR_EXP, 'T', EXP_RATE, nullptr, &s_PhosphorExp[20]},
{SPR_EXP, 'U', 100, &AF(DoSuicide), &s_PhosphorExp[0]}
};
#define MUSHROOM_RATE 25
STATE s_NukeMushroom[] =
{
{MUSHROOM_CLOUD + 0, MUSHROOM_RATE, nullptr, &s_NukeMushroom[1]},
{MUSHROOM_CLOUD + 1, MUSHROOM_RATE, nullptr, &s_NukeMushroom[2]},
{MUSHROOM_CLOUD + 2, MUSHROOM_RATE, nullptr, &s_NukeMushroom[3]},
{MUSHROOM_CLOUD + 3, MUSHROOM_RATE, nullptr, &s_NukeMushroom[4]},
{MUSHROOM_CLOUD + 4, MUSHROOM_RATE, nullptr, &s_NukeMushroom[5]},
{MUSHROOM_CLOUD + 5, MUSHROOM_RATE, nullptr, &s_NukeMushroom[6]},
{MUSHROOM_CLOUD + 6, MUSHROOM_RATE, nullptr, &s_NukeMushroom[7]},
{MUSHROOM_CLOUD + 7, MUSHROOM_RATE, nullptr, &s_NukeMushroom[8]},
{MUSHROOM_CLOUD + 8, MUSHROOM_RATE, nullptr, &s_NukeMushroom[9]},
{MUSHROOM_CLOUD + 9, MUSHROOM_RATE, nullptr, &s_NukeMushroom[10]},
{MUSHROOM_CLOUD + 10, MUSHROOM_RATE, nullptr, &s_NukeMushroom[11]},
{MUSHROOM_CLOUD + 11, MUSHROOM_RATE, nullptr, &s_NukeMushroom[12]},
{MUSHROOM_CLOUD + 12, MUSHROOM_RATE, nullptr, &s_NukeMushroom[13]},
{MUSHROOM_CLOUD + 13, MUSHROOM_RATE, nullptr, &s_NukeMushroom[14]},
{MUSHROOM_CLOUD + 14, MUSHROOM_RATE, nullptr, &s_NukeMushroom[15]},
{MUSHROOM_CLOUD + 15, MUSHROOM_RATE, nullptr, &s_NukeMushroom[16]},
{MUSHROOM_CLOUD + 16, MUSHROOM_RATE, nullptr, &s_NukeMushroom[17]},
{MUSHROOM_CLOUD + 17, MUSHROOM_RATE, nullptr, &s_NukeMushroom[18]},
{MUSHROOM_CLOUD + 18, MUSHROOM_RATE, nullptr, &s_NukeMushroom[19]},
{MUSHROOM_CLOUD + 19, 100, &AF(DoSuicide), &s_NukeMushroom[0]},
{SPR_MUSHROOM_CLOUD, 'A', MUSHROOM_RATE, nullptr, &s_NukeMushroom[1]},
{SPR_MUSHROOM_CLOUD, 'B', MUSHROOM_RATE, nullptr, &s_NukeMushroom[2]},
{SPR_MUSHROOM_CLOUD, 'C', MUSHROOM_RATE, nullptr, &s_NukeMushroom[3]},
{SPR_MUSHROOM_CLOUD, 'D', MUSHROOM_RATE, nullptr, &s_NukeMushroom[4]},
{SPR_MUSHROOM_CLOUD, 'E', MUSHROOM_RATE, nullptr, &s_NukeMushroom[5]},
{SPR_MUSHROOM_CLOUD, 'F', MUSHROOM_RATE, nullptr, &s_NukeMushroom[6]},
{SPR_MUSHROOM_CLOUD, 'G', MUSHROOM_RATE, nullptr, &s_NukeMushroom[7]},
{SPR_MUSHROOM_CLOUD, 'H', MUSHROOM_RATE, nullptr, &s_NukeMushroom[8]},
{SPR_MUSHROOM_CLOUD, 'I', MUSHROOM_RATE, nullptr, &s_NukeMushroom[9]},
{SPR_MUSHROOM_CLOUD, 'J', MUSHROOM_RATE, nullptr, &s_NukeMushroom[10]},
{SPR_MUSHROOM_CLOUD, 'K', MUSHROOM_RATE, nullptr, &s_NukeMushroom[11]},
{SPR_MUSHROOM_CLOUD, 'L', MUSHROOM_RATE, nullptr, &s_NukeMushroom[12]},
{SPR_MUSHROOM_CLOUD, 'M', MUSHROOM_RATE, nullptr, &s_NukeMushroom[13]},
{SPR_MUSHROOM_CLOUD, 'N', MUSHROOM_RATE, nullptr, &s_NukeMushroom[14]},
{SPR_MUSHROOM_CLOUD, 'O', MUSHROOM_RATE, nullptr, &s_NukeMushroom[15]},
{SPR_MUSHROOM_CLOUD, 'P', MUSHROOM_RATE, nullptr, &s_NukeMushroom[16]},
{SPR_MUSHROOM_CLOUD, 'Q', MUSHROOM_RATE, nullptr, &s_NukeMushroom[17]},
{SPR_MUSHROOM_CLOUD, 'R', MUSHROOM_RATE, nullptr, &s_NukeMushroom[18]},
{SPR_MUSHROOM_CLOUD, 'S', MUSHROOM_RATE, nullptr, &s_NukeMushroom[19]},
{SPR_MUSHROOM_CLOUD, 'T', 100, &AF(DoSuicide), &s_NukeMushroom[0]},
};
#define RADIATION_RATE 16
STATE s_RadiationCloud[] =
{
{RADIATION_CLOUD + 0, RADIATION_RATE, &AF(DoRadiationCloud), &s_RadiationCloud[1]},
{RADIATION_CLOUD + 1, RADIATION_RATE, &AF(DoRadiationCloud), &s_RadiationCloud[2]},
{RADIATION_CLOUD + 2, RADIATION_RATE, &AF(DoRadiationCloud), &s_RadiationCloud[3]},
{RADIATION_CLOUD + 3, RADIATION_RATE, &AF(DoRadiationCloud), &s_RadiationCloud[4]},
{RADIATION_CLOUD + 4, RADIATION_RATE, &AF(DoRadiationCloud), &s_RadiationCloud[5]},
{RADIATION_CLOUD + 5, RADIATION_RATE, &AF(DoRadiationCloud), &s_RadiationCloud[6]},
{RADIATION_CLOUD + 6, RADIATION_RATE, &AF(DoRadiationCloud), &s_RadiationCloud[7]},
{RADIATION_CLOUD + 7, RADIATION_RATE, &AF(DoRadiationCloud), &s_RadiationCloud[8]},
{RADIATION_CLOUD + 8, RADIATION_RATE, &AF(DoRadiationCloud), &s_RadiationCloud[9]},
{RADIATION_CLOUD + 9, RADIATION_RATE, &AF(DoRadiationCloud), &s_RadiationCloud[10]},
{RADIATION_CLOUD + 10, RADIATION_RATE, &AF(DoRadiationCloud), &s_RadiationCloud[11]},
{RADIATION_CLOUD + 11, RADIATION_RATE, &AF(DoRadiationCloud), &s_RadiationCloud[12]},
{RADIATION_CLOUD + 12, RADIATION_RATE, &AF(DoRadiationCloud), &s_RadiationCloud[13]},
{RADIATION_CLOUD + 13, RADIATION_RATE, &AF(DoRadiationCloud), &s_RadiationCloud[14]},
{RADIATION_CLOUD + 14, RADIATION_RATE, &AF(DoRadiationCloud), &s_RadiationCloud[15]},
{RADIATION_CLOUD + 15, RADIATION_RATE, &AF(DoRadiationCloud), &s_RadiationCloud[16]},
{RADIATION_CLOUD + 16, RADIATION_RATE, &AF(DoRadiationCloud), &s_RadiationCloud[17]},
{RADIATION_CLOUD + 17, RADIATION_RATE, &AF(DoRadiationCloud), &s_RadiationCloud[18]},
{RADIATION_CLOUD + 18, RADIATION_RATE, &AF(DoRadiationCloud), &s_RadiationCloud[19]},
{RADIATION_CLOUD + 19, 100, &AF(DoSuicide), &s_RadiationCloud[0]},
{SPR_RADIATION_CLOUD, 'A', RADIATION_RATE, &AF(DoRadiationCloud), &s_RadiationCloud[1]},
{SPR_RADIATION_CLOUD, 'B', RADIATION_RATE, &AF(DoRadiationCloud), &s_RadiationCloud[2]},
{SPR_RADIATION_CLOUD, 'C', RADIATION_RATE, &AF(DoRadiationCloud), &s_RadiationCloud[3]},
{SPR_RADIATION_CLOUD, 'D', RADIATION_RATE, &AF(DoRadiationCloud), &s_RadiationCloud[4]},
{SPR_RADIATION_CLOUD, 'E', RADIATION_RATE, &AF(DoRadiationCloud), &s_RadiationCloud[5]},
{SPR_RADIATION_CLOUD, 'F', RADIATION_RATE, &AF(DoRadiationCloud), &s_RadiationCloud[6]},
{SPR_RADIATION_CLOUD, 'G', RADIATION_RATE, &AF(DoRadiationCloud), &s_RadiationCloud[7]},
{SPR_RADIATION_CLOUD, 'H', RADIATION_RATE, &AF(DoRadiationCloud), &s_RadiationCloud[8]},
{SPR_RADIATION_CLOUD, 'I', RADIATION_RATE, &AF(DoRadiationCloud), &s_RadiationCloud[9]},
{SPR_RADIATION_CLOUD, 'J', RADIATION_RATE, &AF(DoRadiationCloud), &s_RadiationCloud[10]},
{SPR_RADIATION_CLOUD, 'K', RADIATION_RATE, &AF(DoRadiationCloud), &s_RadiationCloud[11]},
{SPR_RADIATION_CLOUD, 'L', RADIATION_RATE, &AF(DoRadiationCloud), &s_RadiationCloud[12]},
{SPR_RADIATION_CLOUD, 'M', RADIATION_RATE, &AF(DoRadiationCloud), &s_RadiationCloud[13]},
{SPR_RADIATION_CLOUD, 'N', RADIATION_RATE, &AF(DoRadiationCloud), &s_RadiationCloud[14]},
{SPR_RADIATION_CLOUD, 'O', RADIATION_RATE, &AF(DoRadiationCloud), &s_RadiationCloud[15]},
{SPR_RADIATION_CLOUD, 'P', RADIATION_RATE, &AF(DoRadiationCloud), &s_RadiationCloud[16]},
{SPR_RADIATION_CLOUD, 'Q', RADIATION_RATE, &AF(DoRadiationCloud), &s_RadiationCloud[17]},
{SPR_RADIATION_CLOUD, 'R', RADIATION_RATE, &AF(DoRadiationCloud), &s_RadiationCloud[18]},
{SPR_RADIATION_CLOUD, 'S', RADIATION_RATE, &AF(DoRadiationCloud), &s_RadiationCloud[19]},
{SPR_RADIATION_CLOUD, 'T', 100, &AF(DoSuicide), &s_RadiationCloud[0]},
};
#define CHEMBOMB_FRAMES 1
#define CHEMBOMB_R0 3038
#define CHEMBOMB_R1 CHEMBOMB_R0 + (CHEMBOMB_FRAMES * 1)
#define CHEMBOMB_R2 CHEMBOMB_R0 + (CHEMBOMB_FRAMES * 2)
#define CHEMBOMB_R3 CHEMBOMB_R0 + (CHEMBOMB_FRAMES * 3)
#define CHEMBOMB_R4 CHEMBOMB_R0 + (CHEMBOMB_FRAMES * 4)
#define CHEMBOMB CHEMBOMB_R0
#define CHEMBOMB_RATE 8
STATE s_ChemBomb[5] =
STATE s_ChemBomb[1] =
{
{CHEMBOMB_R0 + 0, CHEMBOMB_RATE, &AF(DoChemBomb), &s_ChemBomb[1]},
{CHEMBOMB_R1 + 0, CHEMBOMB_RATE, &AF(DoChemBomb), &s_ChemBomb[2]},
{CHEMBOMB_R2 + 0, CHEMBOMB_RATE, &AF(DoChemBomb), &s_ChemBomb[3]},
{CHEMBOMB_R3 + 0, CHEMBOMB_RATE, &AF(DoChemBomb), &s_ChemBomb[4]},
{CHEMBOMB_R4 + 0, CHEMBOMB_RATE, &AF(DoChemBomb), &s_ChemBomb[0]},
{SPR_CHEMBOMB, 'A', CHEMBOMB_RATE, &AF(DoChemBomb), &s_ChemBomb[1]},
};
#define CALTROPS_FRAMES 1
#define CALTROPS_R0 CALTROPS-1
#define CALTROPS_RATE 8
STATE s_Caltrops[] =
{
{CALTROPS_R0 + 0, CALTROPS_RATE, &AF(DoCaltrops), &s_Caltrops[1]},
{CALTROPS_R0 + 1, CALTROPS_RATE, &AF(DoCaltrops), &s_Caltrops[2]},
{CALTROPS_R0 + 2, CALTROPS_RATE, &AF(DoCaltrops), &s_Caltrops[0]},
{SPR_CALTROPSR, 'A', CALTROPS_RATE, &AF(DoCaltrops), &s_Caltrops[1]},
{SPR_CALTROPSR, 'B', CALTROPS_RATE, &AF(DoCaltrops), &s_Caltrops[2]},
{SPR_CALTROPSR, 'C', CALTROPS_RATE, &AF(DoCaltrops), &s_Caltrops[0]},
};
STATE s_CaltropsStick[] =
{
{CALTROPS_R0 + 2, CALTROPS_RATE, &AF(DoCaltropsStick), &s_CaltropsStick[0]},
{SPR_CALTROPSR, 'C', CALTROPS_RATE, &AF(DoCaltropsStick), &s_CaltropsStick[0]},
};
//////////////////////
@ -187,56 +173,52 @@ STATE s_CaltropsStick[] =
//
//////////////////////
#undef FLAG
#define FLAG 2520
#define FLAG_RATE 16
STATE s_CarryFlag[] =
{
{FLAG + 0, FLAG_RATE, &AF(DoCarryFlag), &s_CarryFlag[1]},
{FLAG + 1, FLAG_RATE, &AF(DoCarryFlag), &s_CarryFlag[2]},
{FLAG + 2, FLAG_RATE, &AF(DoCarryFlag), &s_CarryFlag[0]}
{SPR_FLAG, 'A', FLAG_RATE, &AF(DoCarryFlag), &s_CarryFlag[1]},
{SPR_FLAG, 'B', FLAG_RATE, &AF(DoCarryFlag), &s_CarryFlag[2]},
{SPR_FLAG, 'C', FLAG_RATE, &AF(DoCarryFlag), &s_CarryFlag[0]}
};
STATE s_CarryFlagNoDet[] =
{
{FLAG + 0, FLAG_RATE, &AF(DoCarryFlagNoDet), &s_CarryFlagNoDet[1]},
{FLAG + 1, FLAG_RATE, &AF(DoCarryFlagNoDet), &s_CarryFlagNoDet[2]},
{FLAG + 2, FLAG_RATE, &AF(DoCarryFlagNoDet), &s_CarryFlagNoDet[0]}
{SPR_FLAG, 'A', FLAG_RATE, &AF(DoCarryFlagNoDet), &s_CarryFlagNoDet[1]},
{SPR_FLAG, 'B', FLAG_RATE, &AF(DoCarryFlagNoDet), &s_CarryFlagNoDet[2]},
{SPR_FLAG, 'C', FLAG_RATE, &AF(DoCarryFlagNoDet), &s_CarryFlagNoDet[0]}
};
STATE s_Flag[] =
{
{FLAG + 0, FLAG_RATE, &AF(DoFlag), &s_Flag[1]},
{FLAG + 1, FLAG_RATE, &AF(DoFlag), &s_Flag[2]},
{FLAG + 2, FLAG_RATE, &AF(DoFlag), &s_Flag[0]}
{SPR_FLAG, 'A', FLAG_RATE, &AF(DoFlag), &s_Flag[1]},
{SPR_FLAG, 'B', FLAG_RATE, &AF(DoFlag), &s_Flag[2]},
{SPR_FLAG, 'C', FLAG_RATE, &AF(DoFlag), &s_Flag[0]}
};
#define PHOSPHORUS_RATE 8
STATE s_Phosphorus[] =
{
{PHOSPHORUS + 0, PHOSPHORUS_RATE, &AF(DoPhosphorus), &s_Phosphorus[1]},
{PHOSPHORUS + 1, PHOSPHORUS_RATE, &AF(DoPhosphorus), &s_Phosphorus[0]},
{SPR_PHOSPHORUS, 'A', PHOSPHORUS_RATE, &AF(DoPhosphorus), &s_Phosphorus[1]},
{SPR_PHOSPHORUS, 'B', PHOSPHORUS_RATE, &AF(DoPhosphorus), &s_Phosphorus[0]},
};
#define CHUNK1 1685
STATE s_BloodSprayChunk[] =
{
{CHUNK1 + 0, 8, &AF(DoBloodSpray), &s_BloodSprayChunk[1]},
{CHUNK1 + 1, 8, &AF(DoBloodSpray), &s_BloodSprayChunk[2]},
{CHUNK1 + 2, 8, &AF(DoBloodSpray), &s_BloodSprayChunk[3]},
{CHUNK1 + 3, 8, &AF(DoBloodSpray), &s_BloodSprayChunk[4]},
{CHUNK1 + 4, 8, &AF(DoBloodSpray), &s_BloodSprayChunk[5]},
{CHUNK1 + 5, 8, &AF(DoBloodSpray), &s_BloodSprayChunk[0]},
{SPR_CHUNK1, 'A', 8, &AF(DoBloodSpray), &s_BloodSprayChunk[1]},
{SPR_CHUNK1, 'B', 8, &AF(DoBloodSpray), &s_BloodSprayChunk[2]},
{SPR_CHUNK1, 'C', 8, &AF(DoBloodSpray), &s_BloodSprayChunk[3]},
{SPR_CHUNK1, 'D', 8, &AF(DoBloodSpray), &s_BloodSprayChunk[4]},
{SPR_CHUNK1, 'E', 8, &AF(DoBloodSpray), &s_BloodSprayChunk[5]},
{SPR_CHUNK1, 'F', 8, &AF(DoBloodSpray), &s_BloodSprayChunk[0]},
};
#define DRIP 1566
STATE s_BloodSprayDrip[] =
{
{DRIP + 0, PHOSPHORUS_RATE, &AF(DoWallBloodDrip), &s_BloodSprayDrip[1]},
{DRIP + 1, PHOSPHORUS_RATE, &AF(DoWallBloodDrip), &s_BloodSprayDrip[2]},
{DRIP + 2, PHOSPHORUS_RATE, &AF(DoWallBloodDrip), &s_BloodSprayDrip[0]},
{SPR_DRIP, 'A', PHOSPHORUS_RATE, &AF(DoWallBloodDrip), &s_BloodSprayDrip[1]},
{SPR_DRIP, 'B', PHOSPHORUS_RATE, &AF(DoWallBloodDrip), &s_BloodSprayDrip[2]},
{SPR_DRIP, 'C', PHOSPHORUS_RATE, &AF(DoWallBloodDrip), &s_BloodSprayDrip[0]},
};
//---------------------------------------------------------------------------
@ -1245,7 +1227,7 @@ int PlayerInitChemBomb(DSWPlayer* pp)
// Spawn a shot
// Inserting and setting up variables
auto actorNew = SpawnActor(STAT_MISSILE, CHEMBOMB, s_ChemBomb, pp->cursector, pos, pp->GetActor()->spr.Angles.Yaw, CHEMBOMB_VELOCITY);
auto actorNew = SpawnActor(STAT_MISSILE, CHEMBOMB_R0, s_ChemBomb, pp->cursector, pos, pp->GetActor()->spr.Angles.Yaw, CHEMBOMB_VELOCITY);
// don't throw it as far if crawling
if (pp->Flags & (PF_CRAWLING))
@ -1314,7 +1296,7 @@ int InitSpriteChemBomb(DSWActor* actor)
// Spawn a shot
// Inserting and setting up variables
auto actorNew = SpawnActor(STAT_MISSILE, CHEMBOMB, s_ChemBomb, actor->sector(),
auto actorNew = SpawnActor(STAT_MISSILE, CHEMBOMB_R0, s_ChemBomb, actor->sector(),
actor->spr.pos, actor->spr.Angles.Yaw, CHEMBOMB_VELOCITY);
actorNew->user.Flags |= (SPR_XFLIP_TOGGLE);

196
source/games/sw/src/lava.cpp
View file

@ -127,22 +127,10 @@ ATTRIBUTE LavaPissedAttrib =
//////////////////////
#define LAVA_STAND_RATE 12
STATE s_LavaStand[5][1] =
STATE s_LavaStand[1][1] =
{
{
{LAVA_RUN_R0 + 0, LAVA_STAND_RATE, &AF(DoLavaMove), &s_LavaStand[0][0]},
},
{
{LAVA_RUN_R1 + 0, LAVA_STAND_RATE, &AF(DoLavaMove), &s_LavaStand[1][0]},
},
{
{LAVA_RUN_R2 + 0, LAVA_STAND_RATE, &AF(DoLavaMove), &s_LavaStand[2][0]},
},
{
{LAVA_RUN_R3 + 0, LAVA_STAND_RATE, &AF(DoLavaMove), &s_LavaStand[3][0]},
},
{
{LAVA_RUN_R4 + 0, LAVA_STAND_RATE, &AF(DoLavaMove), &s_LavaStand[4][0]},
{SPR_LAVA_RUN, 'A', LAVA_STAND_RATE, &AF(DoLavaMove), &s_LavaStand[0][0]},
},
};
@ -150,10 +138,6 @@ STATE s_LavaStand[5][1] =
STATE* sg_LavaStand[] =
{
s_LavaStand[0],
s_LavaStand[1],
s_LavaStand[2],
s_LavaStand[3],
s_LavaStand[4]
};
@ -166,48 +150,20 @@ STATE* sg_LavaStand[] =
#define LAVA_RUN_RATE 24
STATE s_LavaRun[5][4] =
STATE s_LavaRun[1][4] =
{
{
{LAVA_RUN_R0 + 0, LAVA_RUN_RATE, &AF(DoLavaMove), &s_LavaRun[0][1]},
{LAVA_RUN_R0 + 0, LAVA_RUN_RATE, &AF(DoLavaMove), &s_LavaRun[0][2]},
{LAVA_RUN_R0 + 0, LAVA_RUN_RATE, &AF(DoLavaMove), &s_LavaRun[0][3]},
{LAVA_RUN_R0 + 0, LAVA_RUN_RATE, &AF(DoLavaMove), &s_LavaRun[0][0]},
{SPR_LAVA_RUN, 'A', LAVA_RUN_RATE, &AF(DoLavaMove), &s_LavaRun[0][1]},
{SPR_LAVA_RUN, 'A', LAVA_RUN_RATE, &AF(DoLavaMove), &s_LavaRun[0][2]},
{SPR_LAVA_RUN, 'A', LAVA_RUN_RATE, &AF(DoLavaMove), &s_LavaRun[0][3]},
{SPR_LAVA_RUN, 'A', LAVA_RUN_RATE, &AF(DoLavaMove), &s_LavaRun[0][0]},
},
{
{LAVA_RUN_R1 + 0, LAVA_RUN_RATE, &AF(DoLavaMove), &s_LavaRun[1][1]},
{LAVA_RUN_R1 + 0, LAVA_RUN_RATE, &AF(DoLavaMove), &s_LavaRun[1][2]},
{LAVA_RUN_R1 + 0, LAVA_RUN_RATE, &AF(DoLavaMove), &s_LavaRun[1][3]},
{LAVA_RUN_R1 + 0, LAVA_RUN_RATE, &AF(DoLavaMove), &s_LavaRun[1][0]},
},
{
{LAVA_RUN_R2 + 0, LAVA_RUN_RATE, &AF(DoLavaMove), &s_LavaRun[2][1]},
{LAVA_RUN_R2 + 0, LAVA_RUN_RATE, &AF(DoLavaMove), &s_LavaRun[2][2]},
{LAVA_RUN_R2 + 0, LAVA_RUN_RATE, &AF(DoLavaMove), &s_LavaRun[2][3]},
{LAVA_RUN_R2 + 0, LAVA_RUN_RATE, &AF(DoLavaMove), &s_LavaRun[2][0]},
},
{
{LAVA_RUN_R3 + 0, LAVA_RUN_RATE, &AF(DoLavaMove), &s_LavaRun[3][1]},
{LAVA_RUN_R3 + 0, LAVA_RUN_RATE, &AF(DoLavaMove), &s_LavaRun[3][2]},
{LAVA_RUN_R3 + 0, LAVA_RUN_RATE, &AF(DoLavaMove), &s_LavaRun[3][3]},
{LAVA_RUN_R3 + 0, LAVA_RUN_RATE, &AF(DoLavaMove), &s_LavaRun[3][0]},
},
{
{LAVA_RUN_R4 + 0, LAVA_RUN_RATE, &AF(DoLavaMove), &s_LavaRun[4][1]},
{LAVA_RUN_R4 + 0, LAVA_RUN_RATE, &AF(DoLavaMove), &s_LavaRun[4][2]},
{LAVA_RUN_R4 + 0, LAVA_RUN_RATE, &AF(DoLavaMove), &s_LavaRun[4][3]},
{LAVA_RUN_R4 + 0, LAVA_RUN_RATE, &AF(DoLavaMove), &s_LavaRun[4][0]},
}
};
STATE* sg_LavaRun[] =
{
&s_LavaRun[0][0],
&s_LavaRun[1][0],
&s_LavaRun[2][0],
&s_LavaRun[3][0],
&s_LavaRun[4][0]
};
//////////////////////
@ -218,68 +174,20 @@ STATE* sg_LavaRun[] =
#define LAVA_THROW_RATE 9
STATE s_LavaThrow[5][10] =
STATE s_LavaThrow[1][10] =
{
{
{LAVA_THROW_R0 + 0, LAVA_THROW_RATE, &AF(NullLava), &s_LavaThrow[0][1]},
{LAVA_THROW_R0 + 0, LAVA_THROW_RATE, &AF(NullLava), &s_LavaThrow[0][2]},
{LAVA_THROW_R0 + 0, LAVA_THROW_RATE*2, &AF(NullLava), &s_LavaThrow[0][3]},
{LAVA_THROW_R0 + 0, LAVA_THROW_RATE, &AF(NullLava), &s_LavaThrow[0][4]},
{LAVA_THROW_R0 + 0, LAVA_THROW_RATE, &AF(NullLava), &s_LavaThrow[0][5]},
{LAVA_THROW_R0 + 0, SF_QUICK_CALL, &AF(InitLavaThrow), &s_LavaThrow[0][6]},
{LAVA_THROW_R0 + 0, LAVA_THROW_RATE, &AF(NullLava), &s_LavaThrow[0][7]},
{LAVA_THROW_R0 + 0, LAVA_THROW_RATE, &AF(NullLava), &s_LavaThrow[0][8]},
{LAVA_THROW_R0 + 0, 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_LavaThrow[0][9]},
{LAVA_THROW_R0 + 0, LAVA_THROW_RATE, &AF(DoLavaMove), &s_LavaThrow[0][9]},
{SPR_LAVA_THROW, 'A', LAVA_THROW_RATE, &AF(NullLava), &s_LavaThrow[0][1]},
{SPR_LAVA_THROW, 'A', LAVA_THROW_RATE, &AF(NullLava), &s_LavaThrow[0][2]},
{SPR_LAVA_THROW, 'A', LAVA_THROW_RATE*2, &AF(NullLava), &s_LavaThrow[0][3]},
{SPR_LAVA_THROW, 'A', LAVA_THROW_RATE, &AF(NullLava), &s_LavaThrow[0][4]},
{SPR_LAVA_THROW, 'A', LAVA_THROW_RATE, &AF(NullLava), &s_LavaThrow[0][5]},
{SPR_LAVA_THROW, 'A', SF_QUICK_CALL, &AF(InitLavaThrow), &s_LavaThrow[0][6]},
{SPR_LAVA_THROW, 'A', LAVA_THROW_RATE, &AF(NullLava), &s_LavaThrow[0][7]},
{SPR_LAVA_THROW, 'A', LAVA_THROW_RATE, &AF(NullLava), &s_LavaThrow[0][8]},
{SPR_LAVA_THROW, 'A', 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_LavaThrow[0][9]},
{SPR_LAVA_THROW, 'A', LAVA_THROW_RATE, &AF(DoLavaMove), &s_LavaThrow[0][9]},
},
{
{LAVA_THROW_R1 + 0, LAVA_THROW_RATE, &AF(NullLava), &s_LavaThrow[1][1]},
{LAVA_THROW_R1 + 0, LAVA_THROW_RATE, &AF(NullLava), &s_LavaThrow[1][2]},
{LAVA_THROW_R1 + 0, LAVA_THROW_RATE*2, &AF(NullLava), &s_LavaThrow[1][3]},
{LAVA_THROW_R1 + 0, LAVA_THROW_RATE, &AF(NullLava), &s_LavaThrow[1][4]},
{LAVA_THROW_R1 + 0, LAVA_THROW_RATE, &AF(NullLava), &s_LavaThrow[1][5]},
{LAVA_THROW_R1 + 0, SF_QUICK_CALL, &AF(InitLavaThrow), &s_LavaThrow[1][6]},
{LAVA_THROW_R1 + 0, LAVA_THROW_RATE, &AF(NullLava), &s_LavaThrow[1][7]},
{LAVA_THROW_R1 + 0, LAVA_THROW_RATE, &AF(NullLava), &s_LavaThrow[1][8]},
{LAVA_THROW_R1 + 0, 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_LavaThrow[1][9]},
{LAVA_THROW_R1 + 0, LAVA_THROW_RATE, &AF(DoLavaMove), &s_LavaThrow[1][9]},
},
{
{LAVA_THROW_R2 + 0, LAVA_THROW_RATE, &AF(NullLava), &s_LavaThrow[2][1]},
{LAVA_THROW_R2 + 0, LAVA_THROW_RATE, &AF(NullLava), &s_LavaThrow[2][2]},
{LAVA_THROW_R2 + 0, LAVA_THROW_RATE*2, &AF(NullLava), &s_LavaThrow[2][3]},
{LAVA_THROW_R2 + 0, LAVA_THROW_RATE, &AF(NullLava), &s_LavaThrow[2][4]},
{LAVA_THROW_R2 + 0, LAVA_THROW_RATE, &AF(NullLava), &s_LavaThrow[2][5]},
{LAVA_THROW_R2 + 0, SF_QUICK_CALL, &AF(InitLavaThrow), &s_LavaThrow[2][6]},
{LAVA_THROW_R2 + 0, LAVA_THROW_RATE, &AF(NullLava), &s_LavaThrow[2][7]},
{LAVA_THROW_R2 + 0, LAVA_THROW_RATE, &AF(NullLava), &s_LavaThrow[2][8]},
{LAVA_THROW_R2 + 0, 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_LavaThrow[2][9]},
{LAVA_THROW_R2 + 0, LAVA_THROW_RATE, &AF(DoLavaMove), &s_LavaThrow[2][9]},
},
{
{LAVA_THROW_R3 + 0, LAVA_THROW_RATE, &AF(NullLava), &s_LavaThrow[3][1]},
{LAVA_THROW_R3 + 0, LAVA_THROW_RATE, &AF(NullLava), &s_LavaThrow[3][2]},
{LAVA_THROW_R3 + 0, LAVA_THROW_RATE*2, &AF(NullLava), &s_LavaThrow[3][3]},
{LAVA_THROW_R3 + 0, LAVA_THROW_RATE, &AF(NullLava), &s_LavaThrow[3][4]},
{LAVA_THROW_R3 + 0, LAVA_THROW_RATE, &AF(NullLava), &s_LavaThrow[3][5]},
{LAVA_THROW_R3 + 0, SF_QUICK_CALL, &AF(InitLavaThrow), &s_LavaThrow[3][6]},
{LAVA_THROW_R3 + 0, LAVA_THROW_RATE, &AF(NullLava), &s_LavaThrow[3][7]},
{LAVA_THROW_R3 + 0, LAVA_THROW_RATE, &AF(NullLava), &s_LavaThrow[3][8]},
{LAVA_THROW_R3 + 0, 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_LavaThrow[3][9]},
{LAVA_THROW_R3 + 0, LAVA_THROW_RATE, &AF(DoLavaMove), &s_LavaThrow[3][9]},
},
{
{LAVA_THROW_R4 + 0, LAVA_THROW_RATE, &AF(NullLava), &s_LavaThrow[4][1]},
{LAVA_THROW_R4 + 0, LAVA_THROW_RATE, &AF(NullLava), &s_LavaThrow[4][2]},
{LAVA_THROW_R4 + 0, LAVA_THROW_RATE*2, &AF(NullLava), &s_LavaThrow[4][3]},
{LAVA_THROW_R4 + 0, LAVA_THROW_RATE, &AF(NullLava), &s_LavaThrow[4][4]},
{LAVA_THROW_R4 + 0, LAVA_THROW_RATE, &AF(NullLava), &s_LavaThrow[4][5]},
{LAVA_THROW_R4 + 0, SF_QUICK_CALL, &AF(InitLavaThrow), &s_LavaThrow[4][6]},
{LAVA_THROW_R4 + 0, LAVA_THROW_RATE, &AF(NullLava), &s_LavaThrow[4][7]},
{LAVA_THROW_R4 + 0, LAVA_THROW_RATE, &AF(NullLava), &s_LavaThrow[4][8]},
{LAVA_THROW_R4 + 0, 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_LavaThrow[4][9]},
{LAVA_THROW_R4 + 0, LAVA_THROW_RATE, &AF(DoLavaMove), &s_LavaThrow[4][9]},
}
};
@ -301,68 +209,24 @@ STATE* sg_LavaThrow[] =
#define LAVA_FLAME_RATE 18
STATE s_LavaFlame[5][8] =
STATE s_LavaFlame[1][8] =
{
{
{LAVA_FLAME_R0 + 0, LAVA_FLAME_RATE*2, &AF(NullLava), &s_LavaFlame[0][1]},
{LAVA_FLAME_R0 + 0, LAVA_FLAME_RATE, &AF(NullLava), &s_LavaFlame[0][2]},
{LAVA_FLAME_R0 + 0, LAVA_FLAME_RATE*2, &AF(NullLava), &s_LavaFlame[0][3]},
{LAVA_FLAME_R0 + 0, SF_QUICK_CALL, &AF(InitLavaFlame), &s_LavaFlame[0][4]},
{LAVA_FLAME_R0 + 0, LAVA_FLAME_RATE, &AF(NullLava), &s_LavaFlame[0][5]},
{LAVA_FLAME_R0 + 0, LAVA_FLAME_RATE, &AF(NullLava), &s_LavaFlame[0][6]},
{LAVA_FLAME_R0 + 0, SF_QUICK_CALL, &AF(InitActorDecide), &s_LavaFlame[0][7]},
{LAVA_FLAME_R0 + 0, LAVA_FLAME_RATE, &AF(DoLavaMove), &s_LavaFlame[0][7]},
{SPR_LAVA_FLAME, 'A', LAVA_FLAME_RATE*2, &AF(NullLava), &s_LavaFlame[0][1]},
{SPR_LAVA_FLAME, 'A', LAVA_FLAME_RATE, &AF(NullLava), &s_LavaFlame[0][2]},
{SPR_LAVA_FLAME, 'A', LAVA_FLAME_RATE*2, &AF(NullLava), &s_LavaFlame[0][3]},
{SPR_LAVA_FLAME, 'A', SF_QUICK_CALL, &AF(InitLavaFlame), &s_LavaFlame[0][4]},
{SPR_LAVA_FLAME, 'A', LAVA_FLAME_RATE, &AF(NullLava), &s_LavaFlame[0][5]},
{SPR_LAVA_FLAME, 'A', LAVA_FLAME_RATE, &AF(NullLava), &s_LavaFlame[0][6]},
{SPR_LAVA_FLAME, 'A', SF_QUICK_CALL, &AF(InitActorDecide), &s_LavaFlame[0][7]},
{SPR_LAVA_FLAME, 'A', LAVA_FLAME_RATE, &AF(DoLavaMove), &s_LavaFlame[0][7]},
},
{
{LAVA_FLAME_R1 + 0, LAVA_FLAME_RATE*2, &AF(NullLava), &s_LavaFlame[1][1]},
{LAVA_FLAME_R1 + 0, LAVA_FLAME_RATE, &AF(NullLava), &s_LavaFlame[1][2]},
{LAVA_FLAME_R1 + 0, LAVA_FLAME_RATE*2, &AF(NullLava), &s_LavaFlame[1][3]},
{LAVA_FLAME_R1 + 0, SF_QUICK_CALL, &AF(InitLavaFlame), &s_LavaFlame[1][4]},
{LAVA_FLAME_R1 + 0, LAVA_FLAME_RATE, &AF(NullLava), &s_LavaFlame[1][5]},
{LAVA_FLAME_R1 + 0, LAVA_FLAME_RATE, &AF(NullLava), &s_LavaFlame[1][6]},
{LAVA_FLAME_R1 + 0, SF_QUICK_CALL, &AF(InitActorDecide), &s_LavaFlame[1][7]},
{LAVA_FLAME_R1 + 0, LAVA_FLAME_RATE, &AF(DoLavaMove), &s_LavaFlame[1][7]},
},
{
{LAVA_FLAME_R2 + 0, LAVA_FLAME_RATE*2, &AF(NullLava), &s_LavaFlame[2][1]},
{LAVA_FLAME_R2 + 0, LAVA_FLAME_RATE, &AF(NullLava), &s_LavaFlame[2][2]},
{LAVA_FLAME_R2 + 0, LAVA_FLAME_RATE*2, &AF(NullLava), &s_LavaFlame[2][3]},
{LAVA_FLAME_R2 + 0, SF_QUICK_CALL, &AF(InitLavaFlame), &s_LavaFlame[2][4]},
{LAVA_FLAME_R2 + 0, LAVA_FLAME_RATE, &AF(NullLava), &s_LavaFlame[2][5]},
{LAVA_FLAME_R2 + 0, LAVA_FLAME_RATE, &AF(NullLava), &s_LavaFlame[2][6]},
{LAVA_FLAME_R2 + 0, SF_QUICK_CALL, &AF(InitActorDecide), &s_LavaFlame[2][7]},
{LAVA_FLAME_R2 + 0, LAVA_FLAME_RATE, &AF(DoLavaMove), &s_LavaFlame[2][7]},
},
{
{LAVA_FLAME_R3 + 0, LAVA_FLAME_RATE*2, &AF(NullLava), &s_LavaFlame[3][1]},
{LAVA_FLAME_R3 + 0, LAVA_FLAME_RATE, &AF(NullLava), &s_LavaFlame[3][2]},
{LAVA_FLAME_R3 + 0, LAVA_FLAME_RATE*2, &AF(NullLava), &s_LavaFlame[3][3]},
{LAVA_FLAME_R3 + 0, SF_QUICK_CALL, &AF(InitLavaFlame), &s_LavaFlame[3][4]},
{LAVA_FLAME_R3 + 0, LAVA_FLAME_RATE, &AF(NullLava), &s_LavaFlame[3][5]},
{LAVA_FLAME_R3 + 0, LAVA_FLAME_RATE, &AF(NullLava), &s_LavaFlame[3][6]},
{LAVA_FLAME_R3 + 0, SF_QUICK_CALL, &AF(InitActorDecide), &s_LavaFlame[3][7]},
{LAVA_FLAME_R3 + 0, LAVA_FLAME_RATE, &AF(DoLavaMove), &s_LavaFlame[3][7]},
},
{
{LAVA_FLAME_R4 + 0, LAVA_FLAME_RATE*2, &AF(NullLava), &s_LavaFlame[4][1]},
{LAVA_FLAME_R4 + 0, LAVA_FLAME_RATE, &AF(NullLava), &s_LavaFlame[4][2]},
{LAVA_FLAME_R4 + 0, LAVA_FLAME_RATE*2, &AF(NullLava), &s_LavaFlame[4][3]},
{LAVA_FLAME_R4 + 0, SF_QUICK_CALL, &AF(InitLavaFlame), &s_LavaFlame[4][4]},
{LAVA_FLAME_R4 + 0, LAVA_FLAME_RATE, &AF(NullLava), &s_LavaFlame[4][5]},
{LAVA_FLAME_R4 + 0, LAVA_FLAME_RATE, &AF(NullLava), &s_LavaFlame[4][6]},
{LAVA_FLAME_R4 + 0, SF_QUICK_CALL, &AF(InitActorDecide), &s_LavaFlame[4][7]},
{LAVA_FLAME_R4 + 0, LAVA_FLAME_RATE, &AF(DoLavaMove), &s_LavaFlame[4][7]},
}
};
STATE* sg_LavaFlame[] =
{
&s_LavaFlame[0][0],
&s_LavaFlame[1][0],
&s_LavaFlame[2][0],
&s_LavaFlame[3][0],
&s_LavaFlame[4][0]
};
//////////////////////
@ -375,13 +239,13 @@ STATE* sg_LavaFlame[] =
STATE s_LavaDie[] =
{
{LAVA_DIE + 0, LAVA_DIE_RATE, &AF(NullLava), &s_LavaDie[1]},
{LAVA_DEAD, LAVA_DIE_RATE, &AF(DoActorDebris), &s_LavaDie[1]}
{SPR_LAVA_DIE, 'A', LAVA_DIE_RATE, &AF(NullLava), &s_LavaDie[1]},
{SPR_LAVA_DEAD, 'A', LAVA_DIE_RATE, &AF(DoActorDebris), &s_LavaDie[1]}
};
STATE s_LavaDead[] =
{
{LAVA_DEAD, LAVA_DIE_RATE, &AF(DoActorDebris), &s_LavaDead[0]},
{SPR_LAVA_DEAD, 'A', LAVA_DIE_RATE, &AF(DoActorDebris), &s_LavaDead[0]},
};
STATE* sg_LavaDie[] =

414
source/games/sw/src/miscactr.cpp
View file

@ -57,8 +57,8 @@ ATTRIBUTE ToiletGirlAttrib =
STATE s_ToiletGirlStand[2] =
{
{TOILETGIRL_R0 + 0, TOILETGIRL_RATE, &AF(DoToiletGirl), &s_ToiletGirlStand[1]},
{TOILETGIRL_R0 + 1, TOILETGIRL_RATE, &AF(DoToiletGirl), &s_ToiletGirlStand[0]}
{SPR_TOILETGIRL, 'A', TOILETGIRL_RATE, &AF(DoToiletGirl), &s_ToiletGirlStand[1]},
{SPR_TOILETGIRL, 'B', TOILETGIRL_RATE, &AF(DoToiletGirl), &s_ToiletGirlStand[0]}
};
//////////////////////
@ -66,14 +66,12 @@ STATE s_ToiletGirlStand[2] =
// TOILETGIRL PAIN
//
//////////////////////
#define TOILETGIRL_PAIN_RATE 32
#define TOILETGIRL_PAIN_R0 TOILETGIRL_R0
STATE s_ToiletGirlPain[2] =
{
{TOILETGIRL_PAIN_R0 + 0, TOILETGIRL_PAIN_RATE, &AF(ToiletGirlPain), &s_ToiletGirlPain[1]},
{TOILETGIRL_PAIN_R0 + 0, 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_ToiletGirlPain[0]}
{SPR_TOILETGIRL, 'A', TOILETGIRL_PAIN_RATE, &AF(ToiletGirlPain), &s_ToiletGirlPain[1]},
{SPR_TOILETGIRL, 'A', 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_ToiletGirlPain[0]}
};
//////////////////////
@ -83,26 +81,26 @@ STATE s_ToiletGirlPain[2] =
//////////////////////
#define TOILETGIRL_UZI_RATE 8
#define TOILETGIRL_FIRE_R0 TOILETGIRL_R0 + 2
#define TOILETGIRL_FIRE_R0 TOILETGIRL, 'C'
STATE s_ToiletGirlUzi[16] =
{
{TOILETGIRL_FIRE_R0 + 0, TOILETGIRL_UZI_RATE, &AF(ToiletGirlUzi), &s_ToiletGirlUzi[1]},
{TOILETGIRL_FIRE_R0 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ToiletGirlUzi[2]},
{TOILETGIRL_FIRE_R0 + 1, TOILETGIRL_UZI_RATE, &AF(ToiletGirlUzi), &s_ToiletGirlUzi[3]},
{TOILETGIRL_FIRE_R0 + 1, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ToiletGirlUzi[4]},
{TOILETGIRL_FIRE_R0 + 0, TOILETGIRL_UZI_RATE, &AF(ToiletGirlUzi), &s_ToiletGirlUzi[5]},
{TOILETGIRL_FIRE_R0 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ToiletGirlUzi[6]},
{TOILETGIRL_FIRE_R0 + 1, TOILETGIRL_UZI_RATE, &AF(ToiletGirlUzi), &s_ToiletGirlUzi[7]},
{TOILETGIRL_FIRE_R0 + 1, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ToiletGirlUzi[8]},
{TOILETGIRL_FIRE_R0 + 0, TOILETGIRL_UZI_RATE, &AF(ToiletGirlUzi), &s_ToiletGirlUzi[9]},
{TOILETGIRL_FIRE_R0 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ToiletGirlUzi[10]},
{TOILETGIRL_FIRE_R0 + 1, TOILETGIRL_UZI_RATE, &AF(ToiletGirlUzi), &s_ToiletGirlUzi[11]},
{TOILETGIRL_FIRE_R0 + 1, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ToiletGirlUzi[12]},
{TOILETGIRL_FIRE_R0 + 0, TOILETGIRL_UZI_RATE, &AF(ToiletGirlUzi), &s_ToiletGirlUzi[13]},
{TOILETGIRL_FIRE_R0 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ToiletGirlUzi[14]},
{TOILETGIRL_FIRE_R0 + 1, TOILETGIRL_UZI_RATE, &AF(ToiletGirlUzi), &s_ToiletGirlUzi[15]},
{TOILETGIRL_FIRE_R0 + 1, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ToiletGirlUzi[0]},
{SPR_TOILETGIRL_FIRE, 'A', TOILETGIRL_UZI_RATE, &AF(ToiletGirlUzi), &s_ToiletGirlUzi[1]},
{SPR_TOILETGIRL_FIRE, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ToiletGirlUzi[2]},
{SPR_TOILETGIRL_FIRE, 'B', TOILETGIRL_UZI_RATE, &AF(ToiletGirlUzi), &s_ToiletGirlUzi[3]},
{SPR_TOILETGIRL_FIRE, 'B', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ToiletGirlUzi[4]},
{SPR_TOILETGIRL_FIRE, 'A', TOILETGIRL_UZI_RATE, &AF(ToiletGirlUzi), &s_ToiletGirlUzi[5]},
{SPR_TOILETGIRL_FIRE, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ToiletGirlUzi[6]},
{SPR_TOILETGIRL_FIRE, 'B', TOILETGIRL_UZI_RATE, &AF(ToiletGirlUzi), &s_ToiletGirlUzi[7]},
{SPR_TOILETGIRL_FIRE, 'B', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ToiletGirlUzi[8]},
{SPR_TOILETGIRL_FIRE, 'A', TOILETGIRL_UZI_RATE, &AF(ToiletGirlUzi), &s_ToiletGirlUzi[9]},
{SPR_TOILETGIRL_FIRE, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ToiletGirlUzi[10]},
{SPR_TOILETGIRL_FIRE, 'B', TOILETGIRL_UZI_RATE, &AF(ToiletGirlUzi), &s_ToiletGirlUzi[11]},
{SPR_TOILETGIRL_FIRE, 'B', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ToiletGirlUzi[12]},
{SPR_TOILETGIRL_FIRE, 'A', TOILETGIRL_UZI_RATE, &AF(ToiletGirlUzi), &s_ToiletGirlUzi[13]},
{SPR_TOILETGIRL_FIRE, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ToiletGirlUzi[14]},
{SPR_TOILETGIRL_FIRE, 'B', TOILETGIRL_UZI_RATE, &AF(ToiletGirlUzi), &s_ToiletGirlUzi[15]},
{SPR_TOILETGIRL_FIRE, 'B', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ToiletGirlUzi[0]},
};
//---------------------------------------------------------------------------
@ -126,7 +124,7 @@ int SetupToiletGirl(DSWActor* actor)
actor->user.__legacyState.Attrib = &ToiletGirlAttrib;
actor->user.__legacyState.StateEnd = s_ToiletGirlStand;
actor->user.__legacyState.Rot = 0;
actor->user.__legacyState.RotNum = 0;
actor->spr.scale = DVector2(0.5, 0.5);
actor->vel.X = 0;
@ -306,15 +304,15 @@ ATTRIBUTE WashGirlAttrib =
STATE s_WashGirlStand[2] =
{
{WASHGIRL_R0 + 0, WASHGIRL_RATE, &AF(DoWashGirl), &s_WashGirlStand[1]},
{WASHGIRL_R0 + 1, WASHGIRL_RATE, &AF(DoWashGirl), &s_WashGirlStand[0]}
{SPR_WASHGIRL, 'A', WASHGIRL_RATE, &AF(DoWashGirl), &s_WashGirlStand[1]},
{SPR_WASHGIRL, 'B', WASHGIRL_RATE, &AF(DoWashGirl), &s_WashGirlStand[0]}
};
#define WASHGIRL_RATE2 20
STATE s_WashGirlStandScrub[2] =
{
{WASHGIRL_R0 + 0, WASHGIRL_RATE2, &AF(DoWashGirl), &s_WashGirlStandScrub[1]},
{WASHGIRL_R0 + 1, WASHGIRL_RATE2, &AF(DoWashGirl), &s_WashGirlStandScrub[0]}
{SPR_WASHGIRL, 'A', WASHGIRL_RATE2, &AF(DoWashGirl), &s_WashGirlStandScrub[1]},
{SPR_WASHGIRL, 'B', WASHGIRL_RATE2, &AF(DoWashGirl), &s_WashGirlStandScrub[0]}
};
//////////////////////
@ -324,12 +322,11 @@ STATE s_WashGirlStandScrub[2] =
//////////////////////
#define WASHGIRL_PAIN_RATE 30
#define WASHGIRL_PAIN_R0 WASHGIRL_R0
STATE s_WashGirlPain[2] =
{
{WASHGIRL_PAIN_R0 + 0, WASHGIRL_PAIN_RATE, &AF(WashGirlPain), &s_WashGirlPain[1]},
{WASHGIRL_PAIN_R0 + 0, 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_WashGirlPain[0]}
{SPR_WASHGIRL, 'A', WASHGIRL_PAIN_RATE, &AF(WashGirlPain), &s_WashGirlPain[1]},
{SPR_WASHGIRL, 'A', 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_WashGirlPain[0]}
};
@ -340,26 +337,25 @@ STATE s_WashGirlPain[2] =
//////////////////////
#define WASHGIRL_UZI_RATE 8
#define WASHGIRL_FIRE_R0 WASHGIRL_R0 + 2
STATE s_WashGirlUzi[16] =
{
{WASHGIRL_FIRE_R0 + 0, WASHGIRL_UZI_RATE, &AF(WashGirlUzi), &s_WashGirlUzi[1]},
{WASHGIRL_FIRE_R0 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_WashGirlUzi[2]},
{WASHGIRL_FIRE_R0 + 1, WASHGIRL_UZI_RATE, &AF(WashGirlUzi), &s_WashGirlUzi[3]},
{WASHGIRL_FIRE_R0 + 1, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_WashGirlUzi[4]},
{WASHGIRL_FIRE_R0 + 0, WASHGIRL_UZI_RATE, &AF(WashGirlUzi), &s_WashGirlUzi[5]},
{WASHGIRL_FIRE_R0 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_WashGirlUzi[6]},
{WASHGIRL_FIRE_R0 + 1, WASHGIRL_UZI_RATE, &AF(WashGirlUzi), &s_WashGirlUzi[7]},
{WASHGIRL_FIRE_R0 + 1, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_WashGirlUzi[8]},
{WASHGIRL_FIRE_R0 + 0, WASHGIRL_UZI_RATE, &AF(WashGirlUzi), &s_WashGirlUzi[9]},
{WASHGIRL_FIRE_R0 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_WashGirlUzi[10]},
{WASHGIRL_FIRE_R0 + 1, WASHGIRL_UZI_RATE, &AF(WashGirlUzi), &s_WashGirlUzi[11]},
{WASHGIRL_FIRE_R0 + 1, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_WashGirlUzi[12]},
{WASHGIRL_FIRE_R0 + 0, WASHGIRL_UZI_RATE, &AF(WashGirlUzi), &s_WashGirlUzi[13]},
{WASHGIRL_FIRE_R0 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_WashGirlUzi[14]},
{WASHGIRL_FIRE_R0 + 1, WASHGIRL_UZI_RATE, &AF(WashGirlUzi), &s_WashGirlUzi[15]},
{WASHGIRL_FIRE_R0 + 1, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_WashGirlUzi[0]},
{SPR_WASHGIRL_FIRE, 'A', WASHGIRL_UZI_RATE, &AF(WashGirlUzi), &s_WashGirlUzi[1]},
{SPR_WASHGIRL_FIRE, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_WashGirlUzi[2]},
{SPR_WASHGIRL_FIRE, 'B', WASHGIRL_UZI_RATE, &AF(WashGirlUzi), &s_WashGirlUzi[3]},
{SPR_WASHGIRL_FIRE, 'B', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_WashGirlUzi[4]},
{SPR_WASHGIRL_FIRE, 'A', WASHGIRL_UZI_RATE, &AF(WashGirlUzi), &s_WashGirlUzi[5]},
{SPR_WASHGIRL_FIRE, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_WashGirlUzi[6]},
{SPR_WASHGIRL_FIRE, 'B', WASHGIRL_UZI_RATE, &AF(WashGirlUzi), &s_WashGirlUzi[7]},
{SPR_WASHGIRL_FIRE, 'B', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_WashGirlUzi[8]},
{SPR_WASHGIRL_FIRE, 'A', WASHGIRL_UZI_RATE, &AF(WashGirlUzi), &s_WashGirlUzi[9]},
{SPR_WASHGIRL_FIRE, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_WashGirlUzi[10]},
{SPR_WASHGIRL_FIRE, 'B', WASHGIRL_UZI_RATE, &AF(WashGirlUzi), &s_WashGirlUzi[11]},
{SPR_WASHGIRL_FIRE, 'B', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_WashGirlUzi[12]},
{SPR_WASHGIRL_FIRE, 'A', WASHGIRL_UZI_RATE, &AF(WashGirlUzi), &s_WashGirlUzi[13]},
{SPR_WASHGIRL_FIRE, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_WashGirlUzi[14]},
{SPR_WASHGIRL_FIRE, 'B', WASHGIRL_UZI_RATE, &AF(WashGirlUzi), &s_WashGirlUzi[15]},
{SPR_WASHGIRL_FIRE, 'B', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_WashGirlUzi[0]},
};
//---------------------------------------------------------------------------
@ -382,7 +378,7 @@ int SetupWashGirl(DSWActor* actor)
actor->user.__legacyState.Attrib = &WashGirlAttrib;
actor->user.__legacyState.StateEnd = s_WashGirlStand;
actor->user.__legacyState.Rot = 0;
actor->user.__legacyState.RotNum = 0;
actor->spr.scale = DVector2(0.4374, 0.375);
actor->vel.X = 0;
@ -571,7 +567,7 @@ ATTRIBUTE TrashCanAttrib =
STATE s_TrashCanStand[1] =
{
{TRASHCAN_R0 + 0, TRASHCAN_RATE, &AF(DoTrashCan), &s_TrashCanStand[0]}
{SPR_TRASHCAN, 'A', TRASHCAN_RATE, &AF(DoTrashCan), &s_TrashCanStand[0]}
};
//////////////////////
@ -581,17 +577,16 @@ STATE s_TrashCanStand[1] =
//////////////////////
#define TRASHCAN_PAIN_RATE 8
#define TRASHCAN_PAIN_R0 TRASHCAN
STATE s_TrashCanPain[7] =
{
{TRASHCAN_PAIN_R0 + 0, TRASHCAN_PAIN_RATE, &AF(TrashCanPain), &s_TrashCanPain[1]},
{TRASHCAN_PAIN_R0 + 1, TRASHCAN_PAIN_RATE, &AF(TrashCanPain), &s_TrashCanPain[2]},
{TRASHCAN_PAIN_R0 + 2, TRASHCAN_PAIN_RATE, &AF(TrashCanPain), &s_TrashCanPain[3]},
{TRASHCAN_PAIN_R0 + 3, TRASHCAN_PAIN_RATE, &AF(TrashCanPain), &s_TrashCanPain[4]},
{TRASHCAN_PAIN_R0 + 4, TRASHCAN_PAIN_RATE, &AF(TrashCanPain), &s_TrashCanPain[5]},
{TRASHCAN_PAIN_R0 + 5, TRASHCAN_PAIN_RATE, &AF(TrashCanPain), &s_TrashCanPain[6]},
{TRASHCAN_PAIN_R0 + 6, TRASHCAN_PAIN_RATE, &AF(TrashCanPain), &s_TrashCanPain[0]}
{SPR_TRASHCAN, 'A', TRASHCAN_PAIN_RATE, &AF(TrashCanPain), &s_TrashCanPain[1]},
{SPR_TRASHCAN, 'B', TRASHCAN_PAIN_RATE, &AF(TrashCanPain), &s_TrashCanPain[2]},
{SPR_TRASHCAN, 'C', TRASHCAN_PAIN_RATE, &AF(TrashCanPain), &s_TrashCanPain[3]},
{SPR_TRASHCAN, 'D', TRASHCAN_PAIN_RATE, &AF(TrashCanPain), &s_TrashCanPain[4]},
{SPR_TRASHCAN, 'E', TRASHCAN_PAIN_RATE, &AF(TrashCanPain), &s_TrashCanPain[5]},
{SPR_TRASHCAN, 'F', TRASHCAN_PAIN_RATE, &AF(TrashCanPain), &s_TrashCanPain[6]},
{SPR_TRASHCAN, 'G', TRASHCAN_PAIN_RATE, &AF(TrashCanPain), &s_TrashCanPain[0]}
};
//---------------------------------------------------------------------------
@ -614,7 +609,7 @@ int SetupTrashCan(DSWActor* actor)
actor->user.__legacyState.Attrib = &TrashCanAttrib;
actor->user.__legacyState.StateEnd = s_TrashCanStand;
actor->user.__legacyState.Rot = 0;
actor->user.__legacyState.RotNum = 0;
actor->spr.scale = DVector2(0.71875, 0.65625);
@ -687,21 +682,20 @@ ATTRIBUTE PachinkoLightAttrib =
};
#define PACHINKOLIGHT_RATE 120
#define PACHINKOLIGHT_R0 623
STATE s_PachinkoLightStand[] =
{
{PACHINKOLIGHT_R0 + 0, PACHINKOLIGHT_RATE, nullptr, &s_PachinkoLightStand[0]}
{SPR_PACHINKOLIGHT, 'F', PACHINKOLIGHT_RATE, nullptr, &s_PachinkoLightStand[0]}
};
STATE s_PachinkoLightOperate[] =
{
{PACHINKOLIGHT_R0 - 0, 12, &AF(PachinkoLightOperate), &s_PachinkoLightOperate[1]},
{PACHINKOLIGHT_R0 - 1, 12, &AF(PachinkoLightOperate), &s_PachinkoLightOperate[2]},
{PACHINKOLIGHT_R0 - 2, 12, &AF(PachinkoLightOperate), &s_PachinkoLightOperate[3]},
{PACHINKOLIGHT_R0 - 3, 12, &AF(PachinkoLightOperate), &s_PachinkoLightOperate[4]},
{PACHINKOLIGHT_R0 - 4, 12, &AF(PachinkoLightOperate), &s_PachinkoLightOperate[5]},
{PACHINKOLIGHT_R0 - 5, 12, &AF(PachinkoLightOperate), &s_PachinkoLightOperate[0]},
{SPR_PACHINKOLIGHT, 'F', 12, &AF(PachinkoLightOperate), &s_PachinkoLightOperate[1]},
{SPR_PACHINKOLIGHT, 'E', 12, &AF(PachinkoLightOperate), &s_PachinkoLightOperate[2]},
{SPR_PACHINKOLIGHT, 'D', 12, &AF(PachinkoLightOperate), &s_PachinkoLightOperate[3]},
{SPR_PACHINKOLIGHT, 'C', 12, &AF(PachinkoLightOperate), &s_PachinkoLightOperate[4]},
{SPR_PACHINKOLIGHT, 'B', 12, &AF(PachinkoLightOperate), &s_PachinkoLightOperate[5]},
{SPR_PACHINKOLIGHT, 'A', 12, &AF(PachinkoLightOperate), &s_PachinkoLightOperate[0]},
};
//---------------------------------------------------------------------------
@ -724,7 +718,7 @@ int SetupPachinkoLight(DSWActor* actor)
actor->user.__legacyState.Attrib = &PachinkoLightAttrib;
actor->user.__legacyState.StateEnd = s_PachinkoLightStand;
actor->user.__legacyState.Rot = 0;
actor->user.__legacyState.RotNum = 0;
actor->user.ID = PACHINKOLIGHT_R0;
actor->vel.X = 0;
@ -783,34 +777,34 @@ ATTRIBUTE Pachinko1Attrib =
STATE s_Pachinko1Stand[] =
{
{PACHINKO1_R0 + 0, PACHINKO1_RATE, nullptr, &s_Pachinko1Stand[0]}
{SPR_PACHINKO1, 'A', PACHINKO1_RATE, nullptr, &s_Pachinko1Stand[0]}
};
STATE s_Pachinko1Operate[] =
{
{PACHINKO1_R0 + 0, 12, &AF(Pachinko1Operate), &s_Pachinko1Operate[1]},
{PACHINKO1_R0 + 1, 12, &AF(Pachinko1Operate), &s_Pachinko1Operate[2]},
{PACHINKO1_R0 + 2, 12, &AF(Pachinko1Operate), &s_Pachinko1Operate[3]},
{PACHINKO1_R0 + 3, 12, &AF(Pachinko1Operate), &s_Pachinko1Operate[4]},
{PACHINKO1_R0 + 4, 12, &AF(Pachinko1Operate), &s_Pachinko1Operate[5]},
{PACHINKO1_R0 + 5, 12, &AF(Pachinko1Operate), &s_Pachinko1Operate[6]},
{PACHINKO1_R0 + 6, 12, &AF(Pachinko1Operate), &s_Pachinko1Operate[7]},
{PACHINKO1_R0 + 7, 12, &AF(Pachinko1Operate), &s_Pachinko1Operate[8]},
{PACHINKO1_R0 + 8, 12, &AF(Pachinko1Operate), &s_Pachinko1Operate[9]},
{PACHINKO1_R0 + 9, 12, &AF(Pachinko1Operate), &s_Pachinko1Operate[10]},
{PACHINKO1_R0 + 10, 12, &AF(Pachinko1Operate), &s_Pachinko1Operate[11]},
{PACHINKO1_R0 + 11, 12, &AF(Pachinko1Operate), &s_Pachinko1Operate[12]},
{PACHINKO1_R0 + 12, 12, &AF(Pachinko1Operate), &s_Pachinko1Operate[13]},
{PACHINKO1_R0 + 13, 12, &AF(Pachinko1Operate), &s_Pachinko1Operate[14]},
{PACHINKO1_R0 + 14, 12, &AF(Pachinko1Operate), &s_Pachinko1Operate[15]},
{PACHINKO1_R0 + 15, 12, &AF(Pachinko1Operate), &s_Pachinko1Operate[16]},
{PACHINKO1_R0 + 16, 12, &AF(Pachinko1Operate), &s_Pachinko1Operate[17]},
{PACHINKO1_R0 + 17, 12, &AF(Pachinko1Operate), &s_Pachinko1Operate[18]},
{PACHINKO1_R0 + 18, 12, &AF(Pachinko1Operate), &s_Pachinko1Operate[19]},
{PACHINKO1_R0 + 19, 12, &AF(Pachinko1Operate), &s_Pachinko1Operate[20]},
{PACHINKO1_R0 + 20, 12, &AF(Pachinko1Operate), &s_Pachinko1Operate[21]},
{PACHINKO1_R0 + 21, 12, &AF(Pachinko1Operate), &s_Pachinko1Operate[22]},
{PACHINKO1_R0 + 22, SF_QUICK_CALL, &AF(PachinkoCheckWin), &s_Pachinko1Stand[0]}
{SPR_PACHINKO1, 'A', 12, &AF(Pachinko1Operate), &s_Pachinko1Operate[1]},
{SPR_PACHINKO1, 'B', 12, &AF(Pachinko1Operate), &s_Pachinko1Operate[2]},
{SPR_PACHINKO1, 'C', 12, &AF(Pachinko1Operate), &s_Pachinko1Operate[3]},
{SPR_PACHINKO1, 'D', 12, &AF(Pachinko1Operate), &s_Pachinko1Operate[4]},
{SPR_PACHINKO1, 'E', 12, &AF(Pachinko1Operate), &s_Pachinko1Operate[5]},
{SPR_PACHINKO1, 'F', 12, &AF(Pachinko1Operate), &s_Pachinko1Operate[6]},
{SPR_PACHINKO1, 'G', 12, &AF(Pachinko1Operate), &s_Pachinko1Operate[7]},
{SPR_PACHINKO1, 'H', 12, &AF(Pachinko1Operate), &s_Pachinko1Operate[8]},
{SPR_PACHINKO1, 'I', 12, &AF(Pachinko1Operate), &s_Pachinko1Operate[9]},
{SPR_PACHINKO1, 'J', 12, &AF(Pachinko1Operate), &s_Pachinko1Operate[10]},
{SPR_PACHINKO1, 'K', 12, &AF(Pachinko1Operate), &s_Pachinko1Operate[11]},
{SPR_PACHINKO1, 'L', 12, &AF(Pachinko1Operate), &s_Pachinko1Operate[12]},
{SPR_PACHINKO1, 'M', 12, &AF(Pachinko1Operate), &s_Pachinko1Operate[13]},
{SPR_PACHINKO1, 'N', 12, &AF(Pachinko1Operate), &s_Pachinko1Operate[14]},
{SPR_PACHINKO1, 'O', 12, &AF(Pachinko1Operate), &s_Pachinko1Operate[15]},
{SPR_PACHINKO1, 'P', 12, &AF(Pachinko1Operate), &s_Pachinko1Operate[16]},
{SPR_PACHINKO1, 'Q', 12, &AF(Pachinko1Operate), &s_Pachinko1Operate[17]},
{SPR_PACHINKO1, 'R', 12, &AF(Pachinko1Operate), &s_Pachinko1Operate[18]},
{SPR_PACHINKO1, 'S', 12, &AF(Pachinko1Operate), &s_Pachinko1Operate[19]},
{SPR_PACHINKO1, 'T', 12, &AF(Pachinko1Operate), &s_Pachinko1Operate[20]},
{SPR_PACHINKO1, 'U', 12, &AF(Pachinko1Operate), &s_Pachinko1Operate[21]},
{SPR_PACHINKO1, 'V', 12, &AF(Pachinko1Operate), &s_Pachinko1Operate[22]},
{SPR_PACHINKO1, 'W', SF_QUICK_CALL, &AF(PachinkoCheckWin), &s_Pachinko1Stand[0]}
};
//---------------------------------------------------------------------------
@ -833,7 +827,7 @@ int SetupPachinko1(DSWActor* actor)
actor->user.__legacyState.Attrib = &Pachinko1Attrib;
actor->user.__legacyState.StateEnd = s_Pachinko1Stand;
actor->user.__legacyState.Rot = 0;
actor->user.__legacyState.RotNum = 0;
actor->user.ID = PACHINKO1;
actor->vel.Z = 0;
@ -960,34 +954,34 @@ ATTRIBUTE Pachinko2Attrib =
STATE s_Pachinko2Stand[] =
{
{PACHINKO2_R0 + 0, PACHINKO2_RATE, nullptr, &s_Pachinko2Stand[0]}
{SPR_PACHINKO2, 'A', PACHINKO2_RATE, nullptr, &s_Pachinko2Stand[0]}
};
STATE s_Pachinko2Operate[] =
{
{PACHINKO2_R0 + 0, 12, &AF(Pachinko1Operate), &s_Pachinko2Operate[1]},
{PACHINKO2_R0 + 1, 12, &AF(Pachinko1Operate), &s_Pachinko2Operate[2]},
{PACHINKO2_R0 + 2, 12, &AF(Pachinko1Operate), &s_Pachinko2Operate[3]},
{PACHINKO2_R0 + 3, 12, &AF(Pachinko1Operate), &s_Pachinko2Operate[4]},
{PACHINKO2_R0 + 4, 12, &AF(Pachinko1Operate), &s_Pachinko2Operate[5]},
{PACHINKO2_R0 + 5, 12, &AF(Pachinko1Operate), &s_Pachinko2Operate[6]},
{PACHINKO2_R0 + 6, 12, &AF(Pachinko1Operate), &s_Pachinko2Operate[7]},
{PACHINKO2_R0 + 7, 12, &AF(Pachinko1Operate), &s_Pachinko2Operate[8]},
{PACHINKO2_R0 + 8, 12, &AF(Pachinko1Operate), &s_Pachinko2Operate[9]},
{PACHINKO2_R0 + 9, 12, &AF(Pachinko1Operate), &s_Pachinko2Operate[10]},
{PACHINKO2_R0 + 10, 12, &AF(Pachinko1Operate), &s_Pachinko2Operate[11]},
{PACHINKO2_R0 + 11, 12, &AF(Pachinko1Operate), &s_Pachinko2Operate[12]},
{PACHINKO2_R0 + 12, 12, &AF(Pachinko1Operate), &s_Pachinko2Operate[13]},
{PACHINKO2_R0 + 13, 12, &AF(Pachinko1Operate), &s_Pachinko2Operate[14]},
{PACHINKO2_R0 + 14, 12, &AF(Pachinko1Operate), &s_Pachinko2Operate[15]},
{PACHINKO2_R0 + 15, 12, &AF(Pachinko1Operate), &s_Pachinko2Operate[16]},
{PACHINKO2_R0 + 16, 12, &AF(Pachinko1Operate), &s_Pachinko2Operate[17]},
{PACHINKO2_R0 + 17, 12, &AF(Pachinko1Operate), &s_Pachinko2Operate[18]},
{PACHINKO2_R0 + 18, 12, &AF(Pachinko1Operate), &s_Pachinko2Operate[19]},
{PACHINKO2_R0 + 19, 12, &AF(Pachinko1Operate), &s_Pachinko2Operate[20]},
{PACHINKO2_R0 + 20, 12, &AF(Pachinko1Operate), &s_Pachinko2Operate[21]},
{PACHINKO2_R0 + 21, 12, &AF(Pachinko1Operate), &s_Pachinko2Operate[22]},
{PACHINKO2_R0 + 22, SF_QUICK_CALL, &AF(PachinkoCheckWin), &s_Pachinko2Stand[0]}
{SPR_PACHINKO2, 'A', 12, &AF(Pachinko1Operate), &s_Pachinko2Operate[1]},
{SPR_PACHINKO2, 'B', 12, &AF(Pachinko1Operate), &s_Pachinko2Operate[2]},
{SPR_PACHINKO2, 'C', 12, &AF(Pachinko1Operate), &s_Pachinko2Operate[3]},
{SPR_PACHINKO2, 'D', 12, &AF(Pachinko1Operate), &s_Pachinko2Operate[4]},
{SPR_PACHINKO2, 'E', 12, &AF(Pachinko1Operate), &s_Pachinko2Operate[5]},
{SPR_PACHINKO2, 'F', 12, &AF(Pachinko1Operate), &s_Pachinko2Operate[6]},
{SPR_PACHINKO2, 'G', 12, &AF(Pachinko1Operate), &s_Pachinko2Operate[7]},
{SPR_PACHINKO2, 'H', 12, &AF(Pachinko1Operate), &s_Pachinko2Operate[8]},
{SPR_PACHINKO2, 'I', 12, &AF(Pachinko1Operate), &s_Pachinko2Operate[9]},
{SPR_PACHINKO2, 'J', 12, &AF(Pachinko1Operate), &s_Pachinko2Operate[10]},
{SPR_PACHINKO2, 'K', 12, &AF(Pachinko1Operate), &s_Pachinko2Operate[11]},
{SPR_PACHINKO2, 'L', 12, &AF(Pachinko1Operate), &s_Pachinko2Operate[12]},
{SPR_PACHINKO2, 'M', 12, &AF(Pachinko1Operate), &s_Pachinko2Operate[13]},
{SPR_PACHINKO2, 'N', 12, &AF(Pachinko1Operate), &s_Pachinko2Operate[14]},
{SPR_PACHINKO2, 'O', 12, &AF(Pachinko1Operate), &s_Pachinko2Operate[15]},
{SPR_PACHINKO2, 'P', 12, &AF(Pachinko1Operate), &s_Pachinko2Operate[16]},
{SPR_PACHINKO2, 'Q', 12, &AF(Pachinko1Operate), &s_Pachinko2Operate[17]},
{SPR_PACHINKO2, 'R', 12, &AF(Pachinko1Operate), &s_Pachinko2Operate[18]},
{SPR_PACHINKO2, 'S', 12, &AF(Pachinko1Operate), &s_Pachinko2Operate[19]},
{SPR_PACHINKO2, 'T', 12, &AF(Pachinko1Operate), &s_Pachinko2Operate[20]},
{SPR_PACHINKO2, 'U', 12, &AF(Pachinko1Operate), &s_Pachinko2Operate[21]},
{SPR_PACHINKO2, 'V', 12, &AF(Pachinko1Operate), &s_Pachinko2Operate[22]},
{SPR_PACHINKO2, 'W', SF_QUICK_CALL, &AF(PachinkoCheckWin), &s_Pachinko2Stand[0]}
};
//---------------------------------------------------------------------------
@ -1010,7 +1004,7 @@ int SetupPachinko2(DSWActor* actor)
actor->user.__legacyState.Attrib = &Pachinko2Attrib;
actor->user.__legacyState.StateEnd = s_Pachinko2Stand;
actor->user.__legacyState.Rot = 0;
actor->user.__legacyState.RotNum = 0;
actor->user.ID = PACHINKO2;
actor->vel.Z = 0;
@ -1049,34 +1043,34 @@ ATTRIBUTE Pachinko3Attrib =
STATE s_Pachinko3Stand[] =
{
{PACHINKO3_R0 + 0, PACHINKO3_RATE, nullptr, &s_Pachinko3Stand[0]}
{SPR_PACHINKO3, 'A', PACHINKO3_RATE, nullptr, &s_Pachinko3Stand[0]}
};
STATE s_Pachinko3Operate[] =
{
{PACHINKO3_R0 + 0, 12, &AF(Pachinko1Operate), &s_Pachinko3Operate[1]},
{PACHINKO3_R0 + 1, 12, &AF(Pachinko1Operate), &s_Pachinko3Operate[2]},
{PACHINKO3_R0 + 2, 12, &AF(Pachinko1Operate), &s_Pachinko3Operate[3]},
{PACHINKO3_R0 + 3, 12, &AF(Pachinko1Operate), &s_Pachinko3Operate[4]},
{PACHINKO3_R0 + 4, 12, &AF(Pachinko1Operate), &s_Pachinko3Operate[5]},
{PACHINKO3_R0 + 5, 12, &AF(Pachinko1Operate), &s_Pachinko3Operate[6]},
{PACHINKO3_R0 + 6, 12, &AF(Pachinko1Operate), &s_Pachinko3Operate[7]},
{PACHINKO3_R0 + 7, 12, &AF(Pachinko1Operate), &s_Pachinko3Operate[8]},
{PACHINKO3_R0 + 8, 12, &AF(Pachinko1Operate), &s_Pachinko3Operate[9]},
{PACHINKO3_R0 + 9, 12, &AF(Pachinko1Operate), &s_Pachinko3Operate[10]},
{PACHINKO3_R0 + 10, 12, &AF(Pachinko1Operate), &s_Pachinko3Operate[11]},
{PACHINKO3_R0 + 11, 12, &AF(Pachinko1Operate), &s_Pachinko3Operate[12]},
{PACHINKO3_R0 + 12, 12, &AF(Pachinko1Operate), &s_Pachinko3Operate[13]},
{PACHINKO3_R0 + 13, 12, &AF(Pachinko1Operate), &s_Pachinko3Operate[14]},
{PACHINKO3_R0 + 14, 12, &AF(Pachinko1Operate), &s_Pachinko3Operate[15]},
{PACHINKO3_R0 + 15, 12, &AF(Pachinko1Operate), &s_Pachinko3Operate[16]},
{PACHINKO3_R0 + 16, 12, &AF(Pachinko1Operate), &s_Pachinko3Operate[17]},
{PACHINKO3_R0 + 17, 12, &AF(Pachinko1Operate), &s_Pachinko3Operate[18]},
{PACHINKO3_R0 + 18, 12, &AF(Pachinko1Operate), &s_Pachinko3Operate[19]},
{PACHINKO3_R0 + 19, 12, &AF(Pachinko1Operate), &s_Pachinko3Operate[20]},
{PACHINKO3_R0 + 20, 12, &AF(Pachinko1Operate), &s_Pachinko3Operate[21]},
{PACHINKO3_R0 + 21, 12, &AF(Pachinko1Operate), &s_Pachinko3Operate[22]},
{PACHINKO3_R0 + 22, SF_QUICK_CALL, &AF(PachinkoCheckWin), &s_Pachinko3Stand[0]}
{SPR_PACHINKO3, 'A', 12, &AF(Pachinko1Operate), &s_Pachinko3Operate[1]},
{SPR_PACHINKO3, 'B', 12, &AF(Pachinko1Operate), &s_Pachinko3Operate[2]},
{SPR_PACHINKO3, 'C', 12, &AF(Pachinko1Operate), &s_Pachinko3Operate[3]},
{SPR_PACHINKO3, 'D', 12, &AF(Pachinko1Operate), &s_Pachinko3Operate[4]},
{SPR_PACHINKO3, 'E', 12, &AF(Pachinko1Operate), &s_Pachinko3Operate[5]},
{SPR_PACHINKO3, 'F', 12, &AF(Pachinko1Operate), &s_Pachinko3Operate[6]},
{SPR_PACHINKO3, 'G', 12, &AF(Pachinko1Operate), &s_Pachinko3Operate[7]},
{SPR_PACHINKO3, 'H', 12, &AF(Pachinko1Operate), &s_Pachinko3Operate[8]},
{SPR_PACHINKO3, 'I', 12, &AF(Pachinko1Operate), &s_Pachinko3Operate[9]},
{SPR_PACHINKO3, 'J', 12, &AF(Pachinko1Operate), &s_Pachinko3Operate[10]},
{SPR_PACHINKO3, 'K', 12, &AF(Pachinko1Operate), &s_Pachinko3Operate[11]},
{SPR_PACHINKO3, 'L', 12, &AF(Pachinko1Operate), &s_Pachinko3Operate[12]},
{SPR_PACHINKO3, 'M', 12, &AF(Pachinko1Operate), &s_Pachinko3Operate[13]},
{SPR_PACHINKO3, 'N', 12, &AF(Pachinko1Operate), &s_Pachinko3Operate[14]},
{SPR_PACHINKO3, 'O', 12, &AF(Pachinko1Operate), &s_Pachinko3Operate[15]},
{SPR_PACHINKO3, 'P', 12, &AF(Pachinko1Operate), &s_Pachinko3Operate[16]},
{SPR_PACHINKO3, 'Q', 12, &AF(Pachinko1Operate), &s_Pachinko3Operate[17]},
{SPR_PACHINKO3, 'R', 12, &AF(Pachinko1Operate), &s_Pachinko3Operate[18]},
{SPR_PACHINKO3, 'S', 12, &AF(Pachinko1Operate), &s_Pachinko3Operate[19]},
{SPR_PACHINKO3, 'T', 12, &AF(Pachinko1Operate), &s_Pachinko3Operate[20]},
{SPR_PACHINKO3, 'U', 12, &AF(Pachinko1Operate), &s_Pachinko3Operate[21]},
{SPR_PACHINKO3, 'V', 12, &AF(Pachinko1Operate), &s_Pachinko3Operate[22]},
{SPR_PACHINKO3, 'W', SF_QUICK_CALL, &AF(PachinkoCheckWin), &s_Pachinko3Stand[0]}
};
//---------------------------------------------------------------------------
@ -1099,7 +1093,7 @@ int SetupPachinko3(DSWActor* actor)
actor->user.__legacyState.Attrib = &Pachinko3Attrib;
actor->user.__legacyState.StateEnd = s_Pachinko3Stand;
actor->user.__legacyState.Rot = 0;
actor->user.__legacyState.RotNum = 0;
actor->user.ID = PACHINKO3;
actor->vel.Z = 0;
@ -1138,34 +1132,34 @@ ATTRIBUTE Pachinko4Attrib =
STATE s_Pachinko4Stand[] =
{
{PACHINKO4_R0 + 0, PACHINKO4_RATE, nullptr, &s_Pachinko4Stand[0]}
{SPR_PACHINKO4, 'A', PACHINKO4_RATE, nullptr, &s_Pachinko4Stand[0]}
};
STATE s_Pachinko4Operate[] =
{
{PACHINKO4_R0 + 0, 12, &AF(Pachinko1Operate), &s_Pachinko4Operate[1]},
{PACHINKO4_R0 + 1, 12, &AF(Pachinko1Operate), &s_Pachinko4Operate[2]},
{PACHINKO4_R0 + 2, 12, &AF(Pachinko1Operate), &s_Pachinko4Operate[3]},
{PACHINKO4_R0 + 3, 12, &AF(Pachinko1Operate), &s_Pachinko4Operate[4]},
{PACHINKO4_R0 + 4, 12, &AF(Pachinko1Operate), &s_Pachinko4Operate[5]},
{PACHINKO4_R0 + 5, 12, &AF(Pachinko1Operate), &s_Pachinko4Operate[6]},
{PACHINKO4_R0 + 6, 12, &AF(Pachinko1Operate), &s_Pachinko4Operate[7]},
{PACHINKO4_R0 + 7, 12, &AF(Pachinko1Operate), &s_Pachinko4Operate[8]},
{PACHINKO4_R0 + 8, 12, &AF(Pachinko1Operate), &s_Pachinko4Operate[9]},
{PACHINKO4_R0 + 9, 12, &AF(Pachinko1Operate), &s_Pachinko4Operate[10]},
{PACHINKO4_R0 + 10, 12, &AF(Pachinko1Operate), &s_Pachinko4Operate[11]},
{PACHINKO4_R0 + 11, 12, &AF(Pachinko1Operate), &s_Pachinko4Operate[12]},
{PACHINKO4_R0 + 12, 12, &AF(Pachinko1Operate), &s_Pachinko4Operate[13]},
{PACHINKO4_R0 + 13, 12, &AF(Pachinko1Operate), &s_Pachinko4Operate[14]},
{PACHINKO4_R0 + 14, 12, &AF(Pachinko1Operate), &s_Pachinko4Operate[15]},
{PACHINKO4_R0 + 15, 12, &AF(Pachinko1Operate), &s_Pachinko4Operate[16]},
{PACHINKO4_R0 + 16, 12, &AF(Pachinko1Operate), &s_Pachinko4Operate[17]},
{PACHINKO4_R0 + 17, 12, &AF(Pachinko1Operate), &s_Pachinko4Operate[18]},
{PACHINKO4_R0 + 18, 12, &AF(Pachinko1Operate), &s_Pachinko4Operate[19]},
{PACHINKO4_R0 + 19, 12, &AF(Pachinko1Operate), &s_Pachinko4Operate[20]},
{PACHINKO4_R0 + 20, 12, &AF(Pachinko1Operate), &s_Pachinko4Operate[21]},
{PACHINKO4_R0 + 21, 12, &AF(Pachinko1Operate), &s_Pachinko4Operate[22]},
{PACHINKO4_R0 + 22, SF_QUICK_CALL, &AF(PachinkoCheckWin), &s_Pachinko4Stand[0]}
{SPR_PACHINKO4, 'A', 12, &AF(Pachinko1Operate), &s_Pachinko4Operate[1]},
{SPR_PACHINKO4, 'B', 12, &AF(Pachinko1Operate), &s_Pachinko4Operate[2]},
{SPR_PACHINKO4, 'C', 12, &AF(Pachinko1Operate), &s_Pachinko4Operate[3]},
{SPR_PACHINKO4, 'D', 12, &AF(Pachinko1Operate), &s_Pachinko4Operate[4]},
{SPR_PACHINKO4, 'E', 12, &AF(Pachinko1Operate), &s_Pachinko4Operate[5]},
{SPR_PACHINKO4, 'F', 12, &AF(Pachinko1Operate), &s_Pachinko4Operate[6]},
{SPR_PACHINKO4, 'G', 12, &AF(Pachinko1Operate), &s_Pachinko4Operate[7]},
{SPR_PACHINKO4, 'H', 12, &AF(Pachinko1Operate), &s_Pachinko4Operate[8]},
{SPR_PACHINKO4, 'I', 12, &AF(Pachinko1Operate), &s_Pachinko4Operate[9]},
{SPR_PACHINKO4, 'J', 12, &AF(Pachinko1Operate), &s_Pachinko4Operate[10]},
{SPR_PACHINKO4, 'K', 12, &AF(Pachinko1Operate), &s_Pachinko4Operate[11]},
{SPR_PACHINKO4, 'L', 12, &AF(Pachinko1Operate), &s_Pachinko4Operate[12]},
{SPR_PACHINKO4, 'M', 12, &AF(Pachinko1Operate), &s_Pachinko4Operate[13]},
{SPR_PACHINKO4, 'N', 12, &AF(Pachinko1Operate), &s_Pachinko4Operate[14]},
{SPR_PACHINKO4, 'O', 12, &AF(Pachinko1Operate), &s_Pachinko4Operate[15]},
{SPR_PACHINKO4, 'P', 12, &AF(Pachinko1Operate), &s_Pachinko4Operate[16]},
{SPR_PACHINKO4, 'Q', 12, &AF(Pachinko1Operate), &s_Pachinko4Operate[17]},
{SPR_PACHINKO4, 'R', 12, &AF(Pachinko1Operate), &s_Pachinko4Operate[18]},
{SPR_PACHINKO4, 'S', 12, &AF(Pachinko1Operate), &s_Pachinko4Operate[19]},
{SPR_PACHINKO4, 'T', 12, &AF(Pachinko1Operate), &s_Pachinko4Operate[20]},
{SPR_PACHINKO4, 'U', 12, &AF(Pachinko1Operate), &s_Pachinko4Operate[21]},
{SPR_PACHINKO4, 'V', 12, &AF(Pachinko1Operate), &s_Pachinko4Operate[22]},
{SPR_PACHINKO4, 'W', SF_QUICK_CALL, &AF(PachinkoCheckWin), &s_Pachinko4Stand[0]}
};
//---------------------------------------------------------------------------
@ -1188,7 +1182,7 @@ int SetupPachinko4(DSWActor* actor)
actor->user.__legacyState.Attrib = &Pachinko4Attrib;
actor->user.__legacyState.StateEnd = s_Pachinko4Stand;
actor->user.__legacyState.Rot = 0;
actor->user.__legacyState.RotNum = 0;
actor->user.ID = PACHINKO4;
actor->vel.Z = 0;
@ -1233,8 +1227,8 @@ ATTRIBUTE CarGirlAttrib =
STATE s_CarGirlStand[2] =
{
{CARGIRL_R0 + 0, CARGIRL_RATE, &AF(DoCarGirl), &s_CarGirlStand[1]},
{CARGIRL_R0 + 1, CARGIRL_RATE, &AF(DoCarGirl), &s_CarGirlStand[0]}
{SPR_CARGIRL, 'A', CARGIRL_RATE, &AF(DoCarGirl), &s_CarGirlStand[1]},
{SPR_CARGIRL, 'B', CARGIRL_RATE, &AF(DoCarGirl), &s_CarGirlStand[0]}
};
//////////////////////
@ -1248,8 +1242,8 @@ STATE s_CarGirlStand[2] =
STATE s_CarGirlPain[2] =
{
{CARGIRL_PAIN_R0 + 0, CARGIRL_PAIN_RATE, &AF(CarGirlPain), &s_CarGirlPain[1]},
{CARGIRL_PAIN_R0 + 0, 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_CarGirlPain[0]}
{SPR_CARGIRL, 'A', CARGIRL_PAIN_RATE, &AF(CarGirlPain), &s_CarGirlPain[1]},
{SPR_CARGIRL, 'A', 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_CarGirlPain[0]}
};
//////////////////////
@ -1259,26 +1253,25 @@ STATE s_CarGirlPain[2] =
//////////////////////
#define CARGIRL_UZI_RATE 8
#define CARGIRL_FIRE_R0 CARGIRL_R0 + 2
STATE s_CarGirlUzi[16] =
{
{CARGIRL_FIRE_R0 + 0, 240, &AF(CarGirlUzi), &s_CarGirlUzi[1]},
{CARGIRL_FIRE_R0 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_CarGirlUzi[2]},
{CARGIRL_FIRE_R0 + 1, CARGIRL_UZI_RATE, &AF(CarGirlUzi), &s_CarGirlUzi[3]},
{CARGIRL_FIRE_R0 + 1, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_CarGirlUzi[4]},
{CARGIRL_FIRE_R0 + 0, CARGIRL_UZI_RATE, &AF(CarGirlUzi), &s_CarGirlUzi[5]},
{CARGIRL_FIRE_R0 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_CarGirlUzi[6]},
{CARGIRL_FIRE_R0 + 1, CARGIRL_UZI_RATE, &AF(CarGirlUzi), &s_CarGirlUzi[7]},
{CARGIRL_FIRE_R0 + 1, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_CarGirlUzi[8]},
{CARGIRL_FIRE_R0 + 0, CARGIRL_UZI_RATE, &AF(CarGirlUzi), &s_CarGirlUzi[9]},
{CARGIRL_FIRE_R0 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_CarGirlUzi[10]},
{CARGIRL_FIRE_R0 + 1, CARGIRL_UZI_RATE, &AF(CarGirlUzi), &s_CarGirlUzi[11]},
{CARGIRL_FIRE_R0 + 1, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_CarGirlUzi[12]},
{CARGIRL_FIRE_R0 + 0, CARGIRL_UZI_RATE, &AF(CarGirlUzi), &s_CarGirlUzi[13]},
{CARGIRL_FIRE_R0 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_CarGirlUzi[14]},
{CARGIRL_FIRE_R0 + 1, CARGIRL_UZI_RATE, &AF(CarGirlUzi), &s_CarGirlUzi[15]},
{CARGIRL_FIRE_R0 + 1, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_CarGirlUzi[0]},
{SPR_CARGIRL_FIRE, 'A', 240, &AF(CarGirlUzi), &s_CarGirlUzi[1]},
{SPR_CARGIRL_FIRE, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_CarGirlUzi[2]},
{SPR_CARGIRL_FIRE, 'B', CARGIRL_UZI_RATE, &AF(CarGirlUzi), &s_CarGirlUzi[3]},
{SPR_CARGIRL_FIRE, 'B', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_CarGirlUzi[4]},
{SPR_CARGIRL_FIRE, 'A', CARGIRL_UZI_RATE, &AF(CarGirlUzi), &s_CarGirlUzi[5]},
{SPR_CARGIRL_FIRE, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_CarGirlUzi[6]},
{SPR_CARGIRL_FIRE, 'B', CARGIRL_UZI_RATE, &AF(CarGirlUzi), &s_CarGirlUzi[7]},
{SPR_CARGIRL_FIRE, 'B', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_CarGirlUzi[8]},
{SPR_CARGIRL_FIRE, 'A', CARGIRL_UZI_RATE, &AF(CarGirlUzi), &s_CarGirlUzi[9]},
{SPR_CARGIRL_FIRE, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_CarGirlUzi[10]},
{SPR_CARGIRL_FIRE, 'B', CARGIRL_UZI_RATE, &AF(CarGirlUzi), &s_CarGirlUzi[11]},
{SPR_CARGIRL_FIRE, 'B', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_CarGirlUzi[12]},
{SPR_CARGIRL_FIRE, 'A', CARGIRL_UZI_RATE, &AF(CarGirlUzi), &s_CarGirlUzi[13]},
{SPR_CARGIRL_FIRE, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_CarGirlUzi[14]},
{SPR_CARGIRL_FIRE, 'B', CARGIRL_UZI_RATE, &AF(CarGirlUzi), &s_CarGirlUzi[15]},
{SPR_CARGIRL_FIRE, 'B', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_CarGirlUzi[0]},
};
//---------------------------------------------------------------------------
@ -1302,7 +1295,7 @@ int SetupCarGirl(DSWActor* actor)
actor->user.__legacyState.Attrib = &CarGirlAttrib;
actor->user.__legacyState.StateEnd = s_CarGirlStand;
actor->user.__legacyState.Rot = 0;
actor->user.__legacyState.RotNum = 0;
actor->spr.scale = DVector2(0.453125, 0.390625);
actor->vel.X = 0;
@ -1481,8 +1474,8 @@ ATTRIBUTE MechanicGirlAttrib =
STATE s_MechanicGirlStand[2] =
{
{MECHANICGIRL_R0 + 0, MECHANICGIRL_RATE, &AF(DoMechanicGirl), &s_MechanicGirlStand[1]},
{MECHANICGIRL_R0 + 1, MECHANICGIRL_RATE, &AF(DoMechanicGirl), &s_MechanicGirlStand[0]}
{SPR_MECHANICGIRL, 'A', MECHANICGIRL_RATE, &AF(DoMechanicGirl), &s_MechanicGirlStand[1]},
{SPR_MECHANICGIRL, 'B', MECHANICGIRL_RATE, &AF(DoMechanicGirl), &s_MechanicGirlStand[0]}
};
//////////////////////
@ -1492,12 +1485,11 @@ STATE s_MechanicGirlStand[2] =
//////////////////////
#define MECHANICGIRL_PAIN_RATE 32
#define MECHANICGIRL_PAIN_R0 MECHANICGIRL_R0
STATE s_MechanicGirlPain[2] =
{
{MECHANICGIRL_PAIN_R0 + 0, MECHANICGIRL_PAIN_RATE, &AF(MechanicGirlPain), &s_MechanicGirlPain[1]},
{MECHANICGIRL_PAIN_R0 + 0, 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_MechanicGirlPain[0]}
{SPR_MECHANICGIRL, 'A', MECHANICGIRL_PAIN_RATE, &AF(MechanicGirlPain), &s_MechanicGirlPain[1]},
{SPR_MECHANICGIRL, 'A', 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_MechanicGirlPain[0]}
};
//////////////////////
@ -1507,12 +1499,11 @@ STATE s_MechanicGirlPain[2] =
//////////////////////
#define MECHANICGIRL_DRILL_RATE 32
#define MECHANICGIRL_DRILL_R0 MECHANICGIRL_R0 + 2
STATE s_MechanicGirlDrill[2] =
{
{MECHANICGIRL_DRILL_R0 + 0, MECHANICGIRL_DRILL_RATE, &AF(MechanicGirlDrill), &s_MechanicGirlDrill[1]},
{MECHANICGIRL_DRILL_R0 + 1, MECHANICGIRL_DRILL_RATE, &AF(MechanicGirlDrill), &s_MechanicGirlDrill[0]},
{SPR_MECHANICGIRL_DRILL, 'A', MECHANICGIRL_DRILL_RATE, &AF(MechanicGirlDrill), &s_MechanicGirlDrill[1]},
{SPR_MECHANICGIRL_DRILL, 'B', MECHANICGIRL_DRILL_RATE, &AF(MechanicGirlDrill), &s_MechanicGirlDrill[0]},
};
@ -1537,7 +1528,7 @@ int SetupMechanicGirl(DSWActor* actor)
actor->user.__legacyState.Attrib = &MechanicGirlAttrib;
actor->user.__legacyState.StateEnd = s_MechanicGirlStand;
actor->user.__legacyState.Rot = 0;
actor->user.__legacyState.RotNum = 0;
actor->spr.scale = DVector2(0.421875, 0.40625);
actor->vel.X = 0;
@ -1715,8 +1706,8 @@ ATTRIBUTE SailorGirlAttrib =
STATE s_SailorGirlStand[2] =
{
{SAILORGIRL_R0 + 0, SAILORGIRL_RATE, &AF(DoSailorGirl), &s_SailorGirlStand[1]},
{SAILORGIRL_R0 + 1, SAILORGIRL_RATE, &AF(DoSailorGirl), &s_SailorGirlStand[0]}
{SPR_SAILORGIRL, 'A', SAILORGIRL_RATE, &AF(DoSailorGirl), &s_SailorGirlStand[1]},
{SPR_SAILORGIRL, 'B', SAILORGIRL_RATE, &AF(DoSailorGirl), &s_SailorGirlStand[0]}
};
//////////////////////
@ -1726,12 +1717,11 @@ STATE s_SailorGirlStand[2] =
//////////////////////
#define SAILORGIRL_PAIN_RATE 32
#define SAILORGIRL_PAIN_R0 SAILORGIRL_R0
STATE s_SailorGirlPain[2] =
{
{SAILORGIRL_PAIN_R0 + 0, SAILORGIRL_PAIN_RATE, &AF(SailorGirlPain), &s_SailorGirlPain[1]},
{SAILORGIRL_PAIN_R0 + 0, 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_SailorGirlPain[0]}
{SPR_SAILORGIRL, 'A', SAILORGIRL_PAIN_RATE, &AF(SailorGirlPain), &s_SailorGirlPain[1]},
{SPR_SAILORGIRL, 'A', 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_SailorGirlPain[0]}
};
//////////////////////
@ -1741,11 +1731,10 @@ STATE s_SailorGirlPain[2] =
//////////////////////
#define SAILORGIRL_UZI_RATE 128
#define SAILORGIRL_FIRE_R0 SAILORGIRL_R0 + 2
STATE s_SailorGirlThrow[] =
{
{SAILORGIRL_FIRE_R0 + 0, SAILORGIRL_UZI_RATE, &AF(SailorGirlThrow), &s_SailorGirlThrow[0]},
{SPR_SAILORGIRL_FIRE, 'A', SAILORGIRL_UZI_RATE, &AF(SailorGirlThrow), &s_SailorGirlThrow[0]},
};
short alreadythrew;
@ -1771,7 +1760,7 @@ int SetupSailorGirl(DSWActor* actor)
actor->user.__legacyState.Attrib = &SailorGirlAttrib;
actor->user.__legacyState.StateEnd = s_SailorGirlStand;
actor->user.__legacyState.Rot = 0;
actor->user.__legacyState.RotNum = 0;
actor->spr.scale = DVector2(0.4375, 0.40625);
actor->vel.X = 0;
@ -1961,8 +1950,8 @@ ATTRIBUTE PruneGirlAttrib =
STATE s_PruneGirlStand[2] =
{
{PRUNEGIRL_R0 + 0, PRUNEGIRL_RATE, &AF(DoPruneGirl), &s_PruneGirlStand[1]},
{PRUNEGIRL_R0 + 1, PRUNEGIRL_RATE, &AF(DoPruneGirl), &s_PruneGirlStand[0]}
{SPR_PRUNEGIRL, 'A', PRUNEGIRL_RATE, &AF(DoPruneGirl), &s_PruneGirlStand[1]},
{SPR_PRUNEGIRL, 'B', PRUNEGIRL_RATE, &AF(DoPruneGirl), &s_PruneGirlStand[0]}
};
//////////////////////
@ -1972,12 +1961,11 @@ STATE s_PruneGirlStand[2] =
//////////////////////
#define PRUNEGIRL_PAIN_RATE 32
#define PRUNEGIRL_PAIN_R0 PRUNEGIRL_R0
STATE s_PruneGirlPain[2] =
{
{PRUNEGIRL_PAIN_R0 + 0, PRUNEGIRL_PAIN_RATE, &AF(PruneGirlPain), &s_PruneGirlPain[1]},
{PRUNEGIRL_PAIN_R0 + 0, 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_PruneGirlPain[0]}
{SPR_PRUNEGIRL, 'A', PRUNEGIRL_PAIN_RATE, &AF(PruneGirlPain), &s_PruneGirlPain[1]},
{SPR_PRUNEGIRL, 'A', 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_PruneGirlPain[0]}
};
//---------------------------------------------------------------------------
@ -2001,7 +1989,7 @@ int SetupPruneGirl(DSWActor* actor)
actor->user.__legacyState.Attrib = &PruneGirlAttrib;
actor->user.__legacyState.StateEnd = s_PruneGirlStand;
actor->user.__legacyState.Rot = 0;
actor->user.__legacyState.RotNum = 0;
actor->spr.scale = DVector2(0.515625, 0.4375);
actor->vel.X = 0;

16
source/games/sw/src/namelist.h
View file

@ -731,7 +731,6 @@ x(TRAININGDOLL, 5063)
x(TRAININGDOLLBROKE, 4947)
x(CRYBABY, 5104)
x(NASTERLEEP, 470)
x(NINJA_DEAD, 4226)
x(NINJA_HARAKIRI_DEAD, 4218)
x(NINJA_DEAD1, 4226)
x(PLAYER_NINJA_DEAD, 1160)
@ -803,4 +802,17 @@ x(SWITCH_5_ON, 574)
x(SWITCH_6_ON, 584)
x(EXIT_SWITCH_ON, 2471)
x(SWITCH_SKULL_ON, 554)
x(PACHINKOWINLIGHT, 623)
x(PACHINKOWINLIGHT, 623)
x(COOLIE_DEAD_NOHEAD, 1440)
x(NINJA_DEAD_SLICED, 4236)
x(LAVA_DEAD, 2355)
x(GORO_DEAD, 1512)
x(HORNET_DEAD, 811)
x(RIPPER_DEAD, 1643)
x(RIPPER2_DEAD, 4421)
x(EEL_DEAD, 3795)
x(BUNNY_DEAD, 4584)
x(GIRLNINJA_DEAD, 5205)
x(COOLG_DEAD, 4312)
x(Player_HeadFly, 1134)

911
source/games/sw/src/names2.h
View file

@ -202,34 +202,61 @@ enum ETimers
//******************************************************************************
enum ECounters
{
BOLT_THINMAN_FRAMES = 1,
SPEAR_FRAMES = 1,
COOLIE_CHARGE_FRAMES = 4,
COOLIE_RUN_FRAMES = 4,
COOLIE_PAIN_FRAMES = 1,
COOLG_RUN_FRAMES = 4,
COOLG_CLUB_FRAMES = 2,
COOLG_FIRE_FRAMES = 3,
COOLG_PAIN_FRAMES = 1,
PLAYER_NINJA_SHOOT_FRAMES = 1,
PLAYER_NINJA_RUN_FRAMES = 4,
PLAYER_NINJA_STAND_FRAMES = 1,
PLAYER_NINJA_JUMP_FRAMES = 4,
PLAYER_NINJA_CLIMB_FRAMES = 4,
PLAYER_NINJA_CRAWL_FRAMES = 4,
PLAYER_NINJA_SWIM_FRAMES = 4,
PLAYER_NINJA_SWORD_FRAMES = 3,
PLAYER_NINJA_PUNCH_FRAMES = 2,
PLAYER_NINJA_KICK_FRAMES = 2,
};
enum EPicnums
{
// enemy/item spawn IDs are still needed
COOLIE_RUN_R0 = 1400,
COOLG_RUN_R0 = 4277,
BUNNY_RUN_R0 = 4550,
EEL_RUN_R0 = 3780,
GIRLNINJA_RUN_R0 = 5162,
GORO_RUN_R0 = 1469,
HORNET_RUN_R0 = 800,
LAVA_RUN_R0 = 2355,
NINJA_RUN_R0 = 4096,
NINJA_DEAD = 4227,
NINJA_CRAWL_R0 = 4162,
PLAYER_NINJA_RUN_R0 = 1094,
ZOMBIE_RUN_R0 = PLAYER_NINJA_RUN_R0 + 1,
NINJA_Head_R0 = 1142,
RIPPER_RUN_R0 = 1580,
RIPPER2_RUN_R0 = 4320,
SERP_RUN_R0 = 1300,
SKEL_RUN_R0 = 1367,
ZILLA_RUN_R0 = 5426,
SUMO_RUN_R0 = 1210,
TOILETGIRL_R0 = 5023,
WASHGIRL_R0 = 5032,
MECHANICGIRL_R0 = 4590,
CARGIRL_R0 = 4594,
SAILORGIRL_R0 = 4600,
PRUNEGIRL_R0 = 4604,
Red_COIN = 2440,
Yellow_COIN = 2450,
Green_COIN = 2460,
EXP = 3100, // Use new digitized explosion for big stuff
RADIATION_CLOUD = 3258,
MUSHROOM_CLOUD = 3280,
CHEMBOMB_R0 = 3038,
CALTROPSR = CALTROPS - 1,
TRASHCAN = 2540,
PACHINKO1 = 4768,
PACHINKO2 = 4792,
PACHINKO3 = 4816,
PACHINKO4 = 4840,
PACHINKOLIGHT_R0 = 618,
SKULL_R0 = 820,
SKULL_SERP = (SKULL_R0 + 2),
BETTY_R0 = 817,
PUFF = 1748,
SWITCH_OFF = 561,
TRACK_SPRITE = 1900, //start of track sprites
@ -250,6 +277,8 @@ enum EPicnums
//
//////////////////////
CROSSBOLT = 2230,
STAR = 2039,
ELECTRO = 2025,
@ -275,21 +304,19 @@ enum EPicnums
DART_R7 = 2137,
BOLT_THINMAN_R0 = 2018,
BOLT_THINMAN_R1 = BOLT_THINMAN_R0 - (BOLT_THINMAN_FRAMES * 1),
BOLT_THINMAN_R2 = BOLT_THINMAN_R0 - (BOLT_THINMAN_FRAMES * 2),
BOLT_THINMAN_R3 = BOLT_THINMAN_R0 - (BOLT_THINMAN_FRAMES * 3),
BOLT_THINMAN_R4 = BOLT_THINMAN_R0 - (BOLT_THINMAN_FRAMES * 4),
BOLT_THINMAN_R1 = 2019,
BOLT_THINMAN_R2 = 2020,
BOLT_THINMAN_R3 = 2021,
BOLT_THINMAN_R4 = 2022,
SPEAR_R0 = 2030,
SPEAR_R1 = SPEAR_R0 + (SPEAR_FRAMES * 1),
SPEAR_R2 = SPEAR_R0 + (SPEAR_FRAMES * 2),
SPEAR_R3 = SPEAR_R0 + (SPEAR_FRAMES * 3),
SPEAR_R4 = SPEAR_R0 + (SPEAR_FRAMES * 4),
EMP = 2058,
EXP = 3100, // Use new digitized explosion for big stuff
EXP2 = 2160, // My old explosion is still used for goro head
FIREBALL = 2035,
FIREBALL_FLAMES = 3212,
SPLASH = 772,
BUBBLE = 716,
//////////////////////
//
@ -310,406 +337,15 @@ enum EPicnums
FIRE_FLY_RATE = 50,
BREAK_LIGHT_ANIM = 447,
BREAK_BARREL = 453,
BREAK_PEDISTAL = 463,
BREAK_BOTTLE1 = 468,
BREAK_BOTTLE2 = 475,
//////////////////////
//
// COOLIE
//
//////////////////////
LAVA_BOULDER = 2196,
COOLIE_CHARGE_R0 = 1420,
COOLIE_CHARGE_R1 = COOLIE_CHARGE_R0 + (COOLIE_CHARGE_FRAMES * 1),
COOLIE_CHARGE_R2 = COOLIE_CHARGE_R0 + (COOLIE_CHARGE_FRAMES * 2),
COOLIE_CHARGE_R3 = COOLIE_CHARGE_R0 + (COOLIE_CHARGE_FRAMES * 3),
COOLIE_CHARGE_R4 = COOLIE_CHARGE_R0 + (COOLIE_CHARGE_FRAMES * 4),
};
COOLIE_RUN_R0 = 1400,
COOLIE_RUN_R1 = COOLIE_RUN_R0 + (COOLIE_RUN_FRAMES * 1),
COOLIE_RUN_R2 = COOLIE_RUN_R0 + (COOLIE_RUN_FRAMES * 2),
COOLIE_RUN_R3 = COOLIE_RUN_R0 + (COOLIE_RUN_FRAMES * 3),
COOLIE_RUN_R4 = COOLIE_RUN_R0 + (COOLIE_RUN_FRAMES * 4),
COOLIE_PAIN_R0 = 1420,
COOLIE_PAIN_R1 = COOLIE_PAIN_R0, //+ (COOLIE_PAIN_FRAMES * 1)
COOLIE_PAIN_R2 = COOLIE_PAIN_R0, //+ (COOLIE_PAIN_FRAMES * 2)
COOLIE_PAIN_R3 = COOLIE_PAIN_R0, //+ (COOLIE_PAIN_FRAMES * 3)
COOLIE_PAIN_R4 = COOLIE_PAIN_R0, //+ (COOLIE_PAIN_FRAMES * 4)
COOLG_RUN_R0 = 4277,
COOLG_RUN_R1 = COOLG_RUN_R0 + (COOLG_RUN_FRAMES * 1),
COOLG_RUN_R2 = COOLG_RUN_R0 + (COOLG_RUN_FRAMES * 2),
COOLG_RUN_R3 = COOLG_RUN_R0 + (COOLG_RUN_FRAMES * 3),
COOLG_RUN_R4 = COOLG_RUN_R0 + (COOLG_RUN_FRAMES * 4),
COOLG_CLUB_R0 = 1451,
COOLG_CLUB_R1 = COOLG_CLUB_R0 + (COOLG_CLUB_FRAMES * 1),
COOLG_CLUB_R2 = COOLG_CLUB_R0 + (COOLG_CLUB_FRAMES * 2),
COOLG_CLUB_R3 = COOLG_CLUB_R0 + (COOLG_CLUB_FRAMES * 3),
COOLG_CLUB_R4 = COOLG_CLUB_R0 + (COOLG_CLUB_FRAMES * 4),
COOLG_FIRE_R0 = 4297,
COOLG_FIRE_R1 = COOLG_FIRE_R0 + (COOLG_FIRE_FRAMES * 1),
COOLG_FIRE_R2 = COOLG_FIRE_R0 + (COOLG_FIRE_FRAMES * 2),
COOLG_PAIN_R0 = 4306,
COOLG_PAIN_R1 = COOLG_PAIN_R0, //+ (COOLIE_PAIN_FRAMES * 1)
COOLG_PAIN_R2 = COOLG_PAIN_R0, //+ (COOLIE_PAIN_FRAMES * 2)
COOLG_PAIN_R3 = COOLG_PAIN_R0, //+ (COOLIE_PAIN_FRAMES * 3)
COOLG_PAIN_R4 = COOLG_PAIN_R0, //+ (COOLIE_PAIN_FRAMES * 4)
COOLIE_DEAD_NOHEAD = 1440,
COOLIE_DEAD_HEAD = 4267,
COOLIE_DIE = 4260,
COOLIE_DEAD = 4268,
//////////////////////
//
// PLAYER NINJA
//
//////////////////////
PLAYER_NINJA_SHOOT_R0 = 1069,
PLAYER_NINJA_SHOOT_R1 = PLAYER_NINJA_SHOOT_R0 + (PLAYER_NINJA_SHOOT_FRAMES * 2),
PLAYER_NINJA_SHOOT_R2 = PLAYER_NINJA_SHOOT_R0 + (PLAYER_NINJA_SHOOT_FRAMES * 3),
PLAYER_NINJA_SHOOT_R3 = PLAYER_NINJA_SHOOT_R0 + (PLAYER_NINJA_SHOOT_FRAMES * 4),
PLAYER_NINJA_SHOOT_R4 = PLAYER_NINJA_SHOOT_R0 + (PLAYER_NINJA_SHOOT_FRAMES * 1),
PLAYER_NINJA_RUN_R0 = 1094,
PLAYER_NINJA_RUN_R1 = PLAYER_NINJA_RUN_R0 + (PLAYER_NINJA_RUN_FRAMES * 1),
PLAYER_NINJA_RUN_R2 = PLAYER_NINJA_RUN_R0 + (PLAYER_NINJA_RUN_FRAMES * 2),
PLAYER_NINJA_RUN_R3 = PLAYER_NINJA_RUN_R0 + (PLAYER_NINJA_RUN_FRAMES * 3),
PLAYER_NINJA_RUN_R4 = PLAYER_NINJA_RUN_R0 + (PLAYER_NINJA_RUN_FRAMES * 4),
ZOMBIE_RUN_R0 = PLAYER_NINJA_RUN_R0+1,
PLAYER_NINJA_STAND_R0 = PLAYER_NINJA_RUN_R0,
PLAYER_NINJA_STAND_R1 = PLAYER_NINJA_RUN_R1,
PLAYER_NINJA_STAND_R2 = PLAYER_NINJA_RUN_R2,
PLAYER_NINJA_STAND_R3 = PLAYER_NINJA_RUN_R3,
PLAYER_NINJA_STAND_R4 = PLAYER_NINJA_RUN_R4,
PLAYER_NINJA_JUMP_R0 = 1074,
PLAYER_NINJA_JUMP_R1 = PLAYER_NINJA_JUMP_R0 + (PLAYER_NINJA_JUMP_FRAMES * 1),
PLAYER_NINJA_JUMP_R2 = PLAYER_NINJA_JUMP_R0 + (PLAYER_NINJA_JUMP_FRAMES * 2),
PLAYER_NINJA_JUMP_R3 = PLAYER_NINJA_JUMP_R0 + (PLAYER_NINJA_JUMP_FRAMES * 3),
PLAYER_NINJA_JUMP_R4 = PLAYER_NINJA_JUMP_R0 + (PLAYER_NINJA_JUMP_FRAMES * 4),
PLAYER_NINJA_FALL_R0 = PLAYER_NINJA_JUMP_R0+2,
PLAYER_NINJA_FALL_R1 = PLAYER_NINJA_JUMP_R1+2,
PLAYER_NINJA_FALL_R2 = PLAYER_NINJA_JUMP_R2+2,
PLAYER_NINJA_FALL_R3 = PLAYER_NINJA_JUMP_R3+2,
PLAYER_NINJA_FALL_R4 = PLAYER_NINJA_JUMP_R4+2,
PLAYER_NINJA_CLIMB_R0 = 1024,
PLAYER_NINJA_CLIMB_R1 = PLAYER_NINJA_CLIMB_R0 + (PLAYER_NINJA_CLIMB_FRAMES * 1),
PLAYER_NINJA_CLIMB_R2 = PLAYER_NINJA_CLIMB_R0 + (PLAYER_NINJA_CLIMB_FRAMES * 2),
PLAYER_NINJA_CLIMB_R3 = PLAYER_NINJA_CLIMB_R0 + (PLAYER_NINJA_CLIMB_FRAMES * 3),
PLAYER_NINJA_CLIMB_R4 = PLAYER_NINJA_CLIMB_R0 + (PLAYER_NINJA_CLIMB_FRAMES * 4),
PLAYER_NINJA_CRAWL_R0 = 1044,
PLAYER_NINJA_CRAWL_R1 = PLAYER_NINJA_CRAWL_R0 + (PLAYER_NINJA_CRAWL_FRAMES * 1),
PLAYER_NINJA_CRAWL_R2 = PLAYER_NINJA_CRAWL_R0 + (PLAYER_NINJA_CRAWL_FRAMES * 2),
PLAYER_NINJA_CRAWL_R3 = PLAYER_NINJA_CRAWL_R0 + (PLAYER_NINJA_CRAWL_FRAMES * 3),
PLAYER_NINJA_CRAWL_R4 = PLAYER_NINJA_CRAWL_R0 + (PLAYER_NINJA_CRAWL_FRAMES * 4),
PLAYER_NINJA_SWIM_R0 = 1114,
PLAYER_NINJA_SWIM_R1 = PLAYER_NINJA_SWIM_R0 + (PLAYER_NINJA_SWIM_FRAMES * 1),
PLAYER_NINJA_SWIM_R2 = PLAYER_NINJA_SWIM_R0 + (PLAYER_NINJA_SWIM_FRAMES * 2),
PLAYER_NINJA_SWIM_R3 = PLAYER_NINJA_SWIM_R0 + (PLAYER_NINJA_SWIM_FRAMES * 3),
PLAYER_NINJA_SWIM_R4 = PLAYER_NINJA_SWIM_R0 + (PLAYER_NINJA_SWIM_FRAMES * 4),
PLAYER_NINJA_SWORD_R0 = 1161,
PLAYER_NINJA_SWORD_R1 = PLAYER_NINJA_SWORD_R0 + (PLAYER_NINJA_SWORD_FRAMES * 1),
PLAYER_NINJA_SWORD_R2 = PLAYER_NINJA_SWORD_R0 + (PLAYER_NINJA_SWORD_FRAMES * 2),
PLAYER_NINJA_SWORD_R3 = PLAYER_NINJA_SWORD_R0 + (PLAYER_NINJA_SWORD_FRAMES * 3),
PLAYER_NINJA_SWORD_R4 = PLAYER_NINJA_SWORD_R0 + (PLAYER_NINJA_SWORD_FRAMES * 4),
PLAYER_NINJA_PUNCH_R0 = 1176,
PLAYER_NINJA_PUNCH_R1 = PLAYER_NINJA_PUNCH_R0 + (PLAYER_NINJA_PUNCH_FRAMES * 1),
PLAYER_NINJA_PUNCH_R2 = PLAYER_NINJA_PUNCH_R0 + (PLAYER_NINJA_PUNCH_FRAMES * 2),
PLAYER_NINJA_PUNCH_R3 = PLAYER_NINJA_PUNCH_R0 + (PLAYER_NINJA_PUNCH_FRAMES * 3),
PLAYER_NINJA_PUNCH_R4 = PLAYER_NINJA_PUNCH_R0 + (PLAYER_NINJA_PUNCH_FRAMES * 4),
PLAYER_NINJA_KICK_R0 = 1186,
PLAYER_NINJA_KICK_R1 = PLAYER_NINJA_KICK_R0 + (PLAYER_NINJA_KICK_FRAMES * 1),
PLAYER_NINJA_KICK_R2 = PLAYER_NINJA_KICK_R0 + (PLAYER_NINJA_KICK_FRAMES * 2),
PLAYER_NINJA_KICK_R3 = PLAYER_NINJA_KICK_R0 + (PLAYER_NINJA_KICK_FRAMES * 3),
PLAYER_NINJA_KICK_R4 = PLAYER_NINJA_KICK_R0 + (PLAYER_NINJA_KICK_FRAMES * 4),
PLAYER_NINJA_DIE = 1152,
PLAYER_NINJA_FLY = 1069,
};
//////////////////////
//
// EVIL NINJA
//
//////////////////////
#define NINJA_RUN_FRAMES 4
#define NINJA_RUN_R0 4096
#define NINJA_RUN_R1 NINJA_RUN_R0 + (NINJA_RUN_FRAMES * 1)
#define NINJA_RUN_R2 NINJA_RUN_R0 + (NINJA_RUN_FRAMES * 2)
#define NINJA_RUN_R3 NINJA_RUN_R0 + (NINJA_RUN_FRAMES * 3)
#define NINJA_RUN_R4 NINJA_RUN_R0 + (NINJA_RUN_FRAMES * 4)
#define NINJA_STAND_FRAMES 1
#define NINJA_STAND_R0 NINJA_RUN_R0
#define NINJA_STAND_R1 NINJA_RUN_R1
#define NINJA_STAND_R2 NINJA_RUN_R2
#define NINJA_STAND_R3 NINJA_RUN_R3
#define NINJA_STAND_R4 NINJA_RUN_R4
#define NINJA_CRAWL_FRAMES 4
#define NINJA_CRAWL_R0 4162
#define NINJA_CRAWL_R1 NINJA_CRAWL_R0 + (NINJA_CRAWL_FRAMES * 1)
#define NINJA_CRAWL_R2 NINJA_CRAWL_R0 + (NINJA_CRAWL_FRAMES * 2)
#define NINJA_CRAWL_R3 NINJA_CRAWL_R0 + (NINJA_CRAWL_FRAMES * 3)
#define NINJA_CRAWL_R4 NINJA_CRAWL_R0 + (NINJA_CRAWL_FRAMES * 4)
#define NINJA_SWIM_FRAMES 4
#define NINJA_SWIM_R0 4122
#define NINJA_SWIM_R1 NINJA_SWIM_R0 + (NINJA_SWIM_FRAMES * 1)
#define NINJA_SWIM_R2 NINJA_SWIM_R0 + (NINJA_SWIM_FRAMES * 2)
#define NINJA_SWIM_R3 NINJA_SWIM_R0 + (NINJA_SWIM_FRAMES * 3)
#define NINJA_SWIM_R4 NINJA_SWIM_R0 + (NINJA_SWIM_FRAMES * 4)
#define NINJA_HARI_KARI_FRAMES 8
#define NINJA_HARI_KARI_R0 4211
#define NINJA_HARI_KARI_R1 NINJA_HARI_KARI_R0
#define NINJA_HARI_KARI_R2 NINJA_HARI_KARI_R0
#define NINJA_HARI_KARI_R3 NINJA_HARI_KARI_R0
#define NINJA_HARI_KARI_R4 NINJA_HARI_KARI_R0
#define NINJA_CLIMB_FRAMES 4
#define NINJA_CLIMB_R0 4182
#define NINJA_CLIMB_R1 NINJA_CLIMB_R0 + (NINJA_CLIMB_FRAMES * 1)
#define NINJA_CLIMB_R2 NINJA_CLIMB_R0 + (NINJA_CLIMB_FRAMES * 2)
#define NINJA_CLIMB_R3 NINJA_CLIMB_R0 + (NINJA_CLIMB_FRAMES * 3)
#define NINJA_CLIMB_R4 NINJA_CLIMB_R0 + (NINJA_CLIMB_FRAMES * 4)
#define NINJA_THROW_FRAMES 3
#define NINJA_THROW_R0 4202
#define NINJA_THROW_R1 NINJA_THROW_R0 + (NINJA_THROW_FRAMES * 1)
#define NINJA_THROW_R2 NINJA_THROW_R0 + (NINJA_THROW_FRAMES * 2)
// don't have rotations for pain frames currently
#if 1
#define NINJA_PAIN_FRAMES 2
#define NINJA_PAIN_R0 4219 //4164
#define NINJA_PAIN_R1 NINJA_PAIN_R0
#define NINJA_PAIN_R2 NINJA_PAIN_R0
#define NINJA_PAIN_R3 NINJA_PAIN_R0
#define NINJA_PAIN_R4 NINJA_PAIN_R0
#endif
#define NINJA_JUMP_FRAMES 4
#define NINJA_JUMP_R0 4142
#define NINJA_JUMP_R1 NINJA_JUMP_R0 + (NINJA_JUMP_FRAMES * 1)
#define NINJA_JUMP_R2 NINJA_JUMP_R0 + (NINJA_JUMP_FRAMES * 2)
#define NINJA_JUMP_R3 NINJA_JUMP_R0 + (NINJA_JUMP_FRAMES * 3)
#define NINJA_JUMP_R4 NINJA_JUMP_R0 + (NINJA_JUMP_FRAMES * 4)
#define NINJA_FALL_R0 NINJA_JUMP_R0+2
#define NINJA_FALL_R1 NINJA_JUMP_R1+2
#define NINJA_FALL_R2 NINJA_JUMP_R2+2
#define NINJA_FALL_R3 NINJA_JUMP_R3+2
#define NINJA_FALL_R4 NINJA_JUMP_R4+2
#define NINJA_LAND_R0 NINJA_JUMP_R0+3
#define NINJA_LAND_R1 NINJA_JUMP_R1+3
#define NINJA_LAND_R2 NINJA_JUMP_R2+3
#define NINJA_LAND_R3 NINJA_JUMP_R3+3
#define NINJA_LAND_R4 NINJA_JUMP_R4+3
#define NINJA_KNEEL_R0 NINJA_CRAWL_R0
#define NINJA_KNEEL_R1 NINJA_CRAWL_R1
#define NINJA_KNEEL_R2 NINJA_CRAWL_R2
#define NINJA_KNEEL_R3 NINJA_CRAWL_R3
#define NINJA_KNEEL_R4 NINJA_CRAWL_R4
#define NINJA_FLY_FRAMES 2
#define NINJA_FLY_R0 4116
#define NINJA_FLY_R1 NINJA_FLY_R0 + (NINJA_FLY_FRAMES * 1)
#define NINJA_FLY_R2 NINJA_FLY_R0 + (NINJA_FLY_FRAMES * 2)
#define NINJA_FLY_R3 NINJA_FLY_R0 + (NINJA_FLY_FRAMES * 3)
#define NINJA_FLY_R4 NINJA_FLY_R0 + (NINJA_FLY_FRAMES * 4)
#define NINJA_FIRE_FRAMES 2
#define NINJA_FIRE_R0 4116
#define NINJA_FIRE_R1 NINJA_FIRE_R0 + (NINJA_FIRE_FRAMES * 1)
#define NINJA_FIRE_R2 NINJA_FIRE_R0 + (NINJA_FIRE_FRAMES * 2)
#define NINJA_FIRE_R3 NINJA_FIRE_R0 + (NINJA_FIRE_FRAMES * 3)
#define NINJA_FIRE_R4 NINJA_FIRE_R0 + (NINJA_FIRE_FRAMES * 4)
#define NINJA_DIE 4219
#define NINJA_DEAD NINJA_DIE+8
#define NINJA_SLICED 4227
#define NINJA_DEAD_SLICED NINJA_SLICED+9
#define NINJA_SLICED_HACK 4211
#define NINJA_Head_FRAMES 1
#define NINJA_Head_R0 1142
#define NINJA_Head_R1 NINJA_Head_R0 + (NINJA_Head_FRAMES * 1)
#define NINJA_Head_R2 NINJA_Head_R0 + (NINJA_Head_FRAMES * 2)
#define NINJA_Head_R3 NINJA_Head_R0 + (NINJA_Head_FRAMES * 3)
#define NINJA_Head_R4 NINJA_Head_R0 + (NINJA_Head_FRAMES * 4)
#define NINJA_HeadHurl_FRAMES 1
#define NINJA_HeadHurl_R0 1147
#define NINJA_HeadHurl_R1 NINJA_HeadHurl_R0 + (NINJA_HeadHurl_FRAMES * 1)
#define NINJA_HeadHurl_R2 NINJA_HeadHurl_R0 + (NINJA_HeadHurl_FRAMES * 2)
#define NINJA_HeadHurl_R3 NINJA_HeadHurl_R0 + (NINJA_HeadHurl_FRAMES * 3)
#define NINJA_HeadHurl_R4 NINJA_HeadHurl_R0 + (NINJA_HeadHurl_FRAMES * 4)
//////////////////////
//
// SERP BOSS
//
//////////////////////
#define SERP_RUN_FRAMES 3
#define SERP_RUN_R0 1300
#define SERP_RUN_R1 SERP_RUN_R0 + (SERP_RUN_FRAMES * 1)
#define SERP_RUN_R2 SERP_RUN_R0 + (SERP_RUN_FRAMES * 2)
#define SERP_RUN_R3 SERP_RUN_R0 + (SERP_RUN_FRAMES * 3)
#define SERP_RUN_R4 SERP_RUN_R0 + (SERP_RUN_FRAMES * 4)
#define SERP_SLASH_FRAMES 5
#define SERP_SLASH_R0 972
#define SERP_SLASH_R1 SERP_SLASH_R0 + (SERP_SLASH_FRAMES * 1)
#define SERP_SLASH_R2 SERP_SLASH_R0 + (SERP_SLASH_FRAMES * 2)
#define SERP_SLASH_R3 SERP_SLASH_R0 + (SERP_SLASH_FRAMES * 3)
#define SERP_SLASH_R4 SERP_SLASH_R0 + (SERP_SLASH_FRAMES * 4)
#define SERP_SPELL_FRAMES 4
#define SERP_SPELL_R0 997
#define SERP_SPELL_R1 SERP_SPELL_R0 + (SERP_SPELL_FRAMES * 1)
#define SERP_SPELL_R2 SERP_SPELL_R0 + (SERP_SPELL_FRAMES * 2)
#define SERP_SPELL_R3 SERP_SPELL_R0 + (SERP_SPELL_FRAMES * 3)
#define SERP_SPELL_R4 SERP_SPELL_R0 + (SERP_SPELL_FRAMES * 4)
#define SERP_DIE 960
#define SERP_DEAD 969
//////////////////////
//
// LAVA BOSS
//
//////////////////////
#define LAVA_RUN_FRAMES 1
#define LAVA_RUN_R0 2355
#define LAVA_RUN_R1 LAVA_RUN_R0 //+ (LAVA_RUN_FRAMES * 1)
#define LAVA_RUN_R2 LAVA_RUN_R0 //+ (LAVA_RUN_FRAMES * 2)
#define LAVA_RUN_R3 LAVA_RUN_R0 //+ (LAVA_RUN_FRAMES * 3)
#define LAVA_RUN_R4 LAVA_RUN_R0 //+ (LAVA_RUN_FRAMES * 4)
#define LAVA_THROW_FRAMES 1
#define LAVA_THROW_R0 2355
#define LAVA_THROW_R1 LAVA_THROW_R0 //+ (LAVA_THROW_FRAMES * 1)
#define LAVA_THROW_R2 LAVA_THROW_R0 //+ (LAVA_THROW_FRAMES * 2)
#define LAVA_THROW_R3 LAVA_THROW_R0 //+ (LAVA_THROW_FRAMES * 3)
#define LAVA_THROW_R4 LAVA_THROW_R0 //+ (LAVA_THROW_FRAMES * 4)
#define LAVA_FLAME_FRAMES 1
#define LAVA_FLAME_R0 2355
#define LAVA_FLAME_R1 LAVA_FLAME_R0 //+ (LAVA_FLAME_FRAMES * 1)
#define LAVA_FLAME_R2 LAVA_FLAME_R0 //+ (LAVA_FLAME_FRAMES * 2)
#define LAVA_FLAME_R3 LAVA_FLAME_R0 //+ (LAVA_FLAME_FRAMES * 3)
#define LAVA_FLAME_R4 LAVA_FLAME_R0 //+ (LAVA_FLAME_FRAMES * 4)
#define LAVA_DIE 2355
#define LAVA_DEAD 2355
// 10 frames
#define LAVA_BOULDER 2196
//////////////////////
//
// SKEL
//
//////////////////////
#define SKEL_RUN_FRAMES 6
#define SKEL_RUN_R0 1367
#define SKEL_RUN_R1 SKEL_RUN_R0 + (SKEL_RUN_FRAMES * 1)
#define SKEL_RUN_R2 SKEL_RUN_R0 + (SKEL_RUN_FRAMES * 2)
#define SKEL_RUN_R3 SKEL_RUN_R0 + (SKEL_RUN_FRAMES * 3)
#define SKEL_RUN_R4 SKEL_RUN_R0 + (SKEL_RUN_FRAMES * 4)
#define SKEL_SLASH_FRAMES 3
#define SKEL_SLASH_R0 1326
#define SKEL_SLASH_R1 SKEL_SLASH_R0 + (SKEL_SLASH_FRAMES * 1)
#define SKEL_SLASH_R2 SKEL_SLASH_R0 + (SKEL_SLASH_FRAMES * 2)
#define SKEL_SLASH_R3 SKEL_SLASH_R0 + (SKEL_SLASH_FRAMES * 3)
#define SKEL_SLASH_R4 SKEL_SLASH_R0 + (SKEL_SLASH_FRAMES * 4)
#define SKEL_SPELL_FRAMES 4
#define SKEL_SPELL_R0 1341
#define SKEL_SPELL_R1 SKEL_SPELL_R0 + (SKEL_SPELL_FRAMES * 1)
#define SKEL_SPELL_R2 SKEL_SPELL_R0 + (SKEL_SPELL_FRAMES * 2)
#define SKEL_SPELL_R3 SKEL_SPELL_R0 + (SKEL_SPELL_FRAMES * 3)
#define SKEL_SPELL_R4 SKEL_SPELL_R0 + (SKEL_SPELL_FRAMES * 4)
#define SKEL_PAIN_FRAMES 1
#define SKEL_PAIN_R0 SKEL_SLASH_R0+1
#define SKEL_PAIN_R1 SKEL_SLASH_R1+1
#define SKEL_PAIN_R2 SKEL_SLASH_R2+1
#define SKEL_PAIN_R3 SKEL_SLASH_R3+1
#define SKEL_PAIN_R4 SKEL_SLASH_R4+1
#define SKEL_TELEPORT 1361
#define SKEL_DIE 1320
//////////////////////
//
// GORO
//
//////////////////////
#define GORO_RUN_FRAMES 4
#define GORO_RUN_R0 1469
#define GORO_RUN_R1 GORO_RUN_R0 + (GORO_RUN_FRAMES * 1)
#define GORO_RUN_R2 GORO_RUN_R0 + (GORO_RUN_FRAMES * 2)
#define GORO_RUN_R3 GORO_RUN_R0 + (GORO_RUN_FRAMES * 3)
#define GORO_RUN_R4 GORO_RUN_R0 + (GORO_RUN_FRAMES * 4)
#define GORO_CHOP_FRAMES 3
#define GORO_CHOP_R0 1489
#define GORO_CHOP_R1 GORO_CHOP_R0 + (GORO_CHOP_FRAMES * 1)
#define GORO_CHOP_R2 GORO_CHOP_R0 + (GORO_CHOP_FRAMES * 2)
#define GORO_CHOP_R3 GORO_RUN_R3
#define GORO_CHOP_R4 GORO_RUN_R4
#define GORO_STAND_R0 GORO_CHOP_R0
#define GORO_STAND_R1 GORO_CHOP_R1
#define GORO_STAND_R2 GORO_CHOP_R2
#define GORO_STAND_R3 GORO_CHOP_R3
#define GORO_STAND_R4 GORO_CHOP_R4
#define GORO_SPELL_FRAMES 2
#define GORO_SPELL_R0 1513
#define GORO_SPELL_R1 GORO_SPELL_R0 + (GORO_SPELL_FRAMES * 1)
#define GORO_SPELL_R2 GORO_SPELL_R0 + (GORO_SPELL_FRAMES * 2)
#define GORO_SPELL_R3 GORO_RUN_R3
#define GORO_SPELL_R4 GORO_RUN_R4
#define GORO_DIE 1504
#define GORO_DEAD 1504+8
//////////////////////
//
@ -724,427 +360,8 @@ enum EPicnums
#define FIREBALL_R3 FIREBALL_R0 + (FIREBALL_FRAMES * 3)
#define FIREBALL_R4 FIREBALL_R0 + (FIREBALL_FRAMES * 4)
//////////////////////
//
// HORNET
//
//////////////////////
#define HORNET_RUN_FRAMES 2
#define HORNET_RUN_R0 800
#define HORNET_RUN_R1 HORNET_RUN_R0 + (HORNET_RUN_FRAMES * 1)
#define HORNET_RUN_R2 HORNET_RUN_R0 + (HORNET_RUN_FRAMES * 2)
#define HORNET_RUN_R3 HORNET_RUN_R0 + (HORNET_RUN_FRAMES * 3)
#define HORNET_RUN_R4 HORNET_RUN_R0 + (HORNET_RUN_FRAMES * 4)
#define HORNET_DIE 810
#define HORNET_DEAD 811
//////////////////////
//
// SKULL
//
//////////////////////
#define SKULL_FRAMES 1
#define SKULL_R0 820
#define SKULL_R1 SKULL_R0 + (SKULL_FRAMES * 1)
#define SKULL_R2 SKULL_R0 + (SKULL_FRAMES * 2)
#define SKULL_R3 SKULL_R0 + (SKULL_FRAMES * 3)
#define SKULL_R4 SKULL_R0 + (SKULL_FRAMES * 4)
#define SKULL_DIE 825
#define SKULL_EXPLODE 825
#define SKULL_SERP (SKULL_R0 + 2)
// MECHANICAL BETTY VERSION
#define BETTY_FRAMES 3
#define BETTY_R0 817
#define BETTY_R1 BETTY_R0
#define BETTY_R2 BETTY_R0
#define BETTY_R3 BETTY_R0
#define BETTY_R4 BETTY_R0
//////////////////////
//
// RIPPER
//
//////////////////////
#define RIPPER_RUN_FRAMES 4
#define RIPPER_RUN_R0 1580
#define RIPPER_RUN_R1 RIPPER_RUN_R0 + (RIPPER_RUN_FRAMES * 1)
#define RIPPER_RUN_R2 RIPPER_RUN_R0 + (RIPPER_RUN_FRAMES * 2)
#define RIPPER_RUN_R3 RIPPER_RUN_R0 + (RIPPER_RUN_FRAMES * 3)
#define RIPPER_RUN_R4 RIPPER_RUN_R0 + (RIPPER_RUN_FRAMES * 4)
#define RIPPER_JUMP_FRAMES 2
#define RIPPER_JUMP_R0 1620
#define RIPPER_JUMP_R1 RIPPER_JUMP_R0 + (RIPPER_JUMP_FRAMES * 1)
#define RIPPER_JUMP_R2 RIPPER_JUMP_R0 + (RIPPER_JUMP_FRAMES * 2)
#define RIPPER_JUMP_R3 RIPPER_JUMP_R0 + (RIPPER_JUMP_FRAMES * 3)
#define RIPPER_JUMP_R4 RIPPER_JUMP_R0 + (RIPPER_JUMP_FRAMES * 4)
#define RIPPER_FALL_R0 RIPPER_JUMP_R0+1
#define RIPPER_FALL_R1 RIPPER_JUMP_R1+1
#define RIPPER_FALL_R2 RIPPER_JUMP_R2+1
#define RIPPER_FALL_R3 RIPPER_JUMP_R3+1
#define RIPPER_FALL_R4 RIPPER_JUMP_R4+1
#define RIPPER_STAND_R0 RIPPER_JUMP_R0
#define RIPPER_STAND_R1 RIPPER_JUMP_R1
#define RIPPER_STAND_R2 RIPPER_JUMP_R2
#define RIPPER_STAND_R3 RIPPER_JUMP_R3
#define RIPPER_STAND_R4 RIPPER_JUMP_R4
#define RIPPER_HANG_FRAMES 1
#define RIPPER_HANG_R0 1645
#define RIPPER_HANG_R1 1645
#define RIPPER_HANG_R2 1639
#define RIPPER_HANG_R3 1637
#define RIPPER_HANG_R4 1635
#define RIPPER_SWIPE_FRAMES 4
#define RIPPER_SWIPE_R0 1600
#define RIPPER_SWIPE_R1 RIPPER_SWIPE_R0 + (RIPPER_SWIPE_FRAMES * 1)
#define RIPPER_SWIPE_R2 RIPPER_SWIPE_R0 + (RIPPER_SWIPE_FRAMES * 2)
#define RIPPER_SWIPE_R3 RIPPER_SWIPE_R0 + (RIPPER_SWIPE_FRAMES * 3)
#define RIPPER_SWIPE_R4 RIPPER_SWIPE_R0 + (RIPPER_SWIPE_FRAMES * 4)
#define RIPPER_HEART_FRAMES 1
#define RIPPER_HEART_R0 1635
#define RIPPER_HEART_R1 RIPPER_HEART_R0
#define RIPPER_HEART_R2 RIPPER_HEART_R0
#define RIPPER_HEART_R3 RIPPER_HEART_R0
#define RIPPER_HEART_R4 RIPPER_HEART_R0
#define RIPPER_DIE 1640
#define RIPPER_DEAD 1643
// The new Ripper
#define RIPPER2_RUN_FRAMES 4
#define RIPPER2_RUN_R0 4320
#define RIPPER2_RUN_R1 RIPPER2_RUN_R0 + (RIPPER2_RUN_FRAMES * 1)
#define RIPPER2_RUN_R2 RIPPER2_RUN_R0 + (RIPPER2_RUN_FRAMES * 2)
#define RIPPER2_RUN_R3 RIPPER2_RUN_R0 + (RIPPER2_RUN_FRAMES * 3)
#define RIPPER2_RUN_R4 RIPPER2_RUN_R0 + (RIPPER2_RUN_FRAMES * 4)
#define RIPPER2_RUNFAST_FRAMES 4
#define RIPPER2_RUNFAST_R0 4340
#define RIPPER2_RUNFAST_R1 RIPPER2_RUNFAST_R0 + (RIPPER2_RUNFAST_FRAMES * 1)
#define RIPPER2_RUNFAST_R2 RIPPER2_RUNFAST_R0 + (RIPPER2_RUNFAST_FRAMES * 2)
#define RIPPER2_RUNFAST_R3 RIPPER2_RUNFAST_R0 + (RIPPER2_RUNFAST_FRAMES * 3)
#define RIPPER2_RUNFAST_R4 RIPPER2_RUNFAST_R0 + (RIPPER2_RUNFAST_FRAMES * 4)
#define RIPPER2_JUMP_FRAMES 4
#define RIPPER2_JUMP_R0 4374
#define RIPPER2_JUMP_R1 RIPPER2_JUMP_R0 + (RIPPER2_JUMP_FRAMES * 1)
#define RIPPER2_JUMP_R2 RIPPER2_JUMP_R0 + (RIPPER2_JUMP_FRAMES * 2)
#define RIPPER2_JUMP_R3 RIPPER2_JUMP_R0 + (RIPPER2_JUMP_FRAMES * 3)
#define RIPPER2_JUMP_R4 RIPPER2_JUMP_R0 + (RIPPER2_JUMP_FRAMES * 4)
#define RIPPER2_FALL_R0 RIPPER2_JUMP_R0+2
#define RIPPER2_FALL_R1 RIPPER2_JUMP_R1+2
#define RIPPER2_FALL_R2 RIPPER2_JUMP_R2+2
#define RIPPER2_FALL_R3 RIPPER2_JUMP_R3+2
#define RIPPER2_FALL_R4 RIPPER2_JUMP_R4+2
#define RIPPER2_STAND_R0 RIPPER2_JUMP_R0+3
#define RIPPER2_STAND_R1 RIPPER2_JUMP_R1+3
#define RIPPER2_STAND_R2 RIPPER2_JUMP_R2+3
#define RIPPER2_STAND_R3 RIPPER2_JUMP_R3+3
#define RIPPER2_STAND_R4 RIPPER2_JUMP_R4+3
#define RIPPER2_HANG_FRAMES 1
#define RIPPER2_HANG_R0 4369
#define RIPPER2_HANG_R1 RIPPER2_HANG_R0 + (RIPPER2_HANG_FRAMES * 1)
#define RIPPER2_HANG_R2 RIPPER2_HANG_R0 + (RIPPER2_HANG_FRAMES * 2)
#define RIPPER2_HANG_R3 RIPPER2_HANG_R0 + (RIPPER2_HANG_FRAMES * 3)
#define RIPPER2_HANG_R4 RIPPER2_HANG_R0 + (RIPPER2_HANG_FRAMES * 4)
#define RIPPER2_SWIPE_FRAMES 4
#define RIPPER2_SWIPE_R0 4394
#define RIPPER2_SWIPE_R1 RIPPER2_SWIPE_R0 + (RIPPER2_SWIPE_FRAMES * 1)
#define RIPPER2_SWIPE_R2 RIPPER2_SWIPE_R0 + (RIPPER2_SWIPE_FRAMES * 2)
#define RIPPER2_SWIPE_R3 RIPPER2_SWIPE_R0 + (RIPPER2_SWIPE_FRAMES * 3)
#define RIPPER2_SWIPE_R4 RIPPER2_SWIPE_R0 + (RIPPER2_SWIPE_FRAMES * 4)
#define RIPPER2_MEKONG_FRAMES 3
#define RIPPER2_MEKONG_R0 4360
#define RIPPER2_MEKONG_R1 RIPPER2_MEKONG_R0 + (RIPPER2_MEKONG_FRAMES * 1)
#define RIPPER2_MEKONG_R2 RIPPER2_MEKONG_R0 + (RIPPER2_MEKONG_FRAMES * 2)
#define RIPPER2_MEKONG_R3 RIPPER2_MEKONG_R0 + (RIPPER2_MEKONG_FRAMES * 3)
#define RIPPER2_MEKONG_R4 RIPPER2_MEKONG_R0 + (RIPPER2_MEKONG_FRAMES * 4)
#define RIPPER2_HEART_FRAMES 2
#define RIPPER2_HEART_R0 4422
#define RIPPER2_HEART_R1 RIPPER2_HEART_R0
#define RIPPER2_HEART_R2 RIPPER2_HEART_R0
#define RIPPER2_HEART_R3 RIPPER2_HEART_R0
#define RIPPER2_HEART_R4 RIPPER2_HEART_R0
#define RIPPER2_DIE 4414 // Has 8 frames now
#define RIPPER2_DEAD 4421
//////////////////////
//
// EEL
//
//////////////////////
#define EEL_RUN_FRAMES 3
#define EEL_RUN_R0 3780
#define EEL_RUN_R1 EEL_RUN_R0 + (EEL_RUN_FRAMES * 1)
#define EEL_RUN_R2 EEL_RUN_R0 + (EEL_RUN_FRAMES * 2)
#define EEL_RUN_R3 EEL_RUN_R0 + (EEL_RUN_FRAMES * 3)
#define EEL_RUN_R4 EEL_RUN_R0 + (EEL_RUN_FRAMES * 4)
#define EEL_FIRE_FRAMES 3
#define EEL_FIRE_R0 3760
#define EEL_FIRE_R1 EEL_FIRE_R0 + (EEL_FIRE_FRAMES * 1)
#define EEL_FIRE_R2 EEL_FIRE_R0 + (EEL_FIRE_FRAMES * 2)
#define EEL_FIRE_R3 EEL_FIRE_R0 + (EEL_FIRE_FRAMES * 3)
#define EEL_FIRE_R4 EEL_RUN_R0 + (EEL_RUN_FRAMES * 4)
#define EEL_DIE 3795
#define EEL_DEAD 3795
//////////////////////
//
// SUMO
//
//////////////////////
#define SUMO_RUN_FRAMES 4
#define SUMO_RUN_R0 1210
#define SUMO_RUN_R1 SUMO_RUN_R0 + (SUMO_RUN_FRAMES * 1)
#define SUMO_RUN_R2 SUMO_RUN_R0 + (SUMO_RUN_FRAMES * 2)
#define SUMO_RUN_R3 SUMO_RUN_R0 + (SUMO_RUN_FRAMES * 3)
#define SUMO_RUN_R4 SUMO_RUN_R0 + (SUMO_RUN_FRAMES * 4)
#define SUMO_PAIN_FRAMES 1
#define SUMO_PAIN_R0 1265
#define SUMO_PAIN_R1 SUMO_PAIN_R0 //+ (SUMO_PAIN_FRAMES * 1)
#define SUMO_PAIN_R2 SUMO_PAIN_R0 //+ (SUMO_PAIN_FRAMES * 2)
#define SUMO_PAIN_R3 SUMO_PAIN_R0 //+ (SUMO_PAIN_FRAMES * 3)
#define SUMO_PAIN_R4 SUMO_PAIN_R0 //+ (SUMO_PAIN_FRAMES * 4)
#define SUMO_STOMP_FRAMES 3
#define SUMO_STOMP_R0 1230
#define SUMO_STOMP_R1 SUMO_STOMP_R0 + (SUMO_STOMP_FRAMES * 1)
#define SUMO_STOMP_R2 SUMO_STOMP_R0 + (SUMO_STOMP_FRAMES * 2)
#define SUMO_STOMP_R3 SUMO_STOMP_R0 + (SUMO_STOMP_FRAMES * 3)
#define SUMO_STOMP_R4 SUMO_STOMP_R0 + (SUMO_STOMP_FRAMES * 4)
#define SUMO_CLAP_FRAMES 4
#define SUMO_CLAP_R0 1245
#define SUMO_CLAP_R1 SUMO_CLAP_R0 + (SUMO_CLAP_FRAMES * 1)
#define SUMO_CLAP_R2 SUMO_CLAP_R0 + (SUMO_CLAP_FRAMES * 2)
#define SUMO_CLAP_R3 SUMO_CLAP_R0 + (SUMO_CLAP_FRAMES * 3)
#define SUMO_CLAP_R4 SUMO_CLAP_R0 + (SUMO_CLAP_FRAMES * 4)
#define SUMO_FART_FRAMES 4
#define SUMO_FART_R0 1280
#define SUMO_FART_R1 SUMO_FART_R0
#define SUMO_FART_R2 SUMO_FART_R0
#define SUMO_FART_R3 SUMO_FART_R0
#define SUMO_FART_R4 SUMO_FART_R0
#define SUMO_DIE 1270
#define SUMO_DEAD 1277
#define TRASHCAN 2540
//////////////////////
//
// GIRLS
//
//////////////////////
#define TOILETGIRL_R0 5023
#define WASHGIRL_R0 5032
#define MECHANICGIRL_R0 4590
#define CARGIRL_R0 4594
#define SAILORGIRL_R0 4600
#define PRUNEGIRL_R0 4604
// Pachinko machines
#define PACHINKO1 4768
#define PACHINKO2 4792
#define PACHINKO3 4816
#define PACHINKO4 4840
/////////////////////////////////////////////////////////////////////////////////
//////////////////////
//
// BUNNY
//
//////////////////////
#define BUNNY_RUN_FRAMES 5
#define BUNNY_RUN_R0 4550
#define BUNNY_RUN_R1 BUNNY_RUN_R0 + (BUNNY_RUN_FRAMES * 1)
#define BUNNY_RUN_R2 BUNNY_RUN_R0 + (BUNNY_RUN_FRAMES * 2)
#define BUNNY_RUN_R3 BUNNY_RUN_R0 + (BUNNY_RUN_FRAMES * 3)
#define BUNNY_RUN_R4 BUNNY_RUN_R0 + (BUNNY_RUN_FRAMES * 4)
#define BUNNY_STAND_R0 BUNNY_RUN_R0
#define BUNNY_STAND_R1 BUNNY_RUN_R1
#define BUNNY_STAND_R2 BUNNY_RUN_R2
#define BUNNY_STAND_R3 BUNNY_RUN_R3
#define BUNNY_STAND_R4 BUNNY_RUN_R4
#define BUNNY_SWIPE_FRAMES 5
#define BUNNY_SWIPE_R0 4575
#define BUNNY_SWIPE_R1 BUNNY_SWIPE_R0 + (BUNNY_SWIPE_FRAMES * 1)
#define BUNNY_SWIPE_R2 BUNNY_SWIPE_R0 + (BUNNY_SWIPE_FRAMES * 1)
#define BUNNY_SWIPE_R3 BUNNY_SWIPE_R0 + (BUNNY_SWIPE_FRAMES * 1)
#define BUNNY_SWIPE_R4 BUNNY_SWIPE_R0 + (BUNNY_SWIPE_FRAMES * 1)
#define BUNNY_DIE 4580
#define BUNNY_DEAD 4584
//////////////////////
//
// EVIL GIRLNINJA
//
//////////////////////
#define GIRLNINJA_RUN_FRAMES 4
#define GIRLNINJA_RUN_R0 5162
#define GIRLNINJA_RUN_R1 GIRLNINJA_RUN_R0 + (GIRLNINJA_RUN_FRAMES * 1)
#define GIRLNINJA_RUN_R2 GIRLNINJA_RUN_R0 + (GIRLNINJA_RUN_FRAMES * 2)
#define GIRLNINJA_RUN_R3 GIRLNINJA_RUN_R0 + (GIRLNINJA_RUN_FRAMES * 3)
#define GIRLNINJA_RUN_R4 GIRLNINJA_RUN_R0 + (GIRLNINJA_RUN_FRAMES * 4)
#define GIRLNINJA_STAND_FRAMES 1
#define GIRLNINJA_STAND_R0 GIRLNINJA_RUN_R0
#define GIRLNINJA_STAND_R1 GIRLNINJA_RUN_R1
#define GIRLNINJA_STAND_R2 GIRLNINJA_RUN_R2
#define GIRLNINJA_STAND_R3 GIRLNINJA_RUN_R3
#define GIRLNINJA_STAND_R4 GIRLNINJA_RUN_R4
#define GIRLNINJA_CRAWL_FRAMES 1
#define GIRLNINJA_CRAWL_R0 5211
#define GIRLNINJA_CRAWL_R1 GIRLNINJA_CRAWL_R0 + (GIRLNINJA_CRAWL_FRAMES * 1)
#define GIRLNINJA_CRAWL_R2 GIRLNINJA_CRAWL_R0 + (GIRLNINJA_CRAWL_FRAMES * 2)
#define GIRLNINJA_CRAWL_R3 GIRLNINJA_CRAWL_R0 + (GIRLNINJA_CRAWL_FRAMES * 3)
#define GIRLNINJA_CRAWL_R4 GIRLNINJA_CRAWL_R0 + (GIRLNINJA_CRAWL_FRAMES * 4)
#define GIRLNINJA_THROW_FRAMES 3
#define GIRLNINJA_THROW_R0 5246
#define GIRLNINJA_THROW_R1 GIRLNINJA_THROW_R0 + (GIRLNINJA_THROW_FRAMES * 1)
#define GIRLNINJA_THROW_R2 GIRLNINJA_THROW_R0 + (GIRLNINJA_THROW_FRAMES * 2)
// don't have rotations for pain frames currently
#if 1
#define GIRLNINJA_PAIN_FRAMES 1
#define GIRLNINJA_PAIN_R0 5192
#define GIRLNINJA_PAIN_R1 GIRLNINJA_PAIN_R0
#define GIRLNINJA_PAIN_R2 GIRLNINJA_PAIN_R0
#define GIRLNINJA_PAIN_R3 GIRLNINJA_PAIN_R0
#define GIRLNINJA_PAIN_R4 GIRLNINJA_PAIN_R0
#endif
#define GIRLNINJA_JUMP_FRAMES 4
#define GIRLNINJA_JUMP_R0 5226
#define GIRLNINJA_JUMP_R1 GIRLNINJA_JUMP_R0 + (GIRLNINJA_JUMP_FRAMES * 1)
#define GIRLNINJA_JUMP_R2 GIRLNINJA_JUMP_R0 + (GIRLNINJA_JUMP_FRAMES * 2)
#define GIRLNINJA_JUMP_R3 GIRLNINJA_JUMP_R0 + (GIRLNINJA_JUMP_FRAMES * 3)
#define GIRLNINJA_JUMP_R4 GIRLNINJA_JUMP_R0 + (GIRLNINJA_JUMP_FRAMES * 4)
#define GIRLNINJA_FALL_R0 GIRLNINJA_JUMP_R0+2
#define GIRLNINJA_FALL_R1 GIRLNINJA_JUMP_R1+2
#define GIRLNINJA_FALL_R2 GIRLNINJA_JUMP_R2+2
#define GIRLNINJA_FALL_R3 GIRLNINJA_JUMP_R3+2
#define GIRLNINJA_FALL_R4 GIRLNINJA_JUMP_R4+2
#define GIRLNINJA_LAND_R0 GIRLNINJA_JUMP_R0+3
#define GIRLNINJA_LAND_R1 GIRLNINJA_JUMP_R1+3
#define GIRLNINJA_LAND_R2 GIRLNINJA_JUMP_R2+3
#define GIRLNINJA_LAND_R3 GIRLNINJA_JUMP_R3+3
#define GIRLNINJA_LAND_R4 GIRLNINJA_JUMP_R4+3
#define GIRLNINJA_KNEEL_R0 GIRLNINJA_CRAWL_R0
#define GIRLNINJA_KNEEL_R1 GIRLNINJA_CRAWL_R1
#define GIRLNINJA_KNEEL_R2 GIRLNINJA_CRAWL_R2
#define GIRLNINJA_KNEEL_R3 GIRLNINJA_CRAWL_R3
#define GIRLNINJA_KNEEL_R4 GIRLNINJA_CRAWL_R4
#define GIRLNINJA_FIRE_FRAMES 2
#define GIRLNINJA_FIRE_R0 5182
#define GIRLNINJA_FIRE_R1 GIRLNINJA_FIRE_R0 + (GIRLNINJA_FIRE_FRAMES * 1)
#define GIRLNINJA_FIRE_R2 GIRLNINJA_FIRE_R0 + (GIRLNINJA_FIRE_FRAMES * 2)
#define GIRLNINJA_FIRE_R3 GIRLNINJA_FIRE_R0 + (GIRLNINJA_FIRE_FRAMES * 3)
#define GIRLNINJA_FIRE_R4 GIRLNINJA_FIRE_R0 + (GIRLNINJA_FIRE_FRAMES * 4)
#define GIRLNINJA_STAB_FRAMES 1
#define GIRLNINJA_STAB_R0 5206
#define GIRLNINJA_STAB_R1 GIRLNINJA_STAB_R0 + (GIRLNINJA_STAB_FRAMES * 1)
#define GIRLNINJA_STAB_R2 GIRLNINJA_STAB_R0 + (GIRLNINJA_STAB_FRAMES * 2)
#define GIRLNINJA_STAB_R3 GIRLNINJA_STAB_R0 + (GIRLNINJA_STAB_FRAMES * 3)
#define GIRLNINJA_STAB_R4 GIRLNINJA_STAB_R0 + (GIRLNINJA_STAB_FRAMES * 4)
#define GIRLNINJA_DIE 5197
#define GIRLNINJA_DEAD GIRLNINJA_DIE+8
#define GIRLNINJA_SLICED 4227
#define GIRLNINJA_DEAD_SLICED GIRLNINJA_SLICED+9
//////////////////////
//
// ZILLA
//
//////////////////////
#define ZILLA_RUN_FRAMES 4
#define ZILLA_RUN_R0 5426
#define ZILLA_RUN_R1 ZILLA_RUN_R0 - (ZILLA_RUN_FRAMES * 1)
#define ZILLA_RUN_R2 ZILLA_RUN_R0 - (ZILLA_RUN_FRAMES * 2)
#define ZILLA_RUN_R3 ZILLA_RUN_R0 - (ZILLA_RUN_FRAMES * 3)
#define ZILLA_RUN_R4 ZILLA_RUN_R0 - (ZILLA_RUN_FRAMES * 4)
#define ZILLA_PAIN_FRAMES 1
#define ZILLA_PAIN_R0 5524
#define ZILLA_PAIN_R1 ZILLA_PAIN_R0 - (ZILLA_PAIN_FRAMES * 1)
#define ZILLA_PAIN_R2 ZILLA_PAIN_R0 - (ZILLA_PAIN_FRAMES * 2)
#define ZILLA_PAIN_R3 ZILLA_PAIN_R0 - (ZILLA_PAIN_FRAMES * 3)
#define ZILLA_PAIN_R4 ZILLA_PAIN_R0 - (ZILLA_PAIN_FRAMES * 4)
#define ZILLA_ROCKET_FRAMES 4
#define ZILLA_ROCKET_R0 5446
#define ZILLA_ROCKET_R1 ZILLA_ROCKET_R0 - (ZILLA_ROCKET_FRAMES * 1)
#define ZILLA_ROCKET_R2 ZILLA_ROCKET_R0 - (ZILLA_ROCKET_FRAMES * 2)
#define ZILLA_ROCKET_R3 ZILLA_ROCKET_R0 - (ZILLA_ROCKET_FRAMES * 3)
#define ZILLA_ROCKET_R4 ZILLA_ROCKET_R0 - (ZILLA_ROCKET_FRAMES * 4)
#define ZILLA_RAIL_FRAMES 4
#define ZILLA_RAIL_R0 5466
#define ZILLA_RAIL_R1 ZILLA_RAIL_R0 - (ZILLA_RAIL_FRAMES * 1)
#define ZILLA_RAIL_R2 ZILLA_RAIL_R0 - (ZILLA_RAIL_FRAMES * 2)
#define ZILLA_RAIL_R3 ZILLA_RAIL_R0 - (ZILLA_RAIL_FRAMES * 3)
#define ZILLA_RAIL_R4 ZILLA_RAIL_R0 - (ZILLA_RAIL_FRAMES * 4)
#define ZILLA_SHOOT_FRAMES 4
#define ZILLA_SHOOT_R0 5506
#define ZILLA_SHOOT_R1 ZILLA_SHOOT_R0 - (ZILLA_SHOOT_FRAMES * 1)
#define ZILLA_SHOOT_R2 ZILLA_SHOOT_R0 - (ZILLA_SHOOT_FRAMES * 2)
#define ZILLA_SHOOT_R3 ZILLA_SHOOT_R0 - (ZILLA_SHOOT_FRAMES * 3)
#define ZILLA_SHOOT_R4 ZILLA_SHOOT_R0 - (ZILLA_SHOOT_FRAMES * 4)
#define ZILLA_RECHARGE_FRAMES 4
#define ZILLA_RECHARGE_R0 5486
#define ZILLA_RECHARGE_R1 ZILLA_RECHARGE_R0 - (ZILLA_RECHARGE_FRAMES * 1)
#define ZILLA_RECHARGE_R2 ZILLA_RECHARGE_R0 - (ZILLA_RECHARGE_FRAMES * 2)
#define ZILLA_RECHARGE_R3 ZILLA_RECHARGE_R0 - (ZILLA_RECHARGE_FRAMES * 3)
#define ZILLA_RECHARGE_R4 ZILLA_RECHARGE_R0 - (ZILLA_RECHARGE_FRAMES * 4)
#define ZILLA_DIE 5510
#define ZILLA_DEAD 5518
////////////////////////////////////
#define TRASHCAN 2540
#define SCROLL 516
#define SCROLL_FIRE 524

986
source/games/sw/src/ninja.cpp
View file

File diff suppressed because it is too large Load diff

592
source/games/sw/src/player.cpp
View file

@ -208,48 +208,16 @@ void DSWPlayer::OnDestroy()
#define PLAYER_NINJA_RATE 14
STATE s_PlayerNinjaRun[5][6] =
STATE s_PlayerNinjaRun[1][6] =
{
{
{PLAYER_NINJA_RUN_R0 + 0, PLAYER_NINJA_RATE | SF_TIC_ADJUST, nullptr, &s_PlayerNinjaRun[0][1]},
{PLAYER_NINJA_RUN_R0 + 1, PLAYER_NINJA_RATE | SF_TIC_ADJUST, nullptr, &s_PlayerNinjaRun[0][2]},
{PLAYER_NINJA_RUN_R0 + 1, 0 | SF_QUICK_CALL, &AF(DoFootPrints), &s_PlayerNinjaRun[0][3]},
{PLAYER_NINJA_RUN_R0 + 2, PLAYER_NINJA_RATE | SF_TIC_ADJUST, nullptr, &s_PlayerNinjaRun[0][4]},
{PLAYER_NINJA_RUN_R0 + 3, PLAYER_NINJA_RATE | SF_TIC_ADJUST, nullptr, &s_PlayerNinjaRun[0][5]},
{PLAYER_NINJA_RUN_R0 + 3, 0 | SF_QUICK_CALL, &AF(DoFootPrints), &s_PlayerNinjaRun[0][0]},
},
{
{PLAYER_NINJA_RUN_R1 + 0, PLAYER_NINJA_RATE | SF_TIC_ADJUST, nullptr, &s_PlayerNinjaRun[1][1]},
{PLAYER_NINJA_RUN_R1 + 1, PLAYER_NINJA_RATE | SF_TIC_ADJUST, nullptr, &s_PlayerNinjaRun[1][2]},
{PLAYER_NINJA_RUN_R1 + 1, 0 | SF_QUICK_CALL, &AF(DoFootPrints), &s_PlayerNinjaRun[1][3]},
{PLAYER_NINJA_RUN_R1 + 2, PLAYER_NINJA_RATE | SF_TIC_ADJUST, nullptr, &s_PlayerNinjaRun[1][4]},
{PLAYER_NINJA_RUN_R1 + 3, PLAYER_NINJA_RATE | SF_TIC_ADJUST, nullptr, &s_PlayerNinjaRun[1][5]},
{PLAYER_NINJA_RUN_R1 + 3, 0 | SF_QUICK_CALL, &AF(DoFootPrints), &s_PlayerNinjaRun[1][0]},
},
{
{PLAYER_NINJA_RUN_R2 + 0, PLAYER_NINJA_RATE | SF_TIC_ADJUST, nullptr, &s_PlayerNinjaRun[2][1]},
{PLAYER_NINJA_RUN_R2 + 1, PLAYER_NINJA_RATE | SF_TIC_ADJUST, nullptr, &s_PlayerNinjaRun[2][2]},
{PLAYER_NINJA_RUN_R2 + 1, 0 | SF_QUICK_CALL, &AF(DoFootPrints), &s_PlayerNinjaRun[2][3]},
{PLAYER_NINJA_RUN_R2 + 2, PLAYER_NINJA_RATE | SF_TIC_ADJUST, nullptr, &s_PlayerNinjaRun[2][4]},
{PLAYER_NINJA_RUN_R2 + 3, PLAYER_NINJA_RATE | SF_TIC_ADJUST, nullptr, &s_PlayerNinjaRun[2][5]},
{PLAYER_NINJA_RUN_R2 + 3, 0 | SF_QUICK_CALL, &AF(DoFootPrints), &s_PlayerNinjaRun[2][0]},
},
{
{PLAYER_NINJA_RUN_R3 + 0, PLAYER_NINJA_RATE | SF_TIC_ADJUST, nullptr, &s_PlayerNinjaRun[3][1]},
{PLAYER_NINJA_RUN_R3 + 1, PLAYER_NINJA_RATE | SF_TIC_ADJUST, nullptr, &s_PlayerNinjaRun[3][2]},
{PLAYER_NINJA_RUN_R3 + 1, 0 | SF_QUICK_CALL, &AF(DoFootPrints), &s_PlayerNinjaRun[3][3]},
{PLAYER_NINJA_RUN_R3 + 2, PLAYER_NINJA_RATE | SF_TIC_ADJUST, nullptr, &s_PlayerNinjaRun[3][4]},
{PLAYER_NINJA_RUN_R3 + 3, PLAYER_NINJA_RATE | SF_TIC_ADJUST, nullptr, &s_PlayerNinjaRun[3][5]},
{PLAYER_NINJA_RUN_R3 + 3, 0 | SF_QUICK_CALL, &AF(DoFootPrints), &s_PlayerNinjaRun[3][0]},
},
{
{PLAYER_NINJA_RUN_R4 + 0, PLAYER_NINJA_RATE | SF_TIC_ADJUST, nullptr, &s_PlayerNinjaRun[4][1]},
{PLAYER_NINJA_RUN_R4 + 1, PLAYER_NINJA_RATE | SF_TIC_ADJUST, nullptr, &s_PlayerNinjaRun[4][2]},
{PLAYER_NINJA_RUN_R4 + 1, 0 | SF_QUICK_CALL, &AF(DoFootPrints), &s_PlayerNinjaRun[4][3]},
{PLAYER_NINJA_RUN_R4 + 2, PLAYER_NINJA_RATE | SF_TIC_ADJUST, nullptr, &s_PlayerNinjaRun[4][4]},
{PLAYER_NINJA_RUN_R4 + 3, PLAYER_NINJA_RATE | SF_TIC_ADJUST, nullptr, &s_PlayerNinjaRun[4][5]},
{PLAYER_NINJA_RUN_R4 + 3, 0 | SF_QUICK_CALL, &AF(DoFootPrints), &s_PlayerNinjaRun[4][0]},
{SPR_PLAYER_NINJA_RUN, 'A', PLAYER_NINJA_RATE | SF_TIC_ADJUST, nullptr, &s_PlayerNinjaRun[0][1]},
{SPR_PLAYER_NINJA_RUN, 'B', PLAYER_NINJA_RATE | SF_TIC_ADJUST, nullptr, &s_PlayerNinjaRun[0][2]},
{SPR_PLAYER_NINJA_RUN, 'B', 0 | SF_QUICK_CALL, &AF(DoFootPrints), &s_PlayerNinjaRun[0][3]},
{SPR_PLAYER_NINJA_RUN, 'C', PLAYER_NINJA_RATE | SF_TIC_ADJUST, nullptr, &s_PlayerNinjaRun[0][4]},
{SPR_PLAYER_NINJA_RUN, 'D', PLAYER_NINJA_RATE | SF_TIC_ADJUST, nullptr, &s_PlayerNinjaRun[0][5]},
{SPR_PLAYER_NINJA_RUN, 'D', 0 | SF_QUICK_CALL, &AF(DoFootPrints), &s_PlayerNinjaRun[0][0]},
},
};
@ -257,10 +225,6 @@ STATE s_PlayerNinjaRun[5][6] =
STATE* sg_PlayerNinjaRun[] =
{
s_PlayerNinjaRun[0],
s_PlayerNinjaRun[1],
s_PlayerNinjaRun[2],
s_PlayerNinjaRun[3],
s_PlayerNinjaRun[4]
};
#endif
@ -272,31 +236,15 @@ STATE* sg_PlayerNinjaRun[] =
#define PLAYER_NINJA_STAND_RATE 10
STATE s_PlayerNinjaStand[5][1] =
STATE s_PlayerNinjaStand[1][1] =
{
{
{PLAYER_NINJA_STAND_R0 + 0, PLAYER_NINJA_STAND_RATE, nullptr, &s_PlayerNinjaStand[0][0]},
},
{
{PLAYER_NINJA_STAND_R1 + 0, PLAYER_NINJA_STAND_RATE, nullptr, &s_PlayerNinjaStand[1][0]},
},
{
{PLAYER_NINJA_STAND_R2 + 0, PLAYER_NINJA_STAND_RATE, nullptr, &s_PlayerNinjaStand[2][0]},
},
{
{PLAYER_NINJA_STAND_R3 + 0, PLAYER_NINJA_STAND_RATE, nullptr, &s_PlayerNinjaStand[3][0]},
},
{
{PLAYER_NINJA_STAND_R4 + 0, PLAYER_NINJA_STAND_RATE, nullptr, &s_PlayerNinjaStand[4][0]},
{SPR_PLAYER_NINJA_STAND, 'A', PLAYER_NINJA_STAND_RATE, nullptr, &s_PlayerNinjaStand[0][0]},
},
};
STATE* sg_PlayerNinjaStand[] =
{
s_PlayerNinjaStand[0],
s_PlayerNinjaStand[1],
s_PlayerNinjaStand[2],
s_PlayerNinjaStand[3],
s_PlayerNinjaStand[4]
};
@ -307,37 +255,13 @@ int DoPlayerSpriteReset(DSWActor* actor);
#if 1
STATE s_PlayerNinjaThrow[5][4] =
STATE s_PlayerNinjaThrow[1][4] =
{
{
{PLAYER_NINJA_SHOOT_R0 + 0, PLAYER_NINJA_STAR_RATE, nullptr, &s_PlayerNinjaThrow[0][1]},
{PLAYER_NINJA_SHOOT_R0 + 0, PLAYER_NINJA_STAR_RATE, nullptr, &s_PlayerNinjaThrow[0][2]},
{PLAYER_NINJA_SHOOT_R0 + 0, PLAYER_NINJA_STAR_RATE, nullptr, &s_PlayerNinjaThrow[0][3]},
{PLAYER_NINJA_SHOOT_R0 + 0, PLAYER_NINJA_STAR_RATE | SF_PLAYER_FUNC, &AF(DoPlayerSpriteReset), &s_PlayerNinjaThrow[0][3]},
},
{
{PLAYER_NINJA_SHOOT_R1 + 0, PLAYER_NINJA_STAR_RATE, nullptr, &s_PlayerNinjaThrow[1][1]},
{PLAYER_NINJA_SHOOT_R1 + 0, PLAYER_NINJA_STAR_RATE, nullptr, &s_PlayerNinjaThrow[1][2]},
{PLAYER_NINJA_SHOOT_R1 + 0, PLAYER_NINJA_STAR_RATE, nullptr, &s_PlayerNinjaThrow[1][3]},
{PLAYER_NINJA_SHOOT_R1 + 0, PLAYER_NINJA_STAR_RATE | SF_PLAYER_FUNC, &AF(DoPlayerSpriteReset), &s_PlayerNinjaThrow[0][3]},
},
{
{PLAYER_NINJA_SHOOT_R2 + 0, PLAYER_NINJA_STAR_RATE, nullptr, &s_PlayerNinjaThrow[2][1]},
{PLAYER_NINJA_SHOOT_R2 + 0, PLAYER_NINJA_STAR_RATE, nullptr, &s_PlayerNinjaThrow[2][2]},
{PLAYER_NINJA_SHOOT_R2 + 0, PLAYER_NINJA_STAR_RATE, nullptr, &s_PlayerNinjaThrow[2][3]},
{PLAYER_NINJA_SHOOT_R2 + 0, PLAYER_NINJA_STAR_RATE | SF_PLAYER_FUNC, &AF(DoPlayerSpriteReset), &s_PlayerNinjaThrow[0][3]},
},
{
{PLAYER_NINJA_SHOOT_R3 + 0, PLAYER_NINJA_STAR_RATE, nullptr, &s_PlayerNinjaThrow[3][1]},
{PLAYER_NINJA_SHOOT_R3 + 0, PLAYER_NINJA_STAR_RATE, nullptr, &s_PlayerNinjaThrow[3][2]},
{PLAYER_NINJA_SHOOT_R3 + 0, PLAYER_NINJA_STAR_RATE, nullptr, &s_PlayerNinjaThrow[3][3]},
{PLAYER_NINJA_SHOOT_R3 + 0, PLAYER_NINJA_STAR_RATE | SF_PLAYER_FUNC, &AF(DoPlayerSpriteReset), &s_PlayerNinjaThrow[0][3]},
},
{
{PLAYER_NINJA_SHOOT_R4 + 0, PLAYER_NINJA_STAR_RATE, nullptr, &s_PlayerNinjaThrow[4][1]},
{PLAYER_NINJA_SHOOT_R4 + 0, PLAYER_NINJA_STAR_RATE, nullptr, &s_PlayerNinjaThrow[4][2]},
{PLAYER_NINJA_SHOOT_R4 + 0, PLAYER_NINJA_STAR_RATE, nullptr, &s_PlayerNinjaThrow[4][3]},
{PLAYER_NINJA_SHOOT_R4 + 0, PLAYER_NINJA_STAR_RATE | SF_PLAYER_FUNC, &AF(DoPlayerSpriteReset), &s_PlayerNinjaThrow[0][3]},
{SPR_PLAYER_NINJA_SHOOT, 'A', PLAYER_NINJA_STAR_RATE, nullptr, &s_PlayerNinjaThrow[0][1]},
{SPR_PLAYER_NINJA_SHOOT, 'A', PLAYER_NINJA_STAR_RATE, nullptr, &s_PlayerNinjaThrow[0][2]},
{SPR_PLAYER_NINJA_SHOOT, 'A', PLAYER_NINJA_STAR_RATE, nullptr, &s_PlayerNinjaThrow[0][3]},
{SPR_PLAYER_NINJA_SHOOT, 'A', PLAYER_NINJA_STAR_RATE | SF_PLAYER_FUNC, &AF(DoPlayerSpriteReset), &s_PlayerNinjaThrow[0][3]},
},
};
#endif
@ -345,10 +269,6 @@ STATE s_PlayerNinjaThrow[5][4] =
STATE* sg_PlayerNinjaThrow[] =
{
s_PlayerNinjaThrow[0],
s_PlayerNinjaThrow[1],
s_PlayerNinjaThrow[2],
s_PlayerNinjaThrow[3],
s_PlayerNinjaThrow[4]
};
//////////////////////
@ -359,37 +279,13 @@ STATE* sg_PlayerNinjaThrow[] =
#define PLAYER_NINJA_JUMP_RATE 24
STATE s_PlayerNinjaJump[5][4] =
STATE s_PlayerNinjaJump[1][4] =
{
{
{PLAYER_NINJA_JUMP_R0 + 0, PLAYER_NINJA_JUMP_RATE, nullptr, &s_PlayerNinjaJump[0][1]},
{PLAYER_NINJA_JUMP_R0 + 1, PLAYER_NINJA_JUMP_RATE, nullptr, &s_PlayerNinjaJump[0][2]},
{PLAYER_NINJA_JUMP_R0 + 2, PLAYER_NINJA_JUMP_RATE, nullptr, &s_PlayerNinjaJump[0][3]},
{PLAYER_NINJA_JUMP_R0 + 3, PLAYER_NINJA_JUMP_RATE, nullptr, &s_PlayerNinjaJump[0][3]},
},
{
{PLAYER_NINJA_JUMP_R1 + 0, PLAYER_NINJA_JUMP_RATE, nullptr, &s_PlayerNinjaJump[1][1]},
{PLAYER_NINJA_JUMP_R1 + 1, PLAYER_NINJA_JUMP_RATE, nullptr, &s_PlayerNinjaJump[1][2]},
{PLAYER_NINJA_JUMP_R1 + 2, PLAYER_NINJA_JUMP_RATE, nullptr, &s_PlayerNinjaJump[1][3]},
{PLAYER_NINJA_JUMP_R1 + 3, PLAYER_NINJA_JUMP_RATE, nullptr, &s_PlayerNinjaJump[1][3]},
},
{
{PLAYER_NINJA_JUMP_R2 + 0, PLAYER_NINJA_JUMP_RATE, nullptr, &s_PlayerNinjaJump[2][1]},
{PLAYER_NINJA_JUMP_R2 + 1, PLAYER_NINJA_JUMP_RATE, nullptr, &s_PlayerNinjaJump[2][2]},
{PLAYER_NINJA_JUMP_R2 + 2, PLAYER_NINJA_JUMP_RATE, nullptr, &s_PlayerNinjaJump[2][3]},
{PLAYER_NINJA_JUMP_R2 + 3, PLAYER_NINJA_JUMP_RATE, nullptr, &s_PlayerNinjaJump[2][3]},
},
{
{PLAYER_NINJA_JUMP_R3 + 0, PLAYER_NINJA_JUMP_RATE, nullptr, &s_PlayerNinjaJump[3][1]},
{PLAYER_NINJA_JUMP_R3 + 1, PLAYER_NINJA_JUMP_RATE, nullptr, &s_PlayerNinjaJump[3][2]},
{PLAYER_NINJA_JUMP_R3 + 2, PLAYER_NINJA_JUMP_RATE, nullptr, &s_PlayerNinjaJump[3][3]},
{PLAYER_NINJA_JUMP_R3 + 3, PLAYER_NINJA_JUMP_RATE, nullptr, &s_PlayerNinjaJump[3][3]},
},
{
{PLAYER_NINJA_JUMP_R4 + 0, PLAYER_NINJA_JUMP_RATE, nullptr, &s_PlayerNinjaJump[4][1]},
{PLAYER_NINJA_JUMP_R4 + 1, PLAYER_NINJA_JUMP_RATE, nullptr, &s_PlayerNinjaJump[4][2]},
{PLAYER_NINJA_JUMP_R4 + 2, PLAYER_NINJA_JUMP_RATE, nullptr, &s_PlayerNinjaJump[4][3]},
{PLAYER_NINJA_JUMP_R4 + 3, PLAYER_NINJA_JUMP_RATE, nullptr, &s_PlayerNinjaJump[4][3]},
{SPR_PLAYER_NINJA_JUMP, 'A', PLAYER_NINJA_JUMP_RATE, nullptr, &s_PlayerNinjaJump[0][1]},
{SPR_PLAYER_NINJA_JUMP, 'B', PLAYER_NINJA_JUMP_RATE, nullptr, &s_PlayerNinjaJump[0][2]},
{SPR_PLAYER_NINJA_JUMP, 'C', PLAYER_NINJA_JUMP_RATE, nullptr, &s_PlayerNinjaJump[0][3]},
{SPR_PLAYER_NINJA_JUMP, 'D', PLAYER_NINJA_JUMP_RATE, nullptr, &s_PlayerNinjaJump[0][3]},
},
};
@ -397,10 +293,6 @@ STATE s_PlayerNinjaJump[5][4] =
STATE* sg_PlayerNinjaJump[] =
{
s_PlayerNinjaJump[0],
s_PlayerNinjaJump[1],
s_PlayerNinjaJump[2],
s_PlayerNinjaJump[3],
s_PlayerNinjaJump[4]
};
@ -412,27 +304,11 @@ STATE* sg_PlayerNinjaJump[] =
#define PLAYER_NINJA_FALL_RATE 16
STATE s_PlayerNinjaFall[5][2] =
STATE s_PlayerNinjaFall[1][2] =
{
{
{PLAYER_NINJA_JUMP_R0 + 1, PLAYER_NINJA_FALL_RATE, nullptr, &s_PlayerNinjaFall[0][1]},
{PLAYER_NINJA_JUMP_R0 + 2, PLAYER_NINJA_FALL_RATE, nullptr, &s_PlayerNinjaFall[0][1]},
},
{
{PLAYER_NINJA_JUMP_R1 + 1, PLAYER_NINJA_FALL_RATE, nullptr, &s_PlayerNinjaFall[1][1]},
{PLAYER_NINJA_JUMP_R1 + 2, PLAYER_NINJA_FALL_RATE, nullptr, &s_PlayerNinjaFall[1][1]},
},
{
{PLAYER_NINJA_JUMP_R2 + 1, PLAYER_NINJA_FALL_RATE, nullptr, &s_PlayerNinjaFall[2][1]},
{PLAYER_NINJA_JUMP_R2 + 2, PLAYER_NINJA_FALL_RATE, nullptr, &s_PlayerNinjaFall[2][1]},
},
{
{PLAYER_NINJA_JUMP_R3 + 1, PLAYER_NINJA_FALL_RATE, nullptr, &s_PlayerNinjaFall[3][1]},
{PLAYER_NINJA_JUMP_R3 + 2, PLAYER_NINJA_FALL_RATE, nullptr, &s_PlayerNinjaFall[3][1]},
},
{
{PLAYER_NINJA_JUMP_R4 + 1, PLAYER_NINJA_FALL_RATE, nullptr, &s_PlayerNinjaFall[4][1]},
{PLAYER_NINJA_JUMP_R4 + 2, PLAYER_NINJA_FALL_RATE, nullptr, &s_PlayerNinjaFall[4][1]},
{SPR_PLAYER_NINJA_JUMP, 'B', PLAYER_NINJA_FALL_RATE, nullptr, &s_PlayerNinjaFall[0][1]},
{SPR_PLAYER_NINJA_JUMP, 'C', PLAYER_NINJA_FALL_RATE, nullptr, &s_PlayerNinjaFall[0][1]},
},
};
@ -440,10 +316,6 @@ STATE s_PlayerNinjaFall[5][2] =
STATE* sg_PlayerNinjaFall[] =
{
s_PlayerNinjaFall[0],
s_PlayerNinjaFall[1],
s_PlayerNinjaFall[2],
s_PlayerNinjaFall[3],
s_PlayerNinjaFall[4]
};
//////////////////////
@ -454,47 +326,19 @@ STATE* sg_PlayerNinjaFall[] =
#define PLAYER_NINJA_CLIMB_RATE 20
STATE s_PlayerNinjaClimb[5][4] =
STATE s_PlayerNinjaClimb[1][4] =
{
{
{PLAYER_NINJA_CLIMB_R0 + 0, PLAYER_NINJA_CLIMB_RATE, nullptr, &s_PlayerNinjaClimb[0][1]},
{PLAYER_NINJA_CLIMB_R0 + 1, PLAYER_NINJA_CLIMB_RATE, nullptr, &s_PlayerNinjaClimb[0][2]},
{PLAYER_NINJA_CLIMB_R0 + 2, PLAYER_NINJA_CLIMB_RATE, nullptr, &s_PlayerNinjaClimb[0][3]},
{PLAYER_NINJA_CLIMB_R0 + 3, PLAYER_NINJA_CLIMB_RATE, nullptr, &s_PlayerNinjaClimb[0][0]},
},
{
{PLAYER_NINJA_CLIMB_R1 + 0, PLAYER_NINJA_CLIMB_RATE, nullptr, &s_PlayerNinjaClimb[1][1]},
{PLAYER_NINJA_CLIMB_R1 + 1, PLAYER_NINJA_CLIMB_RATE, nullptr, &s_PlayerNinjaClimb[1][2]},
{PLAYER_NINJA_CLIMB_R1 + 2, PLAYER_NINJA_CLIMB_RATE, nullptr, &s_PlayerNinjaClimb[1][3]},
{PLAYER_NINJA_CLIMB_R1 + 3, PLAYER_NINJA_CLIMB_RATE, nullptr, &s_PlayerNinjaClimb[1][0]},
},
{
{PLAYER_NINJA_CLIMB_R2 + 0, PLAYER_NINJA_CLIMB_RATE, nullptr, &s_PlayerNinjaClimb[2][1]},
{PLAYER_NINJA_CLIMB_R2 + 1, PLAYER_NINJA_CLIMB_RATE, nullptr, &s_PlayerNinjaClimb[2][2]},
{PLAYER_NINJA_CLIMB_R2 + 2, PLAYER_NINJA_CLIMB_RATE, nullptr, &s_PlayerNinjaClimb[2][3]},
{PLAYER_NINJA_CLIMB_R2 + 3, PLAYER_NINJA_CLIMB_RATE, nullptr, &s_PlayerNinjaClimb[2][0]},
},
{
{PLAYER_NINJA_CLIMB_R3 + 0, PLAYER_NINJA_CLIMB_RATE, nullptr, &s_PlayerNinjaClimb[3][1]},
{PLAYER_NINJA_CLIMB_R3 + 1, PLAYER_NINJA_CLIMB_RATE, nullptr, &s_PlayerNinjaClimb[3][2]},
{PLAYER_NINJA_CLIMB_R3 + 2, PLAYER_NINJA_CLIMB_RATE, nullptr, &s_PlayerNinjaClimb[3][3]},
{PLAYER_NINJA_CLIMB_R3 + 3, PLAYER_NINJA_CLIMB_RATE, nullptr, &s_PlayerNinjaClimb[3][0]},
},
{
{PLAYER_NINJA_CLIMB_R4 + 0, PLAYER_NINJA_CLIMB_RATE, nullptr, &s_PlayerNinjaClimb[4][1]},
{PLAYER_NINJA_CLIMB_R4 + 1, PLAYER_NINJA_CLIMB_RATE, nullptr, &s_PlayerNinjaClimb[4][2]},
{PLAYER_NINJA_CLIMB_R4 + 2, PLAYER_NINJA_CLIMB_RATE, nullptr, &s_PlayerNinjaClimb[4][3]},
{PLAYER_NINJA_CLIMB_R4 + 3, PLAYER_NINJA_CLIMB_RATE, nullptr, &s_PlayerNinjaClimb[4][0]},
{SPR_PLAYER_NINJA_CLIMB, 'A', PLAYER_NINJA_CLIMB_RATE, nullptr, &s_PlayerNinjaClimb[0][1]},
{SPR_PLAYER_NINJA_CLIMB, 'B', PLAYER_NINJA_CLIMB_RATE, nullptr, &s_PlayerNinjaClimb[0][2]},
{SPR_PLAYER_NINJA_CLIMB, 'C', PLAYER_NINJA_CLIMB_RATE, nullptr, &s_PlayerNinjaClimb[0][3]},
{SPR_PLAYER_NINJA_CLIMB, 'D', PLAYER_NINJA_CLIMB_RATE, nullptr, &s_PlayerNinjaClimb[0][0]},
},
};
STATE* sg_PlayerNinjaClimb[] =
{
s_PlayerNinjaClimb[0],
s_PlayerNinjaClimb[1],
s_PlayerNinjaClimb[2],
s_PlayerNinjaClimb[3],
s_PlayerNinjaClimb[4]
};
//////////////////////
@ -505,47 +349,15 @@ STATE* sg_PlayerNinjaClimb[] =
#define PLAYER_NINJA_CRAWL_RATE 14
STATE s_PlayerNinjaCrawl[5][6] =
STATE s_PlayerNinjaCrawl[1][6] =
{
{
{PLAYER_NINJA_CRAWL_R0 + 0, PLAYER_NINJA_CRAWL_RATE, nullptr, &s_PlayerNinjaCrawl[0][1]},
{PLAYER_NINJA_CRAWL_R0 + 1, PLAYER_NINJA_CRAWL_RATE, nullptr, &s_PlayerNinjaCrawl[0][2]},
{PLAYER_NINJA_CRAWL_R0 + 1, 0 | SF_QUICK_CALL, &AF(DoFootPrints), &s_PlayerNinjaCrawl[0][3]},
{PLAYER_NINJA_CRAWL_R0 + 2, PLAYER_NINJA_CRAWL_RATE, nullptr, &s_PlayerNinjaCrawl[0][4]},
{PLAYER_NINJA_CRAWL_R0 + 1, PLAYER_NINJA_CRAWL_RATE, nullptr, &s_PlayerNinjaCrawl[0][5]},
{PLAYER_NINJA_CRAWL_R0 + 1, 0 | SF_QUICK_CALL, &AF(DoFootPrints), &s_PlayerNinjaCrawl[0][0]},
},
{
{PLAYER_NINJA_CRAWL_R1 + 0, PLAYER_NINJA_CRAWL_RATE, nullptr, &s_PlayerNinjaCrawl[1][1]},
{PLAYER_NINJA_CRAWL_R1 + 1, PLAYER_NINJA_CRAWL_RATE, nullptr, &s_PlayerNinjaCrawl[1][2]},
{PLAYER_NINJA_CRAWL_R1 + 1, 0 | SF_QUICK_CALL, &AF(DoFootPrints), &s_PlayerNinjaCrawl[1][3]},
{PLAYER_NINJA_CRAWL_R1 + 2, PLAYER_NINJA_CRAWL_RATE, nullptr, &s_PlayerNinjaCrawl[1][4]},
{PLAYER_NINJA_CRAWL_R1 + 1, PLAYER_NINJA_CRAWL_RATE, nullptr, &s_PlayerNinjaCrawl[1][5]},
{PLAYER_NINJA_CRAWL_R1 + 1, 0 | SF_QUICK_CALL, &AF(DoFootPrints), &s_PlayerNinjaCrawl[1][0]},
},
{
{PLAYER_NINJA_CRAWL_R2 + 0, PLAYER_NINJA_CRAWL_RATE, nullptr, &s_PlayerNinjaCrawl[2][1]},
{PLAYER_NINJA_CRAWL_R2 + 1, PLAYER_NINJA_CRAWL_RATE, nullptr, &s_PlayerNinjaCrawl[2][2]},
{PLAYER_NINJA_CRAWL_R2 + 1, 0 | SF_QUICK_CALL, &AF(DoFootPrints), &s_PlayerNinjaCrawl[2][3]},
{PLAYER_NINJA_CRAWL_R2 + 2, PLAYER_NINJA_CRAWL_RATE, nullptr, &s_PlayerNinjaCrawl[2][4]},
{PLAYER_NINJA_CRAWL_R2 + 1, PLAYER_NINJA_CRAWL_RATE, nullptr, &s_PlayerNinjaCrawl[2][5]},
{PLAYER_NINJA_CRAWL_R2 + 1, 0 | SF_QUICK_CALL, &AF(DoFootPrints), &s_PlayerNinjaCrawl[2][0]},
},
{
{PLAYER_NINJA_CRAWL_R3 + 0, PLAYER_NINJA_CRAWL_RATE, nullptr, &s_PlayerNinjaCrawl[3][1]},
{PLAYER_NINJA_CRAWL_R3 + 1, PLAYER_NINJA_CRAWL_RATE, nullptr, &s_PlayerNinjaCrawl[3][2]},
{PLAYER_NINJA_CRAWL_R3 + 1, 0 | SF_QUICK_CALL, &AF(DoFootPrints), &s_PlayerNinjaCrawl[3][3]},
{PLAYER_NINJA_CRAWL_R3 + 2, PLAYER_NINJA_CRAWL_RATE, nullptr, &s_PlayerNinjaCrawl[3][4]},
{PLAYER_NINJA_CRAWL_R3 + 1, PLAYER_NINJA_CRAWL_RATE, nullptr, &s_PlayerNinjaCrawl[3][5]},
{PLAYER_NINJA_CRAWL_R3 + 1, 0 | SF_QUICK_CALL, &AF(DoFootPrints), &s_PlayerNinjaCrawl[3][0]},
},
{
{PLAYER_NINJA_CRAWL_R4 + 0, PLAYER_NINJA_CRAWL_RATE, nullptr, &s_PlayerNinjaCrawl[4][1]},
{PLAYER_NINJA_CRAWL_R4 + 1, PLAYER_NINJA_CRAWL_RATE, nullptr, &s_PlayerNinjaCrawl[4][2]},
{PLAYER_NINJA_CRAWL_R4 + 1, 0 | SF_QUICK_CALL, &AF(DoFootPrints), &s_PlayerNinjaCrawl[4][3]},
{PLAYER_NINJA_CRAWL_R4 + 2, PLAYER_NINJA_CRAWL_RATE, nullptr, &s_PlayerNinjaCrawl[4][4]},
{PLAYER_NINJA_CRAWL_R4 + 1, PLAYER_NINJA_CRAWL_RATE, nullptr, &s_PlayerNinjaCrawl[4][5]},
{PLAYER_NINJA_CRAWL_R4 + 1, 0 | SF_QUICK_CALL, &AF(DoFootPrints), &s_PlayerNinjaCrawl[4][0]},
{SPR_PLAYER_NINJA_CRAWL, 'A', PLAYER_NINJA_CRAWL_RATE, nullptr, &s_PlayerNinjaCrawl[0][1]},
{SPR_PLAYER_NINJA_CRAWL, 'B', PLAYER_NINJA_CRAWL_RATE, nullptr, &s_PlayerNinjaCrawl[0][2]},
{SPR_PLAYER_NINJA_CRAWL, 'B', 0 | SF_QUICK_CALL, &AF(DoFootPrints), &s_PlayerNinjaCrawl[0][3]},
{SPR_PLAYER_NINJA_CRAWL, 'C', PLAYER_NINJA_CRAWL_RATE, nullptr, &s_PlayerNinjaCrawl[0][4]},
{SPR_PLAYER_NINJA_CRAWL, 'B', PLAYER_NINJA_CRAWL_RATE, nullptr, &s_PlayerNinjaCrawl[0][5]},
{SPR_PLAYER_NINJA_CRAWL, 'B', 0 | SF_QUICK_CALL, &AF(DoFootPrints), &s_PlayerNinjaCrawl[0][0]},
},
};
@ -553,10 +365,6 @@ STATE s_PlayerNinjaCrawl[5][6] =
STATE* sg_PlayerNinjaCrawl[] =
{
s_PlayerNinjaCrawl[0],
s_PlayerNinjaCrawl[1],
s_PlayerNinjaCrawl[2],
s_PlayerNinjaCrawl[3],
s_PlayerNinjaCrawl[4]
};
//////////////////////
@ -567,37 +375,13 @@ STATE* sg_PlayerNinjaCrawl[] =
#define PLAYER_NINJA_SWIM_RATE 22 // Was 18
STATE s_PlayerNinjaSwim[5][4] =
STATE s_PlayerNinjaSwim[1][4] =
{
{
{PLAYER_NINJA_SWIM_R0 + 0, PLAYER_NINJA_SWIM_RATE, nullptr, &s_PlayerNinjaSwim[0][1]},
{PLAYER_NINJA_SWIM_R0 + 1, PLAYER_NINJA_SWIM_RATE, nullptr, &s_PlayerNinjaSwim[0][2]},
{PLAYER_NINJA_SWIM_R0 + 2, PLAYER_NINJA_SWIM_RATE, nullptr, &s_PlayerNinjaSwim[0][3]},
{PLAYER_NINJA_SWIM_R0 + 3, PLAYER_NINJA_SWIM_RATE, nullptr, &s_PlayerNinjaSwim[0][0]},
},
{
{PLAYER_NINJA_SWIM_R1 + 0, PLAYER_NINJA_SWIM_RATE, nullptr, &s_PlayerNinjaSwim[1][1]},
{PLAYER_NINJA_SWIM_R1 + 1, PLAYER_NINJA_SWIM_RATE, nullptr, &s_PlayerNinjaSwim[1][2]},
{PLAYER_NINJA_SWIM_R1 + 2, PLAYER_NINJA_SWIM_RATE, nullptr, &s_PlayerNinjaSwim[1][3]},
{PLAYER_NINJA_SWIM_R1 + 3, PLAYER_NINJA_SWIM_RATE, nullptr, &s_PlayerNinjaSwim[1][0]},
},
{
{PLAYER_NINJA_SWIM_R2 + 0, PLAYER_NINJA_SWIM_RATE, nullptr, &s_PlayerNinjaSwim[2][1]},
{PLAYER_NINJA_SWIM_R2 + 1, PLAYER_NINJA_SWIM_RATE, nullptr, &s_PlayerNinjaSwim[2][2]},
{PLAYER_NINJA_SWIM_R2 + 2, PLAYER_NINJA_SWIM_RATE, nullptr, &s_PlayerNinjaSwim[2][3]},
{PLAYER_NINJA_SWIM_R2 + 3, PLAYER_NINJA_SWIM_RATE, nullptr, &s_PlayerNinjaSwim[2][0]},
},
{
{PLAYER_NINJA_SWIM_R3 + 0, PLAYER_NINJA_SWIM_RATE, nullptr, &s_PlayerNinjaSwim[3][1]},
{PLAYER_NINJA_SWIM_R3 + 1, PLAYER_NINJA_SWIM_RATE, nullptr, &s_PlayerNinjaSwim[3][2]},
{PLAYER_NINJA_SWIM_R3 + 2, PLAYER_NINJA_SWIM_RATE, nullptr, &s_PlayerNinjaSwim[3][3]},
{PLAYER_NINJA_SWIM_R3 + 3, PLAYER_NINJA_SWIM_RATE, nullptr, &s_PlayerNinjaSwim[3][0]},
},
{
{PLAYER_NINJA_SWIM_R4 + 0, PLAYER_NINJA_SWIM_RATE, nullptr, &s_PlayerNinjaSwim[4][1]},
{PLAYER_NINJA_SWIM_R4 + 1, PLAYER_NINJA_SWIM_RATE, nullptr, &s_PlayerNinjaSwim[4][2]},
{PLAYER_NINJA_SWIM_R4 + 2, PLAYER_NINJA_SWIM_RATE, nullptr, &s_PlayerNinjaSwim[4][3]},
{PLAYER_NINJA_SWIM_R4 + 3, PLAYER_NINJA_SWIM_RATE, nullptr, &s_PlayerNinjaSwim[4][0]},
{SPR_PLAYER_NINJA_SWIM, 'A', PLAYER_NINJA_SWIM_RATE, nullptr, &s_PlayerNinjaSwim[0][1]},
{SPR_PLAYER_NINJA_SWIM, 'B', PLAYER_NINJA_SWIM_RATE, nullptr, &s_PlayerNinjaSwim[0][2]},
{SPR_PLAYER_NINJA_SWIM, 'C', PLAYER_NINJA_SWIM_RATE, nullptr, &s_PlayerNinjaSwim[0][3]},
{SPR_PLAYER_NINJA_SWIM, 'D', PLAYER_NINJA_SWIM_RATE, nullptr, &s_PlayerNinjaSwim[0][0]},
},
};
@ -605,224 +389,78 @@ STATE s_PlayerNinjaSwim[5][4] =
STATE* sg_PlayerNinjaSwim[] =
{
s_PlayerNinjaSwim[0],
s_PlayerNinjaSwim[1],
s_PlayerNinjaSwim[2],
s_PlayerNinjaSwim[3],
s_PlayerNinjaSwim[4]
};
#define NINJA_HeadHurl_RATE 16
#define NINJA_Head_RATE 16
#define NINJA_HeadFly 1134
#define NINJA_HeadFly_RATE 16
STATE s_PlayerHeadFly[5][8] =
STATE s_PlayerHeadFly[1][8] =
{
{
{NINJA_HeadFly + 0, NINJA_HeadFly_RATE, nullptr, &s_PlayerHeadFly[0][1]},
{NINJA_HeadFly + 1, NINJA_HeadFly_RATE, nullptr, &s_PlayerHeadFly[0][2]},
{NINJA_HeadFly + 2, NINJA_HeadFly_RATE, nullptr, &s_PlayerHeadFly[0][3]},
{NINJA_HeadFly + 3, NINJA_HeadFly_RATE, nullptr, &s_PlayerHeadFly[0][4]},
{NINJA_HeadFly + 4, NINJA_HeadFly_RATE, nullptr, &s_PlayerHeadFly[0][5]},
{NINJA_HeadFly + 5, NINJA_HeadFly_RATE, nullptr, &s_PlayerHeadFly[0][6]},
{NINJA_HeadFly + 6, NINJA_HeadFly_RATE, nullptr, &s_PlayerHeadFly[0][7]},
{NINJA_HeadFly + 7, NINJA_HeadFly_RATE, nullptr, &s_PlayerHeadFly[0][0]}
},
{
{NINJA_HeadFly + 0, NINJA_HeadFly_RATE, nullptr, &s_PlayerHeadFly[1][1]},
{NINJA_HeadFly + 1, NINJA_HeadFly_RATE, nullptr, &s_PlayerHeadFly[1][2]},
{NINJA_HeadFly + 2, NINJA_HeadFly_RATE, nullptr, &s_PlayerHeadFly[1][3]},
{NINJA_HeadFly + 3, NINJA_HeadFly_RATE, nullptr, &s_PlayerHeadFly[1][4]},
{NINJA_HeadFly + 4, NINJA_HeadFly_RATE, nullptr, &s_PlayerHeadFly[1][5]},
{NINJA_HeadFly + 5, NINJA_HeadFly_RATE, nullptr, &s_PlayerHeadFly[1][6]},
{NINJA_HeadFly + 6, NINJA_HeadFly_RATE, nullptr, &s_PlayerHeadFly[1][7]},
{NINJA_HeadFly + 7, NINJA_HeadFly_RATE, nullptr, &s_PlayerHeadFly[1][0]}
},
{
{NINJA_HeadFly + 0, NINJA_HeadFly_RATE, nullptr, &s_PlayerHeadFly[2][1]},
{NINJA_HeadFly + 1, NINJA_HeadFly_RATE, nullptr, &s_PlayerHeadFly[2][2]},
{NINJA_HeadFly + 2, NINJA_HeadFly_RATE, nullptr, &s_PlayerHeadFly[2][3]},
{NINJA_HeadFly + 3, NINJA_HeadFly_RATE, nullptr, &s_PlayerHeadFly[2][4]},
{NINJA_HeadFly + 4, NINJA_HeadFly_RATE, nullptr, &s_PlayerHeadFly[2][5]},
{NINJA_HeadFly + 5, NINJA_HeadFly_RATE, nullptr, &s_PlayerHeadFly[2][6]},
{NINJA_HeadFly + 6, NINJA_HeadFly_RATE, nullptr, &s_PlayerHeadFly[2][7]},
{NINJA_HeadFly + 7, NINJA_HeadFly_RATE, nullptr, &s_PlayerHeadFly[2][0]}
},
{
{NINJA_HeadFly + 0, NINJA_HeadFly_RATE, nullptr, &s_PlayerHeadFly[3][1]},
{NINJA_HeadFly + 1, NINJA_HeadFly_RATE, nullptr, &s_PlayerHeadFly[3][2]},
{NINJA_HeadFly + 2, NINJA_HeadFly_RATE, nullptr, &s_PlayerHeadFly[3][3]},
{NINJA_HeadFly + 3, NINJA_HeadFly_RATE, nullptr, &s_PlayerHeadFly[3][4]},
{NINJA_HeadFly + 4, NINJA_HeadFly_RATE, nullptr, &s_PlayerHeadFly[3][5]},
{NINJA_HeadFly + 5, NINJA_HeadFly_RATE, nullptr, &s_PlayerHeadFly[3][6]},
{NINJA_HeadFly + 6, NINJA_HeadFly_RATE, nullptr, &s_PlayerHeadFly[3][7]},
{NINJA_HeadFly + 7, NINJA_HeadFly_RATE, nullptr, &s_PlayerHeadFly[3][0]}
},
{
{NINJA_HeadFly + 0, NINJA_HeadFly_RATE, nullptr, &s_PlayerHeadFly[4][1]},
{NINJA_HeadFly + 1, NINJA_HeadFly_RATE, nullptr, &s_PlayerHeadFly[4][2]},
{NINJA_HeadFly + 2, NINJA_HeadFly_RATE, nullptr, &s_PlayerHeadFly[4][3]},
{NINJA_HeadFly + 3, NINJA_HeadFly_RATE, nullptr, &s_PlayerHeadFly[4][4]},
{NINJA_HeadFly + 4, NINJA_HeadFly_RATE, nullptr, &s_PlayerHeadFly[4][5]},
{NINJA_HeadFly + 5, NINJA_HeadFly_RATE, nullptr, &s_PlayerHeadFly[4][6]},
{NINJA_HeadFly + 6, NINJA_HeadFly_RATE, nullptr, &s_PlayerHeadFly[4][7]},
{NINJA_HeadFly + 7, NINJA_HeadFly_RATE, nullptr, &s_PlayerHeadFly[4][0]}
{SPR_NINJA_HeadFly, 'A', NINJA_HeadFly_RATE, nullptr, &s_PlayerHeadFly[0][1]},
{SPR_NINJA_HeadFly, 'B', NINJA_HeadFly_RATE, nullptr, &s_PlayerHeadFly[0][2]},
{SPR_NINJA_HeadFly, 'C', NINJA_HeadFly_RATE, nullptr, &s_PlayerHeadFly[0][3]},
{SPR_NINJA_HeadFly, 'D', NINJA_HeadFly_RATE, nullptr, &s_PlayerHeadFly[0][4]},
{SPR_NINJA_HeadFly, 'E', NINJA_HeadFly_RATE, nullptr, &s_PlayerHeadFly[0][5]},
{SPR_NINJA_HeadFly, 'F', NINJA_HeadFly_RATE, nullptr, &s_PlayerHeadFly[0][6]},
{SPR_NINJA_HeadFly, 'G', NINJA_HeadFly_RATE, nullptr, &s_PlayerHeadFly[0][7]},
{SPR_NINJA_HeadFly, 'H', NINJA_HeadFly_RATE, nullptr, &s_PlayerHeadFly[0][0]}
},
};
STATE* sg_PlayerHeadFly[] =
{
s_PlayerHeadFly[0],
s_PlayerHeadFly[1],
s_PlayerHeadFly[2],
s_PlayerHeadFly[3],
s_PlayerHeadFly[4]
};
//#define NINJA_Head_FRAMES 1
//#define NINJA_Head_R0 1142
//#define NINJA_Head_R1 NINJA_Head_R0 + (NINJA_Head_FRAMES * 1)
//#define NINJA_Head_R2 NINJA_Head_R0 + (NINJA_Head_FRAMES * 2)
//#define NINJA_Head_R3 NINJA_Head_R0 + (NINJA_Head_FRAMES * 3)
//#define NINJA_Head_R4 NINJA_Head_R0 + (NINJA_Head_FRAMES * 4)
STATE s_PlayerHead[5][1] =
STATE s_PlayerHead[1][1] =
{
{
{NINJA_Head_R0 + 0, NINJA_Head_RATE, nullptr, &s_PlayerHead[0][0]},
},
{
{NINJA_Head_R1 + 0, NINJA_Head_RATE, nullptr, &s_PlayerHead[1][0]},
},
{
{NINJA_Head_R2 + 0, NINJA_Head_RATE, nullptr, &s_PlayerHead[2][0]},
},
{
{NINJA_Head_R3 + 0, NINJA_Head_RATE, nullptr, &s_PlayerHead[3][0]},
},
{
{NINJA_Head_R4 + 0, NINJA_Head_RATE, nullptr, &s_PlayerHead[4][0]},
{SPR_NINJA_Head, 'A', NINJA_Head_RATE, nullptr, &s_PlayerHead[0][0]},
},
};
STATE* sg_PlayerHead[] =
{
s_PlayerHead[0],
s_PlayerHead[1],
s_PlayerHead[2],
s_PlayerHead[3],
s_PlayerHead[4]
};
#define NINJA_HeadHurl_FRAMES 1
#define NINJA_HeadHurl_R0 1147
#define NINJA_HeadHurl_R1 NINJA_HeadHurl_R0 + (NINJA_HeadHurl_FRAMES * 1)
#define NINJA_HeadHurl_R2 NINJA_HeadHurl_R0 + (NINJA_HeadHurl_FRAMES * 2)
#define NINJA_HeadHurl_R3 NINJA_HeadHurl_R0 + (NINJA_HeadHurl_FRAMES * 3)
#define NINJA_HeadHurl_R4 NINJA_HeadHurl_R0 + (NINJA_HeadHurl_FRAMES * 4)
STATE s_PlayerHeadHurl[5][1] =
STATE s_PlayerHeadHurl[1][1] =
{
{
{NINJA_HeadHurl_R0 + 0, NINJA_HeadHurl_RATE, nullptr, &s_PlayerHeadHurl[0][0]},
},
{
{NINJA_HeadHurl_R1 + 0, NINJA_HeadHurl_RATE, nullptr, &s_PlayerHeadHurl[1][0]},
},
{
{NINJA_HeadHurl_R2 + 0, NINJA_HeadHurl_RATE, nullptr, &s_PlayerHeadHurl[2][0]},
},
{
{NINJA_HeadHurl_R3 + 0, NINJA_HeadHurl_RATE, nullptr, &s_PlayerHeadHurl[3][0]},
},
{
{NINJA_HeadHurl_R4 + 0, NINJA_HeadHurl_RATE, nullptr, &s_PlayerHeadHurl[4][0]},
{SPR_NINJA_HeadHurl, 'A', NINJA_HeadHurl_RATE, nullptr, &s_PlayerHeadHurl[0][0]},
},
};
STATE* sg_PlayerHeadHurl[] =
{
s_PlayerHeadHurl[0],
s_PlayerHeadHurl[1],
s_PlayerHeadHurl[2],
s_PlayerHeadHurl[3],
s_PlayerHeadHurl[4]
};
#define PLAYER_NINJA_DIE_RATE 22
STATE s_PlayerDeath[5][10] =
STATE s_PlayerDeath[1][10] =
{
{
{PLAYER_NINJA_DIE + 0, PLAYER_NINJA_DIE_RATE, nullptr, &s_PlayerDeath[0][1]},
{PLAYER_NINJA_DIE + 1, PLAYER_NINJA_DIE_RATE, nullptr, &s_PlayerDeath[0][2]},
{PLAYER_NINJA_DIE + 2, PLAYER_NINJA_DIE_RATE, nullptr, &s_PlayerDeath[0][3]},
{PLAYER_NINJA_DIE + 3, PLAYER_NINJA_DIE_RATE, nullptr, &s_PlayerDeath[0][4]},
{PLAYER_NINJA_DIE + 4, PLAYER_NINJA_DIE_RATE, nullptr, &s_PlayerDeath[0][5]},
{PLAYER_NINJA_DIE + 5, PLAYER_NINJA_DIE_RATE, nullptr, &s_PlayerDeath[0][6]},
{PLAYER_NINJA_DIE + 6, PLAYER_NINJA_DIE_RATE, nullptr, &s_PlayerDeath[0][7]},
{PLAYER_NINJA_DIE + 7, PLAYER_NINJA_DIE_RATE, nullptr, &s_PlayerDeath[0][8]},
{PLAYER_NINJA_DIE + 8, 0 | SF_QUICK_CALL, &AF(QueueFloorBlood), &s_PlayerDeath[0][9]},
{PLAYER_NINJA_DIE + 8, PLAYER_NINJA_DIE_RATE, nullptr, &s_PlayerDeath[0][9]},
},
{
{PLAYER_NINJA_DIE + 0, PLAYER_NINJA_DIE_RATE, nullptr, &s_PlayerDeath[1][1]},
{PLAYER_NINJA_DIE + 1, PLAYER_NINJA_DIE_RATE, nullptr, &s_PlayerDeath[1][2]},
{PLAYER_NINJA_DIE + 2, PLAYER_NINJA_DIE_RATE, nullptr, &s_PlayerDeath[1][3]},
{PLAYER_NINJA_DIE + 3, PLAYER_NINJA_DIE_RATE, nullptr, &s_PlayerDeath[1][4]},
{PLAYER_NINJA_DIE + 4, PLAYER_NINJA_DIE_RATE, nullptr, &s_PlayerDeath[1][5]},
{PLAYER_NINJA_DIE + 5, PLAYER_NINJA_DIE_RATE, nullptr, &s_PlayerDeath[1][6]},
{PLAYER_NINJA_DIE + 6, PLAYER_NINJA_DIE_RATE, nullptr, &s_PlayerDeath[1][7]},
{PLAYER_NINJA_DIE + 7, PLAYER_NINJA_DIE_RATE, nullptr, &s_PlayerDeath[1][8]},
{PLAYER_NINJA_DIE + 8, 0 | SF_QUICK_CALL, &AF(QueueFloorBlood), &s_PlayerDeath[1][9]},
{PLAYER_NINJA_DIE + 8, PLAYER_NINJA_DIE_RATE, nullptr, &s_PlayerDeath[1][9]},
},
{
{PLAYER_NINJA_DIE + 0, PLAYER_NINJA_DIE_RATE, nullptr, &s_PlayerDeath[2][1]},
{PLAYER_NINJA_DIE + 1, PLAYER_NINJA_DIE_RATE, nullptr, &s_PlayerDeath[2][2]},
{PLAYER_NINJA_DIE + 2, PLAYER_NINJA_DIE_RATE, nullptr, &s_PlayerDeath[2][3]},
{PLAYER_NINJA_DIE + 3, PLAYER_NINJA_DIE_RATE, nullptr, &s_PlayerDeath[2][4]},
{PLAYER_NINJA_DIE + 4, PLAYER_NINJA_DIE_RATE, nullptr, &s_PlayerDeath[2][5]},
{PLAYER_NINJA_DIE + 5, PLAYER_NINJA_DIE_RATE, nullptr, &s_PlayerDeath[2][6]},
{PLAYER_NINJA_DIE + 6, PLAYER_NINJA_DIE_RATE, nullptr, &s_PlayerDeath[2][7]},
{PLAYER_NINJA_DIE + 7, PLAYER_NINJA_DIE_RATE, nullptr, &s_PlayerDeath[2][8]},
{PLAYER_NINJA_DIE + 8, 0 | SF_QUICK_CALL, &AF(QueueFloorBlood), &s_PlayerDeath[2][9]},
{PLAYER_NINJA_DIE + 8, PLAYER_NINJA_DIE_RATE, nullptr, &s_PlayerDeath[2][9]},
},
{
{PLAYER_NINJA_DIE + 0, PLAYER_NINJA_DIE_RATE, nullptr, &s_PlayerDeath[3][1]},
{PLAYER_NINJA_DIE + 1, PLAYER_NINJA_DIE_RATE, nullptr, &s_PlayerDeath[3][2]},
{PLAYER_NINJA_DIE + 2, PLAYER_NINJA_DIE_RATE, nullptr, &s_PlayerDeath[3][3]},
{PLAYER_NINJA_DIE + 3, PLAYER_NINJA_DIE_RATE, nullptr, &s_PlayerDeath[3][4]},
{PLAYER_NINJA_DIE + 4, PLAYER_NINJA_DIE_RATE, nullptr, &s_PlayerDeath[3][5]},
{PLAYER_NINJA_DIE + 5, PLAYER_NINJA_DIE_RATE, nullptr, &s_PlayerDeath[3][6]},
{PLAYER_NINJA_DIE + 6, PLAYER_NINJA_DIE_RATE, nullptr, &s_PlayerDeath[3][7]},
{PLAYER_NINJA_DIE + 7, PLAYER_NINJA_DIE_RATE, nullptr, &s_PlayerDeath[3][8]},
{PLAYER_NINJA_DIE + 8, 0 | SF_QUICK_CALL, &AF(QueueFloorBlood), &s_PlayerDeath[3][9]},
{PLAYER_NINJA_DIE + 8, PLAYER_NINJA_DIE_RATE, nullptr, &s_PlayerDeath[3][9]},
},
{
{PLAYER_NINJA_DIE + 0, PLAYER_NINJA_DIE_RATE, nullptr, &s_PlayerDeath[4][1]},
{PLAYER_NINJA_DIE + 1, PLAYER_NINJA_DIE_RATE, nullptr, &s_PlayerDeath[4][2]},
{PLAYER_NINJA_DIE + 2, PLAYER_NINJA_DIE_RATE, nullptr, &s_PlayerDeath[4][3]},
{PLAYER_NINJA_DIE + 3, PLAYER_NINJA_DIE_RATE, nullptr, &s_PlayerDeath[4][4]},
{PLAYER_NINJA_DIE + 4, PLAYER_NINJA_DIE_RATE, nullptr, &s_PlayerDeath[4][5]},
{PLAYER_NINJA_DIE + 5, PLAYER_NINJA_DIE_RATE, nullptr, &s_PlayerDeath[4][6]},
{PLAYER_NINJA_DIE + 6, PLAYER_NINJA_DIE_RATE, nullptr, &s_PlayerDeath[4][7]},
{PLAYER_NINJA_DIE + 7, PLAYER_NINJA_DIE_RATE, nullptr, &s_PlayerDeath[4][8]},
{PLAYER_NINJA_DIE + 8, 0 | SF_QUICK_CALL, &AF(QueueFloorBlood), &s_PlayerDeath[4][9]},
{PLAYER_NINJA_DIE + 8, PLAYER_NINJA_DIE_RATE, nullptr, &s_PlayerDeath[4][9]},
{SPR_PLAYER_NINJA_DIE, 'A', PLAYER_NINJA_DIE_RATE, nullptr, &s_PlayerDeath[0][1]},
{SPR_PLAYER_NINJA_DIE, 'B', PLAYER_NINJA_DIE_RATE, nullptr, &s_PlayerDeath[0][2]},
{SPR_PLAYER_NINJA_DIE, 'C', PLAYER_NINJA_DIE_RATE, nullptr, &s_PlayerDeath[0][3]},
{SPR_PLAYER_NINJA_DIE, 'D', PLAYER_NINJA_DIE_RATE, nullptr, &s_PlayerDeath[0][4]},
{SPR_PLAYER_NINJA_DIE, 'E', PLAYER_NINJA_DIE_RATE, nullptr, &s_PlayerDeath[0][5]},
{SPR_PLAYER_NINJA_DIE, 'F', PLAYER_NINJA_DIE_RATE, nullptr, &s_PlayerDeath[0][6]},
{SPR_PLAYER_NINJA_DIE, 'G', PLAYER_NINJA_DIE_RATE, nullptr, &s_PlayerDeath[0][7]},
{SPR_PLAYER_NINJA_DIE, 'H', PLAYER_NINJA_DIE_RATE, nullptr, &s_PlayerDeath[0][8]},
{SPR_PLAYER_NINJA_DIE, 'I', 0 | SF_QUICK_CALL, &AF(QueueFloorBlood), &s_PlayerDeath[0][9]},
{SPR_PLAYER_NINJA_DIE, 'I', PLAYER_NINJA_DIE_RATE, nullptr, &s_PlayerDeath[0][9]},
},
};
STATE* sg_PlayerDeath[] =
{
s_PlayerDeath[0],
s_PlayerDeath[1],
s_PlayerDeath[2],
s_PlayerDeath[3],
s_PlayerDeath[4]
};
//////////////////////
@ -833,37 +471,13 @@ STATE* sg_PlayerDeath[] =
#define PLAYER_NINJA_SWORD_RATE 12
STATE s_PlayerNinjaSword[5][4] =
STATE s_PlayerNinjaSword[1][4] =
{
{
{PLAYER_NINJA_SWORD_R0 + 0, PLAYER_NINJA_SWORD_RATE, nullptr, &s_PlayerNinjaSword[0][1]},
{PLAYER_NINJA_SWORD_R0 + 1, PLAYER_NINJA_SWORD_RATE, nullptr, &s_PlayerNinjaSword[0][2]},
{PLAYER_NINJA_SWORD_R0 + 2, PLAYER_NINJA_SWORD_RATE, nullptr, &s_PlayerNinjaSword[0][3]},
{PLAYER_NINJA_SWORD_R0 + 2, PLAYER_NINJA_SWORD_RATE | SF_PLAYER_FUNC, &AF(DoPlayerSpriteReset), &s_PlayerNinjaSword[0][0]},
},
{
{PLAYER_NINJA_SWORD_R1 + 0, PLAYER_NINJA_SWORD_RATE, nullptr, &s_PlayerNinjaSword[1][1]},
{PLAYER_NINJA_SWORD_R1 + 1, PLAYER_NINJA_SWORD_RATE, nullptr, &s_PlayerNinjaSword[1][2]},
{PLAYER_NINJA_SWORD_R1 + 2, PLAYER_NINJA_SWORD_RATE, nullptr, &s_PlayerNinjaSword[1][3]},
{PLAYER_NINJA_SWORD_R1 + 2, PLAYER_NINJA_SWORD_RATE | SF_PLAYER_FUNC, &AF(DoPlayerSpriteReset), &s_PlayerNinjaSword[1][0]},
},
{
{PLAYER_NINJA_SWORD_R2 + 0, PLAYER_NINJA_SWORD_RATE, nullptr, &s_PlayerNinjaSword[2][1]},
{PLAYER_NINJA_SWORD_R2 + 1, PLAYER_NINJA_SWORD_RATE, nullptr, &s_PlayerNinjaSword[2][2]},
{PLAYER_NINJA_SWORD_R2 + 2, PLAYER_NINJA_SWORD_RATE, nullptr, &s_PlayerNinjaSword[2][3]},
{PLAYER_NINJA_SWORD_R2 + 2, PLAYER_NINJA_SWORD_RATE | SF_PLAYER_FUNC, &AF(DoPlayerSpriteReset), &s_PlayerNinjaSword[2][0]},
},
{
{PLAYER_NINJA_SWORD_R3 + 0, PLAYER_NINJA_SWORD_RATE, nullptr, &s_PlayerNinjaSword[3][1]},
{PLAYER_NINJA_SWORD_R3 + 1, PLAYER_NINJA_SWORD_RATE, nullptr, &s_PlayerNinjaSword[3][2]},
{PLAYER_NINJA_SWORD_R3 + 2, PLAYER_NINJA_SWORD_RATE, nullptr, &s_PlayerNinjaSword[3][3]},
{PLAYER_NINJA_SWORD_R3 + 2, PLAYER_NINJA_SWORD_RATE | SF_PLAYER_FUNC, &AF(DoPlayerSpriteReset), &s_PlayerNinjaSword[3][0]},
},
{
{PLAYER_NINJA_SWORD_R4 + 0, PLAYER_NINJA_SWORD_RATE, nullptr, &s_PlayerNinjaSword[4][1]},
{PLAYER_NINJA_SWORD_R4 + 1, PLAYER_NINJA_SWORD_RATE, nullptr, &s_PlayerNinjaSword[4][2]},
{PLAYER_NINJA_SWORD_R4 + 2, PLAYER_NINJA_SWORD_RATE, nullptr, &s_PlayerNinjaSword[4][3]},
{PLAYER_NINJA_SWORD_R4 + 2, PLAYER_NINJA_SWORD_RATE | SF_PLAYER_FUNC, &AF(DoPlayerSpriteReset), &s_PlayerNinjaSword[4][0]},
{SPR_PLAYER_NINJA_SWORD, 'A', PLAYER_NINJA_SWORD_RATE, nullptr, &s_PlayerNinjaSword[0][1]},
{SPR_PLAYER_NINJA_SWORD, 'B', PLAYER_NINJA_SWORD_RATE, nullptr, &s_PlayerNinjaSword[0][2]},
{SPR_PLAYER_NINJA_SWORD, 'C', PLAYER_NINJA_SWORD_RATE, nullptr, &s_PlayerNinjaSword[0][3]},
{SPR_PLAYER_NINJA_SWORD, 'C', PLAYER_NINJA_SWORD_RATE | SF_PLAYER_FUNC, &AF(DoPlayerSpriteReset), &s_PlayerNinjaSword[0][0]},
},
};
@ -871,10 +485,6 @@ STATE s_PlayerNinjaSword[5][4] =
STATE* sg_PlayerNinjaSword[] =
{
s_PlayerNinjaSword[0],
s_PlayerNinjaSword[1],
s_PlayerNinjaSword[2],
s_PlayerNinjaSword[3],
s_PlayerNinjaSword[4]
};
//////////////////////
@ -885,32 +495,12 @@ STATE* sg_PlayerNinjaSword[] =
#define PLAYER_NINJA_PUNCH_RATE 15
STATE s_PlayerNinjaPunch[5][4] =
STATE s_PlayerNinjaPunch[1][4] =
{
{
{PLAYER_NINJA_PUNCH_R0 + 0, PLAYER_NINJA_PUNCH_RATE, nullptr, &s_PlayerNinjaPunch[0][1]},
{PLAYER_NINJA_PUNCH_R0 + 1, PLAYER_NINJA_PUNCH_RATE, nullptr, &s_PlayerNinjaPunch[0][2]},
{PLAYER_NINJA_PUNCH_R0 + 1, PLAYER_NINJA_PUNCH_RATE | SF_PLAYER_FUNC, &AF(DoPlayerSpriteReset), &s_PlayerNinjaPunch[0][2]},
},
{
{PLAYER_NINJA_PUNCH_R1 + 0, PLAYER_NINJA_PUNCH_RATE, nullptr, &s_PlayerNinjaPunch[1][1]},
{PLAYER_NINJA_PUNCH_R1 + 1, PLAYER_NINJA_PUNCH_RATE, nullptr, &s_PlayerNinjaPunch[1][2]},
{PLAYER_NINJA_PUNCH_R1 + 1, PLAYER_NINJA_PUNCH_RATE | SF_PLAYER_FUNC, &AF(DoPlayerSpriteReset), &s_PlayerNinjaPunch[1][2]},
},
{
{PLAYER_NINJA_PUNCH_R2 + 0, PLAYER_NINJA_PUNCH_RATE, nullptr, &s_PlayerNinjaPunch[2][1]},
{PLAYER_NINJA_PUNCH_R2 + 1, PLAYER_NINJA_PUNCH_RATE, nullptr, &s_PlayerNinjaPunch[2][2]},
{PLAYER_NINJA_PUNCH_R2 + 1, PLAYER_NINJA_PUNCH_RATE | SF_PLAYER_FUNC, &AF(DoPlayerSpriteReset), &s_PlayerNinjaPunch[2][2]},
},
{
{PLAYER_NINJA_PUNCH_R3 + 0, PLAYER_NINJA_PUNCH_RATE, nullptr, &s_PlayerNinjaPunch[3][1]},
{PLAYER_NINJA_PUNCH_R3 + 1, PLAYER_NINJA_PUNCH_RATE, nullptr, &s_PlayerNinjaPunch[3][2]},
{PLAYER_NINJA_PUNCH_R3 + 1, PLAYER_NINJA_PUNCH_RATE | SF_PLAYER_FUNC, &AF(DoPlayerSpriteReset), &s_PlayerNinjaPunch[3][2]},
},
{
{PLAYER_NINJA_PUNCH_R4 + 0, PLAYER_NINJA_PUNCH_RATE, nullptr, &s_PlayerNinjaPunch[4][1]},
{PLAYER_NINJA_PUNCH_R4 + 1, PLAYER_NINJA_PUNCH_RATE, nullptr, &s_PlayerNinjaPunch[4][2]},
{PLAYER_NINJA_PUNCH_R4 + 1, PLAYER_NINJA_PUNCH_RATE | SF_PLAYER_FUNC, &AF(DoPlayerSpriteReset), &s_PlayerNinjaPunch[4][2]},
{SPR_PLAYER_NINJA_PUNCH, 'A', PLAYER_NINJA_PUNCH_RATE, nullptr, &s_PlayerNinjaPunch[0][1]},
{SPR_PLAYER_NINJA_PUNCH, 'B', PLAYER_NINJA_PUNCH_RATE, nullptr, &s_PlayerNinjaPunch[0][2]},
{SPR_PLAYER_NINJA_PUNCH, 'B', PLAYER_NINJA_PUNCH_RATE | SF_PLAYER_FUNC, &AF(DoPlayerSpriteReset), &s_PlayerNinjaPunch[0][2]},
},
};
@ -918,10 +508,6 @@ STATE s_PlayerNinjaPunch[5][4] =
STATE* sg_PlayerNinjaPunch[] =
{
s_PlayerNinjaPunch[0],
s_PlayerNinjaPunch[1],
s_PlayerNinjaPunch[2],
s_PlayerNinjaPunch[3],
s_PlayerNinjaPunch[4]
};
//////////////////////
@ -932,28 +518,11 @@ STATE* sg_PlayerNinjaPunch[] =
#define PLAYER_NINJA_FLY_RATE 15
#define PLAYER_NINJA_FLY_R0 1200
#define PLAYER_NINJA_FLY_R1 1200
#define PLAYER_NINJA_FLY_R2 1200
#define PLAYER_NINJA_FLY_R3 1200
#define PLAYER_NINJA_FLY_R4 1200
STATE s_PlayerNinjaFly[5][4] =
STATE s_PlayerNinjaFly[1][4] =
{
{
{PLAYER_NINJA_FLY_R0 + 0, PLAYER_NINJA_FLY_RATE, nullptr, &s_PlayerNinjaFly[0][0]},
},
{
{PLAYER_NINJA_FLY_R1 + 0, PLAYER_NINJA_FLY_RATE, nullptr, &s_PlayerNinjaFly[1][0]},
},
{
{PLAYER_NINJA_FLY_R2 + 0, PLAYER_NINJA_FLY_RATE, nullptr, &s_PlayerNinjaFly[2][0]},
},
{
{PLAYER_NINJA_FLY_R3 + 0, PLAYER_NINJA_FLY_RATE, nullptr, &s_PlayerNinjaFly[3][0]},
},
{
{PLAYER_NINJA_FLY_R4 + 0, PLAYER_NINJA_FLY_RATE, nullptr, &s_PlayerNinjaFly[4][0]},
{SPR_PLAYER_NINJA_FLY, 'A', PLAYER_NINJA_FLY_RATE, nullptr, &s_PlayerNinjaFly[0][0]},
},
};
@ -961,10 +530,6 @@ STATE s_PlayerNinjaFly[5][4] =
STATE* sg_PlayerNinjaFly[] =
{
s_PlayerNinjaFly[0],
s_PlayerNinjaFly[1],
s_PlayerNinjaFly[2],
s_PlayerNinjaFly[3],
s_PlayerNinjaFly[4]
};
//---------------------------------------------------------------------------
@ -5814,7 +5379,7 @@ void DoPlayerDeathCheckKeys(DSWPlayer* pp)
}
plActor->setStateGroup(NAME_Stand);
plActor->spr.picnum = plActor->user.__legacyState.State->Pic;
plActor->setPicFromState();
plActor->spr.cstat &= ~(CSTAT_SPRITE_YCENTER);
//DoSpawnTeleporterEffect(plActor);
@ -6448,17 +6013,14 @@ void PlayerStateControl(DSWActor* actor)
actor->user.__legacyState.State = actor->user.__legacyState.State->NextState;
}
if (!actor->user.__legacyState.State->Pic)
if (actor->user.__legacyState.State->Sprite == SPR_NULL)
{
NewStateGroup(actor, (STATE* *) actor->user.__legacyState.State->NextState);
}
}
// Set the correct pic
if (actor->user.__legacyState.RotNum > 1)
actor->spr.picnum = actor->user.__legacyState.Rot[0]->Pic;
else
actor->spr.picnum = actor->user.__legacyState.State->Pic;
actor->setPicFromState();
// Call the correct animator
if ((actor->user.__legacyState.State->Tics & SF_PLAYER_FUNC))

382
source/games/sw/src/ripper.cpp
View file

@ -117,48 +117,20 @@ ATTRIBUTE RipperAttrib =
#define RIPPER_RUN_RATE 16
STATE s_RipperRun[5][4] =
STATE s_RipperRun[1][4] =
{
{
{RIPPER_RUN_R0 + 0, RIPPER_RUN_RATE | SF_TIC_ADJUST, &AF(DoRipperMove), &s_RipperRun[0][1]},
{RIPPER_RUN_R0 + 1, RIPPER_RUN_RATE | SF_TIC_ADJUST, &AF(DoRipperMove), &s_RipperRun[0][2]},
{RIPPER_RUN_R0 + 2, RIPPER_RUN_RATE | SF_TIC_ADJUST, &AF(DoRipperMove), &s_RipperRun[0][3]},
{RIPPER_RUN_R0 + 3, RIPPER_RUN_RATE | SF_TIC_ADJUST, &AF(DoRipperMove), &s_RipperRun[0][0]},
{SPR_RIPPER_RUN, 'A', RIPPER_RUN_RATE | SF_TIC_ADJUST, &AF(DoRipperMove), &s_RipperRun[0][1]},
{SPR_RIPPER_RUN, 'B', RIPPER_RUN_RATE | SF_TIC_ADJUST, &AF(DoRipperMove), &s_RipperRun[0][2]},
{SPR_RIPPER_RUN, 'C', RIPPER_RUN_RATE | SF_TIC_ADJUST, &AF(DoRipperMove), &s_RipperRun[0][3]},
{SPR_RIPPER_RUN, 'D', RIPPER_RUN_RATE | SF_TIC_ADJUST, &AF(DoRipperMove), &s_RipperRun[0][0]},
},
{
{RIPPER_RUN_R1 + 0, RIPPER_RUN_RATE | SF_TIC_ADJUST, &AF(DoRipperMove), &s_RipperRun[1][1]},
{RIPPER_RUN_R1 + 1, RIPPER_RUN_RATE | SF_TIC_ADJUST, &AF(DoRipperMove), &s_RipperRun[1][2]},
{RIPPER_RUN_R1 + 2, RIPPER_RUN_RATE | SF_TIC_ADJUST, &AF(DoRipperMove), &s_RipperRun[1][3]},
{RIPPER_RUN_R1 + 3, RIPPER_RUN_RATE | SF_TIC_ADJUST, &AF(DoRipperMove), &s_RipperRun[1][0]},
},
{
{RIPPER_RUN_R2 + 0, RIPPER_RUN_RATE | SF_TIC_ADJUST, &AF(DoRipperMove), &s_RipperRun[2][1]},
{RIPPER_RUN_R2 + 1, RIPPER_RUN_RATE | SF_TIC_ADJUST, &AF(DoRipperMove), &s_RipperRun[2][2]},
{RIPPER_RUN_R2 + 2, RIPPER_RUN_RATE | SF_TIC_ADJUST, &AF(DoRipperMove), &s_RipperRun[2][3]},
{RIPPER_RUN_R2 + 3, RIPPER_RUN_RATE | SF_TIC_ADJUST, &AF(DoRipperMove), &s_RipperRun[2][0]},
},
{
{RIPPER_RUN_R3 + 0, RIPPER_RUN_RATE | SF_TIC_ADJUST, &AF(DoRipperMove), &s_RipperRun[3][1]},
{RIPPER_RUN_R3 + 1, RIPPER_RUN_RATE | SF_TIC_ADJUST, &AF(DoRipperMove), &s_RipperRun[3][2]},
{RIPPER_RUN_R3 + 2, RIPPER_RUN_RATE | SF_TIC_ADJUST, &AF(DoRipperMove), &s_RipperRun[3][3]},
{RIPPER_RUN_R3 + 3, RIPPER_RUN_RATE | SF_TIC_ADJUST, &AF(DoRipperMove), &s_RipperRun[3][0]},
},
{
{RIPPER_RUN_R4 + 0, RIPPER_RUN_RATE | SF_TIC_ADJUST, &AF(DoRipperMove), &s_RipperRun[4][1]},
{RIPPER_RUN_R4 + 1, RIPPER_RUN_RATE | SF_TIC_ADJUST, &AF(DoRipperMove), &s_RipperRun[4][2]},
{RIPPER_RUN_R4 + 2, RIPPER_RUN_RATE | SF_TIC_ADJUST, &AF(DoRipperMove), &s_RipperRun[4][3]},
{RIPPER_RUN_R4 + 3, RIPPER_RUN_RATE | SF_TIC_ADJUST, &AF(DoRipperMove), &s_RipperRun[4][0]},
}
};
STATE* sg_RipperRun[] =
{
&s_RipperRun[0][0],
&s_RipperRun[1][0],
&s_RipperRun[2][0],
&s_RipperRun[3][0],
&s_RipperRun[4][0]
};
//////////////////////
@ -169,22 +141,10 @@ STATE* sg_RipperRun[] =
#define RIPPER_STAND_RATE 12
STATE s_RipperStand[5][1] =
STATE s_RipperStand[1][1] =
{
{
{RIPPER_STAND_R0 + 0, RIPPER_STAND_RATE, &AF(DoRipperMove), &s_RipperStand[0][0]},
},
{
{RIPPER_STAND_R1 + 0, RIPPER_STAND_RATE, &AF(DoRipperMove), &s_RipperStand[1][0]},
},
{
{RIPPER_STAND_R2 + 0, RIPPER_STAND_RATE, &AF(DoRipperMove), &s_RipperStand[2][0]},
},
{
{RIPPER_STAND_R3 + 0, RIPPER_STAND_RATE, &AF(DoRipperMove), &s_RipperStand[3][0]},
},
{
{RIPPER_STAND_R4 + 0, RIPPER_STAND_RATE, &AF(DoRipperMove), &s_RipperStand[4][0]},
{SPR_RIPPER_STAND, 'A', RIPPER_STAND_RATE, &AF(DoRipperMove), &s_RipperStand[0][0]},
},
};
@ -192,10 +152,6 @@ STATE s_RipperStand[5][1] =
STATE* sg_RipperStand[] =
{
s_RipperStand[0],
s_RipperStand[1],
s_RipperStand[2],
s_RipperStand[3],
s_RipperStand[4]
};
//////////////////////
@ -206,68 +162,24 @@ STATE* sg_RipperStand[] =
#define RIPPER_SWIPE_RATE 8
STATE s_RipperSwipe[5][8] =
STATE s_RipperSwipe[1][8] =
{
{
{RIPPER_SWIPE_R0 + 0, RIPPER_SWIPE_RATE, &AF(NullRipper), &s_RipperSwipe[0][1]},
{RIPPER_SWIPE_R0 + 1, RIPPER_SWIPE_RATE, &AF(NullRipper), &s_RipperSwipe[0][2]},
{RIPPER_SWIPE_R0 + 1, 0 | SF_QUICK_CALL, &AF(InitRipperSlash), &s_RipperSwipe[0][3]},
{RIPPER_SWIPE_R0 + 2, RIPPER_SWIPE_RATE, &AF(NullRipper), &s_RipperSwipe[0][4]},
{RIPPER_SWIPE_R0 + 3, RIPPER_SWIPE_RATE, &AF(NullRipper), &s_RipperSwipe[0][5]},
{RIPPER_SWIPE_R0 + 3, 0 | SF_QUICK_CALL, &AF(InitRipperSlash), &s_RipperSwipe[0][6]},
{RIPPER_SWIPE_R0 + 3, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_RipperSwipe[0][7]},
{RIPPER_SWIPE_R0 + 3, RIPPER_SWIPE_RATE, &AF(DoRipperMove), &s_RipperSwipe[0][7]},
{SPR_RIPPER_SWIPE, 'A', RIPPER_SWIPE_RATE, &AF(NullRipper), &s_RipperSwipe[0][1]},
{SPR_RIPPER_SWIPE, 'B', RIPPER_SWIPE_RATE, &AF(NullRipper), &s_RipperSwipe[0][2]},
{SPR_RIPPER_SWIPE, 'B', 0 | SF_QUICK_CALL, &AF(InitRipperSlash), &s_RipperSwipe[0][3]},
{SPR_RIPPER_SWIPE, 'C', RIPPER_SWIPE_RATE, &AF(NullRipper), &s_RipperSwipe[0][4]},
{SPR_RIPPER_SWIPE, 'D', RIPPER_SWIPE_RATE, &AF(NullRipper), &s_RipperSwipe[0][5]},
{SPR_RIPPER_SWIPE, 'D', 0 | SF_QUICK_CALL, &AF(InitRipperSlash), &s_RipperSwipe[0][6]},
{SPR_RIPPER_SWIPE, 'D', 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_RipperSwipe[0][7]},
{SPR_RIPPER_SWIPE, 'D', RIPPER_SWIPE_RATE, &AF(DoRipperMove), &s_RipperSwipe[0][7]},
},
{
{RIPPER_SWIPE_R1 + 0, RIPPER_SWIPE_RATE, &AF(NullRipper), &s_RipperSwipe[1][1]},
{RIPPER_SWIPE_R1 + 1, RIPPER_SWIPE_RATE, &AF(NullRipper), &s_RipperSwipe[1][2]},
{RIPPER_SWIPE_R1 + 1, 0 | SF_QUICK_CALL, &AF(InitRipperSlash), &s_RipperSwipe[1][3]},
{RIPPER_SWIPE_R1 + 2, RIPPER_SWIPE_RATE, &AF(NullRipper), &s_RipperSwipe[1][4]},
{RIPPER_SWIPE_R1 + 3, RIPPER_SWIPE_RATE, &AF(NullRipper), &s_RipperSwipe[1][5]},
{RIPPER_SWIPE_R1 + 3, 0 | SF_QUICK_CALL, &AF(InitRipperSlash), &s_RipperSwipe[1][6]},
{RIPPER_SWIPE_R1 + 3, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_RipperSwipe[1][7]},
{RIPPER_SWIPE_R1 + 3, RIPPER_SWIPE_RATE, &AF(DoRipperMove), &s_RipperSwipe[1][7]},
},
{
{RIPPER_SWIPE_R2 + 0, RIPPER_SWIPE_RATE, &AF(NullRipper), &s_RipperSwipe[2][1]},
{RIPPER_SWIPE_R2 + 1, RIPPER_SWIPE_RATE, &AF(NullRipper), &s_RipperSwipe[2][2]},
{RIPPER_SWIPE_R2 + 1, 0 | SF_QUICK_CALL, &AF(InitRipperSlash), &s_RipperSwipe[2][3]},
{RIPPER_SWIPE_R2 + 2, RIPPER_SWIPE_RATE, &AF(NullRipper), &s_RipperSwipe[2][4]},
{RIPPER_SWIPE_R2 + 3, RIPPER_SWIPE_RATE, &AF(NullRipper), &s_RipperSwipe[2][5]},
{RIPPER_SWIPE_R2 + 3, 0 | SF_QUICK_CALL, &AF(InitRipperSlash), &s_RipperSwipe[2][6]},
{RIPPER_SWIPE_R2 + 3, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_RipperSwipe[2][7]},
{RIPPER_SWIPE_R2 + 3, RIPPER_SWIPE_RATE, &AF(DoRipperMove), &s_RipperSwipe[2][7]},
},
{
{RIPPER_SWIPE_R3 + 0, RIPPER_SWIPE_RATE, &AF(NullRipper), &s_RipperSwipe[3][1]},
{RIPPER_SWIPE_R3 + 1, RIPPER_SWIPE_RATE, &AF(NullRipper), &s_RipperSwipe[3][2]},
{RIPPER_SWIPE_R3 + 1, 0 | SF_QUICK_CALL, &AF(InitRipperSlash), &s_RipperSwipe[3][3]},
{RIPPER_SWIPE_R3 + 2, RIPPER_SWIPE_RATE, &AF(NullRipper), &s_RipperSwipe[3][4]},
{RIPPER_SWIPE_R3 + 3, RIPPER_SWIPE_RATE, &AF(NullRipper), &s_RipperSwipe[3][5]},
{RIPPER_SWIPE_R3 + 3, 0 | SF_QUICK_CALL, &AF(InitRipperSlash), &s_RipperSwipe[3][6]},
{RIPPER_SWIPE_R3 + 3, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_RipperSwipe[3][7]},
{RIPPER_SWIPE_R3 + 3, RIPPER_SWIPE_RATE, &AF(DoRipperMove), &s_RipperSwipe[3][7]},
},
{
{RIPPER_SWIPE_R4 + 0, RIPPER_SWIPE_RATE, &AF(NullRipper), &s_RipperSwipe[4][1]},
{RIPPER_SWIPE_R4 + 1, RIPPER_SWIPE_RATE, &AF(NullRipper), &s_RipperSwipe[4][2]},
{RIPPER_SWIPE_R4 + 1, 0 | SF_QUICK_CALL, &AF(InitRipperSlash), &s_RipperSwipe[4][3]},
{RIPPER_SWIPE_R4 + 2, RIPPER_SWIPE_RATE, &AF(NullRipper), &s_RipperSwipe[4][4]},
{RIPPER_SWIPE_R4 + 3, RIPPER_SWIPE_RATE, &AF(NullRipper), &s_RipperSwipe[4][5]},
{RIPPER_SWIPE_R4 + 3, 0 | SF_QUICK_CALL, &AF(InitRipperSlash), &s_RipperSwipe[4][6]},
{RIPPER_SWIPE_R4 + 3, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_RipperSwipe[4][7]},
{RIPPER_SWIPE_R4 + 3, RIPPER_SWIPE_RATE, &AF(DoRipperMove), &s_RipperSwipe[4][7]},
}
};
STATE* sg_RipperSwipe[] =
{
&s_RipperSwipe[0][0],
&s_RipperSwipe[1][0],
&s_RipperSwipe[2][0],
&s_RipperSwipe[3][0],
&s_RipperSwipe[4][0]
};
@ -279,63 +191,23 @@ STATE* sg_RipperSwipe[] =
#define RIPPER_SPEW_RATE 8
STATE s_RipperSpew[5][7] =
STATE s_RipperSpew[1][7] =
{
{
{RIPPER_SWIPE_R0 + 0, RIPPER_SPEW_RATE, &AF(NullRipper), &s_RipperSpew[0][1]},
{RIPPER_SWIPE_R0 + 1, RIPPER_SPEW_RATE, &AF(NullRipper), &s_RipperSpew[0][2]},
{RIPPER_SWIPE_R0 + 1, 0 | SF_QUICK_CALL, &AF(InitCoolgFire), &s_RipperSpew[0][3]},
{RIPPER_SWIPE_R0 + 2, RIPPER_SPEW_RATE, &AF(NullRipper), &s_RipperSpew[0][4]},
{RIPPER_SWIPE_R0 + 3, RIPPER_SPEW_RATE, &AF(NullRipper), &s_RipperSpew[0][5]},
{RIPPER_SWIPE_R0 + 3, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_RipperSpew[0][6]},
{RIPPER_SWIPE_R0 + 3, RIPPER_SPEW_RATE, &AF(DoRipperMove), &s_RipperSpew[0][6]},
{SPR_RIPPER_SWIPE, 'A', RIPPER_SPEW_RATE, &AF(NullRipper), &s_RipperSpew[0][1]},
{SPR_RIPPER_SWIPE, 'B', RIPPER_SPEW_RATE, &AF(NullRipper), &s_RipperSpew[0][2]},
{SPR_RIPPER_SWIPE, 'B', 0 | SF_QUICK_CALL, &AF(InitCoolgFire), &s_RipperSpew[0][3]},
{SPR_RIPPER_SWIPE, 'C', RIPPER_SPEW_RATE, &AF(NullRipper), &s_RipperSpew[0][4]},
{SPR_RIPPER_SWIPE, 'D', RIPPER_SPEW_RATE, &AF(NullRipper), &s_RipperSpew[0][5]},
{SPR_RIPPER_SWIPE, 'D', 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_RipperSpew[0][6]},
{SPR_RIPPER_SWIPE, 'D', RIPPER_SPEW_RATE, &AF(DoRipperMove), &s_RipperSpew[0][6]},
},
{
{RIPPER_SWIPE_R1 + 0, RIPPER_SPEW_RATE, &AF(NullRipper), &s_RipperSpew[1][1]},
{RIPPER_SWIPE_R1 + 1, RIPPER_SPEW_RATE, &AF(NullRipper), &s_RipperSpew[1][2]},
{RIPPER_SWIPE_R1 + 1, 0 | SF_QUICK_CALL, &AF(InitCoolgFire), &s_RipperSpew[1][3]},
{RIPPER_SWIPE_R1 + 2, RIPPER_SPEW_RATE, &AF(NullRipper), &s_RipperSpew[1][4]},
{RIPPER_SWIPE_R1 + 3, RIPPER_SPEW_RATE, &AF(NullRipper), &s_RipperSpew[1][5]},
{RIPPER_SWIPE_R1 + 3, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_RipperSpew[1][6]},
{RIPPER_SWIPE_R1 + 3, RIPPER_SPEW_RATE, &AF(DoRipperMove), &s_RipperSpew[1][6]},
},
{
{RIPPER_SWIPE_R2 + 0, RIPPER_SPEW_RATE, &AF(NullRipper), &s_RipperSpew[2][1]},
{RIPPER_SWIPE_R2 + 1, RIPPER_SPEW_RATE, &AF(NullRipper), &s_RipperSpew[2][2]},
{RIPPER_SWIPE_R2 + 1, 0 | SF_QUICK_CALL, &AF(InitCoolgFire), &s_RipperSpew[2][3]},
{RIPPER_SWIPE_R2 + 2, RIPPER_SPEW_RATE, &AF(NullRipper), &s_RipperSpew[2][4]},
{RIPPER_SWIPE_R2 + 3, RIPPER_SPEW_RATE, &AF(NullRipper), &s_RipperSpew[2][5]},
{RIPPER_SWIPE_R2 + 3, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_RipperSpew[2][6]},
{RIPPER_SWIPE_R2 + 3, RIPPER_SPEW_RATE, &AF(DoRipperMove), &s_RipperSpew[2][6]},
},
{
{RIPPER_SWIPE_R3 + 0, RIPPER_SPEW_RATE, &AF(NullRipper), &s_RipperSpew[3][1]},
{RIPPER_SWIPE_R3 + 1, RIPPER_SPEW_RATE, &AF(NullRipper), &s_RipperSpew[3][2]},
{RIPPER_SWIPE_R3 + 1, 0 | SF_QUICK_CALL, &AF(InitCoolgFire), &s_RipperSpew[3][3]},
{RIPPER_SWIPE_R3 + 2, RIPPER_SPEW_RATE, &AF(NullRipper), &s_RipperSpew[3][4]},
{RIPPER_SWIPE_R3 + 3, RIPPER_SPEW_RATE, &AF(NullRipper), &s_RipperSpew[3][5]},
{RIPPER_SWIPE_R3 + 3, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_RipperSpew[3][6]},
{RIPPER_SWIPE_R3 + 3, RIPPER_SPEW_RATE, &AF(DoRipperMove), &s_RipperSpew[3][6]},
},
{
{RIPPER_SWIPE_R4 + 0, RIPPER_SPEW_RATE, &AF(NullRipper), &s_RipperSpew[4][1]},
{RIPPER_SWIPE_R4 + 1, RIPPER_SPEW_RATE, &AF(NullRipper), &s_RipperSpew[4][2]},
{RIPPER_SWIPE_R4 + 1, 0 | SF_QUICK_CALL, &AF(InitCoolgFire), &s_RipperSpew[4][3]},
{RIPPER_SWIPE_R4 + 2, RIPPER_SPEW_RATE, &AF(NullRipper), &s_RipperSpew[4][4]},
{RIPPER_SWIPE_R4 + 3, RIPPER_SPEW_RATE, &AF(NullRipper), &s_RipperSpew[4][5]},
{RIPPER_SWIPE_R4 + 3, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_RipperSpew[4][6]},
{RIPPER_SWIPE_R4 + 3, RIPPER_SPEW_RATE, &AF(DoRipperMove), &s_RipperSpew[4][6]},
}
};
STATE* sg_RipperSpew[] =
{
&s_RipperSpew[0][0],
&s_RipperSpew[1][0],
&s_RipperSpew[2][0],
&s_RipperSpew[3][0],
&s_RipperSpew[4][0]
};
@ -347,32 +219,16 @@ STATE* sg_RipperSpew[] =
#define RIPPER_HEART_RATE 14
STATE s_RipperHeart[5][4] =
STATE s_RipperHeart[1][4] =
{
{
{RIPPER_HEART_R0 + 0, RIPPER_HEART_RATE, &AF(DoRipperStandHeart), &s_RipperHeart[0][0]},
{SPR_RIPPER_HEART, 'A', RIPPER_HEART_RATE, &AF(DoRipperStandHeart), &s_RipperHeart[0][0]},
},
{
{RIPPER_HEART_R1 + 0, RIPPER_HEART_RATE, &AF(DoRipperStandHeart), &s_RipperHeart[1][0]},
},
{
{RIPPER_HEART_R2 + 0, RIPPER_HEART_RATE, &AF(DoRipperStandHeart), &s_RipperHeart[2][0]},
},
{
{RIPPER_HEART_R3 + 0, RIPPER_HEART_RATE, &AF(DoRipperStandHeart), &s_RipperHeart[3][0]},
},
{
{RIPPER_HEART_R4 + 0, RIPPER_HEART_RATE, &AF(DoRipperStandHeart), &s_RipperHeart[4][0]},
}
};
STATE* sg_RipperHeart[] =
{
&s_RipperHeart[0][0],
&s_RipperHeart[1][0],
&s_RipperHeart[2][0],
&s_RipperHeart[3][0],
&s_RipperHeart[4][0]
};
//////////////////////
@ -383,33 +239,17 @@ STATE* sg_RipperHeart[] =
#define RIPPER_HANG_RATE 14
STATE s_RipperHang[5][4] =
STATE s_RipperHang[1][4] =
{
{
{RIPPER_HANG_R0 + 0, RIPPER_HANG_RATE, &AF(DoRipperHang), &s_RipperHang[0][0]},
{SPR_RIPPER_HANG, 'A', RIPPER_HANG_RATE, &AF(DoRipperHang), &s_RipperHang[0][0]},
},
{
{RIPPER_HANG_R1 + 0, RIPPER_HANG_RATE, &AF(DoRipperHang), &s_RipperHang[1][0]},
},
{
{RIPPER_HANG_R2 + 0, RIPPER_HANG_RATE, &AF(DoRipperHang), &s_RipperHang[2][0]},
},
{
{RIPPER_HANG_R3 + 0, RIPPER_HANG_RATE, &AF(DoRipperHang), &s_RipperHang[3][0]},
},
{
{RIPPER_HANG_R4 + 0, RIPPER_HANG_RATE, &AF(DoRipperHang), &s_RipperHang[4][0]},
}
};
STATE* sg_RipperHang[] =
{
&s_RipperHang[0][0],
&s_RipperHang[1][0],
&s_RipperHang[2][0],
&s_RipperHang[3][0],
&s_RipperHang[4][0]
};
@ -421,32 +261,16 @@ STATE* sg_RipperHang[] =
#define RIPPER_PAIN_RATE 38
STATE s_RipperPain[5][1] =
STATE s_RipperPain[1][1] =
{
{
{RIPPER_JUMP_R0 + 0, RIPPER_PAIN_RATE, &AF(DoRipperPain), &s_RipperPain[0][0]},
{SPR_RIPPER_JUMP, 'A', RIPPER_PAIN_RATE, &AF(DoRipperPain), &s_RipperPain[0][0]},
},
{
{RIPPER_JUMP_R0 + 0, RIPPER_PAIN_RATE, &AF(DoRipperPain), &s_RipperPain[1][0]},
},
{
{RIPPER_JUMP_R0 + 0, RIPPER_PAIN_RATE, &AF(DoRipperPain), &s_RipperPain[2][0]},
},
{
{RIPPER_JUMP_R0 + 0, RIPPER_PAIN_RATE, &AF(DoRipperPain), &s_RipperPain[3][0]},
},
{
{RIPPER_JUMP_R0 + 0, RIPPER_PAIN_RATE, &AF(DoRipperPain), &s_RipperPain[4][0]},
}
};
STATE* sg_RipperPain[] =
{
&s_RipperPain[0][0],
&s_RipperPain[1][0],
&s_RipperPain[2][0],
&s_RipperPain[3][0],
&s_RipperPain[4][0]
};
//////////////////////
@ -457,38 +281,18 @@ STATE* sg_RipperPain[] =
#define RIPPER_JUMP_RATE 25
STATE s_RipperJump[5][6] =
STATE s_RipperJump[1][6] =
{
{
{RIPPER_JUMP_R0 + 0, RIPPER_JUMP_RATE, &AF(NullRipper), &s_RipperJump[0][1]},
{RIPPER_JUMP_R0 + 1, RIPPER_JUMP_RATE, &AF(DoRipperMoveJump), &s_RipperJump[0][1]},
{SPR_RIPPER_JUMP, 'A', RIPPER_JUMP_RATE, &AF(NullRipper), &s_RipperJump[0][1]},
{SPR_RIPPER_JUMP, 'B', RIPPER_JUMP_RATE, &AF(DoRipperMoveJump), &s_RipperJump[0][1]},
},
{
{RIPPER_JUMP_R1 + 0, RIPPER_JUMP_RATE, &AF(NullRipper), &s_RipperJump[1][1]},
{RIPPER_JUMP_R1 + 1, RIPPER_JUMP_RATE, &AF(DoRipperMoveJump), &s_RipperJump[1][1]},
},
{
{RIPPER_JUMP_R2 + 0, RIPPER_JUMP_RATE, &AF(NullRipper), &s_RipperJump[2][1]},
{RIPPER_JUMP_R2 + 1, RIPPER_JUMP_RATE, &AF(DoRipperMoveJump), &s_RipperJump[2][1]},
},
{
{RIPPER_JUMP_R3 + 0, RIPPER_JUMP_RATE, &AF(NullRipper), &s_RipperJump[3][1]},
{RIPPER_JUMP_R3 + 1, RIPPER_JUMP_RATE, &AF(DoRipperMoveJump), &s_RipperJump[3][1]},
},
{
{RIPPER_JUMP_R4 + 0, RIPPER_JUMP_RATE, &AF(NullRipper), &s_RipperJump[4][1]},
{RIPPER_JUMP_R4 + 1, RIPPER_JUMP_RATE, &AF(DoRipperMoveJump), &s_RipperJump[4][1]},
}
};
STATE* sg_RipperJump[] =
{
&s_RipperJump[0][0],
&s_RipperJump[1][0],
&s_RipperJump[2][0],
&s_RipperJump[3][0],
&s_RipperJump[4][0]
};
@ -500,33 +304,17 @@ STATE* sg_RipperJump[] =
#define RIPPER_FALL_RATE 25
STATE s_RipperFall[5][6] =
STATE s_RipperFall[1][6] =
{
{
{RIPPER_FALL_R0 + 0, RIPPER_FALL_RATE, &AF(DoRipperMoveJump), &s_RipperFall[0][0]},
{SPR_RIPPER_FALL, 'A', RIPPER_FALL_RATE, &AF(DoRipperMoveJump), &s_RipperFall[0][0]},
},
{
{RIPPER_FALL_R1 + 0, RIPPER_FALL_RATE, &AF(DoRipperMoveJump), &s_RipperFall[1][0]},
},
{
{RIPPER_FALL_R2 + 0, RIPPER_FALL_RATE, &AF(DoRipperMoveJump), &s_RipperFall[2][0]},
},
{
{RIPPER_FALL_R3 + 0, RIPPER_FALL_RATE, &AF(DoRipperMoveJump), &s_RipperFall[3][0]},
},
{
{RIPPER_FALL_R4 + 0, RIPPER_FALL_RATE, &AF(DoRipperMoveJump), &s_RipperFall[4][0]},
}
};
STATE* sg_RipperFall[] =
{
&s_RipperFall[0][0],
&s_RipperFall[1][0],
&s_RipperFall[2][0],
&s_RipperFall[3][0],
&s_RipperFall[4][0]
};
@ -539,43 +327,19 @@ STATE* sg_RipperFall[] =
#define RIPPER_JUMP_ATTACK_RATE 35
int DoRipperBeginJumpAttack(DSWActor* actor);
STATE s_RipperJumpAttack[5][6] =
STATE s_RipperJumpAttack[1][6] =
{
{
{RIPPER_JUMP_R0 + 0, RIPPER_JUMP_ATTACK_RATE, &AF(NullRipper), &s_RipperJumpAttack[0][1]},
{RIPPER_JUMP_R0 + 0, 0 | SF_QUICK_CALL, &AF(DoRipperBeginJumpAttack), &s_RipperJumpAttack[0][2]},
{RIPPER_JUMP_R0 + 1, RIPPER_JUMP_ATTACK_RATE, &AF(DoRipperMoveJump), &s_RipperJumpAttack[0][2]},
{SPR_RIPPER_JUMP, 'A', RIPPER_JUMP_ATTACK_RATE, &AF(NullRipper), &s_RipperJumpAttack[0][1]},
{SPR_RIPPER_JUMP, 'A', 0 | SF_QUICK_CALL, &AF(DoRipperBeginJumpAttack), &s_RipperJumpAttack[0][2]},
{SPR_RIPPER_JUMP, 'B', RIPPER_JUMP_ATTACK_RATE, &AF(DoRipperMoveJump), &s_RipperJumpAttack[0][2]},
},
{
{RIPPER_JUMP_R1 + 0, RIPPER_JUMP_ATTACK_RATE, &AF(NullRipper), &s_RipperJumpAttack[1][1]},
{RIPPER_JUMP_R1 + 0, 0 | SF_QUICK_CALL, &AF(DoRipperBeginJumpAttack), &s_RipperJumpAttack[1][2]},
{RIPPER_JUMP_R1 + 1, RIPPER_JUMP_ATTACK_RATE, &AF(DoRipperMoveJump), &s_RipperJumpAttack[1][2]},
},
{
{RIPPER_JUMP_R2 + 0, RIPPER_JUMP_ATTACK_RATE, &AF(NullRipper), &s_RipperJumpAttack[2][1]},
{RIPPER_JUMP_R2 + 0, 0 | SF_QUICK_CALL, &AF(DoRipperBeginJumpAttack), &s_RipperJumpAttack[2][2]},
{RIPPER_JUMP_R2 + 1, RIPPER_JUMP_ATTACK_RATE, &AF(DoRipperMoveJump), &s_RipperJumpAttack[2][2]},
},
{
{RIPPER_JUMP_R3 + 0, RIPPER_JUMP_ATTACK_RATE, &AF(NullRipper), &s_RipperJumpAttack[3][1]},
{RIPPER_JUMP_R3 + 0, 0 | SF_QUICK_CALL, &AF(DoRipperBeginJumpAttack), &s_RipperJumpAttack[3][2]},
{RIPPER_JUMP_R3 + 1, RIPPER_JUMP_ATTACK_RATE, &AF(DoRipperMoveJump), &s_RipperJumpAttack[3][2]},
},
{
{RIPPER_JUMP_R4 + 0, RIPPER_JUMP_ATTACK_RATE, &AF(NullRipper), &s_RipperJumpAttack[4][1]},
{RIPPER_JUMP_R4 + 0, 0 | SF_QUICK_CALL, &AF(DoRipperBeginJumpAttack), &s_RipperJumpAttack[4][2]},
{RIPPER_JUMP_R4 + 1, RIPPER_JUMP_ATTACK_RATE, &AF(DoRipperMoveJump), &s_RipperJumpAttack[4][2]},
}
};
STATE* sg_RipperJumpAttack[] =
{
&s_RipperJumpAttack[0][0],
&s_RipperJumpAttack[1][0],
&s_RipperJumpAttack[2][0],
&s_RipperJumpAttack[3][0],
&s_RipperJumpAttack[4][0]
};
@ -587,38 +351,18 @@ STATE* sg_RipperJumpAttack[] =
#define RIPPER_HANG_JUMP_RATE 20
STATE s_RipperHangJump[5][6] =
STATE s_RipperHangJump[1][6] =
{
{
{RIPPER_JUMP_R0 + 0, RIPPER_HANG_JUMP_RATE, &AF(NullRipper), &s_RipperHangJump[0][1]},
{RIPPER_JUMP_R0 + 1, RIPPER_HANG_JUMP_RATE, &AF(DoRipperHangJF), &s_RipperHangJump[0][1]},
{SPR_RIPPER_JUMP, 'A', RIPPER_HANG_JUMP_RATE, &AF(NullRipper), &s_RipperHangJump[0][1]},
{SPR_RIPPER_JUMP, 'B', RIPPER_HANG_JUMP_RATE, &AF(DoRipperHangJF), &s_RipperHangJump[0][1]},
},
{
{RIPPER_JUMP_R1 + 0, RIPPER_HANG_JUMP_RATE, &AF(NullRipper), &s_RipperHangJump[1][1]},
{RIPPER_JUMP_R1 + 1, RIPPER_HANG_JUMP_RATE, &AF(DoRipperHangJF), &s_RipperHangJump[1][1]},
},
{
{RIPPER_JUMP_R2 + 0, RIPPER_HANG_JUMP_RATE, &AF(NullRipper), &s_RipperHangJump[2][1]},
{RIPPER_JUMP_R2 + 1, RIPPER_HANG_JUMP_RATE, &AF(DoRipperHangJF), &s_RipperHangJump[2][1]},
},
{
{RIPPER_JUMP_R3 + 0, RIPPER_HANG_JUMP_RATE, &AF(NullRipper), &s_RipperHangJump[3][1]},
{RIPPER_JUMP_R3 + 1, RIPPER_HANG_JUMP_RATE, &AF(DoRipperHangJF), &s_RipperHangJump[3][1]},
},
{
{RIPPER_JUMP_R4 + 0, RIPPER_HANG_JUMP_RATE, &AF(NullRipper), &s_RipperHangJump[4][1]},
{RIPPER_JUMP_R4 + 1, RIPPER_HANG_JUMP_RATE, &AF(DoRipperHangJF), &s_RipperHangJump[4][1]},
}
};
STATE* sg_RipperHangJump[] =
{
&s_RipperHangJump[0][0],
&s_RipperHangJump[1][0],
&s_RipperHangJump[2][0],
&s_RipperHangJump[3][0],
&s_RipperHangJump[4][0]
};
//////////////////////
@ -629,33 +373,17 @@ STATE* sg_RipperHangJump[] =
#define RIPPER_FALL_RATE 25
STATE s_RipperHangFall[5][6] =
STATE s_RipperHangFall[1][6] =
{
{
{RIPPER_FALL_R0 + 0, RIPPER_FALL_RATE, &AF(DoRipperHangJF), &s_RipperHangFall[0][0]},
{SPR_RIPPER_FALL, 'A', RIPPER_FALL_RATE, &AF(DoRipperHangJF), &s_RipperHangFall[0][0]},
},
{
{RIPPER_FALL_R1 + 0, RIPPER_FALL_RATE, &AF(DoRipperHangJF), &s_RipperHangFall[1][0]},
},
{
{RIPPER_FALL_R2 + 0, RIPPER_FALL_RATE, &AF(DoRipperHangJF), &s_RipperHangFall[2][0]},
},
{
{RIPPER_FALL_R3 + 0, RIPPER_FALL_RATE, &AF(DoRipperHangJF), &s_RipperHangFall[3][0]},
},
{
{RIPPER_FALL_R4 + 0, RIPPER_FALL_RATE, &AF(DoRipperHangJF), &s_RipperHangFall[4][0]},
}
};
STATE* sg_RipperHangFall[] =
{
&s_RipperHangFall[0][0],
&s_RipperHangFall[1][0],
&s_RipperHangFall[2][0],
&s_RipperHangFall[3][0],
&s_RipperHangFall[4][0]
};
@ -670,21 +398,21 @@ STATE* sg_RipperHangFall[] =
STATE s_RipperDie[] =
{
{RIPPER_DIE + 0, RIPPER_DIE_RATE, &AF(NullRipper), &s_RipperDie[1]},
{RIPPER_DIE + 1, RIPPER_DIE_RATE, &AF(NullRipper), &s_RipperDie[2]},
{RIPPER_DIE + 2, RIPPER_DIE_RATE, &AF(NullRipper), &s_RipperDie[3]},
{RIPPER_DIE + 3, RIPPER_DIE_RATE, &AF(NullRipper), &s_RipperDie[4]},
{RIPPER_DEAD, RIPPER_DIE_RATE, &AF(DoActorDebris), &s_RipperDie[4]},
{SPR_RIPPER_DIE, 'A', RIPPER_DIE_RATE, &AF(NullRipper), &s_RipperDie[1]},
{SPR_RIPPER_DIE, 'B', RIPPER_DIE_RATE, &AF(NullRipper), &s_RipperDie[2]},
{SPR_RIPPER_DIE, 'C', RIPPER_DIE_RATE, &AF(NullRipper), &s_RipperDie[3]},
{SPR_RIPPER_DIE, 'D', RIPPER_DIE_RATE, &AF(NullRipper), &s_RipperDie[4]},
{SPR_RIPPER_DEAD, 'A', RIPPER_DIE_RATE, &AF(DoActorDebris), &s_RipperDie[4]},
};
#define RIPPER_DEAD_RATE 8
STATE s_RipperDead[] =
{
{RIPPER_DIE + 2, RIPPER_DEAD_RATE, nullptr, &s_RipperDead[1]},
{RIPPER_DIE + 3, RIPPER_DEAD_RATE, nullptr, &s_RipperDead[2]},
{RIPPER_DEAD, SF_QUICK_CALL, &AF(QueueFloorBlood), &s_RipperDead[3]},
{RIPPER_DEAD, RIPPER_DEAD_RATE, &AF(DoActorDebris), &s_RipperDead[3]},
{SPR_RIPPER_DIE, 'C', RIPPER_DEAD_RATE, nullptr, &s_RipperDead[1]},
{SPR_RIPPER_DIE, 'D', RIPPER_DEAD_RATE, nullptr, &s_RipperDead[2]},
{SPR_RIPPER_DEAD, 'A', SF_QUICK_CALL, &AF(QueueFloorBlood), &s_RipperDead[3]},
{SPR_RIPPER_DEAD, 'A', RIPPER_DEAD_RATE, &AF(DoActorDebris), &s_RipperDead[3]},
};
STATE* sg_RipperDie[] =
@ -699,12 +427,12 @@ STATE* sg_RipperDead[] =
STATE s_RipperDeathJump[] =
{
{RIPPER_DIE + 0, RIPPER_DIE_RATE, &AF(DoActorDeathMove), &s_RipperDeathJump[0]}
{SPR_RIPPER_DIE, 'A', RIPPER_DIE_RATE, &AF(DoActorDeathMove), &s_RipperDeathJump[0]}
};
STATE s_RipperDeathFall[] =
{
{RIPPER_DIE + 1, RIPPER_DIE_RATE, &AF(DoActorDeathMove), &s_RipperDeathFall[0]}
{SPR_RIPPER_DIE, 'B', RIPPER_DIE_RATE, &AF(DoActorDeathMove), &s_RipperDeathFall[0]}
};

448
source/games/sw/src/ripper2.cpp
View file

@ -115,48 +115,20 @@ ATTRIBUTE Ripper2Attrib =
#define RIPPER2_RUN_RATE 16
STATE s_Ripper2Run[5][4] =
STATE s_Ripper2Run[1][4] =
{
{
{RIPPER2_RUN_R0 + 0, RIPPER2_RUN_RATE | SF_TIC_ADJUST, &AF(DoRipper2Move), &s_Ripper2Run[0][1]},
{RIPPER2_RUN_R0 + 1, RIPPER2_RUN_RATE | SF_TIC_ADJUST, &AF(DoRipper2Move), &s_Ripper2Run[0][2]},
{RIPPER2_RUN_R0 + 2, RIPPER2_RUN_RATE | SF_TIC_ADJUST, &AF(DoRipper2Move), &s_Ripper2Run[0][3]},
{RIPPER2_RUN_R0 + 3, RIPPER2_RUN_RATE | SF_TIC_ADJUST, &AF(DoRipper2Move), &s_Ripper2Run[0][0]},
{SPR_RIPPER2_RUN, 'A', RIPPER2_RUN_RATE | SF_TIC_ADJUST, &AF(DoRipper2Move), &s_Ripper2Run[0][1]},
{SPR_RIPPER2_RUN, 'B', RIPPER2_RUN_RATE | SF_TIC_ADJUST, &AF(DoRipper2Move), &s_Ripper2Run[0][2]},
{SPR_RIPPER2_RUN, 'C', RIPPER2_RUN_RATE | SF_TIC_ADJUST, &AF(DoRipper2Move), &s_Ripper2Run[0][3]},
{SPR_RIPPER2_RUN, 'D', RIPPER2_RUN_RATE | SF_TIC_ADJUST, &AF(DoRipper2Move), &s_Ripper2Run[0][0]},
},
{
{RIPPER2_RUN_R1 + 0, RIPPER2_RUN_RATE | SF_TIC_ADJUST, &AF(DoRipper2Move), &s_Ripper2Run[1][1]},
{RIPPER2_RUN_R1 + 1, RIPPER2_RUN_RATE | SF_TIC_ADJUST, &AF(DoRipper2Move), &s_Ripper2Run[1][2]},
{RIPPER2_RUN_R1 + 2, RIPPER2_RUN_RATE | SF_TIC_ADJUST, &AF(DoRipper2Move), &s_Ripper2Run[1][3]},
{RIPPER2_RUN_R1 + 3, RIPPER2_RUN_RATE | SF_TIC_ADJUST, &AF(DoRipper2Move), &s_Ripper2Run[1][0]},
},
{
{RIPPER2_RUN_R2 + 0, RIPPER2_RUN_RATE | SF_TIC_ADJUST, &AF(DoRipper2Move), &s_Ripper2Run[2][1]},
{RIPPER2_RUN_R2 + 1, RIPPER2_RUN_RATE | SF_TIC_ADJUST, &AF(DoRipper2Move), &s_Ripper2Run[2][2]},
{RIPPER2_RUN_R2 + 2, RIPPER2_RUN_RATE | SF_TIC_ADJUST, &AF(DoRipper2Move), &s_Ripper2Run[2][3]},
{RIPPER2_RUN_R2 + 3, RIPPER2_RUN_RATE | SF_TIC_ADJUST, &AF(DoRipper2Move), &s_Ripper2Run[2][0]},
},
{
{RIPPER2_RUN_R3 + 0, RIPPER2_RUN_RATE | SF_TIC_ADJUST, &AF(DoRipper2Move), &s_Ripper2Run[3][1]},
{RIPPER2_RUN_R3 + 1, RIPPER2_RUN_RATE | SF_TIC_ADJUST, &AF(DoRipper2Move), &s_Ripper2Run[3][2]},
{RIPPER2_RUN_R3 + 2, RIPPER2_RUN_RATE | SF_TIC_ADJUST, &AF(DoRipper2Move), &s_Ripper2Run[3][3]},
{RIPPER2_RUN_R3 + 3, RIPPER2_RUN_RATE | SF_TIC_ADJUST, &AF(DoRipper2Move), &s_Ripper2Run[3][0]},
},
{
{RIPPER2_RUN_R4 + 0, RIPPER2_RUN_RATE | SF_TIC_ADJUST, &AF(DoRipper2Move), &s_Ripper2Run[4][1]},
{RIPPER2_RUN_R4 + 1, RIPPER2_RUN_RATE | SF_TIC_ADJUST, &AF(DoRipper2Move), &s_Ripper2Run[4][2]},
{RIPPER2_RUN_R4 + 2, RIPPER2_RUN_RATE | SF_TIC_ADJUST, &AF(DoRipper2Move), &s_Ripper2Run[4][3]},
{RIPPER2_RUN_R4 + 3, RIPPER2_RUN_RATE | SF_TIC_ADJUST, &AF(DoRipper2Move), &s_Ripper2Run[4][0]},
}
};
STATE* sg_Ripper2Run[] =
{
&s_Ripper2Run[0][0],
&s_Ripper2Run[1][0],
&s_Ripper2Run[2][0],
&s_Ripper2Run[3][0],
&s_Ripper2Run[4][0]
};
//////////////////////
@ -167,48 +139,20 @@ STATE* sg_Ripper2Run[] =
#define RIPPER2_RUNFAST_RATE 14
STATE s_Ripper2RunFast[5][4] =
STATE s_Ripper2RunFast[1][4] =
{
{
{RIPPER2_RUNFAST_R0 + 0, RIPPER2_RUNFAST_RATE | SF_TIC_ADJUST, &AF(DoRipper2Move), &s_Ripper2RunFast[0][1]},
{RIPPER2_RUNFAST_R0 + 1, RIPPER2_RUNFAST_RATE | SF_TIC_ADJUST, &AF(DoRipper2Move), &s_Ripper2RunFast[0][2]},
{RIPPER2_RUNFAST_R0 + 2, RIPPER2_RUNFAST_RATE | SF_TIC_ADJUST, &AF(DoRipper2Move), &s_Ripper2RunFast[0][3]},
{RIPPER2_RUNFAST_R0 + 3, RIPPER2_RUNFAST_RATE | SF_TIC_ADJUST, &AF(DoRipper2Move), &s_Ripper2RunFast[0][0]},
{SPR_RIPPER2_RUNFAST, 'A', RIPPER2_RUNFAST_RATE | SF_TIC_ADJUST, &AF(DoRipper2Move), &s_Ripper2RunFast[0][1]},
{SPR_RIPPER2_RUNFAST, 'B', RIPPER2_RUNFAST_RATE | SF_TIC_ADJUST, &AF(DoRipper2Move), &s_Ripper2RunFast[0][2]},
{SPR_RIPPER2_RUNFAST, 'C', RIPPER2_RUNFAST_RATE | SF_TIC_ADJUST, &AF(DoRipper2Move), &s_Ripper2RunFast[0][3]},
{SPR_RIPPER2_RUNFAST, 'D', RIPPER2_RUNFAST_RATE | SF_TIC_ADJUST, &AF(DoRipper2Move), &s_Ripper2RunFast[0][0]},
},
{
{RIPPER2_RUNFAST_R1 + 0, RIPPER2_RUNFAST_RATE | SF_TIC_ADJUST, &AF(DoRipper2Move), &s_Ripper2RunFast[1][1]},
{RIPPER2_RUNFAST_R1 + 1, RIPPER2_RUNFAST_RATE | SF_TIC_ADJUST, &AF(DoRipper2Move), &s_Ripper2RunFast[1][2]},
{RIPPER2_RUNFAST_R1 + 2, RIPPER2_RUNFAST_RATE | SF_TIC_ADJUST, &AF(DoRipper2Move), &s_Ripper2RunFast[1][3]},
{RIPPER2_RUNFAST_R1 + 3, RIPPER2_RUNFAST_RATE | SF_TIC_ADJUST, &AF(DoRipper2Move), &s_Ripper2RunFast[1][0]},
},
{
{RIPPER2_RUNFAST_R2 + 0, RIPPER2_RUNFAST_RATE | SF_TIC_ADJUST, &AF(DoRipper2Move), &s_Ripper2RunFast[2][1]},
{RIPPER2_RUNFAST_R2 + 1, RIPPER2_RUNFAST_RATE | SF_TIC_ADJUST, &AF(DoRipper2Move), &s_Ripper2RunFast[2][2]},
{RIPPER2_RUNFAST_R2 + 2, RIPPER2_RUNFAST_RATE | SF_TIC_ADJUST, &AF(DoRipper2Move), &s_Ripper2RunFast[2][3]},
{RIPPER2_RUNFAST_R2 + 3, RIPPER2_RUNFAST_RATE | SF_TIC_ADJUST, &AF(DoRipper2Move), &s_Ripper2RunFast[2][0]},
},
{
{RIPPER2_RUNFAST_R3 + 0, RIPPER2_RUNFAST_RATE | SF_TIC_ADJUST, &AF(DoRipper2Move), &s_Ripper2RunFast[3][1]},
{RIPPER2_RUNFAST_R3 + 1, RIPPER2_RUNFAST_RATE | SF_TIC_ADJUST, &AF(DoRipper2Move), &s_Ripper2RunFast[3][2]},
{RIPPER2_RUNFAST_R3 + 2, RIPPER2_RUNFAST_RATE | SF_TIC_ADJUST, &AF(DoRipper2Move), &s_Ripper2RunFast[3][3]},
{RIPPER2_RUNFAST_R3 + 3, RIPPER2_RUNFAST_RATE | SF_TIC_ADJUST, &AF(DoRipper2Move), &s_Ripper2RunFast[3][0]},
},
{
{RIPPER2_RUNFAST_R4 + 0, RIPPER2_RUNFAST_RATE | SF_TIC_ADJUST, &AF(DoRipper2Move), &s_Ripper2RunFast[4][1]},
{RIPPER2_RUNFAST_R4 + 1, RIPPER2_RUNFAST_RATE | SF_TIC_ADJUST, &AF(DoRipper2Move), &s_Ripper2RunFast[4][2]},
{RIPPER2_RUNFAST_R4 + 2, RIPPER2_RUNFAST_RATE | SF_TIC_ADJUST, &AF(DoRipper2Move), &s_Ripper2RunFast[4][3]},
{RIPPER2_RUNFAST_R4 + 3, RIPPER2_RUNFAST_RATE | SF_TIC_ADJUST, &AF(DoRipper2Move), &s_Ripper2RunFast[4][0]},
}
};
STATE* sg_Ripper2RunFast[] =
{
&s_Ripper2RunFast[0][0],
&s_Ripper2RunFast[1][0],
&s_Ripper2RunFast[2][0],
&s_Ripper2RunFast[3][0],
&s_Ripper2RunFast[4][0]
};
//////////////////////
@ -219,32 +163,16 @@ STATE* sg_Ripper2RunFast[] =
#define RIPPER2_STAND_RATE 12
STATE s_Ripper2Stand[5][1] =
STATE s_Ripper2Stand[1][1] =
{
{
{RIPPER2_STAND_R0 + 0, RIPPER2_STAND_RATE, &AF(DoRipper2Move), &s_Ripper2Stand[0][0]},
},
{
{RIPPER2_STAND_R1 + 0, RIPPER2_STAND_RATE, &AF(DoRipper2Move), &s_Ripper2Stand[1][0]},
},
{
{RIPPER2_STAND_R2 + 0, RIPPER2_STAND_RATE, &AF(DoRipper2Move), &s_Ripper2Stand[2][0]},
},
{
{RIPPER2_STAND_R3 + 0, RIPPER2_STAND_RATE, &AF(DoRipper2Move), &s_Ripper2Stand[3][0]},
},
{
{RIPPER2_STAND_R4 + 0, RIPPER2_STAND_RATE, &AF(DoRipper2Move), &s_Ripper2Stand[4][0]},
{SPR_RIPPER2_STAND, 'A', RIPPER2_STAND_RATE, &AF(DoRipper2Move), &s_Ripper2Stand[0][0]},
},
};
STATE* sg_Ripper2Stand[] =
{
s_Ripper2Stand[0],
s_Ripper2Stand[1],
s_Ripper2Stand[2],
s_Ripper2Stand[3],
s_Ripper2Stand[4]
};
//////////////////////
@ -255,68 +183,24 @@ STATE* sg_Ripper2Stand[] =
#define RIPPER2_SWIPE_RATE 14
STATE s_Ripper2Swipe[5][8] =
STATE s_Ripper2Swipe[1][8] =
{
{
{RIPPER2_SWIPE_R0 + 0, RIPPER2_SWIPE_RATE, &AF(NullRipper2), &s_Ripper2Swipe[0][1]},
{RIPPER2_SWIPE_R0 + 1, RIPPER2_SWIPE_RATE, &AF(NullRipper2), &s_Ripper2Swipe[0][2]},
{RIPPER2_SWIPE_R0 + 1, 0 | SF_QUICK_CALL, &AF(InitRipperSlash), &s_Ripper2Swipe[0][3]},
{RIPPER2_SWIPE_R0 + 2, RIPPER2_SWIPE_RATE, &AF(NullRipper2), &s_Ripper2Swipe[0][4]},
{RIPPER2_SWIPE_R0 + 3, RIPPER2_SWIPE_RATE, &AF(NullRipper2), &s_Ripper2Swipe[0][5]},
{RIPPER2_SWIPE_R0 + 3, 0 | SF_QUICK_CALL, &AF(InitRipperSlash), &s_Ripper2Swipe[0][6]},
{RIPPER2_SWIPE_R0 + 3, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_Ripper2Swipe[0][7]},
{RIPPER2_SWIPE_R0 + 3, RIPPER2_SWIPE_RATE, &AF(DoRipper2Move), &s_Ripper2Swipe[0][7]},
{SPR_RIPPER2_SWIPE, 'A', RIPPER2_SWIPE_RATE, &AF(NullRipper2), &s_Ripper2Swipe[0][1]},
{SPR_RIPPER2_SWIPE, 'B', RIPPER2_SWIPE_RATE, &AF(NullRipper2), &s_Ripper2Swipe[0][2]},
{SPR_RIPPER2_SWIPE, 'B', 0 | SF_QUICK_CALL, &AF(InitRipperSlash), &s_Ripper2Swipe[0][3]},
{SPR_RIPPER2_SWIPE, 'C', RIPPER2_SWIPE_RATE, &AF(NullRipper2), &s_Ripper2Swipe[0][4]},
{SPR_RIPPER2_SWIPE, 'D', RIPPER2_SWIPE_RATE, &AF(NullRipper2), &s_Ripper2Swipe[0][5]},
{SPR_RIPPER2_SWIPE, 'D', 0 | SF_QUICK_CALL, &AF(InitRipperSlash), &s_Ripper2Swipe[0][6]},
{SPR_RIPPER2_SWIPE, 'D', 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_Ripper2Swipe[0][7]},
{SPR_RIPPER2_SWIPE, 'D', RIPPER2_SWIPE_RATE, &AF(DoRipper2Move), &s_Ripper2Swipe[0][7]},
},
{
{RIPPER2_SWIPE_R1 + 0, RIPPER2_SWIPE_RATE, &AF(NullRipper2), &s_Ripper2Swipe[1][1]},
{RIPPER2_SWIPE_R1 + 1, RIPPER2_SWIPE_RATE, &AF(NullRipper2), &s_Ripper2Swipe[1][2]},
{RIPPER2_SWIPE_R1 + 1, 0 | SF_QUICK_CALL, &AF(InitRipperSlash), &s_Ripper2Swipe[1][3]},
{RIPPER2_SWIPE_R1 + 2, RIPPER2_SWIPE_RATE, &AF(NullRipper2), &s_Ripper2Swipe[1][4]},
{RIPPER2_SWIPE_R1 + 3, RIPPER2_SWIPE_RATE, &AF(NullRipper2), &s_Ripper2Swipe[1][5]},
{RIPPER2_SWIPE_R1 + 3, 0 | SF_QUICK_CALL, &AF(InitRipperSlash), &s_Ripper2Swipe[1][6]},
{RIPPER2_SWIPE_R1 + 3, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_Ripper2Swipe[1][7]},
{RIPPER2_SWIPE_R1 + 3, RIPPER2_SWIPE_RATE, &AF(DoRipper2Move), &s_Ripper2Swipe[1][7]},
},
{
{RIPPER2_SWIPE_R2 + 0, RIPPER2_SWIPE_RATE, &AF(NullRipper2), &s_Ripper2Swipe[2][1]},
{RIPPER2_SWIPE_R2 + 1, RIPPER2_SWIPE_RATE, &AF(NullRipper2), &s_Ripper2Swipe[2][2]},
{RIPPER2_SWIPE_R2 + 1, 0 | SF_QUICK_CALL, &AF(InitRipperSlash), &s_Ripper2Swipe[2][3]},
{RIPPER2_SWIPE_R2 + 2, RIPPER2_SWIPE_RATE, &AF(NullRipper2), &s_Ripper2Swipe[2][4]},
{RIPPER2_SWIPE_R2 + 3, RIPPER2_SWIPE_RATE, &AF(NullRipper2), &s_Ripper2Swipe[2][5]},
{RIPPER2_SWIPE_R2 + 3, 0 | SF_QUICK_CALL, &AF(InitRipperSlash), &s_Ripper2Swipe[2][6]},
{RIPPER2_SWIPE_R2 + 3, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_Ripper2Swipe[2][7]},
{RIPPER2_SWIPE_R2 + 3, RIPPER2_SWIPE_RATE, &AF(DoRipper2Move), &s_Ripper2Swipe[2][7]},
},
{
{RIPPER2_SWIPE_R3 + 0, RIPPER2_SWIPE_RATE, &AF(NullRipper2), &s_Ripper2Swipe[3][1]},
{RIPPER2_SWIPE_R3 + 1, RIPPER2_SWIPE_RATE, &AF(NullRipper2), &s_Ripper2Swipe[3][2]},
{RIPPER2_SWIPE_R3 + 1, 0 | SF_QUICK_CALL, &AF(InitRipperSlash), &s_Ripper2Swipe[3][3]},
{RIPPER2_SWIPE_R3 + 2, RIPPER2_SWIPE_RATE, &AF(NullRipper2), &s_Ripper2Swipe[3][4]},
{RIPPER2_SWIPE_R3 + 3, RIPPER2_SWIPE_RATE, &AF(NullRipper2), &s_Ripper2Swipe[3][5]},
{RIPPER2_SWIPE_R3 + 3, 0 | SF_QUICK_CALL, &AF(InitRipperSlash), &s_Ripper2Swipe[3][6]},
{RIPPER2_SWIPE_R3 + 3, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_Ripper2Swipe[3][7]},
{RIPPER2_SWIPE_R3 + 3, RIPPER2_SWIPE_RATE, &AF(DoRipper2Move), &s_Ripper2Swipe[3][7]},
},
{
{RIPPER2_SWIPE_R4 + 0, RIPPER2_SWIPE_RATE, &AF(NullRipper2), &s_Ripper2Swipe[4][1]},
{RIPPER2_SWIPE_R4 + 1, RIPPER2_SWIPE_RATE, &AF(NullRipper2), &s_Ripper2Swipe[4][2]},
{RIPPER2_SWIPE_R4 + 1, 0 | SF_QUICK_CALL, &AF(InitRipperSlash), &s_Ripper2Swipe[4][3]},
{RIPPER2_SWIPE_R4 + 2, RIPPER2_SWIPE_RATE, &AF(NullRipper2), &s_Ripper2Swipe[4][4]},
{RIPPER2_SWIPE_R4 + 3, RIPPER2_SWIPE_RATE, &AF(NullRipper2), &s_Ripper2Swipe[4][5]},
{RIPPER2_SWIPE_R4 + 3, 0 | SF_QUICK_CALL, &AF(InitRipperSlash), &s_Ripper2Swipe[4][6]},
{RIPPER2_SWIPE_R4 + 3, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_Ripper2Swipe[4][7]},
{RIPPER2_SWIPE_R4 + 3, RIPPER2_SWIPE_RATE, &AF(DoRipper2Move), &s_Ripper2Swipe[4][7]},
}
};
STATE* sg_Ripper2Swipe[] =
{
&s_Ripper2Swipe[0][0],
&s_Ripper2Swipe[1][0],
&s_Ripper2Swipe[2][0],
&s_Ripper2Swipe[3][0],
&s_Ripper2Swipe[4][0]
};
//////////////////////
@ -327,63 +211,23 @@ STATE* sg_Ripper2Swipe[] =
#define RIPPER2_MEKONG_RATE 18
STATE s_Ripper2Kong[5][7] =
STATE s_Ripper2Kong[1][7] =
{
{
{RIPPER2_MEKONG_R0 + 0, RIPPER2_MEKONG_RATE, &AF(NullRipper2), &s_Ripper2Kong[0][1]},
{RIPPER2_MEKONG_R0 + 0, SF_QUICK_CALL, &AF(ChestRipper2), &s_Ripper2Kong[0][2]},
{RIPPER2_MEKONG_R0 + 1, RIPPER2_MEKONG_RATE, &AF(NullRipper2), &s_Ripper2Kong[0][3]},
{RIPPER2_MEKONG_R0 + 2, RIPPER2_MEKONG_RATE, &AF(NullRipper2), &s_Ripper2Kong[0][4]},
{RIPPER2_MEKONG_R0 + 3, RIPPER2_MEKONG_RATE, &AF(NullRipper2), &s_Ripper2Kong[0][5]},
{RIPPER2_MEKONG_R0 + 3, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_Ripper2Kong[0][6]},
{RIPPER2_MEKONG_R0 + 0, RIPPER2_MEKONG_RATE, &AF(DoRipper2Move), &s_Ripper2Kong[0][6]},
{SPR_RIPPER2_MEKONG, 'A', RIPPER2_MEKONG_RATE, &AF(NullRipper2), &s_Ripper2Kong[0][1]},
{SPR_RIPPER2_MEKONG, 'A', SF_QUICK_CALL, &AF(ChestRipper2), &s_Ripper2Kong[0][2]},
{SPR_RIPPER2_MEKONG, 'B', RIPPER2_MEKONG_RATE, &AF(NullRipper2), &s_Ripper2Kong[0][3]},
{SPR_RIPPER2_MEKONG, 'C', RIPPER2_MEKONG_RATE, &AF(NullRipper2), &s_Ripper2Kong[0][4]},
{SPR_RIPPER2_MEKONG, 'D', RIPPER2_MEKONG_RATE, &AF(NullRipper2), &s_Ripper2Kong[0][5]},
{SPR_RIPPER2_MEKONG, 'D', 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_Ripper2Kong[0][6]},
{SPR_RIPPER2_MEKONG, 'A', RIPPER2_MEKONG_RATE, &AF(DoRipper2Move), &s_Ripper2Kong[0][6]},
},
{
{RIPPER2_MEKONG_R1 + 0, RIPPER2_MEKONG_RATE, &AF(NullRipper2), &s_Ripper2Kong[1][1]},
{RIPPER2_MEKONG_R0 + 0, SF_QUICK_CALL, &AF(ChestRipper2), &s_Ripper2Kong[1][2]},
{RIPPER2_MEKONG_R1 + 1, RIPPER2_MEKONG_RATE, &AF(NullRipper2), &s_Ripper2Kong[1][3]},
{RIPPER2_MEKONG_R1 + 2, RIPPER2_MEKONG_RATE, &AF(NullRipper2), &s_Ripper2Kong[1][4]},
{RIPPER2_MEKONG_R1 + 3, RIPPER2_MEKONG_RATE, &AF(NullRipper2), &s_Ripper2Kong[1][5]},
{RIPPER2_MEKONG_R1 + 3, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_Ripper2Kong[1][6]},
{RIPPER2_MEKONG_R1 + 0, RIPPER2_MEKONG_RATE, &AF(DoRipper2Move), &s_Ripper2Kong[1][6]},
},
{
{RIPPER2_MEKONG_R2 + 0, RIPPER2_MEKONG_RATE, &AF(NullRipper2), &s_Ripper2Kong[2][1]},
{RIPPER2_MEKONG_R0 + 0, SF_QUICK_CALL, &AF(ChestRipper2), &s_Ripper2Kong[2][2]},
{RIPPER2_MEKONG_R2 + 1, RIPPER2_MEKONG_RATE, &AF(NullRipper2), &s_Ripper2Kong[2][3]},
{RIPPER2_MEKONG_R2 + 2, RIPPER2_MEKONG_RATE, &AF(NullRipper2), &s_Ripper2Kong[2][4]},
{RIPPER2_MEKONG_R2 + 3, RIPPER2_MEKONG_RATE, &AF(NullRipper2), &s_Ripper2Kong[2][5]},
{RIPPER2_MEKONG_R2 + 3, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_Ripper2Kong[2][6]},
{RIPPER2_MEKONG_R2 + 0, RIPPER2_MEKONG_RATE, &AF(DoRipper2Move), &s_Ripper2Kong[2][6]},
},
{
{RIPPER2_MEKONG_R3 + 0, RIPPER2_MEKONG_RATE, &AF(NullRipper2), &s_Ripper2Kong[3][1]},
{RIPPER2_MEKONG_R0 + 0, SF_QUICK_CALL, &AF(ChestRipper2), &s_Ripper2Kong[3][2]},
{RIPPER2_MEKONG_R3 + 1, RIPPER2_MEKONG_RATE, &AF(NullRipper2), &s_Ripper2Kong[3][3]},
{RIPPER2_MEKONG_R3 + 2, RIPPER2_MEKONG_RATE, &AF(NullRipper2), &s_Ripper2Kong[3][4]},
{RIPPER2_MEKONG_R3 + 3, RIPPER2_MEKONG_RATE, &AF(NullRipper2), &s_Ripper2Kong[3][5]},
{RIPPER2_MEKONG_R3 + 3, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_Ripper2Kong[3][6]},
{RIPPER2_MEKONG_R3 + 0, RIPPER2_MEKONG_RATE, &AF(DoRipper2Move), &s_Ripper2Kong[3][6]},
},
{
{RIPPER2_MEKONG_R4 + 0, RIPPER2_MEKONG_RATE, &AF(NullRipper2), &s_Ripper2Kong[4][1]},
{RIPPER2_MEKONG_R0 + 0, SF_QUICK_CALL, &AF(ChestRipper2), &s_Ripper2Kong[4][2]},
{RIPPER2_MEKONG_R4 + 1, RIPPER2_MEKONG_RATE, &AF(NullRipper2), &s_Ripper2Kong[4][3]},
{RIPPER2_MEKONG_R4 + 2, RIPPER2_MEKONG_RATE, &AF(NullRipper2), &s_Ripper2Kong[4][4]},
{RIPPER2_MEKONG_R4 + 3, RIPPER2_MEKONG_RATE, &AF(NullRipper2), &s_Ripper2Kong[4][5]},
{RIPPER2_MEKONG_R4 + 3, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_Ripper2Kong[4][6]},
{RIPPER2_MEKONG_R4 + 0, RIPPER2_MEKONG_RATE, &AF(DoRipper2Move), &s_Ripper2Kong[4][6]},
}
};
STATE* sg_Ripper2Kong[] =
{
&s_Ripper2Kong[0][0],
&s_Ripper2Kong[1][0],
&s_Ripper2Kong[2][0],
&s_Ripper2Kong[3][0],
&s_Ripper2Kong[4][0]
};
@ -395,38 +239,18 @@ STATE* sg_Ripper2Kong[] =
#define RIPPER2_HEART_RATE 20
STATE s_Ripper2Heart[5][4] =
STATE s_Ripper2Heart[1][4] =
{
{
{RIPPER2_HEART_R0 + 0, RIPPER2_HEART_RATE, &AF(DoRipper2StandHeart), &s_Ripper2Heart[0][1]},
{RIPPER2_HEART_R0 + 1, RIPPER2_HEART_RATE, &AF(DoRipper2StandHeart), &s_Ripper2Heart[0][0]},
{SPR_RIPPER2_HEART, 'A', RIPPER2_HEART_RATE, &AF(DoRipper2StandHeart), &s_Ripper2Heart[0][1]},
{SPR_RIPPER2_HEART, 'B', RIPPER2_HEART_RATE, &AF(DoRipper2StandHeart), &s_Ripper2Heart[0][0]},
},
{
{RIPPER2_HEART_R1 + 0, RIPPER2_HEART_RATE, &AF(DoRipper2StandHeart), &s_Ripper2Heart[1][1]},
{RIPPER2_HEART_R1 + 1, RIPPER2_HEART_RATE, &AF(DoRipper2StandHeart), &s_Ripper2Heart[1][0]},
},
{
{RIPPER2_HEART_R2 + 0, RIPPER2_HEART_RATE, &AF(DoRipper2StandHeart), &s_Ripper2Heart[2][1]},
{RIPPER2_HEART_R2 + 1, RIPPER2_HEART_RATE, &AF(DoRipper2StandHeart), &s_Ripper2Heart[2][0]},
},
{
{RIPPER2_HEART_R3 + 0, RIPPER2_HEART_RATE, &AF(DoRipper2StandHeart), &s_Ripper2Heart[3][1]},
{RIPPER2_HEART_R3 + 1, RIPPER2_HEART_RATE, &AF(DoRipper2StandHeart), &s_Ripper2Heart[3][0]},
},
{
{RIPPER2_HEART_R4 + 0, RIPPER2_HEART_RATE, &AF(DoRipper2StandHeart), &s_Ripper2Heart[4][1]},
{RIPPER2_HEART_R4 + 1, RIPPER2_HEART_RATE, &AF(DoRipper2StandHeart), &s_Ripper2Heart[4][0]},
}
};
STATE* sg_Ripper2Heart[] =
{
&s_Ripper2Heart[0][0],
&s_Ripper2Heart[1][0],
&s_Ripper2Heart[2][0],
&s_Ripper2Heart[3][0],
&s_Ripper2Heart[4][0]
};
//////////////////////
@ -437,33 +261,17 @@ STATE* sg_Ripper2Heart[] =
#define RIPPER2_HANG_RATE 14
STATE s_Ripper2Hang[5][4] =
STATE s_Ripper2Hang[1][4] =
{
{
{RIPPER2_HANG_R0, RIPPER2_HANG_RATE, &AF(DoRipper2Hang), &s_Ripper2Hang[0][0]},
{SPR_RIPPER2_HANG, 'A', RIPPER2_HANG_RATE, &AF(DoRipper2Hang), &s_Ripper2Hang[0][0]},
},
{
{RIPPER2_HANG_R1, RIPPER2_HANG_RATE, &AF(DoRipper2Hang), &s_Ripper2Hang[1][0]},
},
{
{RIPPER2_HANG_R2, RIPPER2_HANG_RATE, &AF(DoRipper2Hang), &s_Ripper2Hang[2][0]},
},
{
{RIPPER2_HANG_R3, RIPPER2_HANG_RATE, &AF(DoRipper2Hang), &s_Ripper2Hang[3][0]},
},
{
{RIPPER2_HANG_R4, RIPPER2_HANG_RATE, &AF(DoRipper2Hang), &s_Ripper2Hang[4][0]},
}
};
STATE* sg_Ripper2Hang[] =
{
&s_Ripper2Hang[0][0],
&s_Ripper2Hang[1][0],
&s_Ripper2Hang[2][0],
&s_Ripper2Hang[3][0],
&s_Ripper2Hang[4][0]
};
@ -475,32 +283,16 @@ STATE* sg_Ripper2Hang[] =
#define RIPPER2_PAIN_RATE 38
STATE s_Ripper2Pain[5][1] =
STATE s_Ripper2Pain[1][1] =
{
{
{4414 + 0, RIPPER2_PAIN_RATE, &AF(DoRipper2Pain), &s_Ripper2Pain[0][0]},
{SPR_RIPPER_DIE, 'A', RIPPER2_PAIN_RATE, &AF(DoRipper2Pain), &s_Ripper2Pain[0][0]},
},
{
{4414 + 0, RIPPER2_PAIN_RATE, &AF(DoRipper2Pain), &s_Ripper2Pain[1][0]},
},
{
{4414 + 0, RIPPER2_PAIN_RATE, &AF(DoRipper2Pain), &s_Ripper2Pain[2][0]},
},
{
{4414 + 0, RIPPER2_PAIN_RATE, &AF(DoRipper2Pain), &s_Ripper2Pain[3][0]},
},
{
{4414 + 0, RIPPER2_PAIN_RATE, &AF(DoRipper2Pain), &s_Ripper2Pain[4][0]},
}
};
STATE* sg_Ripper2Pain[] =
{
&s_Ripper2Pain[0][0],
&s_Ripper2Pain[1][0],
&s_Ripper2Pain[2][0],
&s_Ripper2Pain[3][0],
&s_Ripper2Pain[4][0]
};
//////////////////////
@ -511,38 +303,18 @@ STATE* sg_Ripper2Pain[] =
#define RIPPER2_JUMP_RATE 25
STATE s_Ripper2Jump[5][6] =
STATE s_Ripper2Jump[1][2] =
{
{
{RIPPER2_JUMP_R0 + 0, RIPPER2_JUMP_RATE, &AF(NullRipper2), &s_Ripper2Jump[0][1]},
{RIPPER2_JUMP_R0 + 1, RIPPER2_JUMP_RATE, &AF(DoRipper2MoveJump), &s_Ripper2Jump[0][1]},
{SPR_RIPPER2_JUMP, 'A', RIPPER2_JUMP_RATE, &AF(NullRipper2), &s_Ripper2Jump[0][1]},
{SPR_RIPPER2_JUMP, 'B', RIPPER2_JUMP_RATE, &AF(DoRipper2MoveJump), &s_Ripper2Jump[0][1]},
},
{
{RIPPER2_JUMP_R1 + 0, RIPPER2_JUMP_RATE, &AF(NullRipper2), &s_Ripper2Jump[1][1]},
{RIPPER2_JUMP_R1 + 1, RIPPER2_JUMP_RATE, &AF(DoRipper2MoveJump), &s_Ripper2Jump[1][1]},
},
{
{RIPPER2_JUMP_R2 + 0, RIPPER2_JUMP_RATE, &AF(NullRipper2), &s_Ripper2Jump[2][1]},
{RIPPER2_JUMP_R2 + 1, RIPPER2_JUMP_RATE, &AF(DoRipper2MoveJump), &s_Ripper2Jump[2][1]},
},
{
{RIPPER2_JUMP_R3 + 0, RIPPER2_JUMP_RATE, &AF(NullRipper2), &s_Ripper2Jump[3][1]},
{RIPPER2_JUMP_R3 + 1, RIPPER2_JUMP_RATE, &AF(DoRipper2MoveJump), &s_Ripper2Jump[3][1]},
},
{
{RIPPER2_JUMP_R4 + 0, RIPPER2_JUMP_RATE, &AF(NullRipper2), &s_Ripper2Jump[4][1]},
{RIPPER2_JUMP_R4 + 1, RIPPER2_JUMP_RATE, &AF(DoRipper2MoveJump), &s_Ripper2Jump[4][1]},
}
};
STATE* sg_Ripper2Jump[] =
{
&s_Ripper2Jump[0][0],
&s_Ripper2Jump[1][0],
&s_Ripper2Jump[2][0],
&s_Ripper2Jump[3][0],
&s_Ripper2Jump[4][0]
};
@ -554,33 +326,17 @@ STATE* sg_Ripper2Jump[] =
#define RIPPER2_FALL_RATE 25
STATE s_Ripper2Fall[5][6] =
STATE s_Ripper2Fall[1][6] =
{
{
{RIPPER2_FALL_R0 + 0, RIPPER2_FALL_RATE, &AF(DoRipper2MoveJump), &s_Ripper2Fall[0][0]},
{SPR_RIPPER2_FALL, 'A', RIPPER2_FALL_RATE, &AF(DoRipper2MoveJump), &s_Ripper2Fall[0][0]},
},
{
{RIPPER2_FALL_R1 + 0, RIPPER2_FALL_RATE, &AF(DoRipper2MoveJump), &s_Ripper2Fall[1][0]},
},
{
{RIPPER2_FALL_R2 + 0, RIPPER2_FALL_RATE, &AF(DoRipper2MoveJump), &s_Ripper2Fall[2][0]},
},
{
{RIPPER2_FALL_R3 + 0, RIPPER2_FALL_RATE, &AF(DoRipper2MoveJump), &s_Ripper2Fall[3][0]},
},
{
{RIPPER2_FALL_R4 + 0, RIPPER2_FALL_RATE, &AF(DoRipper2MoveJump), &s_Ripper2Fall[4][0]},
}
};
STATE* sg_Ripper2Fall[] =
{
&s_Ripper2Fall[0][0],
&s_Ripper2Fall[1][0],
&s_Ripper2Fall[2][0],
&s_Ripper2Fall[3][0],
&s_Ripper2Fall[4][0]
};
@ -593,48 +349,20 @@ STATE* sg_Ripper2Fall[] =
#define RIPPER2_JUMP_ATTACK_RATE 35
int DoRipper2BeginJumpAttack(DSWActor* actor);
STATE s_Ripper2JumpAttack[5][6] =
STATE s_Ripper2JumpAttack[1][6] =
{
{
{RIPPER2_JUMP_R0 + 0, RIPPER2_JUMP_ATTACK_RATE, &AF(NullRipper2), &s_Ripper2JumpAttack[0][1]},
{RIPPER2_JUMP_R0 + 0, 0 | SF_QUICK_CALL, &AF(DoRipper2BeginJumpAttack), &s_Ripper2JumpAttack[0][2]},
{RIPPER2_JUMP_R0 + 2, RIPPER2_JUMP_ATTACK_RATE, &AF(DoRipper2MoveJump), &s_Ripper2JumpAttack[0][3]},
{RIPPER2_JUMP_R0 + 1, RIPPER2_JUMP_ATTACK_RATE, &AF(DoRipper2MoveJump), &s_Ripper2JumpAttack[0][3]},
{SPR_RIPPER2_JUMP, 'A', RIPPER2_JUMP_ATTACK_RATE, &AF(NullRipper2), &s_Ripper2JumpAttack[0][1]},
{SPR_RIPPER2_JUMP, 'A', 0 | SF_QUICK_CALL, &AF(DoRipper2BeginJumpAttack), &s_Ripper2JumpAttack[0][2]},
{SPR_RIPPER2_JUMP, 'C', RIPPER2_JUMP_ATTACK_RATE, &AF(DoRipper2MoveJump), &s_Ripper2JumpAttack[0][3]},
{SPR_RIPPER2_JUMP, 'B', RIPPER2_JUMP_ATTACK_RATE, &AF(DoRipper2MoveJump), &s_Ripper2JumpAttack[0][3]},
},
{
{RIPPER2_JUMP_R1 + 0, RIPPER2_JUMP_ATTACK_RATE, &AF(NullRipper2), &s_Ripper2JumpAttack[1][1]},
{RIPPER2_JUMP_R1 + 0, 0 | SF_QUICK_CALL, &AF(DoRipper2BeginJumpAttack), &s_Ripper2JumpAttack[1][2]},
{RIPPER2_JUMP_R1 + 2, RIPPER2_JUMP_ATTACK_RATE, &AF(DoRipper2MoveJump), &s_Ripper2JumpAttack[1][3]},
{RIPPER2_JUMP_R1 + 1, RIPPER2_JUMP_ATTACK_RATE, &AF(DoRipper2MoveJump), &s_Ripper2JumpAttack[1][3]},
},
{
{RIPPER2_JUMP_R2 + 0, RIPPER2_JUMP_ATTACK_RATE, &AF(NullRipper2), &s_Ripper2JumpAttack[2][1]},
{RIPPER2_JUMP_R2 + 0, 0 | SF_QUICK_CALL, &AF(DoRipper2BeginJumpAttack), &s_Ripper2JumpAttack[2][2]},
{RIPPER2_JUMP_R2 + 2, RIPPER2_JUMP_ATTACK_RATE, &AF(DoRipper2MoveJump), &s_Ripper2JumpAttack[2][3]},
{RIPPER2_JUMP_R1 + 1, RIPPER2_JUMP_ATTACK_RATE, &AF(DoRipper2MoveJump), &s_Ripper2JumpAttack[2][3]},
},
{
{RIPPER2_JUMP_R3 + 0, RIPPER2_JUMP_ATTACK_RATE, &AF(NullRipper2), &s_Ripper2JumpAttack[3][1]},
{RIPPER2_JUMP_R3 + 0, 0 | SF_QUICK_CALL, &AF(DoRipper2BeginJumpAttack), &s_Ripper2JumpAttack[3][2]},
{RIPPER2_JUMP_R3 + 2, RIPPER2_JUMP_ATTACK_RATE, &AF(DoRipper2MoveJump), &s_Ripper2JumpAttack[3][3]},
{RIPPER2_JUMP_R1 + 1, RIPPER2_JUMP_ATTACK_RATE, &AF(DoRipper2MoveJump), &s_Ripper2JumpAttack[3][3]},
},
{
{RIPPER2_JUMP_R4 + 0, RIPPER2_JUMP_ATTACK_RATE, &AF(NullRipper2), &s_Ripper2JumpAttack[4][1]},
{RIPPER2_JUMP_R4 + 0, 0 | SF_QUICK_CALL, &AF(DoRipper2BeginJumpAttack), &s_Ripper2JumpAttack[4][2]},
{RIPPER2_JUMP_R4 + 2, RIPPER2_JUMP_ATTACK_RATE, &AF(DoRipper2MoveJump), &s_Ripper2JumpAttack[4][3]},
{RIPPER2_JUMP_R1 + 1, RIPPER2_JUMP_ATTACK_RATE, &AF(DoRipper2MoveJump), &s_Ripper2JumpAttack[4][3]},
}
};
STATE* sg_Ripper2JumpAttack[] =
{
&s_Ripper2JumpAttack[0][0],
&s_Ripper2JumpAttack[1][0],
&s_Ripper2JumpAttack[2][0],
&s_Ripper2JumpAttack[3][0],
&s_Ripper2JumpAttack[4][0]
};
@ -646,38 +374,18 @@ STATE* sg_Ripper2JumpAttack[] =
#define RIPPER2_HANG_JUMP_RATE 20
STATE s_Ripper2HangJump[5][6] =
STATE s_Ripper2HangJump[1][6] =
{
{
{RIPPER2_JUMP_R0 + 0, RIPPER2_HANG_JUMP_RATE, &AF(NullRipper2), &s_Ripper2HangJump[0][1]},
{RIPPER2_JUMP_R0 + 1, RIPPER2_HANG_JUMP_RATE, &AF(DoRipper2HangJF), &s_Ripper2HangJump[0][1]},
{SPR_RIPPER2_JUMP, 'A', RIPPER2_HANG_JUMP_RATE, &AF(NullRipper2), &s_Ripper2HangJump[0][1]},
{SPR_RIPPER2_JUMP, 'B', RIPPER2_HANG_JUMP_RATE, &AF(DoRipper2HangJF), &s_Ripper2HangJump[0][1]},
},
{
{RIPPER2_JUMP_R1 + 0, RIPPER2_HANG_JUMP_RATE, &AF(NullRipper2), &s_Ripper2HangJump[1][1]},
{RIPPER2_JUMP_R1 + 1, RIPPER2_HANG_JUMP_RATE, &AF(DoRipper2HangJF), &s_Ripper2HangJump[1][1]},
},
{
{RIPPER2_JUMP_R2 + 0, RIPPER2_HANG_JUMP_RATE, &AF(NullRipper2), &s_Ripper2HangJump[2][1]},
{RIPPER2_JUMP_R2 + 1, RIPPER2_HANG_JUMP_RATE, &AF(DoRipper2HangJF), &s_Ripper2HangJump[2][1]},
},
{
{RIPPER2_JUMP_R3 + 0, RIPPER2_HANG_JUMP_RATE, &AF(NullRipper2), &s_Ripper2HangJump[3][1]},
{RIPPER2_JUMP_R3 + 1, RIPPER2_HANG_JUMP_RATE, &AF(DoRipper2HangJF), &s_Ripper2HangJump[3][1]},
},
{
{RIPPER2_JUMP_R4 + 0, RIPPER2_HANG_JUMP_RATE, &AF(NullRipper2), &s_Ripper2HangJump[4][1]},
{RIPPER2_JUMP_R4 + 1, RIPPER2_HANG_JUMP_RATE, &AF(DoRipper2HangJF), &s_Ripper2HangJump[4][1]},
}
};
STATE* sg_Ripper2HangJump[] =
{
&s_Ripper2HangJump[0][0],
&s_Ripper2HangJump[1][0],
&s_Ripper2HangJump[2][0],
&s_Ripper2HangJump[3][0],
&s_Ripper2HangJump[4][0]
};
//////////////////////
@ -688,33 +396,17 @@ STATE* sg_Ripper2HangJump[] =
#define RIPPER2_FALL_RATE 25
STATE s_Ripper2HangFall[5][6] =
STATE s_Ripper2HangFall[1][6] =
{
{
{RIPPER2_FALL_R0 + 0, RIPPER2_FALL_RATE, &AF(DoRipper2HangJF), &s_Ripper2HangFall[0][0]},
{SPR_RIPPER2_FALL, 'A', RIPPER2_FALL_RATE, &AF(DoRipper2HangJF), &s_Ripper2HangFall[0][0]},
},
{
{RIPPER2_FALL_R1 + 0, RIPPER2_FALL_RATE, &AF(DoRipper2HangJF), &s_Ripper2HangFall[1][0]},
},
{
{RIPPER2_FALL_R2 + 0, RIPPER2_FALL_RATE, &AF(DoRipper2HangJF), &s_Ripper2HangFall[2][0]},
},
{
{RIPPER2_FALL_R3 + 0, RIPPER2_FALL_RATE, &AF(DoRipper2HangJF), &s_Ripper2HangFall[3][0]},
},
{
{RIPPER2_FALL_R4 + 0, RIPPER2_FALL_RATE, &AF(DoRipper2HangJF), &s_Ripper2HangFall[4][0]},
}
};
STATE* sg_Ripper2HangFall[] =
{
&s_Ripper2HangFall[0][0],
&s_Ripper2HangFall[1][0],
&s_Ripper2HangFall[2][0],
&s_Ripper2HangFall[3][0],
&s_Ripper2HangFall[4][0]
};
@ -729,29 +421,29 @@ STATE* sg_Ripper2HangFall[] =
STATE s_Ripper2Die[] =
{
{RIPPER2_DIE + 0, RIPPER2_DIE_RATE, &AF(NullRipper2), &s_Ripper2Die[1]},
{RIPPER2_DIE + 1, RIPPER2_DIE_RATE, &AF(NullRipper2), &s_Ripper2Die[2]},
{RIPPER2_DIE + 2, RIPPER2_DIE_RATE, &AF(NullRipper2), &s_Ripper2Die[3]},
{RIPPER2_DIE + 3, RIPPER2_DIE_RATE, &AF(NullRipper2), &s_Ripper2Die[4]},
{RIPPER2_DIE + 4, RIPPER2_DIE_RATE, &AF(NullRipper2), &s_Ripper2Die[5]},
{RIPPER2_DIE + 5, RIPPER2_DIE_RATE, &AF(NullRipper2), &s_Ripper2Die[6]},
{RIPPER2_DIE + 6, RIPPER2_DIE_RATE, &AF(NullRipper2), &s_Ripper2Die[7]},
{RIPPER2_DEAD, RIPPER2_DIE_RATE, &AF(DoActorDebris), &s_Ripper2Die[7]},
{SPR_RIPPER2_DIE, 'A', RIPPER2_DIE_RATE, &AF(NullRipper2), &s_Ripper2Die[1]},
{SPR_RIPPER2_DIE, 'B', RIPPER2_DIE_RATE, &AF(NullRipper2), &s_Ripper2Die[2]},
{SPR_RIPPER2_DIE, 'C', RIPPER2_DIE_RATE, &AF(NullRipper2), &s_Ripper2Die[3]},
{SPR_RIPPER2_DIE, 'D', RIPPER2_DIE_RATE, &AF(NullRipper2), &s_Ripper2Die[4]},
{SPR_RIPPER2_DIE, 'E', RIPPER2_DIE_RATE, &AF(NullRipper2), &s_Ripper2Die[5]},
{SPR_RIPPER2_DIE, 'F', RIPPER2_DIE_RATE, &AF(NullRipper2), &s_Ripper2Die[6]},
{SPR_RIPPER2_DIE, 'G', RIPPER2_DIE_RATE, &AF(NullRipper2), &s_Ripper2Die[7]},
{SPR_RIPPER2_DEAD, 'A', RIPPER2_DIE_RATE, &AF(DoActorDebris), &s_Ripper2Die[7]},
};
#define RIPPER2_DEAD_RATE 8
STATE s_Ripper2Dead[] =
{
{RIPPER2_DIE + 0, RIPPER2_DIE_RATE, &AF(NullRipper2), &s_Ripper2Dead[1]},
{RIPPER2_DIE + 1, RIPPER2_DIE_RATE, &AF(NullRipper2), &s_Ripper2Dead[2]},
{RIPPER2_DIE + 2, RIPPER2_DIE_RATE, &AF(NullRipper2), &s_Ripper2Dead[3]},
{RIPPER2_DIE + 3, RIPPER2_DIE_RATE, &AF(NullRipper2), &s_Ripper2Dead[4]},
{RIPPER2_DIE + 4, RIPPER2_DIE_RATE, &AF(NullRipper2), &s_Ripper2Dead[5]},
{RIPPER2_DIE + 5, RIPPER2_DIE_RATE, &AF(NullRipper2), &s_Ripper2Dead[6]},
{RIPPER2_DIE + 6, RIPPER2_DIE_RATE, &AF(NullRipper2), &s_Ripper2Dead[7]},
{RIPPER2_DEAD, SF_QUICK_CALL, &AF(QueueFloorBlood), &s_Ripper2Dead[8]},
{RIPPER2_DEAD, RIPPER2_DEAD_RATE, &AF(DoActorDebris), &s_Ripper2Dead[8]},
{SPR_RIPPER2_DIE, 'A', RIPPER2_DIE_RATE, &AF(NullRipper2), &s_Ripper2Dead[1]},
{SPR_RIPPER2_DIE, 'B', RIPPER2_DIE_RATE, &AF(NullRipper2), &s_Ripper2Dead[2]},
{SPR_RIPPER2_DIE, 'C', RIPPER2_DIE_RATE, &AF(NullRipper2), &s_Ripper2Dead[3]},
{SPR_RIPPER2_DIE, 'D', RIPPER2_DIE_RATE, &AF(NullRipper2), &s_Ripper2Dead[4]},
{SPR_RIPPER2_DIE, 'E', RIPPER2_DIE_RATE, &AF(NullRipper2), &s_Ripper2Dead[5]},
{SPR_RIPPER2_DIE, 'F', RIPPER2_DIE_RATE, &AF(NullRipper2), &s_Ripper2Dead[6]},
{SPR_RIPPER2_DIE, 'G', RIPPER2_DIE_RATE, &AF(NullRipper2), &s_Ripper2Dead[7]},
{SPR_RIPPER2_DEAD, 'A', SF_QUICK_CALL, &AF(QueueFloorBlood), &s_Ripper2Dead[8]},
{SPR_RIPPER2_DEAD, 'A', RIPPER2_DEAD_RATE, &AF(DoActorDebris), &s_Ripper2Dead[8]},
};
STATE* sg_Ripper2Die[] =
@ -766,12 +458,12 @@ STATE* sg_Ripper2Dead[] =
STATE s_Ripper2DeathJump[] =
{
{RIPPER2_DIE + 0, RIPPER2_DIE_RATE, &AF(DoActorDeathMove), &s_Ripper2DeathJump[0]}
{SPR_RIPPER2_DIE, 'A', RIPPER2_DIE_RATE, &AF(DoActorDeathMove), &s_Ripper2DeathJump[0]}
};
STATE s_Ripper2DeathFall[] =
{
{RIPPER2_DIE + 1, RIPPER2_DIE_RATE, &AF(DoActorDeathMove), &s_Ripper2DeathFall[0]}
{SPR_RIPPER2_DIE, 'B', RIPPER2_DIE_RATE, &AF(DoActorDeathMove), &s_Ripper2DeathFall[0]}
};

1
source/games/sw/src/save.cpp
View file

@ -605,7 +605,6 @@ FSerializer& Serialize(FSerializer& arc, const char* keyname, USER& w, USER* def
("flags", w.Flags, def->Flags)
("flags2", w.Flags2, def->Flags2)
("Tics", w.Tics, def->Tics)
("RotNum", w.__legacyState.RotNum, def->__legacyState.RotNum)
("ID", w.ID, def->ID)
("Health", w.Health, def->Health)
("MaxHealth", w.MaxHealth, def->MaxHealth)

416
source/games/sw/src/serp.cpp
View file

@ -128,48 +128,20 @@ ATTRIBUTE SerpPissedAttrib =
#define SERP_RUN_RATE 24
STATE s_SerpRun[5][4] =
STATE s_SerpRun[1][4] =
{
{
{SERP_RUN_R0 + 0, SERP_RUN_RATE, &AF(DoSerpMove), &s_SerpRun[0][1]},
{SERP_RUN_R0 + 1, SERP_RUN_RATE, &AF(DoSerpMove), &s_SerpRun[0][2]},
{SERP_RUN_R0 + 2, SERP_RUN_RATE, &AF(DoSerpMove), &s_SerpRun[0][3]},
{SERP_RUN_R0 + 1, SERP_RUN_RATE, &AF(DoSerpMove), &s_SerpRun[0][0]},
{SPR_SERP_RUN, 'A', SERP_RUN_RATE, &AF(DoSerpMove), &s_SerpRun[0][1]},
{SPR_SERP_RUN, 'B', SERP_RUN_RATE, &AF(DoSerpMove), &s_SerpRun[0][2]},
{SPR_SERP_RUN, 'C', SERP_RUN_RATE, &AF(DoSerpMove), &s_SerpRun[0][3]},
{SPR_SERP_RUN, 'B', SERP_RUN_RATE, &AF(DoSerpMove), &s_SerpRun[0][0]},
},
{
{SERP_RUN_R1 + 0, SERP_RUN_RATE, &AF(DoSerpMove), &s_SerpRun[1][1]},
{SERP_RUN_R1 + 1, SERP_RUN_RATE, &AF(DoSerpMove), &s_SerpRun[1][2]},
{SERP_RUN_R1 + 2, SERP_RUN_RATE, &AF(DoSerpMove), &s_SerpRun[1][3]},
{SERP_RUN_R1 + 1, SERP_RUN_RATE, &AF(DoSerpMove), &s_SerpRun[1][0]},
},
{
{SERP_RUN_R2 + 0, SERP_RUN_RATE, &AF(DoSerpMove), &s_SerpRun[2][1]},
{SERP_RUN_R2 + 1, SERP_RUN_RATE, &AF(DoSerpMove), &s_SerpRun[2][2]},
{SERP_RUN_R2 + 2, SERP_RUN_RATE, &AF(DoSerpMove), &s_SerpRun[2][3]},
{SERP_RUN_R2 + 1, SERP_RUN_RATE, &AF(DoSerpMove), &s_SerpRun[2][0]},
},
{
{SERP_RUN_R3 + 0, SERP_RUN_RATE, &AF(DoSerpMove), &s_SerpRun[3][1]},
{SERP_RUN_R3 + 1, SERP_RUN_RATE, &AF(DoSerpMove), &s_SerpRun[3][2]},
{SERP_RUN_R3 + 2, SERP_RUN_RATE, &AF(DoSerpMove), &s_SerpRun[3][3]},
{SERP_RUN_R3 + 1, SERP_RUN_RATE, &AF(DoSerpMove), &s_SerpRun[3][0]},
},
{
{SERP_RUN_R4 + 0, SERP_RUN_RATE, &AF(DoSerpMove), &s_SerpRun[4][1]},
{SERP_RUN_R4 + 1, SERP_RUN_RATE, &AF(DoSerpMove), &s_SerpRun[4][2]},
{SERP_RUN_R4 + 2, SERP_RUN_RATE, &AF(DoSerpMove), &s_SerpRun[4][3]},
{SERP_RUN_R4 + 1, SERP_RUN_RATE, &AF(DoSerpMove), &s_SerpRun[4][0]},
}
};
STATE* sg_SerpRun[] =
{
&s_SerpRun[0][0],
&s_SerpRun[1][0],
&s_SerpRun[2][0],
&s_SerpRun[3][0],
&s_SerpRun[4][0]
};
//////////////////////
@ -180,78 +152,26 @@ STATE* sg_SerpRun[] =
#define SERP_SLASH_RATE 9
STATE s_SerpSlash[5][10] =
STATE s_SerpSlash[1][10] =
{
{
{SERP_SLASH_R0 + 2, SERP_SLASH_RATE, &AF(NullSerp), &s_SerpSlash[0][1]},
{SERP_SLASH_R0 + 1, SERP_SLASH_RATE, &AF(NullSerp), &s_SerpSlash[0][2]},
{SERP_SLASH_R0 + 0, SERP_SLASH_RATE*2, &AF(NullSerp), &s_SerpSlash[0][3]},
{SERP_SLASH_R0 + 1, SERP_SLASH_RATE, &AF(NullSerp), &s_SerpSlash[0][4]},
{SERP_SLASH_R0 + 2, SERP_SLASH_RATE, &AF(NullSerp), &s_SerpSlash[0][5]},
{SERP_SLASH_R0 + 3, SF_QUICK_CALL, &AF(InitSerpSlash), &s_SerpSlash[0][6]},
{SERP_SLASH_R0 + 3, SERP_SLASH_RATE, &AF(NullSerp), &s_SerpSlash[0][7]},
{SERP_SLASH_R0 + 4, SERP_SLASH_RATE, &AF(NullSerp), &s_SerpSlash[0][8]},
{SERP_SLASH_R0 + 4, 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_SerpSlash[0][9]},
{SERP_SLASH_R0 + 4, SERP_SLASH_RATE, &AF(DoSerpMove), &s_SerpSlash[0][9]},
{SPR_SERP_SLASH, 'C', SERP_SLASH_RATE, &AF(NullSerp), &s_SerpSlash[0][1]},
{SPR_SERP_SLASH, 'B', SERP_SLASH_RATE, &AF(NullSerp), &s_SerpSlash[0][2]},
{SPR_SERP_SLASH, 'A', SERP_SLASH_RATE*2, &AF(NullSerp), &s_SerpSlash[0][3]},
{SPR_SERP_SLASH, 'B', SERP_SLASH_RATE, &AF(NullSerp), &s_SerpSlash[0][4]},
{SPR_SERP_SLASH, 'C', SERP_SLASH_RATE, &AF(NullSerp), &s_SerpSlash[0][5]},
{SPR_SERP_SLASH, 'D', SF_QUICK_CALL, &AF(InitSerpSlash), &s_SerpSlash[0][6]},
{SPR_SERP_SLASH, 'D', SERP_SLASH_RATE, &AF(NullSerp), &s_SerpSlash[0][7]},
{SPR_SERP_SLASH, 'E', SERP_SLASH_RATE, &AF(NullSerp), &s_SerpSlash[0][8]},
{SPR_SERP_SLASH, 'E', 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_SerpSlash[0][9]},
{SPR_SERP_SLASH, 'E', SERP_SLASH_RATE, &AF(DoSerpMove), &s_SerpSlash[0][9]},
},
{
{SERP_SLASH_R1 + 2, SERP_SLASH_RATE, &AF(NullSerp), &s_SerpSlash[1][1]},
{SERP_SLASH_R1 + 1, SERP_SLASH_RATE, &AF(NullSerp), &s_SerpSlash[1][2]},
{SERP_SLASH_R1 + 0, SERP_SLASH_RATE*2, &AF(NullSerp), &s_SerpSlash[1][3]},
{SERP_SLASH_R1 + 1, SERP_SLASH_RATE, &AF(NullSerp), &s_SerpSlash[1][4]},
{SERP_SLASH_R1 + 2, SERP_SLASH_RATE, &AF(NullSerp), &s_SerpSlash[1][5]},
{SERP_SLASH_R1 + 3, SF_QUICK_CALL, &AF(InitSerpSlash), &s_SerpSlash[1][6]},
{SERP_SLASH_R1 + 3, SERP_SLASH_RATE, &AF(NullSerp), &s_SerpSlash[1][7]},
{SERP_SLASH_R1 + 4, SERP_SLASH_RATE, &AF(NullSerp), &s_SerpSlash[1][8]},
{SERP_SLASH_R1 + 4, 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_SerpSlash[1][9]},
{SERP_SLASH_R1 + 4, SERP_SLASH_RATE, &AF(DoSerpMove), &s_SerpSlash[1][9]},
},
{
{SERP_SLASH_R2 + 2, SERP_SLASH_RATE, &AF(NullSerp), &s_SerpSlash[2][1]},
{SERP_SLASH_R2 + 1, SERP_SLASH_RATE, &AF(NullSerp), &s_SerpSlash[2][2]},
{SERP_SLASH_R2 + 0, SERP_SLASH_RATE*2, &AF(NullSerp), &s_SerpSlash[2][3]},
{SERP_SLASH_R2 + 1, SERP_SLASH_RATE, &AF(NullSerp), &s_SerpSlash[2][4]},
{SERP_SLASH_R2 + 2, SERP_SLASH_RATE, &AF(NullSerp), &s_SerpSlash[2][5]},
{SERP_SLASH_R2 + 3, SF_QUICK_CALL, &AF(InitSerpSlash), &s_SerpSlash[2][6]},
{SERP_SLASH_R2 + 3, SERP_SLASH_RATE, &AF(NullSerp), &s_SerpSlash[2][7]},
{SERP_SLASH_R2 + 4, SERP_SLASH_RATE, &AF(NullSerp), &s_SerpSlash[2][8]},
{SERP_SLASH_R2 + 4, 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_SerpSlash[2][9]},
{SERP_SLASH_R2 + 4, SERP_SLASH_RATE, &AF(DoSerpMove), &s_SerpSlash[2][9]},
},
{
{SERP_SLASH_R3 + 2, SERP_SLASH_RATE, &AF(NullSerp), &s_SerpSlash[3][1]},
{SERP_SLASH_R3 + 1, SERP_SLASH_RATE, &AF(NullSerp), &s_SerpSlash[3][2]},
{SERP_SLASH_R3 + 0, SERP_SLASH_RATE*2, &AF(NullSerp), &s_SerpSlash[3][3]},
{SERP_SLASH_R3 + 1, SERP_SLASH_RATE, &AF(NullSerp), &s_SerpSlash[3][4]},
{SERP_SLASH_R3 + 2, SERP_SLASH_RATE, &AF(NullSerp), &s_SerpSlash[3][5]},
{SERP_SLASH_R3 + 3, SF_QUICK_CALL, &AF(InitSerpSlash), &s_SerpSlash[3][6]},
{SERP_SLASH_R3 + 3, SERP_SLASH_RATE, &AF(NullSerp), &s_SerpSlash[3][7]},
{SERP_SLASH_R3 + 4, SERP_SLASH_RATE, &AF(NullSerp), &s_SerpSlash[3][8]},
{SERP_SLASH_R3 + 4, 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_SerpSlash[3][9]},
{SERP_SLASH_R3 + 4, SERP_SLASH_RATE, &AF(DoSerpMove), &s_SerpSlash[3][9]},
},
{
{SERP_SLASH_R4 + 2, SERP_SLASH_RATE, &AF(NullSerp), &s_SerpSlash[4][1]},
{SERP_SLASH_R4 + 1, SERP_SLASH_RATE, &AF(NullSerp), &s_SerpSlash[4][2]},
{SERP_SLASH_R4 + 0, SERP_SLASH_RATE*2, &AF(NullSerp), &s_SerpSlash[4][3]},
{SERP_SLASH_R4 + 1, SERP_SLASH_RATE, &AF(NullSerp), &s_SerpSlash[4][4]},
{SERP_SLASH_R4 + 2, SERP_SLASH_RATE, &AF(NullSerp), &s_SerpSlash[4][5]},
{SERP_SLASH_R4 + 3, SF_QUICK_CALL, &AF(InitSerpSlash), &s_SerpSlash[4][6]},
{SERP_SLASH_R4 + 3, SERP_SLASH_RATE, &AF(NullSerp), &s_SerpSlash[4][7]},
{SERP_SLASH_R4 + 4, SERP_SLASH_RATE, &AF(NullSerp), &s_SerpSlash[4][8]},
{SERP_SLASH_R4 + 4, 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_SerpSlash[4][9]},
{SERP_SLASH_R4 + 4, SERP_SLASH_RATE, &AF(DoSerpMove), &s_SerpSlash[4][9]},
}
};
STATE* sg_SerpSlash[] =
{
&s_SerpSlash[0][0],
&s_SerpSlash[1][0],
&s_SerpSlash[2][0],
&s_SerpSlash[3][0],
&s_SerpSlash[4][0]
};
@ -263,68 +183,24 @@ STATE* sg_SerpSlash[] =
#define SERP_SKULL_SPELL_RATE 18
STATE s_SerpSkullSpell[5][8] =
STATE s_SerpSkullSpell[1][8] =
{
{
{SERP_SPELL_R0 + 2, SERP_SKULL_SPELL_RATE*2, &AF(NullSerp), &s_SerpSkullSpell[0][1]},
{SERP_SPELL_R0 + 1, SERP_SKULL_SPELL_RATE, &AF(NullSerp), &s_SerpSkullSpell[0][2]},
{SERP_SPELL_R0 + 0, SERP_SKULL_SPELL_RATE*2, &AF(NullSerp), &s_SerpSkullSpell[0][3]},
{SERP_SPELL_R0 + 0, SF_QUICK_CALL, &AF(InitSerpRing), &s_SerpSkullSpell[0][4]},
{SERP_SPELL_R0 + 0, SERP_SKULL_SPELL_RATE, &AF(NullSerp), &s_SerpSkullSpell[0][5]},
{SERP_SPELL_R0 + 1, SERP_SKULL_SPELL_RATE, &AF(NullSerp), &s_SerpSkullSpell[0][6]},
{SERP_SPELL_R0 + 1, SF_QUICK_CALL, &AF(InitActorDecide), &s_SerpSkullSpell[0][7]},
{SERP_SPELL_R0 + 1, SERP_SKULL_SPELL_RATE, &AF(DoSerpMove), &s_SerpSkullSpell[0][7]},
{SPR_SERP_SPELL, 'C', SERP_SKULL_SPELL_RATE*2, &AF(NullSerp), &s_SerpSkullSpell[0][1]},
{SPR_SERP_SPELL, 'B', SERP_SKULL_SPELL_RATE, &AF(NullSerp), &s_SerpSkullSpell[0][2]},
{SPR_SERP_SPELL, 'A', SERP_SKULL_SPELL_RATE*2, &AF(NullSerp), &s_SerpSkullSpell[0][3]},
{SPR_SERP_SPELL, 'A', SF_QUICK_CALL, &AF(InitSerpRing), &s_SerpSkullSpell[0][4]},
{SPR_SERP_SPELL, 'A', SERP_SKULL_SPELL_RATE, &AF(NullSerp), &s_SerpSkullSpell[0][5]},
{SPR_SERP_SPELL, 'B', SERP_SKULL_SPELL_RATE, &AF(NullSerp), &s_SerpSkullSpell[0][6]},
{SPR_SERP_SPELL, 'B', SF_QUICK_CALL, &AF(InitActorDecide), &s_SerpSkullSpell[0][7]},
{SPR_SERP_SPELL, 'B', SERP_SKULL_SPELL_RATE, &AF(DoSerpMove), &s_SerpSkullSpell[0][7]},
},
{
{SERP_SPELL_R1 + 2, SERP_SKULL_SPELL_RATE*2, &AF(NullSerp), &s_SerpSkullSpell[1][1]},
{SERP_SPELL_R1 + 1, SERP_SKULL_SPELL_RATE, &AF(NullSerp), &s_SerpSkullSpell[1][2]},
{SERP_SPELL_R1 + 0, SERP_SKULL_SPELL_RATE*2, &AF(NullSerp), &s_SerpSkullSpell[1][3]},
{SERP_SPELL_R1 + 0, SF_QUICK_CALL, &AF(InitSerpRing), &s_SerpSkullSpell[1][4]},
{SERP_SPELL_R1 + 0, SERP_SKULL_SPELL_RATE, &AF(NullSerp), &s_SerpSkullSpell[1][5]},
{SERP_SPELL_R1 + 1, SERP_SKULL_SPELL_RATE, &AF(NullSerp), &s_SerpSkullSpell[1][6]},
{SERP_SPELL_R1 + 1, SF_QUICK_CALL, &AF(InitActorDecide), &s_SerpSkullSpell[1][7]},
{SERP_SPELL_R1 + 1, SERP_SKULL_SPELL_RATE, &AF(DoSerpMove), &s_SerpSkullSpell[1][7]},
},
{
{SERP_SPELL_R2 + 2, SERP_SKULL_SPELL_RATE*2, &AF(NullSerp), &s_SerpSkullSpell[2][1]},
{SERP_SPELL_R2 + 1, SERP_SKULL_SPELL_RATE, &AF(NullSerp), &s_SerpSkullSpell[2][2]},
{SERP_SPELL_R2 + 0, SERP_SKULL_SPELL_RATE*2, &AF(NullSerp), &s_SerpSkullSpell[2][3]},
{SERP_SPELL_R2 + 0, SF_QUICK_CALL, &AF(InitSerpRing), &s_SerpSkullSpell[2][4]},
{SERP_SPELL_R2 + 0, SERP_SKULL_SPELL_RATE, &AF(NullSerp), &s_SerpSkullSpell[2][5]},
{SERP_SPELL_R2 + 1, SERP_SKULL_SPELL_RATE, &AF(NullSerp), &s_SerpSkullSpell[2][6]},
{SERP_SPELL_R2 + 1, SF_QUICK_CALL, &AF(InitActorDecide), &s_SerpSkullSpell[2][7]},
{SERP_SPELL_R2 + 1, SERP_SKULL_SPELL_RATE, &AF(DoSerpMove), &s_SerpSkullSpell[2][7]},
},
{
{SERP_SPELL_R3 + 2, SERP_SKULL_SPELL_RATE*2, &AF(NullSerp), &s_SerpSkullSpell[3][1]},
{SERP_SPELL_R3 + 1, SERP_SKULL_SPELL_RATE, &AF(NullSerp), &s_SerpSkullSpell[3][2]},
{SERP_SPELL_R3 + 0, SERP_SKULL_SPELL_RATE*2, &AF(NullSerp), &s_SerpSkullSpell[3][3]},
{SERP_SPELL_R3 + 0, SF_QUICK_CALL, &AF(InitSerpRing), &s_SerpSkullSpell[3][4]},
{SERP_SPELL_R3 + 0, SERP_SKULL_SPELL_RATE, &AF(NullSerp), &s_SerpSkullSpell[3][5]},
{SERP_SPELL_R3 + 1, SERP_SKULL_SPELL_RATE, &AF(NullSerp), &s_SerpSkullSpell[3][6]},
{SERP_SPELL_R3 + 1, SF_QUICK_CALL, &AF(InitActorDecide), &s_SerpSkullSpell[3][7]},
{SERP_SPELL_R3 + 1, SERP_SKULL_SPELL_RATE, &AF(DoSerpMove), &s_SerpSkullSpell[3][7]},
},
{
{SERP_SPELL_R4 + 2, SERP_SKULL_SPELL_RATE*2, &AF(NullSerp), &s_SerpSkullSpell[4][1]},
{SERP_SPELL_R4 + 1, SERP_SKULL_SPELL_RATE, &AF(NullSerp), &s_SerpSkullSpell[4][2]},
{SERP_SPELL_R4 + 0, SERP_SKULL_SPELL_RATE*2, &AF(NullSerp), &s_SerpSkullSpell[4][3]},
{SERP_SPELL_R4 + 0, SF_QUICK_CALL, &AF(InitSerpRing), &s_SerpSkullSpell[4][4]},
{SERP_SPELL_R4 + 0, SERP_SKULL_SPELL_RATE, &AF(NullSerp), &s_SerpSkullSpell[4][5]},
{SERP_SPELL_R4 + 1, SERP_SKULL_SPELL_RATE, &AF(NullSerp), &s_SerpSkullSpell[4][6]},
{SERP_SPELL_R4 + 1, SF_QUICK_CALL, &AF(InitActorDecide), &s_SerpSkullSpell[4][7]},
{SERP_SPELL_R4 + 1, SERP_SKULL_SPELL_RATE, &AF(DoSerpMove), &s_SerpSkullSpell[4][7]},
}
};
STATE* sg_SerpSkullSpell[] =
{
&s_SerpSkullSpell[0][0],
&s_SerpSkullSpell[1][0],
&s_SerpSkullSpell[2][0],
&s_SerpSkullSpell[3][0],
&s_SerpSkullSpell[4][0]
};
@ -337,68 +213,24 @@ STATE* sg_SerpSkullSpell[] =
#define SERP_SPELL_RATE 18
STATE s_SerpSpell[5][8] =
STATE s_SerpSpell[1][8] =
{
{
{SERP_SPELL_R0 + 2, SERP_SPELL_RATE*2, &AF(NullSerp), &s_SerpSpell[0][1]},
{SERP_SPELL_R0 + 1, SERP_SPELL_RATE, &AF(NullSerp), &s_SerpSpell[0][2]},
{SERP_SPELL_R0 + 0, SERP_SPELL_RATE*2, &AF(NullSerp), &s_SerpSpell[0][3]},
{SERP_SPELL_R0 + 0, SF_QUICK_CALL, &AF(InitSerpSpell), &s_SerpSpell[0][4]},
{SERP_SPELL_R0 + 0, SERP_SPELL_RATE, &AF(NullSerp), &s_SerpSpell[0][5]},
{SERP_SPELL_R0 + 1, SERP_SPELL_RATE, &AF(NullSerp), &s_SerpSpell[0][6]},
{SERP_SPELL_R0 + 1, SF_QUICK_CALL, &AF(InitActorDecide), &s_SerpSpell[0][7]},
{SERP_SPELL_R0 + 1, SERP_SPELL_RATE, &AF(DoSerpMove), &s_SerpSpell[0][7]},
{SPR_SERP_SPELL, 'C', SERP_SPELL_RATE*2, &AF(NullSerp), &s_SerpSpell[0][1]},
{SPR_SERP_SPELL, 'B', SERP_SPELL_RATE, &AF(NullSerp), &s_SerpSpell[0][2]},
{SPR_SERP_SPELL, 'A', SERP_SPELL_RATE*2, &AF(NullSerp), &s_SerpSpell[0][3]},
{SPR_SERP_SPELL, 'A', SF_QUICK_CALL, &AF(InitSerpSpell), &s_SerpSpell[0][4]},
{SPR_SERP_SPELL, 'A', SERP_SPELL_RATE, &AF(NullSerp), &s_SerpSpell[0][5]},
{SPR_SERP_SPELL, 'B', SERP_SPELL_RATE, &AF(NullSerp), &s_SerpSpell[0][6]},
{SPR_SERP_SPELL, 'B', SF_QUICK_CALL, &AF(InitActorDecide), &s_SerpSpell[0][7]},
{SPR_SERP_SPELL, 'B', SERP_SPELL_RATE, &AF(DoSerpMove), &s_SerpSpell[0][7]},
},
{
{SERP_SPELL_R1 + 2, SERP_SPELL_RATE*2, &AF(NullSerp), &s_SerpSpell[1][1]},
{SERP_SPELL_R1 + 1, SERP_SPELL_RATE, &AF(NullSerp), &s_SerpSpell[1][2]},
{SERP_SPELL_R1 + 0, SERP_SPELL_RATE*2, &AF(NullSerp), &s_SerpSpell[1][3]},
{SERP_SPELL_R1 + 0, SF_QUICK_CALL, &AF(InitSerpSpell), &s_SerpSpell[1][4]},
{SERP_SPELL_R1 + 0, SERP_SPELL_RATE, &AF(NullSerp), &s_SerpSpell[1][5]},
{SERP_SPELL_R1 + 1, SERP_SPELL_RATE, &AF(NullSerp), &s_SerpSpell[1][6]},
{SERP_SPELL_R1 + 1, SF_QUICK_CALL, &AF(InitActorDecide), &s_SerpSpell[1][7]},
{SERP_SPELL_R1 + 1, SERP_SPELL_RATE, &AF(DoSerpMove), &s_SerpSpell[1][7]},
},
{
{SERP_SPELL_R2 + 2, SERP_SPELL_RATE*2, &AF(NullSerp), &s_SerpSpell[2][1]},
{SERP_SPELL_R2 + 1, SERP_SPELL_RATE, &AF(NullSerp), &s_SerpSpell[2][2]},
{SERP_SPELL_R2 + 0, SERP_SPELL_RATE*2, &AF(NullSerp), &s_SerpSpell[2][3]},
{SERP_SPELL_R2 + 0, SF_QUICK_CALL, &AF(InitSerpSpell), &s_SerpSpell[2][4]},
{SERP_SPELL_R2 + 0, SERP_SPELL_RATE, &AF(NullSerp), &s_SerpSpell[2][5]},
{SERP_SPELL_R2 + 1, SERP_SPELL_RATE, &AF(NullSerp), &s_SerpSpell[2][6]},
{SERP_SPELL_R2 + 1, SF_QUICK_CALL, &AF(InitActorDecide), &s_SerpSpell[2][7]},
{SERP_SPELL_R2 + 1, SERP_SPELL_RATE, &AF(DoSerpMove), &s_SerpSpell[2][7]},
},
{
{SERP_SPELL_R3 + 2, SERP_SPELL_RATE*2, &AF(NullSerp), &s_SerpSpell[3][1]},
{SERP_SPELL_R3 + 1, SERP_SPELL_RATE, &AF(NullSerp), &s_SerpSpell[3][2]},
{SERP_SPELL_R3 + 0, SERP_SPELL_RATE*2, &AF(NullSerp), &s_SerpSpell[3][3]},
{SERP_SPELL_R3 + 0, SF_QUICK_CALL, &AF(InitSerpSpell), &s_SerpSpell[3][4]},
{SERP_SPELL_R3 + 0, SERP_SPELL_RATE, &AF(NullSerp), &s_SerpSpell[3][5]},
{SERP_SPELL_R3 + 1, SERP_SPELL_RATE, &AF(NullSerp), &s_SerpSpell[3][6]},
{SERP_SPELL_R3 + 1, SF_QUICK_CALL, &AF(InitActorDecide), &s_SerpSpell[3][7]},
{SERP_SPELL_R3 + 1, SERP_SPELL_RATE, &AF(DoSerpMove), &s_SerpSpell[3][7]},
},
{
{SERP_SPELL_R4 + 2, SERP_SPELL_RATE*2, &AF(NullSerp), &s_SerpSpell[4][1]},
{SERP_SPELL_R4 + 1, SERP_SPELL_RATE, &AF(NullSerp), &s_SerpSpell[4][2]},
{SERP_SPELL_R4 + 0, SERP_SPELL_RATE*2, &AF(NullSerp), &s_SerpSpell[4][3]},
{SERP_SPELL_R4 + 0, SF_QUICK_CALL, &AF(InitSerpSpell), &s_SerpSpell[4][4]},
{SERP_SPELL_R4 + 0, SERP_SPELL_RATE, &AF(NullSerp), &s_SerpSpell[4][5]},
{SERP_SPELL_R4 + 1, SERP_SPELL_RATE, &AF(NullSerp), &s_SerpSpell[4][6]},
{SERP_SPELL_R4 + 1, SF_QUICK_CALL, &AF(InitActorDecide), &s_SerpSpell[4][7]},
{SERP_SPELL_R4 + 1, SERP_SPELL_RATE, &AF(DoSerpMove), &s_SerpSpell[4][7]},
}
};
STATE* sg_SerpSpell[] =
{
&s_SerpSpell[0][0],
&s_SerpSpell[1][0],
&s_SerpSpell[2][0],
&s_SerpSpell[3][0],
&s_SerpSpell[4][0]
};
//////////////////////
@ -407,68 +239,24 @@ STATE* sg_SerpSpell[] =
//
//////////////////////
STATE s_SerpMonstSpell[5][8] =
STATE s_SerpMonstSpell[1][8] =
{
{
{SERP_SPELL_R0 + 2, SERP_SPELL_RATE*2, &AF(NullSerp), &s_SerpMonstSpell[0][1]},
{SERP_SPELL_R0 + 1, SERP_SPELL_RATE, &AF(NullSerp), &s_SerpMonstSpell[0][2]},
{SERP_SPELL_R0 + 0, SERP_SPELL_RATE*2, &AF(NullSerp), &s_SerpMonstSpell[0][3]},
{SERP_SPELL_R0 + 0, SF_QUICK_CALL, &AF(InitSerpMonstSpell), &s_SerpMonstSpell[0][4]},
{SERP_SPELL_R0 + 0, SERP_SPELL_RATE, &AF(NullSerp), &s_SerpMonstSpell[0][5]},
{SERP_SPELL_R0 + 1, SERP_SPELL_RATE, &AF(NullSerp), &s_SerpMonstSpell[0][6]},
{SERP_SPELL_R0 + 1, SF_QUICK_CALL, &AF(InitActorDecide), &s_SerpMonstSpell[0][7]},
{SERP_SPELL_R0 + 1, SERP_SPELL_RATE, &AF(DoSerpMove), &s_SerpMonstSpell[0][7]},
{SPR_SERP_SPELL, 'C', SERP_SPELL_RATE*2, &AF(NullSerp), &s_SerpMonstSpell[0][1]},
{SPR_SERP_SPELL, 'B', SERP_SPELL_RATE, &AF(NullSerp), &s_SerpMonstSpell[0][2]},
{SPR_SERP_SPELL, 'A', SERP_SPELL_RATE*2, &AF(NullSerp), &s_SerpMonstSpell[0][3]},
{SPR_SERP_SPELL, 'A', SF_QUICK_CALL, &AF(InitSerpMonstSpell), &s_SerpMonstSpell[0][4]},
{SPR_SERP_SPELL, 'A', SERP_SPELL_RATE, &AF(NullSerp), &s_SerpMonstSpell[0][5]},
{SPR_SERP_SPELL, 'B', SERP_SPELL_RATE, &AF(NullSerp), &s_SerpMonstSpell[0][6]},
{SPR_SERP_SPELL, 'B', SF_QUICK_CALL, &AF(InitActorDecide), &s_SerpMonstSpell[0][7]},
{SPR_SERP_SPELL, 'B', SERP_SPELL_RATE, &AF(DoSerpMove), &s_SerpMonstSpell[0][7]},
},
{
{SERP_SPELL_R1 + 2, SERP_SPELL_RATE*2, &AF(NullSerp), &s_SerpMonstSpell[1][1]},
{SERP_SPELL_R1 + 1, SERP_SPELL_RATE, &AF(NullSerp), &s_SerpMonstSpell[1][2]},
{SERP_SPELL_R1 + 0, SERP_SPELL_RATE*2, &AF(NullSerp), &s_SerpMonstSpell[1][3]},
{SERP_SPELL_R1 + 0, SF_QUICK_CALL, &AF(InitSerpMonstSpell), &s_SerpMonstSpell[1][4]},
{SERP_SPELL_R1 + 0, SERP_SPELL_RATE, &AF(NullSerp), &s_SerpMonstSpell[1][5]},
{SERP_SPELL_R1 + 1, SERP_SPELL_RATE, &AF(NullSerp), &s_SerpMonstSpell[1][6]},
{SERP_SPELL_R1 + 1, SF_QUICK_CALL, &AF(InitActorDecide), &s_SerpMonstSpell[1][7]},
{SERP_SPELL_R1 + 1, SERP_SPELL_RATE, &AF(DoSerpMove), &s_SerpMonstSpell[1][7]},
},
{
{SERP_SPELL_R2 + 2, SERP_SPELL_RATE*2, &AF(NullSerp), &s_SerpMonstSpell[2][1]},
{SERP_SPELL_R2 + 1, SERP_SPELL_RATE, &AF(NullSerp), &s_SerpMonstSpell[2][2]},
{SERP_SPELL_R2 + 0, SERP_SPELL_RATE*2, &AF(NullSerp), &s_SerpMonstSpell[2][3]},
{SERP_SPELL_R2 + 0, SF_QUICK_CALL, &AF(InitSerpMonstSpell), &s_SerpMonstSpell[2][4]},
{SERP_SPELL_R2 + 0, SERP_SPELL_RATE, &AF(NullSerp), &s_SerpMonstSpell[2][5]},
{SERP_SPELL_R2 + 1, SERP_SPELL_RATE, &AF(NullSerp), &s_SerpMonstSpell[2][6]},
{SERP_SPELL_R2 + 1, SF_QUICK_CALL, &AF(InitActorDecide), &s_SerpMonstSpell[2][7]},
{SERP_SPELL_R2 + 1, SERP_SPELL_RATE, &AF(DoSerpMove), &s_SerpMonstSpell[2][7]},
},
{
{SERP_SPELL_R3 + 2, SERP_SPELL_RATE*2, &AF(NullSerp), &s_SerpMonstSpell[3][1]},
{SERP_SPELL_R3 + 1, SERP_SPELL_RATE, &AF(NullSerp), &s_SerpMonstSpell[3][2]},
{SERP_SPELL_R3 + 0, SERP_SPELL_RATE*2, &AF(NullSerp), &s_SerpMonstSpell[3][3]},
{SERP_SPELL_R3 + 0, SF_QUICK_CALL, &AF(InitSerpMonstSpell), &s_SerpMonstSpell[3][4]},
{SERP_SPELL_R3 + 0, SERP_SPELL_RATE, &AF(NullSerp), &s_SerpMonstSpell[3][5]},
{SERP_SPELL_R3 + 1, SERP_SPELL_RATE, &AF(NullSerp), &s_SerpMonstSpell[3][6]},
{SERP_SPELL_R3 + 1, SF_QUICK_CALL, &AF(InitActorDecide), &s_SerpMonstSpell[3][7]},
{SERP_SPELL_R3 + 1, SERP_SPELL_RATE, &AF(DoSerpMove), &s_SerpMonstSpell[3][7]},
},
{
{SERP_SPELL_R4 + 2, SERP_SPELL_RATE*2, &AF(NullSerp), &s_SerpMonstSpell[4][1]},
{SERP_SPELL_R4 + 1, SERP_SPELL_RATE, &AF(NullSerp), &s_SerpMonstSpell[4][2]},
{SERP_SPELL_R4 + 0, SERP_SPELL_RATE*2, &AF(NullSerp), &s_SerpMonstSpell[4][3]},
{SERP_SPELL_R4 + 0, SF_QUICK_CALL, &AF(InitSerpMonstSpell), &s_SerpMonstSpell[4][4]},
{SERP_SPELL_R4 + 0, SERP_SPELL_RATE, &AF(NullSerp), &s_SerpMonstSpell[4][5]},
{SERP_SPELL_R4 + 1, SERP_SPELL_RATE, &AF(NullSerp), &s_SerpMonstSpell[4][6]},
{SERP_SPELL_R4 + 1, SF_QUICK_CALL, &AF(InitActorDecide), &s_SerpMonstSpell[4][7]},
{SERP_SPELL_R4 + 1, SERP_SPELL_RATE, &AF(DoSerpMove), &s_SerpMonstSpell[4][7]},
}
};
STATE* sg_SerpMonstSpell[] =
{
&s_SerpMonstSpell[0][0],
&s_SerpMonstSpell[1][0],
&s_SerpMonstSpell[2][0],
&s_SerpMonstSpell[3][0],
&s_SerpMonstSpell[4][0]
};
@ -480,78 +268,26 @@ STATE* sg_SerpMonstSpell[] =
#define SERP_SPELL_RATE 18
STATE s_SerpRapidSpell[5][10] =
STATE s_SerpRapidSpell[1][10] =
{
{
{SERP_SPELL_R0 + 2, SERP_SPELL_RATE*2, &AF(NullSerp), &s_SerpRapidSpell[0][1]},
{SERP_SPELL_R0 + 1, SERP_SPELL_RATE, &AF(NullSerp), &s_SerpRapidSpell[0][2]},
{SERP_SPELL_R0 + 0, SERP_SPELL_RATE*2, &AF(NullSerp), &s_SerpRapidSpell[0][3]},
{SERP_SPELL_R0 + 0, SF_QUICK_CALL, &AF(InitSerpSpell), &s_SerpRapidSpell[0][4]},
{SERP_SPELL_R0 + 0, SERP_SPELL_RATE*2, &AF(NullSerp), &s_SerpRapidSpell[0][5]},
{SERP_SPELL_R0 + 0, SF_QUICK_CALL, &AF(InitSerpSpell), &s_SerpRapidSpell[0][6]},
{SERP_SPELL_R0 + 0, SERP_SPELL_RATE, &AF(NullSerp), &s_SerpRapidSpell[0][7]},
{SERP_SPELL_R0 + 1, SERP_SPELL_RATE, &AF(NullSerp), &s_SerpRapidSpell[0][8]},
{SERP_SPELL_R0 + 1, SF_QUICK_CALL, &AF(InitActorDecide), &s_SerpRapidSpell[0][9]},
{SERP_SPELL_R0 + 1, SERP_SPELL_RATE, &AF(DoSerpMove), &s_SerpRapidSpell[0][9]},
{SPR_SERP_SPELL, 'C', SERP_SPELL_RATE*2, &AF(NullSerp), &s_SerpRapidSpell[0][1]},
{SPR_SERP_SPELL, 'B', SERP_SPELL_RATE, &AF(NullSerp), &s_SerpRapidSpell[0][2]},
{SPR_SERP_SPELL, 'A', SERP_SPELL_RATE*2, &AF(NullSerp), &s_SerpRapidSpell[0][3]},
{SPR_SERP_SPELL, 'A', SF_QUICK_CALL, &AF(InitSerpSpell), &s_SerpRapidSpell[0][4]},
{SPR_SERP_SPELL, 'A', SERP_SPELL_RATE*2, &AF(NullSerp), &s_SerpRapidSpell[0][5]},
{SPR_SERP_SPELL, 'A', SF_QUICK_CALL, &AF(InitSerpSpell), &s_SerpRapidSpell[0][6]},
{SPR_SERP_SPELL, 'A', SERP_SPELL_RATE, &AF(NullSerp), &s_SerpRapidSpell[0][7]},
{SPR_SERP_SPELL, 'B', SERP_SPELL_RATE, &AF(NullSerp), &s_SerpRapidSpell[0][8]},
{SPR_SERP_SPELL, 'B', SF_QUICK_CALL, &AF(InitActorDecide), &s_SerpRapidSpell[0][9]},
{SPR_SERP_SPELL, 'B', SERP_SPELL_RATE, &AF(DoSerpMove), &s_SerpRapidSpell[0][9]},
},
{
{SERP_SPELL_R1 + 2, SERP_SPELL_RATE*2, &AF(NullSerp), &s_SerpRapidSpell[1][1]},
{SERP_SPELL_R1 + 1, SERP_SPELL_RATE, &AF(NullSerp), &s_SerpRapidSpell[1][2]},
{SERP_SPELL_R1 + 0, SERP_SPELL_RATE*2, &AF(NullSerp), &s_SerpRapidSpell[1][3]},
{SERP_SPELL_R1 + 0, SF_QUICK_CALL, &AF(InitSerpSpell), &s_SerpRapidSpell[1][4]},
{SERP_SPELL_R1 + 0, SERP_SPELL_RATE*2, &AF(NullSerp), &s_SerpRapidSpell[1][5]},
{SERP_SPELL_R1 + 0, SF_QUICK_CALL, &AF(InitSerpSpell), &s_SerpRapidSpell[1][6]},
{SERP_SPELL_R1 + 0, SERP_SPELL_RATE, &AF(NullSerp), &s_SerpRapidSpell[1][7]},
{SERP_SPELL_R1 + 1, SERP_SPELL_RATE, &AF(NullSerp), &s_SerpRapidSpell[1][8]},
{SERP_SPELL_R1 + 1, SF_QUICK_CALL, &AF(InitActorDecide), &s_SerpRapidSpell[1][9]},
{SERP_SPELL_R1 + 1, SERP_SPELL_RATE, &AF(DoSerpMove), &s_SerpRapidSpell[1][9]},
},
{
{SERP_SPELL_R2 + 2, SERP_SPELL_RATE*2, &AF(NullSerp), &s_SerpRapidSpell[2][1]},
{SERP_SPELL_R2 + 1, SERP_SPELL_RATE, &AF(NullSerp), &s_SerpRapidSpell[2][2]},
{SERP_SPELL_R2 + 0, SERP_SPELL_RATE*2, &AF(NullSerp), &s_SerpRapidSpell[2][3]},
{SERP_SPELL_R2 + 0, SF_QUICK_CALL, &AF(InitSerpSpell), &s_SerpRapidSpell[2][4]},
{SERP_SPELL_R2 + 0, SERP_SPELL_RATE*2, &AF(NullSerp), &s_SerpRapidSpell[2][5]},
{SERP_SPELL_R2 + 0, SF_QUICK_CALL, &AF(InitSerpSpell), &s_SerpRapidSpell[2][6]},
{SERP_SPELL_R2 + 0, SERP_SPELL_RATE, &AF(NullSerp), &s_SerpRapidSpell[2][7]},
{SERP_SPELL_R2 + 1, SERP_SPELL_RATE, &AF(NullSerp), &s_SerpRapidSpell[2][8]},
{SERP_SPELL_R2 + 1, SF_QUICK_CALL, &AF(InitActorDecide), &s_SerpRapidSpell[2][9]},
{SERP_SPELL_R2 + 1, SERP_SPELL_RATE, &AF(DoSerpMove), &s_SerpRapidSpell[2][9]},
},
{
{SERP_SPELL_R3 + 2, SERP_SPELL_RATE*2, &AF(NullSerp), &s_SerpRapidSpell[3][1]},
{SERP_SPELL_R3 + 1, SERP_SPELL_RATE, &AF(NullSerp), &s_SerpRapidSpell[3][2]},
{SERP_SPELL_R3 + 0, SERP_SPELL_RATE*2, &AF(NullSerp), &s_SerpRapidSpell[3][3]},
{SERP_SPELL_R3 + 0, SF_QUICK_CALL, &AF(InitSerpSpell), &s_SerpRapidSpell[3][4]},
{SERP_SPELL_R3 + 0, SERP_SPELL_RATE*2, &AF(NullSerp), &s_SerpRapidSpell[3][5]},
{SERP_SPELL_R3 + 0, SF_QUICK_CALL, &AF(InitSerpSpell), &s_SerpRapidSpell[3][6]},
{SERP_SPELL_R3 + 0, SERP_SPELL_RATE, &AF(NullSerp), &s_SerpRapidSpell[3][7]},
{SERP_SPELL_R3 + 1, SERP_SPELL_RATE, &AF(NullSerp), &s_SerpRapidSpell[3][8]},
{SERP_SPELL_R3 + 1, SF_QUICK_CALL, &AF(InitActorDecide), &s_SerpRapidSpell[3][9]},
{SERP_SPELL_R3 + 1, SERP_SPELL_RATE, &AF(DoSerpMove), &s_SerpRapidSpell[3][9]},
},
{
{SERP_SPELL_R4 + 2, SERP_SPELL_RATE*2, &AF(NullSerp), &s_SerpRapidSpell[4][1]},
{SERP_SPELL_R4 + 1, SERP_SPELL_RATE, &AF(NullSerp), &s_SerpRapidSpell[4][2]},
{SERP_SPELL_R4 + 0, SERP_SPELL_RATE*2, &AF(NullSerp), &s_SerpRapidSpell[4][3]},
{SERP_SPELL_R4 + 0, SF_QUICK_CALL, &AF(InitSerpSpell), &s_SerpRapidSpell[4][4]},
{SERP_SPELL_R4 + 0, SERP_SPELL_RATE*2, &AF(NullSerp), &s_SerpRapidSpell[4][5]},
{SERP_SPELL_R4 + 0, SF_QUICK_CALL, &AF(InitSerpSpell), &s_SerpRapidSpell[4][6]},
{SERP_SPELL_R4 + 0, SERP_SPELL_RATE, &AF(NullSerp), &s_SerpRapidSpell[4][7]},
{SERP_SPELL_R4 + 1, SERP_SPELL_RATE, &AF(NullSerp), &s_SerpRapidSpell[4][8]},
{SERP_SPELL_R4 + 1, SF_QUICK_CALL, &AF(InitActorDecide), &s_SerpRapidSpell[4][9]},
{SERP_SPELL_R4 + 1, SERP_SPELL_RATE, &AF(DoSerpMove), &s_SerpRapidSpell[4][9]},
}
};
STATE* sg_SerpRapidSpell[] =
{
&s_SerpRapidSpell[0][0],
&s_SerpRapidSpell[1][0],
&s_SerpRapidSpell[2][0],
&s_SerpRapidSpell[3][0],
&s_SerpRapidSpell[4][0]
};
//////////////////////
@ -562,22 +298,10 @@ STATE* sg_SerpRapidSpell[] =
#define SERP_STAND_RATE 12
STATE s_SerpStand[5][1] =
STATE s_SerpStand[1][1] =
{
{
{SERP_RUN_R0 + 0, SERP_STAND_RATE, &AF(DoSerpMove), &s_SerpStand[0][0]},
},
{
{SERP_RUN_R1 + 0, SERP_STAND_RATE, &AF(DoSerpMove), &s_SerpStand[1][0]},
},
{
{SERP_RUN_R2 + 0, SERP_STAND_RATE, &AF(DoSerpMove), &s_SerpStand[2][0]},
},
{
{SERP_RUN_R3 + 0, SERP_STAND_RATE, &AF(DoSerpMove), &s_SerpStand[3][0]},
},
{
{SERP_RUN_R4 + 0, SERP_STAND_RATE, &AF(DoSerpMove), &s_SerpStand[4][0]},
{SPR_SERP_RUN, 'A', SERP_STAND_RATE, &AF(DoSerpMove), &s_SerpStand[0][0]},
},
};
@ -585,10 +309,6 @@ STATE s_SerpStand[5][1] =
STATE* sg_SerpStand[] =
{
s_SerpStand[0],
s_SerpStand[1],
s_SerpStand[2],
s_SerpStand[3],
s_SerpStand[4]
};
//////////////////////
@ -601,22 +321,22 @@ STATE* sg_SerpStand[] =
STATE s_SerpDie[] =
{
{SERP_DIE + 0, SERP_DIE_RATE, &AF(NullSerp), &s_SerpDie[1]},
{SERP_DIE + 1, SERP_DIE_RATE, &AF(NullSerp), &s_SerpDie[2]},
{SERP_DIE + 2, SERP_DIE_RATE, &AF(NullSerp), &s_SerpDie[3]},
{SERP_DIE + 3, SERP_DIE_RATE, &AF(NullSerp), &s_SerpDie[4]},
{SERP_DIE + 4, SERP_DIE_RATE, &AF(NullSerp), &s_SerpDie[5]},
{SERP_DIE + 5, SERP_DIE_RATE, &AF(NullSerp), &s_SerpDie[6]},
{SERP_DIE + 6, SERP_DIE_RATE, &AF(NullSerp), &s_SerpDie[7]},
{SERP_DIE + 7, SERP_DIE_RATE, &AF(NullSerp), &s_SerpDie[8]},
{SERP_DIE + 8, SERP_DIE_RATE, &AF(NullSerp), &s_SerpDie[9]},
{SERP_DIE + 8, SF_QUICK_CALL, &AF(DoDeathSpecial), &s_SerpDie[10]},
{SERP_DEAD, SERP_DIE_RATE, &AF(DoActorDebris), &s_SerpDie[10]}
{SPR_SERP_DIE, 'A', SERP_DIE_RATE, &AF(NullSerp), &s_SerpDie[1]},
{SPR_SERP_DIE, 'B', SERP_DIE_RATE, &AF(NullSerp), &s_SerpDie[2]},
{SPR_SERP_DIE, 'C', SERP_DIE_RATE, &AF(NullSerp), &s_SerpDie[3]},
{SPR_SERP_DIE, 'D', SERP_DIE_RATE, &AF(NullSerp), &s_SerpDie[4]},
{SPR_SERP_DIE, 'E', SERP_DIE_RATE, &AF(NullSerp), &s_SerpDie[5]},
{SPR_SERP_DIE, 'F', SERP_DIE_RATE, &AF(NullSerp), &s_SerpDie[6]},
{SPR_SERP_DIE, 'G', SERP_DIE_RATE, &AF(NullSerp), &s_SerpDie[7]},
{SPR_SERP_DIE, 'H', SERP_DIE_RATE, &AF(NullSerp), &s_SerpDie[8]},
{SPR_SERP_DIE, 'I', SERP_DIE_RATE, &AF(NullSerp), &s_SerpDie[9]},
{SPR_SERP_DIE, 'I', SF_QUICK_CALL, &AF(DoDeathSpecial), &s_SerpDie[10]},
{SPR_SERP_DEAD, 'A', SERP_DIE_RATE, &AF(DoActorDebris), &s_SerpDie[10]}
};
STATE s_SerpDead[] =
{
{SERP_DEAD, SERP_DIE_RATE, &AF(DoActorDebris), &s_SerpDead[0]},
{SPR_SERP_DEAD, 'A', SERP_DIE_RATE, &AF(DoActorDebris), &s_SerpDead[0]},
};
STATE* sg_SerpDie[] =

254
source/games/sw/src/skel.cpp
View file

@ -115,58 +115,22 @@ ATTRIBUTE SkelAttrib =
// +4 on frame #3 to add character
STATE s_SkelRun[5][6] =
STATE s_SkelRun[1][6] =
{
{
{SKEL_RUN_R0 + 0, SKEL_RUN_RATE+4, &AF(DoSkelMove), &s_SkelRun[0][1]},
{SKEL_RUN_R0 + 1, SKEL_RUN_RATE, &AF(DoSkelMove), &s_SkelRun[0][2]},
{SKEL_RUN_R0 + 2, SKEL_RUN_RATE, &AF(DoSkelMove), &s_SkelRun[0][3]},
{SKEL_RUN_R0 + 3, SKEL_RUN_RATE+4, &AF(DoSkelMove), &s_SkelRun[0][4]},
{SKEL_RUN_R0 + 4, SKEL_RUN_RATE, &AF(DoSkelMove), &s_SkelRun[0][5]},
{SKEL_RUN_R0 + 5, SKEL_RUN_RATE, &AF(DoSkelMove), &s_SkelRun[0][0]},
{SPR_SKEL_RUN, 'A', SKEL_RUN_RATE+4, &AF(DoSkelMove), &s_SkelRun[0][1]},
{SPR_SKEL_RUN, 'B', SKEL_RUN_RATE, &AF(DoSkelMove), &s_SkelRun[0][2]},
{SPR_SKEL_RUN, 'C', SKEL_RUN_RATE, &AF(DoSkelMove), &s_SkelRun[0][3]},
{SPR_SKEL_RUN, 'D', SKEL_RUN_RATE+4, &AF(DoSkelMove), &s_SkelRun[0][4]},
{SPR_SKEL_RUN, 'E', SKEL_RUN_RATE, &AF(DoSkelMove), &s_SkelRun[0][5]},
{SPR_SKEL_RUN, 'F', SKEL_RUN_RATE, &AF(DoSkelMove), &s_SkelRun[0][0]},
},
{
{SKEL_RUN_R1 + 0, SKEL_RUN_RATE+4, &AF(DoSkelMove), &s_SkelRun[1][1]},
{SKEL_RUN_R1 + 1, SKEL_RUN_RATE, &AF(DoSkelMove), &s_SkelRun[1][2]},
{SKEL_RUN_R1 + 2, SKEL_RUN_RATE, &AF(DoSkelMove), &s_SkelRun[1][3]},
{SKEL_RUN_R1 + 3, SKEL_RUN_RATE+4, &AF(DoSkelMove), &s_SkelRun[1][4]},
{SKEL_RUN_R1 + 4, SKEL_RUN_RATE, &AF(DoSkelMove), &s_SkelRun[1][5]},
{SKEL_RUN_R1 + 5, SKEL_RUN_RATE, &AF(DoSkelMove), &s_SkelRun[1][0]},
},
{
{SKEL_RUN_R2 + 0, SKEL_RUN_RATE+4, &AF(DoSkelMove), &s_SkelRun[2][1]},
{SKEL_RUN_R2 + 1, SKEL_RUN_RATE, &AF(DoSkelMove), &s_SkelRun[2][2]},
{SKEL_RUN_R2 + 2, SKEL_RUN_RATE, &AF(DoSkelMove), &s_SkelRun[2][3]},
{SKEL_RUN_R2 + 3, SKEL_RUN_RATE+4, &AF(DoSkelMove), &s_SkelRun[2][4]},
{SKEL_RUN_R2 + 4, SKEL_RUN_RATE, &AF(DoSkelMove), &s_SkelRun[2][5]},
{SKEL_RUN_R2 + 5, SKEL_RUN_RATE, &AF(DoSkelMove), &s_SkelRun[2][0]},
},
{
{SKEL_RUN_R3 + 0, SKEL_RUN_RATE+4, &AF(DoSkelMove), &s_SkelRun[3][1]},
{SKEL_RUN_R3 + 1, SKEL_RUN_RATE, &AF(DoSkelMove), &s_SkelRun[3][2]},
{SKEL_RUN_R3 + 2, SKEL_RUN_RATE, &AF(DoSkelMove), &s_SkelRun[3][3]},
{SKEL_RUN_R3 + 3, SKEL_RUN_RATE+4, &AF(DoSkelMove), &s_SkelRun[3][4]},
{SKEL_RUN_R3 + 4, SKEL_RUN_RATE, &AF(DoSkelMove), &s_SkelRun[3][5]},
{SKEL_RUN_R3 + 5, SKEL_RUN_RATE, &AF(DoSkelMove), &s_SkelRun[3][0]},
},
{
{SKEL_RUN_R4 + 0, SKEL_RUN_RATE+4, &AF(DoSkelMove), &s_SkelRun[4][1]},
{SKEL_RUN_R4 + 1, SKEL_RUN_RATE, &AF(DoSkelMove), &s_SkelRun[4][2]},
{SKEL_RUN_R4 + 2, SKEL_RUN_RATE, &AF(DoSkelMove), &s_SkelRun[4][3]},
{SKEL_RUN_R4 + 3, SKEL_RUN_RATE+4, &AF(DoSkelMove), &s_SkelRun[4][4]},
{SKEL_RUN_R4 + 4, SKEL_RUN_RATE, &AF(DoSkelMove), &s_SkelRun[4][5]},
{SKEL_RUN_R4 + 5, SKEL_RUN_RATE, &AF(DoSkelMove), &s_SkelRun[4][0]},
}
};
STATE* sg_SkelRun[] =
{
&s_SkelRun[0][0],
&s_SkelRun[1][0],
&s_SkelRun[2][0],
&s_SkelRun[3][0],
&s_SkelRun[4][0]
};
//////////////////////
@ -177,63 +141,23 @@ STATE* sg_SkelRun[] =
#define SKEL_SLASH_RATE 20
STATE s_SkelSlash[5][7] =
STATE s_SkelSlash[1][7] =
{
{
{SKEL_SLASH_R0 + 0, SKEL_SLASH_RATE, &AF(NullSkel), &s_SkelSlash[0][1]},
{SKEL_SLASH_R0 + 1, SKEL_SLASH_RATE, &AF(NullSkel), &s_SkelSlash[0][2]},
{SKEL_SLASH_R0 + 2, 0|SF_QUICK_CALL, &AF(InitSkelSlash), &s_SkelSlash[0][3]},
{SKEL_SLASH_R0 + 2, SKEL_SLASH_RATE*2, &AF(NullSkel), &s_SkelSlash[0][4]},
{SKEL_SLASH_R0 + 1, SKEL_SLASH_RATE, &AF(NullSkel), &s_SkelSlash[0][5]},
{SKEL_SLASH_R0 + 1, 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_SkelSlash[0][6]},
{SKEL_SLASH_R0 + 1, SKEL_SLASH_RATE, &AF(DoSkelMove), &s_SkelSlash[0][6]},
{SPR_SKEL_SLASH, 'A', SKEL_SLASH_RATE, &AF(NullSkel), &s_SkelSlash[0][1]},
{SPR_SKEL_SLASH, 'B', SKEL_SLASH_RATE, &AF(NullSkel), &s_SkelSlash[0][2]},
{SPR_SKEL_SLASH, 'C', 0|SF_QUICK_CALL, &AF(InitSkelSlash), &s_SkelSlash[0][3]},
{SPR_SKEL_SLASH, 'C', SKEL_SLASH_RATE*2, &AF(NullSkel), &s_SkelSlash[0][4]},
{SPR_SKEL_SLASH, 'B', SKEL_SLASH_RATE, &AF(NullSkel), &s_SkelSlash[0][5]},
{SPR_SKEL_SLASH, 'B', 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_SkelSlash[0][6]},
{SPR_SKEL_SLASH, 'B', SKEL_SLASH_RATE, &AF(DoSkelMove), &s_SkelSlash[0][6]},
},
{
{SKEL_SLASH_R1 + 0, SKEL_SLASH_RATE, &AF(NullSkel), &s_SkelSlash[1][1]},
{SKEL_SLASH_R1 + 1, SKEL_SLASH_RATE, &AF(NullSkel), &s_SkelSlash[1][2]},
{SKEL_SLASH_R1 + 2, 0|SF_QUICK_CALL, &AF(InitSkelSlash), &s_SkelSlash[1][3]},
{SKEL_SLASH_R1 + 2, SKEL_SLASH_RATE*2, &AF(NullSkel), &s_SkelSlash[1][4]},
{SKEL_SLASH_R1 + 1, SKEL_SLASH_RATE, &AF(NullSkel), &s_SkelSlash[1][5]},
{SKEL_SLASH_R1 + 1, 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_SkelSlash[1][6]},
{SKEL_SLASH_R1 + 1, SKEL_SLASH_RATE, &AF(DoSkelMove), &s_SkelSlash[1][6]},
},
{
{SKEL_SLASH_R2 + 0, SKEL_SLASH_RATE, &AF(NullSkel), &s_SkelSlash[2][1]},
{SKEL_SLASH_R2 + 1, SKEL_SLASH_RATE, &AF(NullSkel), &s_SkelSlash[2][2]},
{SKEL_SLASH_R2 + 2, 0|SF_QUICK_CALL, &AF(InitSkelSlash), &s_SkelSlash[2][3]},
{SKEL_SLASH_R2 + 2, SKEL_SLASH_RATE*2, &AF(NullSkel), &s_SkelSlash[2][4]},
{SKEL_SLASH_R2 + 1, SKEL_SLASH_RATE, &AF(NullSkel), &s_SkelSlash[2][5]},
{SKEL_SLASH_R2 + 1, 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_SkelSlash[2][6]},
{SKEL_SLASH_R2 + 1, SKEL_SLASH_RATE, &AF(DoSkelMove), &s_SkelSlash[2][6]},
},
{
{SKEL_SLASH_R3 + 0, SKEL_SLASH_RATE, &AF(NullSkel), &s_SkelSlash[3][1]},
{SKEL_SLASH_R3 + 1, SKEL_SLASH_RATE, &AF(NullSkel), &s_SkelSlash[3][2]},
{SKEL_SLASH_R3 + 2, 0|SF_QUICK_CALL, &AF(InitSkelSlash), &s_SkelSlash[3][3]},
{SKEL_SLASH_R3 + 2, SKEL_SLASH_RATE*2, &AF(NullSkel), &s_SkelSlash[3][4]},
{SKEL_SLASH_R3 + 1, SKEL_SLASH_RATE, &AF(NullSkel), &s_SkelSlash[3][5]},
{SKEL_SLASH_R3 + 1, 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_SkelSlash[3][6]},
{SKEL_SLASH_R3 + 1, SKEL_SLASH_RATE, &AF(DoSkelMove), &s_SkelSlash[3][6]},
},
{
{SKEL_SLASH_R4 + 0, SKEL_SLASH_RATE, &AF(NullSkel), &s_SkelSlash[4][1]},
{SKEL_SLASH_R4 + 1, SKEL_SLASH_RATE, &AF(NullSkel), &s_SkelSlash[4][2]},
{SKEL_SLASH_R4 + 2, 0|SF_QUICK_CALL, &AF(InitSkelSlash), &s_SkelSlash[4][3]},
{SKEL_SLASH_R4 + 2, SKEL_SLASH_RATE*2, &AF(NullSkel), &s_SkelSlash[4][4]},
{SKEL_SLASH_R4 + 1, SKEL_SLASH_RATE, &AF(NullSkel), &s_SkelSlash[4][5]},
{SKEL_SLASH_R4 + 1, 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_SkelSlash[4][6]},
{SKEL_SLASH_R4 + 1, SKEL_SLASH_RATE, &AF(DoSkelMove), &s_SkelSlash[4][6]},
}
};
STATE* sg_SkelSlash[] =
{
&s_SkelSlash[0][0],
&s_SkelSlash[1][0],
&s_SkelSlash[2][0],
&s_SkelSlash[3][0],
&s_SkelSlash[4][0]
};
@ -245,63 +169,23 @@ STATE* sg_SkelSlash[] =
#define SKEL_SPELL_RATE 20
STATE s_SkelSpell[5][7] =
STATE s_SkelSpell[1][7] =
{
{
{SKEL_SPELL_R0 + 0, SKEL_SPELL_RATE+9, &AF(NullSkel), &s_SkelSpell[0][1]},
{SKEL_SPELL_R0 + 1, SKEL_SPELL_RATE, &AF(NullSkel), &s_SkelSpell[0][2]},
{SKEL_SPELL_R0 + 2, SKEL_SPELL_RATE, &AF(NullSkel), &s_SkelSpell[0][3]},
{SKEL_SPELL_R0 + 3, SKEL_SPELL_RATE*2, &AF(NullSkel), &s_SkelSpell[0][4]},
{SKEL_SPELL_R0 + 3, 0|SF_QUICK_CALL, &AF(InitSkelSpell), &s_SkelSpell[0][5]},
{SKEL_SPELL_R0 + 3, 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_SkelSpell[0][6]},
{SKEL_SPELL_R0 + 3, SKEL_SPELL_RATE, &AF(DoSkelMove), &s_SkelSpell[0][6]},
{SPR_SKEL_SPELL, 'A', SKEL_SPELL_RATE+9, &AF(NullSkel), &s_SkelSpell[0][1]},
{SPR_SKEL_SPELL, 'B', SKEL_SPELL_RATE, &AF(NullSkel), &s_SkelSpell[0][2]},
{SPR_SKEL_SPELL, 'C', SKEL_SPELL_RATE, &AF(NullSkel), &s_SkelSpell[0][3]},
{SPR_SKEL_SPELL, 'D', SKEL_SPELL_RATE*2, &AF(NullSkel), &s_SkelSpell[0][4]},
{SPR_SKEL_SPELL, 'D', 0|SF_QUICK_CALL, &AF(InitSkelSpell), &s_SkelSpell[0][5]},
{SPR_SKEL_SPELL, 'D', 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_SkelSpell[0][6]},
{SPR_SKEL_SPELL, 'D', SKEL_SPELL_RATE, &AF(DoSkelMove), &s_SkelSpell[0][6]},
},
{
{SKEL_SPELL_R1 + 0, SKEL_SPELL_RATE+9, &AF(NullSkel), &s_SkelSpell[1][1]},
{SKEL_SPELL_R1 + 1, SKEL_SPELL_RATE, &AF(NullSkel), &s_SkelSpell[1][2]},
{SKEL_SPELL_R1 + 2, SKEL_SPELL_RATE, &AF(NullSkel), &s_SkelSpell[1][3]},
{SKEL_SPELL_R1 + 3, SKEL_SPELL_RATE*2, &AF(NullSkel), &s_SkelSpell[1][4]},
{SKEL_SPELL_R1 + 3, 0|SF_QUICK_CALL, &AF(InitSkelSpell), &s_SkelSpell[1][5]},
{SKEL_SPELL_R1 + 3, 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_SkelSpell[1][6]},
{SKEL_SPELL_R1 + 3, SKEL_SPELL_RATE, &AF(DoSkelMove), &s_SkelSpell[1][6]},
},
{
{SKEL_SPELL_R2 + 0, SKEL_SPELL_RATE+9, &AF(NullSkel), &s_SkelSpell[2][1]},
{SKEL_SPELL_R2 + 1, SKEL_SPELL_RATE, &AF(NullSkel), &s_SkelSpell[2][2]},
{SKEL_SPELL_R2 + 2, SKEL_SPELL_RATE, &AF(NullSkel), &s_SkelSpell[2][3]},
{SKEL_SPELL_R2 + 3, SKEL_SPELL_RATE*2, &AF(NullSkel), &s_SkelSpell[2][4]},
{SKEL_SPELL_R2 + 3, 0|SF_QUICK_CALL, &AF(InitSkelSpell), &s_SkelSpell[2][5]},
{SKEL_SPELL_R2 + 3, 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_SkelSpell[2][6]},
{SKEL_SPELL_R2 + 3, SKEL_SPELL_RATE, &AF(DoSkelMove), &s_SkelSpell[2][6]},
},
{
{SKEL_SPELL_R3 + 0, SKEL_SPELL_RATE+9, &AF(NullSkel), &s_SkelSpell[3][1]},
{SKEL_SPELL_R3 + 1, SKEL_SPELL_RATE, &AF(NullSkel), &s_SkelSpell[3][2]},
{SKEL_SPELL_R3 + 2, SKEL_SPELL_RATE, &AF(NullSkel), &s_SkelSpell[3][3]},
{SKEL_SPELL_R3 + 3, SKEL_SPELL_RATE*2, &AF(NullSkel), &s_SkelSpell[3][4]},
{SKEL_SPELL_R3 + 3, 0|SF_QUICK_CALL, &AF(InitSkelSpell), &s_SkelSpell[3][5]},
{SKEL_SPELL_R3 + 3, 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_SkelSpell[3][6]},
{SKEL_SPELL_R3 + 3, SKEL_SPELL_RATE, &AF(DoSkelMove), &s_SkelSpell[3][6]},
},
{
{SKEL_SPELL_R4 + 0, SKEL_SPELL_RATE+9, &AF(NullSkel), &s_SkelSpell[4][1]},
{SKEL_SPELL_R4 + 1, SKEL_SPELL_RATE, &AF(NullSkel), &s_SkelSpell[4][2]},
{SKEL_SPELL_R4 + 2, SKEL_SPELL_RATE, &AF(NullSkel), &s_SkelSpell[4][3]},
{SKEL_SPELL_R4 + 3, SKEL_SPELL_RATE*2, &AF(NullSkel), &s_SkelSpell[4][4]},
{SKEL_SPELL_R4 + 3, 0|SF_QUICK_CALL, &AF(InitSkelSpell), &s_SkelSpell[4][5]},
{SKEL_SPELL_R4 + 3, 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_SkelSpell[4][6]},
{SKEL_SPELL_R4 + 3, SKEL_SPELL_RATE, &AF(DoSkelMove), &s_SkelSpell[4][6]},
}
};
STATE* sg_SkelSpell[] =
{
&s_SkelSpell[0][0],
&s_SkelSpell[1][0],
&s_SkelSpell[2][0],
&s_SkelSpell[3][0],
&s_SkelSpell[4][0]
};
//////////////////////
@ -312,32 +196,16 @@ STATE* sg_SkelSpell[] =
#define SKEL_PAIN_RATE 38
STATE s_SkelPain[5][1] =
STATE s_SkelPain[1][1] =
{
{
{SKEL_PAIN_R0 + 0, SKEL_PAIN_RATE, &AF(DoSkelPain), &s_SkelPain[0][0]},
{SPR_SKEL_PAIN, 'A', SKEL_PAIN_RATE, &AF(DoSkelPain), &s_SkelPain[0][0]},
},
{
{SKEL_PAIN_R1 + 0, SKEL_PAIN_RATE, &AF(DoSkelPain), &s_SkelPain[1][0]},
},
{
{SKEL_PAIN_R2 + 0, SKEL_PAIN_RATE, &AF(DoSkelPain), &s_SkelPain[2][0]},
},
{
{SKEL_PAIN_R3 + 0, SKEL_PAIN_RATE, &AF(DoSkelPain), &s_SkelPain[3][0]},
},
{
{SKEL_PAIN_R4 + 0, SKEL_PAIN_RATE, &AF(DoSkelPain), &s_SkelPain[4][0]},
}
};
STATE* sg_SkelPain[] =
{
&s_SkelPain[0][0],
&s_SkelPain[1][0],
&s_SkelPain[2][0],
&s_SkelPain[3][0],
&s_SkelPain[4][0]
};
@ -352,34 +220,28 @@ STATE* sg_SkelPain[] =
STATE s_SkelTeleport[] =
{
{SKEL_TELEPORT + 0, 1, nullptr, &s_SkelTeleport[1]},
{SKEL_TELEPORT + 0, 0|SF_QUICK_CALL, &AF(DoSkelInitTeleport), &s_SkelTeleport[2]},
{SKEL_TELEPORT + 0, SKEL_TELEPORT_RATE, nullptr, &s_SkelTeleport[3]},
{SKEL_TELEPORT + 1, SKEL_TELEPORT_RATE, nullptr, &s_SkelTeleport[4]},
{SKEL_TELEPORT + 2, SKEL_TELEPORT_RATE, nullptr, &s_SkelTeleport[5]},
{SKEL_TELEPORT + 3, SKEL_TELEPORT_RATE, nullptr, &s_SkelTeleport[6]},
{SKEL_TELEPORT + 4, SKEL_TELEPORT_RATE, nullptr, &s_SkelTeleport[7]},
{SKEL_TELEPORT + 5, SKEL_TELEPORT_RATE, nullptr, &s_SkelTeleport[8]},
{SKEL_TELEPORT + 5, 0|SF_QUICK_CALL, &AF(DoSkelTeleport), &s_SkelTeleport[9]},
{SKEL_TELEPORT + 5, SKEL_TELEPORT_RATE, nullptr, &s_SkelTeleport[10]},
{SKEL_TELEPORT + 4, SKEL_TELEPORT_RATE, nullptr, &s_SkelTeleport[11]},
{SKEL_TELEPORT + 3, SKEL_TELEPORT_RATE, nullptr, &s_SkelTeleport[12]},
{SKEL_TELEPORT + 2, SKEL_TELEPORT_RATE, nullptr, &s_SkelTeleport[13]},
{SKEL_TELEPORT + 1, SKEL_TELEPORT_RATE, nullptr, &s_SkelTeleport[14]},
{SKEL_TELEPORT + 0, SKEL_TELEPORT_RATE, &AF(DoSkelTermTeleport), &s_SkelTeleport[15]},
{SKEL_TELEPORT + 0, 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_SkelTeleport[16]},
{SKEL_TELEPORT + 0, SKEL_TELEPORT_RATE, &AF(DoSkelMove), &s_SkelTeleport[16]},
{SPR_SKEL_TELEPORT, 'A', 1, nullptr, &s_SkelTeleport[1]},
{SPR_SKEL_TELEPORT, 'A', 0|SF_QUICK_CALL, &AF(DoSkelInitTeleport), &s_SkelTeleport[2]},
{SPR_SKEL_TELEPORT, 'A', SKEL_TELEPORT_RATE, nullptr, &s_SkelTeleport[3]},
{SPR_SKEL_TELEPORT, 'B', SKEL_TELEPORT_RATE, nullptr, &s_SkelTeleport[4]},
{SPR_SKEL_TELEPORT, 'C', SKEL_TELEPORT_RATE, nullptr, &s_SkelTeleport[5]},
{SPR_SKEL_TELEPORT, 'D', SKEL_TELEPORT_RATE, nullptr, &s_SkelTeleport[6]},
{SPR_SKEL_TELEPORT, 'E', SKEL_TELEPORT_RATE, nullptr, &s_SkelTeleport[7]},
{SPR_SKEL_TELEPORT, 'F', SKEL_TELEPORT_RATE, nullptr, &s_SkelTeleport[8]},
{SPR_SKEL_TELEPORT, 'F', 0|SF_QUICK_CALL, &AF(DoSkelTeleport), &s_SkelTeleport[9]},
{SPR_SKEL_TELEPORT, 'F', SKEL_TELEPORT_RATE, nullptr, &s_SkelTeleport[10]},
{SPR_SKEL_TELEPORT, 'E', SKEL_TELEPORT_RATE, nullptr, &s_SkelTeleport[11]},
{SPR_SKEL_TELEPORT, 'D', SKEL_TELEPORT_RATE, nullptr, &s_SkelTeleport[12]},
{SPR_SKEL_TELEPORT, 'C', SKEL_TELEPORT_RATE, nullptr, &s_SkelTeleport[13]},
{SPR_SKEL_TELEPORT, 'B', SKEL_TELEPORT_RATE, nullptr, &s_SkelTeleport[14]},
{SPR_SKEL_TELEPORT, 'A', SKEL_TELEPORT_RATE, &AF(DoSkelTermTeleport), &s_SkelTeleport[15]},
{SPR_SKEL_TELEPORT, 'A', 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_SkelTeleport[16]},
{SPR_SKEL_TELEPORT, 'A', SKEL_TELEPORT_RATE, &AF(DoSkelMove), &s_SkelTeleport[16]},
};
STATE* sg_SkelTeleport[] =
{
s_SkelTeleport,
s_SkelTeleport,
s_SkelTeleport,
s_SkelTeleport,
s_SkelTeleport
};
//////////////////////
@ -390,22 +252,10 @@ STATE* sg_SkelTeleport[] =
#define SKEL_STAND_RATE 12
STATE s_SkelStand[5][1] =
STATE s_SkelStand[1][1] =
{
{
{SKEL_RUN_R0 + 0, SKEL_STAND_RATE, &AF(DoSkelMove), &s_SkelStand[0][0]},
},
{
{SKEL_RUN_R1 + 0, SKEL_STAND_RATE, &AF(DoSkelMove), &s_SkelStand[1][0]},
},
{
{SKEL_RUN_R2 + 0, SKEL_STAND_RATE, &AF(DoSkelMove), &s_SkelStand[2][0]},
},
{
{SKEL_RUN_R3 + 0, SKEL_STAND_RATE, &AF(DoSkelMove), &s_SkelStand[3][0]},
},
{
{SKEL_RUN_R4 + 0, SKEL_STAND_RATE, &AF(DoSkelMove), &s_SkelStand[4][0]},
{SPR_SKEL_RUN, 'A', SKEL_STAND_RATE, &AF(DoSkelMove), &s_SkelStand[0][0]},
},
};
@ -413,10 +263,6 @@ STATE s_SkelStand[5][1] =
STATE* sg_SkelStand[] =
{
s_SkelStand[0],
s_SkelStand[1],
s_SkelStand[2],
s_SkelStand[3],
s_SkelStand[4]
};
//////////////////////
@ -429,12 +275,12 @@ STATE* sg_SkelStand[] =
STATE s_SkelDie[] =
{
{SKEL_DIE + 0, SKEL_DIE_RATE, nullptr, &s_SkelDie[1]},
{SKEL_DIE + 1, SKEL_DIE_RATE, nullptr, &s_SkelDie[2]},
{SKEL_DIE + 2, SKEL_DIE_RATE, nullptr, &s_SkelDie[3]},
{SKEL_DIE + 3, SKEL_DIE_RATE, nullptr, &s_SkelDie[4]},
{SKEL_DIE + 4, SKEL_DIE_RATE, nullptr, &s_SkelDie[5]},
{SKEL_DIE + 5, SKEL_DIE_RATE, &AF(DoSuicide), &s_SkelDie[5]},
{SPR_SKEL_DIE, 'A', SKEL_DIE_RATE, nullptr, &s_SkelDie[1]},
{SPR_SKEL_DIE, 'B', SKEL_DIE_RATE, nullptr, &s_SkelDie[2]},
{SPR_SKEL_DIE, 'C', SKEL_DIE_RATE, nullptr, &s_SkelDie[3]},
{SPR_SKEL_DIE, 'D', SKEL_DIE_RATE, nullptr, &s_SkelDie[4]},
{SPR_SKEL_DIE, 'E', SKEL_DIE_RATE, nullptr, &s_SkelDie[5]},
{SPR_SKEL_DIE, 'F', SKEL_DIE_RATE, &AF(DoSuicide), &s_SkelDie[5]},
};
STATE* sg_SkelDie[] =

156
source/games/sw/src/skull.cpp
View file

@ -50,33 +50,17 @@ extern DAMAGE_DATA DamageData[];
#define SKULL_RATE 10
STATE s_SkullWait[5][1] =
STATE s_SkullWait[1][1] =
{
{
{SKULL_R0 + 0, SKULL_RATE, &AF(DoSkullWait), &s_SkullWait[0][0]},
{SPR_SKULL, 'A', SKULL_RATE, &AF(DoSkullWait), &s_SkullWait[0][0]},
},
{
{SKULL_R1 + 0, SKULL_RATE, &AF(DoSkullWait), &s_SkullWait[1][0]},
},
{
{SKULL_R2 + 0, SKULL_RATE, &AF(DoSkullWait), &s_SkullWait[2][0]},
},
{
{SKULL_R3 + 0, SKULL_RATE, &AF(DoSkullWait), &s_SkullWait[3][0]},
},
{
{SKULL_R4 + 0, SKULL_RATE, &AF(DoSkullWait), &s_SkullWait[4][0]},
}
};
STATE* sg_SkullWait[] =
{
&s_SkullWait[0][0],
&s_SkullWait[1][0],
&s_SkullWait[2][0],
&s_SkullWait[3][0],
&s_SkullWait[4][0]
};
ATTRIBUTE SkullAttrib =
@ -96,33 +80,17 @@ ATTRIBUTE SkullAttrib =
//
//////////////////////
STATE s_SkullRing[5][1] =
STATE s_SkullRing[1][1] =
{
{
{SKULL_R0 + 0, SKULL_RATE, &AF(DoSerpRing), &s_SkullRing[0][0]},
{SPR_SKULL, 'A', SKULL_RATE, &AF(DoSerpRing), &s_SkullRing[0][0]},
},
{
{SKULL_R1 + 0, SKULL_RATE, &AF(DoSerpRing), &s_SkullRing[1][0]},
},
{
{SKULL_R2 + 0, SKULL_RATE, &AF(DoSerpRing), &s_SkullRing[2][0]},
},
{
{SKULL_R3 + 0, SKULL_RATE, &AF(DoSerpRing), &s_SkullRing[3][0]},
},
{
{SKULL_R4 + 0, SKULL_RATE, &AF(DoSerpRing), &s_SkullRing[4][0]},
}
};
STATE* sg_SkullRing[] =
{
&s_SkullRing[0][0],
&s_SkullRing[1][0],
&s_SkullRing[2][0],
&s_SkullRing[3][0],
&s_SkullRing[4][0]
};
@ -133,33 +101,17 @@ STATE* sg_SkullRing[] =
//
//////////////////////
STATE s_SkullJump[5][1] =
STATE s_SkullJump[1][1] =
{
{
{SKULL_R0 + 0, SKULL_RATE, &AF(DoSkullJump), &s_SkullJump[0][0]},
{SPR_SKULL, 'A', SKULL_RATE, &AF(DoSkullJump), &s_SkullJump[0][0]},
},
{
{SKULL_R1 + 0, SKULL_RATE, &AF(DoSkullJump), &s_SkullJump[1][0]},
},
{
{SKULL_R2 + 0, SKULL_RATE, &AF(DoSkullJump), &s_SkullJump[2][0]},
},
{
{SKULL_R3 + 0, SKULL_RATE, &AF(DoSkullJump), &s_SkullJump[3][0]},
},
{
{SKULL_R4 + 0, SKULL_RATE, &AF(DoSkullJump), &s_SkullJump[4][0]},
}
};
STATE* sg_SkullJump[] =
{
&s_SkullJump[0][0],
&s_SkullJump[1][0],
&s_SkullJump[2][0],
&s_SkullJump[3][0],
&s_SkullJump[4][0]
};
@ -173,24 +125,24 @@ STATE* sg_SkullJump[] =
STATE s_SkullExplode[] =
{
{SKULL_EXPLODE + 0, 1, nullptr, &s_SkullExplode[1]},
{SKULL_EXPLODE + 0, SF_QUICK_CALL, &AF(DoDamageTest), &s_SkullExplode[2]},
{SKULL_EXPLODE + 0, SKULL_EXPLODE_RATE, nullptr, &s_SkullExplode[3]},
{SKULL_EXPLODE + 1, SKULL_EXPLODE_RATE, nullptr, &s_SkullExplode[4]},
{SKULL_EXPLODE + 2, SF_QUICK_CALL, &AF(DoSkullSpawnShrap), &s_SkullExplode[5]},
{SKULL_EXPLODE + 2, SKULL_EXPLODE_RATE, nullptr, &s_SkullExplode[6]},
{SKULL_EXPLODE + 3, SKULL_EXPLODE_RATE, nullptr, &s_SkullExplode[7]},
{SKULL_EXPLODE + 4, SKULL_EXPLODE_RATE, nullptr, &s_SkullExplode[8]},
{SKULL_EXPLODE + 5, SKULL_EXPLODE_RATE, nullptr, &s_SkullExplode[9]},
{SKULL_EXPLODE + 6, SKULL_EXPLODE_RATE, nullptr, &s_SkullExplode[10]},
{SKULL_EXPLODE + 7, SKULL_EXPLODE_RATE, nullptr, &s_SkullExplode[11]},
{SKULL_EXPLODE + 8, SKULL_EXPLODE_RATE, nullptr, &s_SkullExplode[12]},
{SKULL_EXPLODE + 9, SKULL_EXPLODE_RATE, nullptr, &s_SkullExplode[13]},
{SKULL_EXPLODE +10, SKULL_EXPLODE_RATE, nullptr, &s_SkullExplode[14]},
{SKULL_EXPLODE +11, SKULL_EXPLODE_RATE, nullptr, &s_SkullExplode[15]},
{SKULL_EXPLODE +12, SKULL_EXPLODE_RATE, nullptr, &s_SkullExplode[16]},
{SKULL_EXPLODE +13, SKULL_EXPLODE_RATE, nullptr, &s_SkullExplode[17]},
{SKULL_EXPLODE +13, SKULL_EXPLODE_RATE, &AF(DoSuicide), &s_SkullExplode[17]}
{SPR_SKULL_EXPLODE, 'A', 1, nullptr, &s_SkullExplode[1]},
{SPR_SKULL_EXPLODE, 'A', SF_QUICK_CALL, &AF(DoDamageTest), &s_SkullExplode[2]},
{SPR_SKULL_EXPLODE, 'A', SKULL_EXPLODE_RATE, nullptr, &s_SkullExplode[3]},
{SPR_SKULL_EXPLODE, 'B', SKULL_EXPLODE_RATE, nullptr, &s_SkullExplode[4]},
{SPR_SKULL_EXPLODE, 'C', SF_QUICK_CALL, &AF(DoSkullSpawnShrap), &s_SkullExplode[5]},
{SPR_SKULL_EXPLODE, 'C', SKULL_EXPLODE_RATE, nullptr, &s_SkullExplode[6]},
{SPR_SKULL_EXPLODE, 'D', SKULL_EXPLODE_RATE, nullptr, &s_SkullExplode[7]},
{SPR_SKULL_EXPLODE, 'E', SKULL_EXPLODE_RATE, nullptr, &s_SkullExplode[8]},
{SPR_SKULL_EXPLODE, 'F', SKULL_EXPLODE_RATE, nullptr, &s_SkullExplode[9]},
{SPR_SKULL_EXPLODE, 'G', SKULL_EXPLODE_RATE, nullptr, &s_SkullExplode[10]},
{SPR_SKULL_EXPLODE, 'H', SKULL_EXPLODE_RATE, nullptr, &s_SkullExplode[11]},
{SPR_SKULL_EXPLODE, 'I', SKULL_EXPLODE_RATE, nullptr, &s_SkullExplode[12]},
{SPR_SKULL_EXPLODE, 'J', SKULL_EXPLODE_RATE, nullptr, &s_SkullExplode[13]},
{SPR_SKULL_EXPLODE, 'K', SKULL_EXPLODE_RATE, nullptr, &s_SkullExplode[14]},
{SPR_SKULL_EXPLODE, 'L', SKULL_EXPLODE_RATE, nullptr, &s_SkullExplode[15]},
{SPR_SKULL_EXPLODE, 'M', SKULL_EXPLODE_RATE, nullptr, &s_SkullExplode[16]},
{SPR_SKULL_EXPLODE, 'N', SKULL_EXPLODE_RATE, nullptr, &s_SkullExplode[17]},
{SPR_SKULL_EXPLODE, 'N', SKULL_EXPLODE_RATE, &AF(DoSuicide), &s_SkullExplode[17]}
};
STATE* sg_SkullExplode[] =
@ -341,7 +293,7 @@ int DoSkullBeginDeath(DSWActor* actor)
}
actor->spr.cstat &= ~(CSTAT_SPRITE_BLOCK|CSTAT_SPRITE_BLOCK_HITSCAN);
actor->user.__legacyState.RotNum = 0;
actor->user.Tics = 0;
actor->user.ID = SKULL_R0;
actor->user.Radius = DamageData[DMG_SKULL_EXP].radius; //*DamageRadiusSkull;
@ -512,43 +464,19 @@ int DoSkullWait(DSWActor* actor)
#define BETTY_RATE 10
STATE s_BettyWait[5][3] =
STATE s_BettyWait[1][3] =
{
{
{BETTY_R0 + 0, BETTY_RATE, &AF(DoBettyWait), &s_BettyWait[0][1]},
{BETTY_R0 + 1, BETTY_RATE, &AF(DoBettyWait), &s_BettyWait[0][2]},
{BETTY_R0 + 2, BETTY_RATE, &AF(DoBettyWait), &s_BettyWait[0][0]},
{SPR_BETTY, 'A', BETTY_RATE, &AF(DoBettyWait), &s_BettyWait[0][1]},
{SPR_BETTY, 'B', BETTY_RATE, &AF(DoBettyWait), &s_BettyWait[0][2]},
{SPR_BETTY, 'C', BETTY_RATE, &AF(DoBettyWait), &s_BettyWait[0][0]},
},
{
{BETTY_R1 + 0, BETTY_RATE, &AF(DoBettyWait), &s_BettyWait[1][1]},
{BETTY_R1 + 1, BETTY_RATE, &AF(DoBettyWait), &s_BettyWait[1][2]},
{BETTY_R1 + 2, BETTY_RATE, &AF(DoBettyWait), &s_BettyWait[1][0]},
},
{
{BETTY_R2 + 0, BETTY_RATE, &AF(DoBettyWait), &s_BettyWait[2][1]},
{BETTY_R2 + 1, BETTY_RATE, &AF(DoBettyWait), &s_BettyWait[2][2]},
{BETTY_R2 + 2, BETTY_RATE, &AF(DoBettyWait), &s_BettyWait[2][0]},
},
{
{BETTY_R3 + 0, BETTY_RATE, &AF(DoBettyWait), &s_BettyWait[3][1]},
{BETTY_R3 + 1, BETTY_RATE, &AF(DoBettyWait), &s_BettyWait[3][2]},
{BETTY_R3 + 2, BETTY_RATE, &AF(DoBettyWait), &s_BettyWait[3][0]},
},
{
{BETTY_R4 + 0, BETTY_RATE, &AF(DoBettyWait), &s_BettyWait[4][1]},
{BETTY_R4 + 1, BETTY_RATE, &AF(DoBettyWait), &s_BettyWait[4][2]},
{BETTY_R4 + 2, BETTY_RATE, &AF(DoBettyWait), &s_BettyWait[4][0]},
}
};
STATE* sg_BettyWait[] =
{
&s_BettyWait[0][0],
&s_BettyWait[1][0],
&s_BettyWait[2][0],
&s_BettyWait[3][0],
&s_BettyWait[4][0]
};
ATTRIBUTE BettyAttrib =
@ -565,33 +493,17 @@ ATTRIBUTE BettyAttrib =
//
//////////////////////
STATE s_BettyJump[5][1] =
STATE s_BettyJump[1][1] =
{
{
{BETTY_R0 + 0, BETTY_RATE, &AF(DoBettyJump), &s_BettyJump[0][0]},
{SPR_BETTY, 'A', BETTY_RATE, &AF(DoBettyJump), &s_BettyJump[0][0]},
},
{
{BETTY_R1 + 0, BETTY_RATE, &AF(DoBettyJump), &s_BettyJump[1][0]},
},
{
{BETTY_R2 + 0, BETTY_RATE, &AF(DoBettyJump), &s_BettyJump[2][0]},
},
{
{BETTY_R3 + 0, BETTY_RATE, &AF(DoBettyJump), &s_BettyJump[3][0]},
},
{
{BETTY_R4 + 0, BETTY_RATE, &AF(DoBettyJump), &s_BettyJump[4][0]},
}
};
STATE* sg_BettyJump[] =
{
&s_BettyJump[0][0],
&s_BettyJump[1][0],
&s_BettyJump[2][0],
&s_BettyJump[3][0],
&s_BettyJump[4][0]
};
@ -606,8 +518,8 @@ STATE* sg_BettyJump[] =
STATE s_BettyExplode[] =
{
{BETTY_EXPLODE + 0, SF_QUICK_CALL, &AF(DoDamageTest), &s_BettyExplode[1]},
{BETTY_EXPLODE + 0, BETTY_EXPLODE_RATE, &AF(DoSuicide), &s_BettyExplode[0]}
{SPR_BETTY, 'A', SF_QUICK_CALL, &AF(DoDamageTest), &s_BettyExplode[1]},
{SPR_BETTY, 'A', BETTY_EXPLODE_RATE, &AF(DoSuicide), &s_BettyExplode[0]}
};
STATE* sg_BettyExplode[] =
@ -746,7 +658,7 @@ int DoBettyBeginDeath(DSWActor* actor)
}
actor->spr.cstat &= ~(CSTAT_SPRITE_BLOCK|CSTAT_SPRITE_BLOCK_HITSCAN);
actor->user.__legacyState.RotNum = 0;
actor->user.Tics = 0;
actor->user.ID = BETTY_R0;
actor->user.Radius = DamageData[DMG_SKULL_EXP].radius; //*DamageRadiusBetty;

243
source/games/sw/src/sprite.cpp
View file

@ -120,82 +120,81 @@ int DirArr[] = {NORTH, NE, EAST, SE, SOUTH, SW, WEST, NW, NORTH, NE, EAST, SE, S
STATE s_DebrisNinja[] =
{
{NINJA_DIE + 3, 100, &AF(DoActorDebris), &s_DebrisNinja[0]},
{SPR_NINJA_DIE, 'D', 100, &AF(DoActorDebris), &s_DebrisNinja[0]},
};
STATE s_DebrisRat[] =
{
{750, 100, &AF(DoActorDebris), &s_DebrisRat[0]},
{SPR_RAT_DEBRIS, 'A', 100, &AF(DoActorDebris), &s_DebrisRat[0]},
};
STATE s_DebrisCrab[] =
{
{423, 100, &AF(DoActorDebris), &s_DebrisCrab[0]},
{SPR_CRAB_DEBRIS, 'A', 100, &AF(DoActorDebris), &s_DebrisCrab[0]},
};
STATE s_DebrisStarFish[] =
{
{426, 100, &AF(DoActorDebris), &s_DebrisStarFish[0]},
{SPR_STARFISH_DEBRIS, 'A', 100, &AF(DoActorDebris), &s_DebrisStarFish[0]},
};
// temporary
#define ICON_REPAIR_KIT 1813
#define REPAIR_KIT_RATE 1100
STATE s_RepairKit[] =
{
{ICON_REPAIR_KIT + 0, REPAIR_KIT_RATE, &AF(DoGet), &s_RepairKit[0]}
{SPR_ICON_REPAIR_KIT, 'A', REPAIR_KIT_RATE, &AF(DoGet), &s_RepairKit[0]}
};
STATE s_GoldSkelKey[] =
{
{GOLD_SKELKEY, 100, &AF(DoGet), &s_GoldSkelKey[0]}
{SPR_GOLD_SKELKEY, 'A', 100, &AF(DoGet), &s_GoldSkelKey[0]}
};
STATE s_BlueKey[] =
{
{BLUE_KEY, 100, &AF(DoGet), &s_BlueKey[0]}
{SPR_BLUE_KEY, 'A', 100, &AF(DoGet), &s_BlueKey[0]}
};
STATE s_BlueCard[] =
{
{BLUE_CARD, 100, &AF(DoGet), &s_BlueCard[0]}
{SPR_BLUE_CARD, 'A', 100, &AF(DoGet), &s_BlueCard[0]}
};
STATE s_SilverSkelKey[] =
{
{SILVER_SKELKEY, 100, &AF(DoGet), &s_SilverSkelKey[0]}
{SPR_SILVER_SKELKEY, 'A', 100, &AF(DoGet), &s_SilverSkelKey[0]}
};
STATE s_RedKey[] =
{
{RED_KEY, 100, &AF(DoGet), &s_RedKey[0]}
{SPR_RED_KEY, 'A', 100, &AF(DoGet), &s_RedKey[0]}
};
STATE s_RedCard[] =
{
{RED_CARD, 100, &AF(DoGet), &s_RedCard[0]}
{SPR_RED_CARD, 'A', 100, &AF(DoGet), &s_RedCard[0]}
};
STATE s_BronzeSkelKey[] =
{
{BRONZE_SKELKEY, 100, &AF(DoGet), &s_BronzeSkelKey[0]}
{SPR_BRONZE_SKELKEY, 'A', 100, &AF(DoGet), &s_BronzeSkelKey[0]}
};
STATE s_GreenKey[] =
{
{GREEN_KEY, 100, &AF(DoGet), &s_GreenKey[0]}
{SPR_GREEN_KEY, 'A', 100, &AF(DoGet), &s_GreenKey[0]}
};
STATE s_GreenCard[] =
{
{GREEN_CARD, 100, &AF(DoGet), &s_GreenCard[0]}
{SPR_GREEN_CARD, 'A', 100, &AF(DoGet), &s_GreenCard[0]}
};
STATE s_RedSkelKey[] =
{
{RED_SKELKEY, 100, &AF(DoGet), &s_RedSkelKey[0]}
{SPR_RED_SKELKEY, 'A', 100, &AF(DoGet), &s_RedSkelKey[0]}
};
STATE s_YellowKey[] =
{
{YELLOW_KEY, 100, &AF(DoGet), &s_YellowKey[0]}
{SPR_YELLOW_KEY, 'A', 100, &AF(DoGet), &s_YellowKey[0]}
};
STATE s_YellowCard[] =
{
{YELLOW_CARD, 100, &AF(DoGet), &s_YellowCard[0]}
{SPR_YELLOW_CARD, 'A', 100, &AF(DoGet), &s_YellowCard[0]}
};
STATE* s_Key[] =
@ -217,275 +216,272 @@ STATE* s_Key[] =
#define KEY_RATE 25
#define Red_COIN 2440
#define Yellow_COIN 2450
#define Green_COIN 2460
#define RED_COIN_RATE 10
#define YELLOW_COIN_RATE 8
#define GREEN_COIN_RATE 6
STATE s_RedCoin[] =
{
{Red_COIN + 0, RED_COIN_RATE, &AF(DoCoin), &s_RedCoin[1]},
{Red_COIN + 1, RED_COIN_RATE, &AF(DoCoin), &s_RedCoin[2]},
{Red_COIN + 2, RED_COIN_RATE, &AF(DoCoin), &s_RedCoin[3]},
{Red_COIN + 3, RED_COIN_RATE, &AF(DoCoin), &s_RedCoin[4]},
{Red_COIN + 4, RED_COIN_RATE, &AF(DoCoin), &s_RedCoin[5]},
{Red_COIN + 5, RED_COIN_RATE, &AF(DoCoin), &s_RedCoin[6]},
{Red_COIN + 6, RED_COIN_RATE, &AF(DoCoin), &s_RedCoin[7]},
{Red_COIN + 7, RED_COIN_RATE, &AF(DoCoin), &s_RedCoin[0]},
{SPR_Red_COIN, 'A', RED_COIN_RATE, &AF(DoCoin), &s_RedCoin[1]},
{SPR_Red_COIN, 'B', RED_COIN_RATE, &AF(DoCoin), &s_RedCoin[2]},
{SPR_Red_COIN, 'C', RED_COIN_RATE, &AF(DoCoin), &s_RedCoin[3]},
{SPR_Red_COIN, 'D', RED_COIN_RATE, &AF(DoCoin), &s_RedCoin[4]},
{SPR_Red_COIN, 'E', RED_COIN_RATE, &AF(DoCoin), &s_RedCoin[5]},
{SPR_Red_COIN, 'F', RED_COIN_RATE, &AF(DoCoin), &s_RedCoin[6]},
{SPR_Red_COIN, 'G', RED_COIN_RATE, &AF(DoCoin), &s_RedCoin[7]},
{SPR_Red_COIN, 'H', RED_COIN_RATE, &AF(DoCoin), &s_RedCoin[0]},
};
// !JIM! Frank, I made coins go progressively faster
STATE s_YellowCoin[] =
{
{Yellow_COIN + 0, YELLOW_COIN_RATE, &AF(DoCoin), &s_YellowCoin[1]},
{Yellow_COIN + 1, YELLOW_COIN_RATE, &AF(DoCoin), &s_YellowCoin[2]},
{Yellow_COIN + 2, YELLOW_COIN_RATE, &AF(DoCoin), &s_YellowCoin[3]},
{Yellow_COIN + 3, YELLOW_COIN_RATE, &AF(DoCoin), &s_YellowCoin[4]},
{Yellow_COIN + 4, YELLOW_COIN_RATE, &AF(DoCoin), &s_YellowCoin[5]},
{Yellow_COIN + 5, YELLOW_COIN_RATE, &AF(DoCoin), &s_YellowCoin[6]},
{Yellow_COIN + 6, YELLOW_COIN_RATE, &AF(DoCoin), &s_YellowCoin[7]},
{Yellow_COIN + 7, YELLOW_COIN_RATE, &AF(DoCoin), &s_YellowCoin[0]},
{SPR_Yellow_COIN, 'A', YELLOW_COIN_RATE, &AF(DoCoin), &s_YellowCoin[1]},
{SPR_Yellow_COIN, 'B', YELLOW_COIN_RATE, &AF(DoCoin), &s_YellowCoin[2]},
{SPR_Yellow_COIN, 'C', YELLOW_COIN_RATE, &AF(DoCoin), &s_YellowCoin[3]},
{SPR_Yellow_COIN, 'D', YELLOW_COIN_RATE, &AF(DoCoin), &s_YellowCoin[4]},
{SPR_Yellow_COIN, 'E', YELLOW_COIN_RATE, &AF(DoCoin), &s_YellowCoin[5]},
{SPR_Yellow_COIN, 'F', YELLOW_COIN_RATE, &AF(DoCoin), &s_YellowCoin[6]},
{SPR_Yellow_COIN, 'G', YELLOW_COIN_RATE, &AF(DoCoin), &s_YellowCoin[7]},
{SPR_Yellow_COIN, 'H', YELLOW_COIN_RATE, &AF(DoCoin), &s_YellowCoin[0]},
};
STATE s_GreenCoin[] =
{
{Green_COIN + 0, GREEN_COIN_RATE, &AF(DoCoin), &s_GreenCoin[1]},
{Green_COIN + 1, GREEN_COIN_RATE, &AF(DoCoin), &s_GreenCoin[2]},
{Green_COIN + 2, GREEN_COIN_RATE, &AF(DoCoin), &s_GreenCoin[3]},
{Green_COIN + 3, GREEN_COIN_RATE, &AF(DoCoin), &s_GreenCoin[4]},
{Green_COIN + 4, GREEN_COIN_RATE, &AF(DoCoin), &s_GreenCoin[5]},
{Green_COIN + 5, GREEN_COIN_RATE, &AF(DoCoin), &s_GreenCoin[6]},
{Green_COIN + 6, GREEN_COIN_RATE, &AF(DoCoin), &s_GreenCoin[7]},
{Green_COIN + 7, GREEN_COIN_RATE, &AF(DoCoin), &s_GreenCoin[0]},
{SPR_Green_COIN, 'A', GREEN_COIN_RATE, &AF(DoCoin), &s_GreenCoin[1]},
{SPR_Green_COIN, 'B', GREEN_COIN_RATE, &AF(DoCoin), &s_GreenCoin[2]},
{SPR_Green_COIN, 'C', GREEN_COIN_RATE, &AF(DoCoin), &s_GreenCoin[3]},
{SPR_Green_COIN, 'D', GREEN_COIN_RATE, &AF(DoCoin), &s_GreenCoin[4]},
{SPR_Green_COIN, 'E', GREEN_COIN_RATE, &AF(DoCoin), &s_GreenCoin[5]},
{SPR_Green_COIN, 'F', GREEN_COIN_RATE, &AF(DoCoin), &s_GreenCoin[6]},
{SPR_Green_COIN, 'G', GREEN_COIN_RATE, &AF(DoCoin), &s_GreenCoin[7]},
{SPR_Green_COIN, 'H', GREEN_COIN_RATE, &AF(DoCoin), &s_GreenCoin[0]},
};
STATE s_FireFly[] =
{
{FIRE_FLY0, FIRE_FLY_RATE * 4, &AF(DoFireFly), &s_FireFly[0]}
{SPR_FIRE_FLY0, 'A', FIRE_FLY_RATE * 4, &AF(DoFireFly), &s_FireFly[0]}
};
STATE s_IconStar[] =
{
{ICON_STAR, 100, &AF(DoGet), &s_IconStar[0]}
{SPR_ICON_STAR, 'A', 100, &AF(DoGet), &s_IconStar[0]}
};
STATE s_IconUzi[] =
{
{ICON_UZI, 100, &AF(DoGet), &s_IconUzi[0]}
{SPR_ICON_UZI, 'A', 100, &AF(DoGet), &s_IconUzi[0]}
};
STATE s_IconLgUziAmmo[] =
{
{ICON_LG_UZI_AMMO, 100, &AF(DoGet), &s_IconLgUziAmmo[0]}
{SPR_ICON_LG_UZI_AMMO, 'A', 100, &AF(DoGet), &s_IconLgUziAmmo[0]}
};
STATE s_IconUziFloor[] =
{
{ICON_UZIFLOOR, 100, &AF(DoGet), &s_IconUziFloor[0]}
{SPR_ICON_UZIFLOOR, 'A', 100, &AF(DoGet), &s_IconUziFloor[0]}
};
STATE s_IconRocket[] =
{
{ICON_ROCKET, 100, &AF(DoGet), &s_IconRocket[0]}
{SPR_ICON_ROCKET, 'A', 100, &AF(DoGet), &s_IconRocket[0]}
};
STATE s_IconLgRocket[] =
{
{ICON_LG_ROCKET, 100, &AF(DoGet), &s_IconLgRocket[0]}
{SPR_ICON_LG_ROCKET, 'A', 100, &AF(DoGet), &s_IconLgRocket[0]}
};
STATE s_IconShotgun[] =
{
{ICON_SHOTGUN, 100, &AF(DoGet), &s_IconShotgun[0]}
{SPR_ICON_SHOTGUN, 'A', 100, &AF(DoGet), &s_IconShotgun[0]}
};
STATE s_IconLgShotshell[] =
{
{ICON_LG_SHOTSHELL, 100, &AF(DoGet), &s_IconLgShotshell[0]}
{SPR_ICON_LG_SHOTSHELL, 'A', 100, &AF(DoGet), &s_IconLgShotshell[0]}
};
STATE s_IconAutoRiot[] =
{
{ICON_AUTORIOT, 100, &AF(DoGet), &s_IconAutoRiot[0]}
{SPR_ICON_AUTORIOT, 'A', 100, &AF(DoGet), &s_IconAutoRiot[0]}
};
STATE s_IconGrenadeLauncher[] =
{
{ICON_GRENADE_LAUNCHER, 100, &AF(DoGet), &s_IconGrenadeLauncher[0]}
{SPR_ICON_GRENADE_LAUNCHER, 'A', 100, &AF(DoGet), &s_IconGrenadeLauncher[0]}
};
STATE s_IconLgGrenade[] =
{
{ICON_LG_GRENADE, 100, &AF(DoGet), &s_IconLgGrenade[0]}
{SPR_ICON_LG_GRENADE, 'A', 100, &AF(DoGet), &s_IconLgGrenade[0]}
};
STATE s_IconLgMine[] =
{
{ICON_LG_MINE, 100, &AF(DoGet), &s_IconLgMine[0]}
{SPR_ICON_LG_MINE, 'A', 100, &AF(DoGet), &s_IconLgMine[0]}
};
STATE s_IconGuardHead[] =
{
{ICON_GUARD_HEAD + 0, 15, &AF(DoGet), &s_IconGuardHead[0]},
{SPR_ICON_GUARD_HEAD, 'A', 15, &AF(DoGet), &s_IconGuardHead[0]},
};
#define FIREBALL_LG_AMMO_RATE 12
STATE s_IconFireballLgAmmo[] =
{
{ICON_FIREBALL_LG_AMMO + 0, FIREBALL_LG_AMMO_RATE, &AF(DoGet), &s_IconFireballLgAmmo[1]},
{ICON_FIREBALL_LG_AMMO + 1, FIREBALL_LG_AMMO_RATE, &AF(DoGet), &s_IconFireballLgAmmo[2]},
{ICON_FIREBALL_LG_AMMO + 2, FIREBALL_LG_AMMO_RATE, &AF(DoGet), &s_IconFireballLgAmmo[0]},
{SPR_ICON_FIREBALL_LG_AMMO, 'A', FIREBALL_LG_AMMO_RATE, &AF(DoGet), &s_IconFireballLgAmmo[1]},
{SPR_ICON_FIREBALL_LG_AMMO, 'B', FIREBALL_LG_AMMO_RATE, &AF(DoGet), &s_IconFireballLgAmmo[2]},
{SPR_ICON_FIREBALL_LG_AMMO, 'C', FIREBALL_LG_AMMO_RATE, &AF(DoGet), &s_IconFireballLgAmmo[0]},
};
STATE s_IconHeart[] =
{
{ICON_HEART + 0, 25, &AF(DoGet), &s_IconHeart[1]},
{ICON_HEART + 1, 25, &AF(DoGet), &s_IconHeart[0]},
{SPR_ICON_HEART, 'A', 25, &AF(DoGet), &s_IconHeart[1]},
{SPR_ICON_HEART, 'B', 25, &AF(DoGet), &s_IconHeart[0]},
};
#define HEART_LG_AMMO_RATE 12
STATE s_IconHeartLgAmmo[] =
{
{ICON_HEART_LG_AMMO + 0, HEART_LG_AMMO_RATE, &AF(DoGet), &s_IconHeartLgAmmo[1]},
{ICON_HEART_LG_AMMO + 1, HEART_LG_AMMO_RATE, &AF(DoGet), &s_IconHeartLgAmmo[0]},
{SPR_ICON_HEART_LG_AMMO, 'A', HEART_LG_AMMO_RATE, &AF(DoGet), &s_IconHeartLgAmmo[1]},
{SPR_ICON_HEART_LG_AMMO, 'B', HEART_LG_AMMO_RATE, &AF(DoGet), &s_IconHeartLgAmmo[0]},
};
STATE s_IconMicroGun[] =
{
{ICON_MICRO_GUN, 100, &AF(DoGet), &s_IconMicroGun[0]}
{SPR_ICON_MICRO_GUN, 'A', 100, &AF(DoGet), &s_IconMicroGun[0]}
};
STATE s_IconMicroBattery[] =
{
{ICON_MICRO_BATTERY, 100, &AF(DoGet), &s_IconMicroBattery[0]}
{SPR_ICON_MICRO_BATTERY, 'A', 100, &AF(DoGet), &s_IconMicroBattery[0]}
};
// !JIM! Added rail crap
STATE s_IconRailGun[] =
{
{ICON_RAIL_GUN, 100, &AF(DoGet), &s_IconRailGun[0]}
{SPR_ICON_RAIL_GUN, 'A', 100, &AF(DoGet), &s_IconRailGun[0]}
};
STATE s_IconRailAmmo[] =
{
{ICON_RAIL_AMMO, 100, &AF(DoGet), &s_IconRailAmmo[0]}
{SPR_ICON_RAIL_AMMO, 'A', 100, &AF(DoGet), &s_IconRailAmmo[0]}
};
STATE s_IconElectro[] =
{
{ICON_ELECTRO + 0, 25, &AF(DoGet), &s_IconElectro[1]},
{ICON_ELECTRO + 1, 25, &AF(DoGet), &s_IconElectro[0]},
{SPR_ICON_ELECTRO, 'A', 25, &AF(DoGet), &s_IconElectro[1]},
{SPR_ICON_ELECTRO, 'B', 25, &AF(DoGet), &s_IconElectro[0]},
};
#define ICON_SPELL_RATE 8
STATE s_IconSpell[] =
{
{ICON_SPELL + 0, ICON_SPELL_RATE, &AF(DoGet), &s_IconSpell[1]},
{ICON_SPELL + 1, ICON_SPELL_RATE, &AF(DoGet), &s_IconSpell[2]},
{ICON_SPELL + 2, ICON_SPELL_RATE, &AF(DoGet), &s_IconSpell[3]},
{ICON_SPELL + 3, ICON_SPELL_RATE, &AF(DoGet), &s_IconSpell[4]},
{ICON_SPELL + 4, ICON_SPELL_RATE, &AF(DoGet), &s_IconSpell[5]},
{ICON_SPELL + 5, ICON_SPELL_RATE, &AF(DoGet), &s_IconSpell[6]},
{ICON_SPELL + 6, ICON_SPELL_RATE, &AF(DoGet), &s_IconSpell[7]},
{ICON_SPELL + 7, ICON_SPELL_RATE, &AF(DoGet), &s_IconSpell[8]},
{ICON_SPELL + 8, ICON_SPELL_RATE, &AF(DoGet), &s_IconSpell[9]},
{ICON_SPELL + 9, ICON_SPELL_RATE, &AF(DoGet), &s_IconSpell[10]},
{ICON_SPELL + 10, ICON_SPELL_RATE, &AF(DoGet), &s_IconSpell[11]},
{ICON_SPELL + 11, ICON_SPELL_RATE, &AF(DoGet), &s_IconSpell[12]},
{ICON_SPELL + 12, ICON_SPELL_RATE, &AF(DoGet), &s_IconSpell[13]},
{ICON_SPELL + 13, ICON_SPELL_RATE, &AF(DoGet), &s_IconSpell[14]},
{ICON_SPELL + 14, ICON_SPELL_RATE, &AF(DoGet), &s_IconSpell[15]},
{ICON_SPELL + 15, ICON_SPELL_RATE, &AF(DoGet), &s_IconSpell[0]},
{SPR_ICON_SPELL, 'A', ICON_SPELL_RATE, &AF(DoGet), &s_IconSpell[1]},
{SPR_ICON_SPELL, 'B', ICON_SPELL_RATE, &AF(DoGet), &s_IconSpell[2]},
{SPR_ICON_SPELL, 'C', ICON_SPELL_RATE, &AF(DoGet), &s_IconSpell[3]},
{SPR_ICON_SPELL, 'D', ICON_SPELL_RATE, &AF(DoGet), &s_IconSpell[4]},
{SPR_ICON_SPELL, 'E', ICON_SPELL_RATE, &AF(DoGet), &s_IconSpell[5]},
{SPR_ICON_SPELL, 'F', ICON_SPELL_RATE, &AF(DoGet), &s_IconSpell[6]},
{SPR_ICON_SPELL, 'G', ICON_SPELL_RATE, &AF(DoGet), &s_IconSpell[7]},
{SPR_ICON_SPELL, 'H', ICON_SPELL_RATE, &AF(DoGet), &s_IconSpell[8]},
{SPR_ICON_SPELL, 'I', ICON_SPELL_RATE, &AF(DoGet), &s_IconSpell[9]},
{SPR_ICON_SPELL, 'J', ICON_SPELL_RATE, &AF(DoGet), &s_IconSpell[10]},
{SPR_ICON_SPELL, 'K', ICON_SPELL_RATE, &AF(DoGet), &s_IconSpell[11]},
{SPR_ICON_SPELL, 'L', ICON_SPELL_RATE, &AF(DoGet), &s_IconSpell[12]},
{SPR_ICON_SPELL, 'M', ICON_SPELL_RATE, &AF(DoGet), &s_IconSpell[13]},
{SPR_ICON_SPELL, 'N', ICON_SPELL_RATE, &AF(DoGet), &s_IconSpell[14]},
{SPR_ICON_SPELL, 'O', ICON_SPELL_RATE, &AF(DoGet), &s_IconSpell[15]},
{SPR_ICON_SPELL, 'P', ICON_SPELL_RATE, &AF(DoGet), &s_IconSpell[0]},
};
STATE s_IconArmor[] =
{
{ICON_ARMOR + 0, 15, &AF(DoGet), &s_IconArmor[0]},
{SPR_ICON_ARMOR, 'A', 15, &AF(DoGet), &s_IconArmor[0]},
};
STATE s_IconMedkit[] =
{
{ICON_MEDKIT + 0, 15, &AF(DoGet), &s_IconMedkit[0]},
{SPR_ICON_MEDKIT, 'A', 15, &AF(DoGet), &s_IconMedkit[0]},
};
STATE s_IconChemBomb[] =
{
{ICON_CHEMBOMB, 15, &AF(DoGet), &s_IconChemBomb[0]},
{SPR_ICON_CHEMBOMB, 'A', 15, &AF(DoGet), &s_IconChemBomb[0]},
};
STATE s_IconFlashBomb[] =
{
{ICON_FLASHBOMB, 15, &AF(DoGet), &s_IconFlashBomb[0]},
{SPR_ICON_FLASHBOMB, 'A', 15, &AF(DoGet), &s_IconFlashBomb[0]},
};
STATE s_IconNuke[] =
{
{ICON_NUKE, 15, &AF(DoGet), &s_IconNuke[0]},
{SPR_ICON_NUKE, 'A', 15, &AF(DoGet), &s_IconNuke[0]},
};
STATE s_IconCaltrops[] =
{
{ICON_CALTROPS, 15, &AF(DoGet), &s_IconCaltrops[0]},
{SPR_ICON_CALTROPS, 'A', 15, &AF(DoGet), &s_IconCaltrops[0]},
};
#define ICON_SM_MEDKIT 1802
STATE s_IconSmMedkit[] =
{
{ICON_SM_MEDKIT + 0, 15, &AF(DoGet), &s_IconSmMedkit[0]},
{SPR_ICON_SM_MEDKIT, 'A', 15, &AF(DoGet), &s_IconSmMedkit[0]},
};
#define ICON_BOOSTER 1810
STATE s_IconBooster[] =
{
{ICON_BOOSTER + 0, 15, &AF(DoGet), &s_IconBooster[0]},
{SPR_ICON_BOOSTER, 'A', 15, &AF(DoGet), &s_IconBooster[0]},
};
#define ICON_HEAT_CARD 1819
STATE s_IconHeatCard[] =
{
{ICON_HEAT_CARD + 0, 15, &AF(DoGet), &s_IconHeatCard[0]},
{SPR_ICON_HEAT_CARD, 'A', 15, &AF(DoGet), &s_IconHeatCard[0]},
};
#if 0
STATE s_IconEnvironSuit[] =
{
{ICON_ENVIRON_SUIT + 0, 20, &AF(DoGet), &s_IconEnvironSuit[0]},
{SPR_ICON_ENVIRON_SUIT, 'A', 20, &AF(DoGet), &s_IconEnvironSuit[0]},
};
#endif
STATE s_IconCloak[] =
{
{ICON_CLOAK + 0, 20, &AF(DoGet), &s_IconCloak[0]},
{SPR_ICON_CLOAK, 'A', 20, &AF(DoGet), &s_IconCloak[0]},
};
STATE s_IconFly[] =
{
{ICON_FLY + 0, 20, &AF(DoGet), &s_IconFly[1]},
{ICON_FLY + 1, 20, &AF(DoGet), &s_IconFly[2]},
{ICON_FLY + 2, 20, &AF(DoGet), &s_IconFly[3]},
{ICON_FLY + 3, 20, &AF(DoGet), &s_IconFly[4]},
{ICON_FLY + 4, 20, &AF(DoGet), &s_IconFly[5]},
{ICON_FLY + 5, 20, &AF(DoGet), &s_IconFly[6]},
{ICON_FLY + 6, 20, &AF(DoGet), &s_IconFly[7]},
{ICON_FLY + 7, 20, &AF(DoGet), &s_IconFly[0]}
{SPR_ICON_FLY, 'A', 20, &AF(DoGet), &s_IconFly[1]},
{SPR_ICON_FLY, 'B', 20, &AF(DoGet), &s_IconFly[2]},
{SPR_ICON_FLY, 'C', 20, &AF(DoGet), &s_IconFly[3]},
{SPR_ICON_FLY, 'D', 20, &AF(DoGet), &s_IconFly[4]},
{SPR_ICON_FLY, 'E', 20, &AF(DoGet), &s_IconFly[5]},
{SPR_ICON_FLY, 'F', 20, &AF(DoGet), &s_IconFly[6]},
{SPR_ICON_FLY, 'G', 20, &AF(DoGet), &s_IconFly[7]},
{SPR_ICON_FLY, 'H', 20, &AF(DoGet), &s_IconFly[0]}
};
STATE s_IconNightVision[] =
{
{ICON_NIGHT_VISION + 0, 20, &AF(DoGet), &s_IconNightVision[0]},
{SPR_ICON_NIGHT_VISION, 'A', 20, &AF(DoGet), &s_IconNightVision[0]},
};
STATE s_IconFlag[] =
{
{ICON_FLAG + 0, 32, &AF(DoGet), &s_IconFlag[1]},
{ICON_FLAG + 1, 32, &AF(DoGet), &s_IconFlag[2]},
{ICON_FLAG + 2, 32, &AF(DoGet), &s_IconFlag[0]}
{SPR_ICON_FLAG, 'A', 32, &AF(DoGet), &s_IconFlag[1]},
{SPR_ICON_FLAG, 'B', 32, &AF(DoGet), &s_IconFlag[2]},
{SPR_ICON_FLAG, 'C', 32, &AF(DoGet), &s_IconFlag[0]}
};
//---------------------------------------------------------------------------
@ -828,7 +824,7 @@ DSWActor* SpawnActor(int stat, int id, STATE* state, sectortype* sect, const DVe
// be careful State can be nullptr
if (spawnedActor->user.__legacyState.State)
{
spawnedActor->spr.picnum = spawnedActor->user.__legacyState.State->Pic;
spawnedActor->setPicFromState();
spawnedActor->spr.cstat2 |= CSTAT2_SPRITE_NOANIMATE; // just in case
}
@ -4158,12 +4154,14 @@ int SpawnItemsMatch(short match)
num = SP_TAG3(itActor) - 1;
if (!ItemSpotClear(itActor, STAT_ITEM, s_Key[num]->Pic))
auto keypic = legacyTileNum(picFromState(s_Key[num]));
if (!ItemSpotClear(itActor, STAT_ITEM, keypic))
break;
spawnedActor = SpawnActor(STAT_ITEM, s_Key[num]->Pic, s_Key[num], itActor->sector(), itActor->spr.pos, itActor->spr.Angles.Yaw);
spawnedActor = SpawnActor(STAT_ITEM, keypic, s_Key[num], itActor->sector(), itActor->spr.pos, itActor->spr.Angles.Yaw);
spawnedActor->spr.picnum = spawnedActor->user.ID = s_Key[num]->Pic;
spawnedActor->spr.picnum = spawnedActor->user.ID = keypic;
// need to set the palette here - suggest table lookup
@ -4199,8 +4197,8 @@ int NewStateGroup(DSWActor* actor, STATE* StateGroup[])
ASSERT(actor->hasU());
// Kind of a goofy check, but it should catch alot of invalid states!
// BTW, 6144 is the max tile number allowed in editart.
if (actor->user.__legacyState.State && (actor->user.__legacyState.State->Pic < 0 || actor->user.__legacyState.State->Pic > MAXTILES)) // JBF: verify this!
if (actor->user.__legacyState.State && (actor->user.__legacyState.State->Sprite < 0 || actor->user.__legacyState.State->Sprite > SPR_MAX)) // JBF: verify this!
return 0;
actor->user.__legacyState.Rot = StateGroup;
@ -5971,7 +5969,7 @@ int StateControl(DSWActor* actor)
if (!actor->hasU())
break;
if (!actor->user.__legacyState.State->Pic)
if (!actor->user.__legacyState.State->Sprite)
{
NewStateGroup(actor, (STATE* *) actor->user.__legacyState.State->NextState);
}
@ -5981,17 +5979,14 @@ int StateControl(DSWActor* actor)
{
ASSERT(actor->user.__legacyState.State);
// Set the correct pic
if ((actor->user.__legacyState.State->Tics & SF_WALL_STATE))
if ((actor->user.__legacyState.State->Tics & SF_WALL_STATE)) // never used anywhere...
{
ASSERT(actor->user.WallP);
actor->user.WallP->setwalltexture(tileGetTextureID(actor->user.__legacyState.State->Pic));
actor->user.WallP->setwalltexture(picFromState(actor->user.__legacyState.State));
}
else
{
if (actor->user.__legacyState.RotNum > 1)
actor->spr.picnum = actor->user.__legacyState.Rot[0]->Pic;
else
actor->spr.picnum = actor->user.__legacyState.State->Pic;
actor->setPicFromState();
}
// Call the correct animator

322
source/games/sw/src/spritenames.h Normal file
View file

@ -0,0 +1,322 @@
x(BUNNY_RUN)
x(BUNNY_STAND)
x(BUNNY_SWIPE)
x(BUNNY_DIE)
x(BUNNY_DEAD)
x(COOLG_RUN)
x(COOLG_CLUB)
x(COOLG_FIRE)
x(COOLG_PAIN)
x(COOLG_DIE)
x(COOLG_DEAD)
x(COOLG_BIRTH)
x(COOLIE_CHARGE)
x(COOLIE_RUN)
x(COOLIE_PAIN)
x(COOLIE_DEAD_NOHEAD)
x(COOLIE_DEAD_HEAD)
x(COOLIE_DIE)
x(COOLIE_DEAD)
x(EEL_RUN)
x(EEL_FIRE)
x(EEL_DIE)
x(EEL_DEAD)
x(GIRLNINJA_RUN)
x(GIRLNINJA_STAND)
x(GIRLNINJA_CRAWL)
x(GIRLNINJA_THROW)
x(GIRLNINJA_PAIN)
x(GIRLNINJA_JUMP)
x(GIRLNINJA_KNEEL)
x(GIRLNINJA_FIRE)
x(GIRLNINJA_STAB)
x(GIRLNINJA_DIE)
x(GIRLNINJA_DEAD)
x(GIRLNINJA_SLICED)
x(GIRLNINJA_DEAD_SLICED)
x(GORO_RUN)
x(GORO_CHOP)
x(GORO_STAND)
x(GORO_SPELL)
x(GORO_DIE)
x(GORO_DEAD)
x(HORNET_RUN)
x(HORNET_DIE)
x(HORNET_DEAD)
x(GOREDrip)
x(EXP)
x(RADIATION_CLOUD)
x(MUSHROOM_CLOUD)
x(CHEMBOMB)
x(CALTROPSR)
x(FLAG)
x(PHOSPHORUS)
x(CHUNK1)
x(DRIP)
x(LAVA_RUN)
x(LAVA_THROW)
x(LAVA_FLAME)
x(LAVA_DIE)
x(LAVA_DEAD)
x(TRASHCAN)
x(PACHINKOLIGHT)
x(PACHINKO1)
x(PACHINKO2)
x(PACHINKO3)
x(PACHINKO4)
x(TOILETGIRL)
x(TOILETGIRL_FIRE)
x(WASHGIRL)
x(WASHGIRL_FIRE)
x(CARGIRL)
x(CARGIRL_FIRE)
x(MECHANICGIRL)
x(MECHANICGIRL_DRILL)
x(SAILORGIRL)
x(SAILORGIRL_FIRE)
x(PRUNEGIRL)
x(NINJA_RUN)
x(NINJA_STAND)
x(NINJA_CRAWL)
x(NINJA_SWIM)
x(NINJA_HARI_KARI)
x(NINJA_CLIMB)
x(NINJA_THROW)
x(NINJA_PAIN)
x(NINJA_JUMP)
x(NINJA_FLY)
x(NINJA_FIRE)
x(NINJA_DIE)
x(NINJA_SLICED)
x(NINJA_SLICED_HACK)
x(NINJA_GRAB_THROAT)
x(PLAYER_NINJA_RUN)
x(PLAYER_NINJA_SHOOT)
x(PLAYER_NINJA_STAND)
x(PLAYER_NINJA_JUMP)
x(PLAYER_NINJA_CLIMB)
x(PLAYER_NINJA_CRAWL)
x(PLAYER_NINJA_SWIM)
x(PLAYER_NINJA_SWORD)
x(PLAYER_NINJA_PUNCH)
x(PLAYER_NINJA_KICK)
x(PLAYER_NINJA_DIE)
x(PLAYER_NINJA_FLY)
x(NINJA_Head)
x(NINJA_HeadHurl)
x(NINJA_HeadFly)
x(RIPPER_RUN)
x(RIPPER_JUMP)
x(RIPPER_FALL)
x(RIPPER_STAND)
x(RIPPER_SWIPE)
x(RIPPER_HEART)
x(RIPPER_DIE)
x(RIPPER_DEAD)
x(RIPPER_HANG)
x(RIPPER2_RUN)
x(RIPPER2_RUNFAST)
x(RIPPER2_JUMP)
x(RIPPER2_FALL)
x(RIPPER2_STAND)
x(RIPPER2_HANG)
x(RIPPER2_SWIPE)
x(RIPPER2_MEKONG)
x(RIPPER2_HEART)
x(RIPPER2_DIE)
x(RIPPER2_DEAD)
x(SERP_RUN)
x(SERP_SLASH)
x(SERP_SPELL)
x(SERP_DIE)
x(SERP_DEAD)
x(SKEL_RUN)
x(SKEL_SLASH)
x(SKEL_SPELL)
x(SKEL_PAIN)
x(SKEL_TELEPORT)
x(SKEL_DIE)
x(SKULL)
x(SKULL_EXPLODE)
x(BETTY)
x(RAT_DEBRIS)
x(CRAB_DEBRIS)
x(STARFISH_DEBRIS)
x(ICON_REPAIR_KIT)
x(GOLD_SKELKEY)
x(BLUE_KEY)
x(BLUE_CARD)
x(SILVER_SKELKEY)
x(RED_KEY)
x(RED_CARD)
x(BRONZE_SKELKEY)
x(GREEN_KEY)
x(GREEN_CARD)
x(RED_SKELKEY)
x(YELLOW_KEY)
x(YELLOW_CARD)
x(Red_COIN)
x(Yellow_COIN)
x(Green_COIN)
x(FIRE_FLY0)
x(ICON_STAR)
x(ICON_UZI)
x(ICON_LG_UZI_AMMO)
x(ICON_UZIFLOOR)
x(ICON_ROCKET)
x(ICON_LG_ROCKET)
x(ICON_SHOTGUN)
x(ICON_LG_SHOTSHELL)
x(ICON_AUTORIOT)
x(ICON_GRENADE_LAUNCHER)
x(ICON_LG_GRENADE)
x(ICON_LG_MINE)
x(ICON_GUARD_HEAD)
x(ICON_FIREBALL_LG_AMMO)
x(ICON_HEART)
x(ICON_HEART_LG_AMMO)
x(ICON_MICRO_GUN)
x(ICON_MICRO_BATTERY)
x(ICON_RAIL_GUN)
x(ICON_RAIL_AMMO)
x(ICON_ELECTRO)
x(ICON_SPELL)
x(ICON_ARMOR)
x(ICON_MEDKIT)
x(ICON_CHEMBOMB)
x(ICON_FLASHBOMB)
x(ICON_NUKE)
x(ICON_CALTROPS)
x(ICON_SM_MEDKIT)
x(ICON_BOOSTER)
x(ICON_HEAT_CARD)
x(ICON_CLOAK)
x(ICON_FLY)
x(ICON_NIGHT_VISION)
x(ICON_FLAG)
x(SUMO_RUN)
x(SUMO_PAIN)
x(SUMO_STOMP)
x(SUMO_CLAP)
x(SUMO_FART)
x(SUMO_DIE)
x(SUMO_DEAD)
x(NOTRESTORED)
x(SUICIDES)
x(DEADLOWANG)
x(BREAK_LIGHT_ANIM)
x(BREAK_BARREL)
x(BREAK_PEDISTAL)
x(BREAK_BOTTLE1)
x(BREAK_BOTTLE2)
x(PUFF)
x(LASER_PUFF)
x(RAIL_PUFF)
x(TRACER)
x(EMP)
x(UZI_SMOKE)
x(UZI_BULLET)
x(UZI_SPARK)
x(BUBBLE)
x(SPLASH)
x(CROSSBOLT)
x(STAR)
x(STAR_DOWN)
x(LAVA_BOULDER)
x(GRENADE)
x(MINE)
x(METEOR)
x(METEOR_EXP)
x(SERP_METEOR)
x(SPEAR)
x(ROCKET)
x(BUNNYROCKET)
x(MICRO)
x(BOLT_THINMAN)
x(BOLT_FATMAN)
x(BOLT_SHRAPNEL)
x(COOLG_FIRE_DONE)
x(COOLG_DRIP)
x(GORE_FLOOR_SPLASH)
x(GORE_SPLASH)
x(PLASMA)
x(PLASMA_Drip)
x(TELEPORT_EFFECT)
x(ELECTRO)
x(GRENADE_EXP)
x(FIREBALL_DISS)
x(NAP_EXP)
x(FIREBALL_FLAMES)
x(FIREBALL)
x(BLOOD_WORM)
x(Vomit1)
x(Vomit2)
x(VomitSplash)
x(GORE_Head)
x(GORE_Leg)
x(GORE_Eye)
x(GORE_Torso)
x(GORE_Arm)
x(GORE_Lung)
x(GORE_Liver)
x(GORE_SkullCap)
x(GORE_ChunkS)
x(GORE_Drip)
x(GORE_Flame)
x(UZI_SHELL)
x(SHOT_SHELL)
x(GORE_FlameChunkA)
x(GORE_FlameChunkB)
x(COIN_SHRAP)
x(MARBEL)
x(GLASS_SHRAP_A)
x(GLASS_SHRAP_B)
x(GLASS_SHRAP_C)
x(WOOD_SHRAP_A)
x(WOOD_SHRAP_B)
x(WOOD_SHRAP_C)
x(STONE_SHRAP_A)
x(STONE_SHRAP_B)
x(STONE_SHRAP_C)
x(METAL_SHRAP_A)
x(METAL_SHRAP_B)
x(METAL_SHRAP_C)
x(PAPER_SHRAP_A)
x(PAPER_SHRAP_B)
x(PAPER_SHRAP_C)
x(FLOORBLOOD1)
x(FOOTPRINT1)
x(FOOTPRINT2)
x(FOOTPRINT3)
x(WALLBLOOD1)
x(WALLBLOOD2)
x(WALLBLOOD3)
x(WALLBLOOD4)
x(ZILLA_RUN)
x(ZILLA_PAIN)
x(ZILLA_ROCKET)
x(ZILLA_RAIL)
x(ZILLA_SHOOT)
x(ZILLA_RECHARGE)
x(ZILLA_DIE)
x(ZILLA_DEAD)

266
source/games/sw/src/sumo.cpp
View file

@ -127,47 +127,19 @@ ATTRIBUTE SumoAttrib =
#define SUMO_RATE 24
STATE s_SumoRun[5][4] =
STATE s_SumoRun[1][4] =
{
{
{SUMO_RUN_R0 + 0, SUMO_RATE, &AF(DoSumoMove), &s_SumoRun[0][1]},
{SUMO_RUN_R0 + 1, SUMO_RATE, &AF(DoSumoMove), &s_SumoRun[0][2]},
{SUMO_RUN_R0 + 2, SUMO_RATE, &AF(DoSumoMove), &s_SumoRun[0][3]},
{SUMO_RUN_R0 + 3, SUMO_RATE, &AF(DoSumoMove), &s_SumoRun[0][0]}
{SPR_SUMO_RUN, 'A', SUMO_RATE, &AF(DoSumoMove), &s_SumoRun[0][1]},
{SPR_SUMO_RUN, 'B', SUMO_RATE, &AF(DoSumoMove), &s_SumoRun[0][2]},
{SPR_SUMO_RUN, 'C', SUMO_RATE, &AF(DoSumoMove), &s_SumoRun[0][3]},
{SPR_SUMO_RUN, 'D', SUMO_RATE, &AF(DoSumoMove), &s_SumoRun[0][0]}
},
{
{SUMO_RUN_R1 + 0, SUMO_RATE, &AF(DoSumoMove), &s_SumoRun[1][1]},
{SUMO_RUN_R1 + 1, SUMO_RATE, &AF(DoSumoMove), &s_SumoRun[1][2]},
{SUMO_RUN_R1 + 2, SUMO_RATE, &AF(DoSumoMove), &s_SumoRun[1][3]},
{SUMO_RUN_R1 + 3, SUMO_RATE, &AF(DoSumoMove), &s_SumoRun[1][0]}
},
{
{SUMO_RUN_R2 + 0, SUMO_RATE, &AF(DoSumoMove), &s_SumoRun[2][1]},
{SUMO_RUN_R2 + 1, SUMO_RATE, &AF(DoSumoMove), &s_SumoRun[2][2]},
{SUMO_RUN_R2 + 2, SUMO_RATE, &AF(DoSumoMove), &s_SumoRun[2][3]},
{SUMO_RUN_R2 + 3, SUMO_RATE, &AF(DoSumoMove), &s_SumoRun[2][0]}
},
{
{SUMO_RUN_R3 + 0, SUMO_RATE, &AF(DoSumoMove), &s_SumoRun[3][1]},
{SUMO_RUN_R3 + 1, SUMO_RATE, &AF(DoSumoMove), &s_SumoRun[3][2]},
{SUMO_RUN_R3 + 2, SUMO_RATE, &AF(DoSumoMove), &s_SumoRun[3][3]},
{SUMO_RUN_R3 + 3, SUMO_RATE, &AF(DoSumoMove), &s_SumoRun[3][0]}
},
{
{SUMO_RUN_R4 + 0, SUMO_RATE, &AF(DoSumoMove), &s_SumoRun[4][1]},
{SUMO_RUN_R4 + 1, SUMO_RATE, &AF(DoSumoMove), &s_SumoRun[4][2]},
{SUMO_RUN_R4 + 2, SUMO_RATE, &AF(DoSumoMove), &s_SumoRun[4][3]},
{SUMO_RUN_R4 + 3, SUMO_RATE, &AF(DoSumoMove), &s_SumoRun[4][0]},
}
};
STATE* sg_SumoRun[] =
{
&s_SumoRun[0][0],
&s_SumoRun[1][0],
&s_SumoRun[2][0],
&s_SumoRun[3][0],
&s_SumoRun[4][0]
};
@ -178,32 +150,16 @@ STATE* sg_SumoRun[] =
//
//////////////////////
STATE s_SumoStand[5][1] =
STATE s_SumoStand[1][1] =
{
{
{SUMO_RUN_R0 + 0, SUMO_RATE, &AF(DoSumoMove), &s_SumoStand[0][0]}
{SPR_SUMO_RUN, 'A', SUMO_RATE, &AF(DoSumoMove), &s_SumoStand[0][0]}
},
{
{SUMO_RUN_R1 + 0, SUMO_RATE, &AF(DoSumoMove), &s_SumoStand[1][0]}
},
{
{SUMO_RUN_R2 + 0, SUMO_RATE, &AF(DoSumoMove), &s_SumoStand[2][0]}
},
{
{SUMO_RUN_R3 + 0, SUMO_RATE, &AF(DoSumoMove), &s_SumoStand[3][0]}
},
{
{SUMO_RUN_R4 + 0, SUMO_RATE, &AF(DoSumoMove), &s_SumoStand[4][0]}
}
};
STATE* sg_SumoStand[] =
{
&s_SumoStand[0][0],
&s_SumoStand[1][0],
&s_SumoStand[2][0],
&s_SumoStand[3][0],
&s_SumoStand[4][0]
};
//////////////////////
@ -214,37 +170,17 @@ STATE* sg_SumoStand[] =
#define SUMO_PAIN_RATE 30
STATE s_SumoPain[5][2] =
STATE s_SumoPain[1][2] =
{
{
{SUMO_PAIN_R0 + 0, SUMO_PAIN_RATE, &AF(NullSumo), &s_SumoPain[0][1]},
{SUMO_PAIN_R0 + 0, 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_SumoPain[0][0]}
{SPR_SUMO_PAIN, 'A', SUMO_PAIN_RATE, &AF(NullSumo), &s_SumoPain[0][1]},
{SPR_SUMO_PAIN, 'A', 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_SumoPain[0][0]}
},
{
{SUMO_PAIN_R1 + 0, SUMO_PAIN_RATE, &AF(NullSumo), &s_SumoPain[1][1]},
{SUMO_PAIN_R1 + 0, 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_SumoPain[1][0]}
},
{
{SUMO_PAIN_R2 + 0, SUMO_PAIN_RATE, &AF(NullSumo), &s_SumoPain[2][1]},
{SUMO_PAIN_R2 + 0, 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_SumoPain[2][0]}
},
{
{SUMO_PAIN_R3 + 0, SUMO_PAIN_RATE, &AF(NullSumo), &s_SumoPain[3][1]},
{SUMO_PAIN_R3 + 0, 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_SumoPain[3][0]}
},
{
{SUMO_PAIN_R4 + 0, SUMO_PAIN_RATE, &AF(NullSumo), &s_SumoPain[4][1]},
{SUMO_PAIN_R4 + 0, 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_SumoPain[4][0]}
}
};
STATE* sg_SumoPain[] =
{
&s_SumoPain[0][0],
&s_SumoPain[1][0],
&s_SumoPain[2][0],
&s_SumoPain[3][0],
&s_SumoPain[4][0]
};
//////////////////////
@ -255,57 +191,21 @@ STATE* sg_SumoPain[] =
#define SUMO_FART_RATE 12
STATE s_SumoFart[5][6] =
STATE s_SumoFart[1][6] =
{
{
{SUMO_FART_R0 + 0, SUMO_FART_RATE, &AF(NullSumo), &s_SumoFart[0][1]},
{SUMO_FART_R0 + 0, SF_QUICK_CALL, &AF(InitSumoFart), &s_SumoFart[0][2]},
{SUMO_FART_R0 + 1, SUMO_FART_RATE, &AF(NullSumo), &s_SumoFart[0][3]},
{SUMO_FART_R0 + 2, SUMO_FART_RATE, &AF(NullSumo), &s_SumoFart[0][4]},
{SUMO_FART_R0 + 3, SUMO_FART_RATE*10, &AF(NullSumo), &s_SumoFart[0][5]},
{SUMO_FART_R0 + 3, SF_QUICK_CALL, &AF(InitActorDecide), &s_SumoFart[0][0]}
{SPR_SUMO_FART, 'A', SUMO_FART_RATE, &AF(NullSumo), &s_SumoFart[0][1]},
{SPR_SUMO_FART, 'A', SF_QUICK_CALL, &AF(InitSumoFart), &s_SumoFart[0][2]},
{SPR_SUMO_FART, 'B', SUMO_FART_RATE, &AF(NullSumo), &s_SumoFart[0][3]},
{SPR_SUMO_FART, 'C', SUMO_FART_RATE, &AF(NullSumo), &s_SumoFart[0][4]},
{SPR_SUMO_FART, 'D', SUMO_FART_RATE*10, &AF(NullSumo), &s_SumoFart[0][5]},
{SPR_SUMO_FART, 'D', SF_QUICK_CALL, &AF(InitActorDecide), &s_SumoFart[0][0]}
},
{
{SUMO_FART_R1 + 0, SUMO_FART_RATE, &AF(NullSumo), &s_SumoFart[1][1]},
{SUMO_FART_R1 + 0, SF_QUICK_CALL, &AF(InitSumoFart), &s_SumoFart[1][2]},
{SUMO_FART_R1 + 1, SUMO_FART_RATE, &AF(NullSumo), &s_SumoFart[1][3]},
{SUMO_FART_R1 + 2, SUMO_FART_RATE, &AF(NullSumo), &s_SumoFart[1][4]},
{SUMO_FART_R1 + 3, SUMO_FART_RATE*10, &AF(NullSumo), &s_SumoFart[1][5]},
{SUMO_FART_R1 + 0, SF_QUICK_CALL, &AF(InitActorDecide), &s_SumoFart[1][0]}
},
{
{SUMO_FART_R2 + 0, SUMO_FART_RATE, &AF(NullSumo), &s_SumoFart[2][1]},
{SUMO_FART_R2 + 0, SF_QUICK_CALL, &AF(InitSumoFart), &s_SumoFart[2][2]},
{SUMO_FART_R2 + 1, SUMO_FART_RATE, &AF(NullSumo), &s_SumoFart[2][3]},
{SUMO_FART_R2 + 2, SUMO_FART_RATE, &AF(NullSumo), &s_SumoFart[2][4]},
{SUMO_FART_R2 + 3, SUMO_FART_RATE*10, &AF(NullSumo), &s_SumoFart[2][5]},
{SUMO_FART_R2 + 0, SF_QUICK_CALL, &AF(InitActorDecide), &s_SumoFart[2][0]}
},
{
{SUMO_FART_R3 + 0, SUMO_FART_RATE, &AF(NullSumo), &s_SumoFart[3][1]},
{SUMO_FART_R3 + 0, SF_QUICK_CALL, &AF(InitSumoFart), &s_SumoFart[3][2]},
{SUMO_FART_R3 + 1, SUMO_FART_RATE, &AF(NullSumo), &s_SumoFart[3][3]},
{SUMO_FART_R3 + 2, SUMO_FART_RATE, &AF(NullSumo), &s_SumoFart[3][4]},
{SUMO_FART_R3 + 3, SUMO_FART_RATE*10, &AF(NullSumo), &s_SumoFart[3][5]},
{SUMO_FART_R3 + 0, SF_QUICK_CALL, &AF(InitActorDecide), &s_SumoFart[3][0]}
},
{
{SUMO_FART_R4 + 0, SUMO_FART_RATE, &AF(NullSumo), &s_SumoFart[4][1]},
{SUMO_FART_R4 + 0, SF_QUICK_CALL, &AF(InitSumoFart), &s_SumoFart[4][2]},
{SUMO_FART_R4 + 1, SUMO_FART_RATE, &AF(NullSumo), &s_SumoFart[4][3]},
{SUMO_FART_R4 + 2, SUMO_FART_RATE, &AF(NullSumo), &s_SumoFart[4][4]},
{SUMO_FART_R4 + 3, SUMO_FART_RATE*10, &AF(NullSumo), &s_SumoFart[4][5]},
{SUMO_FART_R4 + 0, SF_QUICK_CALL, &AF(InitActorDecide), &s_SumoFart[4][0]}
}
};
STATE* sg_SumoFart[] =
{
&s_SumoFart[0][0],
&s_SumoFart[1][0],
&s_SumoFart[2][0],
&s_SumoFart[3][0],
&s_SumoFart[4][0]
};
//////////////////////
@ -316,57 +216,21 @@ STATE* sg_SumoFart[] =
#define SUMO_CLAP_RATE 12
STATE s_SumoClap[5][6] =
STATE s_SumoClap[1][6] =
{
{
{SUMO_CLAP_R0 + 0, SUMO_CLAP_RATE, &AF(NullSumo), &s_SumoClap[0][1]},
{SUMO_CLAP_R0 + 1, SUMO_CLAP_RATE, &AF(NullSumo), &s_SumoClap[0][2]},
{SUMO_CLAP_R0 + 2, SUMO_CLAP_RATE, &AF(NullSumo), &s_SumoClap[0][3]},
{SUMO_CLAP_R0 + 2, SF_QUICK_CALL, &AF(InitSumoClap), &s_SumoClap[0][4]},
{SUMO_CLAP_R0 + 3, SUMO_CLAP_RATE*10, &AF(NullSumo), &s_SumoClap[0][5]},
{SUMO_CLAP_R0 + 3, SF_QUICK_CALL, &AF(InitActorDecide), &s_SumoClap[0][5]}
{SPR_SUMO_CLAP, 'A', SUMO_CLAP_RATE, &AF(NullSumo), &s_SumoClap[0][1]},
{SPR_SUMO_CLAP, 'B', SUMO_CLAP_RATE, &AF(NullSumo), &s_SumoClap[0][2]},
{SPR_SUMO_CLAP, 'C', SUMO_CLAP_RATE, &AF(NullSumo), &s_SumoClap[0][3]},
{SPR_SUMO_CLAP, 'C', SF_QUICK_CALL, &AF(InitSumoClap), &s_SumoClap[0][4]},
{SPR_SUMO_CLAP, 'D', SUMO_CLAP_RATE*10, &AF(NullSumo), &s_SumoClap[0][5]},
{SPR_SUMO_CLAP, 'D', SF_QUICK_CALL, &AF(InitActorDecide), &s_SumoClap[0][5]}
},
{
{SUMO_CLAP_R1 + 0, SUMO_CLAP_RATE, &AF(NullSumo), &s_SumoClap[1][1]},
{SUMO_CLAP_R1 + 1, SUMO_CLAP_RATE, &AF(NullSumo), &s_SumoClap[1][2]},
{SUMO_CLAP_R1 + 2, SUMO_CLAP_RATE, &AF(NullSumo), &s_SumoClap[1][3]},
{SUMO_CLAP_R1 + 2, SF_QUICK_CALL, &AF(InitSumoClap), &s_SumoClap[1][4]},
{SUMO_CLAP_R1 + 3, SUMO_CLAP_RATE*10, &AF(NullSumo), &s_SumoClap[1][5]},
{SUMO_CLAP_R1 + 3, SF_QUICK_CALL, &AF(InitActorDecide), &s_SumoClap[1][5]}
},
{
{SUMO_CLAP_R2 + 0, SUMO_CLAP_RATE, &AF(NullSumo), &s_SumoClap[2][1]},
{SUMO_CLAP_R2 + 1, SUMO_CLAP_RATE, &AF(NullSumo), &s_SumoClap[2][2]},
{SUMO_CLAP_R2 + 2, SUMO_CLAP_RATE, &AF(NullSumo), &s_SumoClap[2][3]},
{SUMO_CLAP_R2 + 2, SF_QUICK_CALL, &AF(InitSumoClap), &s_SumoClap[2][4]},
{SUMO_CLAP_R2 + 3, SUMO_CLAP_RATE*10, &AF(NullSumo), &s_SumoClap[2][5]},
{SUMO_CLAP_R2 + 3, SF_QUICK_CALL, &AF(InitActorDecide), &s_SumoClap[2][5]}
},
{
{SUMO_CLAP_R3 + 0, SUMO_CLAP_RATE, &AF(NullSumo), &s_SumoClap[3][1]},
{SUMO_CLAP_R3 + 1, SUMO_CLAP_RATE, &AF(NullSumo), &s_SumoClap[3][2]},
{SUMO_CLAP_R3 + 2, SUMO_CLAP_RATE, &AF(NullSumo), &s_SumoClap[3][3]},
{SUMO_CLAP_R3 + 2, SF_QUICK_CALL, &AF(InitSumoClap), &s_SumoClap[3][4]},
{SUMO_CLAP_R3 + 3, SUMO_CLAP_RATE*10, &AF(NullSumo), &s_SumoClap[3][5]},
{SUMO_CLAP_R3 + 3, SF_QUICK_CALL, &AF(InitActorDecide), &s_SumoClap[3][5]}
},
{
{SUMO_CLAP_R4 + 0, SUMO_CLAP_RATE, &AF(NullSumo), &s_SumoClap[4][1]},
{SUMO_CLAP_R4 + 1, SUMO_CLAP_RATE, &AF(NullSumo), &s_SumoClap[4][2]},
{SUMO_CLAP_R4 + 2, SUMO_CLAP_RATE, &AF(NullSumo), &s_SumoClap[4][3]},
{SUMO_CLAP_R4 + 2, SF_QUICK_CALL, &AF(InitSumoClap), &s_SumoClap[4][4]},
{SUMO_CLAP_R4 + 3, SUMO_CLAP_RATE*10, &AF(NullSumo), &s_SumoClap[4][5]},
{SUMO_CLAP_R4 + 3, SF_QUICK_CALL, &AF(InitActorDecide), &s_SumoClap[4][5]}
}
};
STATE* sg_SumoClap[] =
{
&s_SumoClap[0][0],
&s_SumoClap[1][0],
&s_SumoClap[2][0],
&s_SumoClap[3][0],
&s_SumoClap[4][0]
};
//////////////////////
@ -377,48 +241,16 @@ STATE* sg_SumoClap[] =
#define SUMO_STOMP_RATE 30
STATE s_SumoStomp[5][6] =
STATE s_SumoStomp[1][6] =
{
{
{SUMO_STOMP_R0 + 0, SUMO_STOMP_RATE, &AF(NullSumo), &s_SumoStomp[0][1]},
{SUMO_STOMP_R0 + 1, SUMO_STOMP_RATE*3, &AF(NullSumo), &s_SumoStomp[0][2]},
{SUMO_STOMP_R0 + 2, SUMO_STOMP_RATE, &AF(NullSumo), &s_SumoStomp[0][3]},
{SUMO_STOMP_R0 + 2, 0|SF_QUICK_CALL, &AF(InitSumoStomp), &s_SumoStomp[0][4]},
{SUMO_STOMP_R0 + 2, 8, &AF(NullSumo), &s_SumoStomp[0][5]},
{SUMO_STOMP_R0 + 2, 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_SumoStomp[0][5]}
{SPR_SUMO_STOMP, 'A', SUMO_STOMP_RATE, &AF(NullSumo), &s_SumoStomp[0][1]},
{SPR_SUMO_STOMP, 'B', SUMO_STOMP_RATE*3, &AF(NullSumo), &s_SumoStomp[0][2]},
{SPR_SUMO_STOMP, 'C', SUMO_STOMP_RATE, &AF(NullSumo), &s_SumoStomp[0][3]},
{SPR_SUMO_STOMP, 'C', 0|SF_QUICK_CALL, &AF(InitSumoStomp), &s_SumoStomp[0][4]},
{SPR_SUMO_STOMP, 'C', 8, &AF(NullSumo), &s_SumoStomp[0][5]},
{SPR_SUMO_STOMP, 'C', 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_SumoStomp[0][5]}
},
{
{SUMO_STOMP_R1 + 0, SUMO_STOMP_RATE, &AF(NullSumo), &s_SumoStomp[1][1]},
{SUMO_STOMP_R1 + 1, SUMO_STOMP_RATE*3, &AF(NullSumo), &s_SumoStomp[1][2]},
{SUMO_STOMP_R1 + 2, SUMO_STOMP_RATE, &AF(NullSumo), &s_SumoStomp[1][3]},
{SUMO_STOMP_R1 + 2, 0|SF_QUICK_CALL, &AF(InitSumoStomp), &s_SumoStomp[1][4]},
{SUMO_STOMP_R1 + 2, 8, &AF(NullSumo), &s_SumoStomp[1][5]},
{SUMO_STOMP_R1 + 2, 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_SumoStomp[1][5]}
},
{
{SUMO_STOMP_R2 + 0, SUMO_STOMP_RATE, &AF(NullSumo), &s_SumoStomp[2][1]},
{SUMO_STOMP_R2 + 1, SUMO_STOMP_RATE*3, &AF(NullSumo), &s_SumoStomp[2][2]},
{SUMO_STOMP_R2 + 2, SUMO_STOMP_RATE, &AF(NullSumo), &s_SumoStomp[2][3]},
{SUMO_STOMP_R2 + 2, 0|SF_QUICK_CALL, &AF(InitSumoStomp), &s_SumoStomp[2][4]},
{SUMO_STOMP_R2 + 2, 8, &AF(NullSumo), &s_SumoStomp[2][5]},
{SUMO_STOMP_R2 + 2, 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_SumoStomp[2][5]}
},
{
{SUMO_STOMP_R3 + 0, SUMO_STOMP_RATE, &AF(NullSumo), &s_SumoStomp[3][1]},
{SUMO_STOMP_R3 + 1, SUMO_STOMP_RATE*3, &AF(NullSumo), &s_SumoStomp[3][2]},
{SUMO_STOMP_R3 + 2, SUMO_STOMP_RATE, &AF(NullSumo), &s_SumoStomp[3][3]},
{SUMO_STOMP_R3 + 2, 0|SF_QUICK_CALL, &AF(InitSumoStomp), &s_SumoStomp[3][4]},
{SUMO_STOMP_R3 + 2, 8, &AF(NullSumo), &s_SumoStomp[3][5]},
{SUMO_STOMP_R3 + 2, 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_SumoStomp[3][5]}
},
{
{SUMO_STOMP_R4 + 0, SUMO_STOMP_RATE, &AF(NullSumo), &s_SumoStomp[4][1]},
{SUMO_STOMP_R4 + 1, SUMO_STOMP_RATE*3, &AF(NullSumo), &s_SumoStomp[4][2]},
{SUMO_STOMP_R4 + 2, SUMO_STOMP_RATE, &AF(NullSumo), &s_SumoStomp[4][3]},
{SUMO_STOMP_R4 + 2, 0|SF_QUICK_CALL, &AF(InitSumoStomp), &s_SumoStomp[4][4]},
{SUMO_STOMP_R4 + 2, 8, &AF(NullSumo), &s_SumoStomp[4][5]},
{SUMO_STOMP_R4 + 2, 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_SumoStomp[4][5]}
}
};
STATE* sg_SumoStomp[] =
@ -441,23 +273,23 @@ STATE* sg_SumoStomp[] =
STATE s_SumoDie[] =
{
{SUMO_DIE + 0, SUMO_DIE_RATE*2, &AF(NullSumo), &s_SumoDie[1]},
{SUMO_DIE + 1, SUMO_DIE_RATE, &AF(NullSumo), &s_SumoDie[2]},
{SUMO_DIE + 2, SUMO_DIE_RATE, &AF(NullSumo), &s_SumoDie[3]},
{SUMO_DIE + 3, SUMO_DIE_RATE, &AF(NullSumo), &s_SumoDie[4]},
{SUMO_DIE + 4, SUMO_DIE_RATE, &AF(NullSumo), &s_SumoDie[5]},
{SUMO_DIE + 5, SUMO_DIE_RATE, &AF(NullSumo), &s_SumoDie[6]},
{SUMO_DIE + 6, SUMO_DIE_RATE, &AF(NullSumo), &s_SumoDie[7]},
{SUMO_DIE + 6, SUMO_DIE_RATE*3, &AF(NullSumo), &s_SumoDie[8]},
{SUMO_DIE + 7, SUMO_DIE_RATE, &AF(NullSumo), &s_SumoDie[9]},
{SUMO_DIE + 6, SUMO_DIE_RATE, &AF(NullSumo), &s_SumoDie[10]},
{SUMO_DIE + 7, SUMO_DIE_RATE, &AF(NullSumo), &s_SumoDie[11]},
{SUMO_DIE + 6, SUMO_DIE_RATE-8, &AF(NullSumo), &s_SumoDie[12]},
{SUMO_DIE + 7, SUMO_DIE_RATE, &AF(NullSumo), &s_SumoDie[13]},
{SUMO_DIE + 7, SF_QUICK_CALL, &AF(DoSumoDeathMelt), &s_SumoDie[14]},
{SUMO_DIE + 6, SUMO_DIE_RATE-15, &AF(NullSumo), &s_SumoDie[15]},
{SUMO_DEAD, SF_QUICK_CALL, &AF(QueueFloorBlood), &s_SumoDie[16]},
{SUMO_DEAD, SUMO_DIE_RATE, &AF(DoActorDebris), &s_SumoDie[16]}
{SPR_SUMO_DIE, 'A', SUMO_DIE_RATE*2, &AF(NullSumo), &s_SumoDie[1]},
{SPR_SUMO_DIE, 'B', SUMO_DIE_RATE, &AF(NullSumo), &s_SumoDie[2]},
{SPR_SUMO_DIE, 'C', SUMO_DIE_RATE, &AF(NullSumo), &s_SumoDie[3]},
{SPR_SUMO_DIE, 'D', SUMO_DIE_RATE, &AF(NullSumo), &s_SumoDie[4]},
{SPR_SUMO_DIE, 'E', SUMO_DIE_RATE, &AF(NullSumo), &s_SumoDie[5]},
{SPR_SUMO_DIE, 'F', SUMO_DIE_RATE, &AF(NullSumo), &s_SumoDie[6]},
{SPR_SUMO_DIE, 'G', SUMO_DIE_RATE, &AF(NullSumo), &s_SumoDie[7]},
{SPR_SUMO_DIE, 'G', SUMO_DIE_RATE*3, &AF(NullSumo), &s_SumoDie[8]},
{SPR_SUMO_DIE, 'H', SUMO_DIE_RATE, &AF(NullSumo), &s_SumoDie[9]},
{SPR_SUMO_DIE, 'G', SUMO_DIE_RATE, &AF(NullSumo), &s_SumoDie[10]},
{SPR_SUMO_DIE, 'H', SUMO_DIE_RATE, &AF(NullSumo), &s_SumoDie[11]},
{SPR_SUMO_DIE, 'G', SUMO_DIE_RATE-8, &AF(NullSumo), &s_SumoDie[12]},
{SPR_SUMO_DIE, 'H', SUMO_DIE_RATE, &AF(NullSumo), &s_SumoDie[13]},
{SPR_SUMO_DIE, 'H', SF_QUICK_CALL, &AF(DoSumoDeathMelt), &s_SumoDie[14]},
{SPR_SUMO_DIE, 'G', SUMO_DIE_RATE-15, &AF(NullSumo), &s_SumoDie[15]},
{SPR_SUMO_DEAD, 'A', SF_QUICK_CALL, &AF(QueueFloorBlood), &s_SumoDie[16]},
{SPR_SUMO_DEAD, 'A', SUMO_DIE_RATE, &AF(DoActorDebris), &s_SumoDie[16]}
};
STATE* sg_SumoDie[] =
@ -467,7 +299,7 @@ STATE* sg_SumoDie[] =
STATE s_SumoDead[] =
{
{SUMO_DEAD, SUMO_DIE_RATE, &AF(DoActorDebris), &s_SumoDead[0]},
{SPR_SUMO_DEAD, 'A', SUMO_DIE_RATE, &AF(DoActorDebris), &s_SumoDead[0]},
};
STATE* sg_SumoDead[] =

13
source/games/sw/src/swactor.h
View file

@ -6,6 +6,16 @@ BEGIN_SW_NS
struct Personality;
FTextureID picFromState(STATE* s)
{
auto& spritedef = SpriteDefs[s->Sprite];
unsigned framenum = s->Frame - 'A';
if (framenum >= spritedef.numframes) return FNullTextureID();
auto& frame = SpriteFrames[spritedef.spriteframes + framenum];
return frame.Texture[0];
}
class DSWActor : public DCoreActor
{
DECLARE_CLASS(DSWActor, DCoreActor)
@ -55,8 +65,7 @@ public:
void callAction();
void callStateAction();
int callFunction(VMFunction* func);
void setPicFromState() { spr.setspritetexture(picFromState(user.__legacyState.State)); }
};
inline void UpdateChangeXY(DSWActor* actor)

4
source/games/sw/src/track.cpp
View file

@ -801,8 +801,6 @@ void SectorObjectSetupBounds(SECTOR_OBJECT* sop)
if (!itActor->hasU())
SpawnUser(itActor, 0, nullptr);
itActor->user.__legacyState.RotNum = 0;
itActor->backuppos();
itActor->user.oz = itActor->opos.Z;
@ -3124,7 +3122,7 @@ bool ActorTrackDecide(TRACK_POINT* tpoint, DSWActor* actor)
break;
case TRACK_ACTOR_DEATH1:
if (actor->hasState(NAME_Death2))
if (actor->hasState(NAME_Death1))
{
actor->user.WaitTics = 4 * 120;
actor->setStateGroup(NAME_Death1);

2213
source/games/sw/src/weapon.cpp
View file

File diff suppressed because it is too large Load diff

5
source/games/sw/src/weapon.h
View file

@ -173,15 +173,10 @@ int DoDamageTest(DSWActor*);
extern short StatDamageList[STAT_DAMAGE_LIST_SIZE];
#define RADIATION_CLOUD 3258
#define MUSHROOM_CLOUD 3280
extern STATE s_NukeMushroom[];
void WallBounce(DSWActor*, DAngle ang);
#define PUFF 1748
#define CALTROPS 2218
#define PHOSPHORUS 1397
int PlayerInitChemBomb(DSWPlayer* pp);
int InitChemBomb(DSWActor*);

382
source/games/sw/src/zilla.cpp
View file

@ -116,57 +116,21 @@ ATTRIBUTE ZillaAttrib =
#define ZILLA_RATE 48
STATE s_ZillaRun[5][6] =
STATE s_ZillaRun[1][6] =
{
{
{ZILLA_RUN_R0 + 0, ZILLA_RATE, &AF(DoZillaMove), &s_ZillaRun[0][1]},
{ZILLA_RUN_R0 + 1, SF_QUICK_CALL, &AF(DoZillaStomp), &s_ZillaRun[0][2]},
{ZILLA_RUN_R0 + 1, ZILLA_RATE, &AF(DoZillaMove), &s_ZillaRun[0][3]},
{ZILLA_RUN_R0 + 2, ZILLA_RATE, &AF(DoZillaMove), &s_ZillaRun[0][4]},
{ZILLA_RUN_R0 + 3, SF_QUICK_CALL, &AF(DoZillaStomp), &s_ZillaRun[0][5]},
{ZILLA_RUN_R0 + 3, ZILLA_RATE, &AF(DoZillaMove), &s_ZillaRun[0][0]}
{SPR_ZILLA_RUN, 'A', ZILLA_RATE, &AF(DoZillaMove), &s_ZillaRun[0][1]},
{SPR_ZILLA_RUN, 'B', SF_QUICK_CALL, &AF(DoZillaStomp), &s_ZillaRun[0][2]},
{SPR_ZILLA_RUN, 'B', ZILLA_RATE, &AF(DoZillaMove), &s_ZillaRun[0][3]},
{SPR_ZILLA_RUN, 'C', ZILLA_RATE, &AF(DoZillaMove), &s_ZillaRun[0][4]},
{SPR_ZILLA_RUN, 'D', SF_QUICK_CALL, &AF(DoZillaStomp), &s_ZillaRun[0][5]},
{SPR_ZILLA_RUN, 'D', ZILLA_RATE, &AF(DoZillaMove), &s_ZillaRun[0][0]}
},
{
{ZILLA_RUN_R1 + 0, ZILLA_RATE, &AF(DoZillaMove), &s_ZillaRun[1][1]},
{ZILLA_RUN_R1 + 1, SF_QUICK_CALL, &AF(DoZillaStomp), &s_ZillaRun[1][2]},
{ZILLA_RUN_R1 + 1, ZILLA_RATE, &AF(DoZillaMove), &s_ZillaRun[1][3]},
{ZILLA_RUN_R1 + 2, ZILLA_RATE, &AF(DoZillaMove), &s_ZillaRun[1][4]},
{ZILLA_RUN_R1 + 3, SF_QUICK_CALL, &AF(DoZillaStomp), &s_ZillaRun[1][5]},
{ZILLA_RUN_R1 + 3, ZILLA_RATE, &AF(DoZillaMove), &s_ZillaRun[1][0]}
},
{
{ZILLA_RUN_R2 + 0, ZILLA_RATE, &AF(DoZillaMove), &s_ZillaRun[2][1]},
{ZILLA_RUN_R2 + 1, SF_QUICK_CALL, &AF(DoZillaStomp), &s_ZillaRun[2][2]},
{ZILLA_RUN_R2 + 1, ZILLA_RATE, &AF(DoZillaMove), &s_ZillaRun[2][3]},
{ZILLA_RUN_R2 + 2, ZILLA_RATE, &AF(DoZillaMove), &s_ZillaRun[2][4]},
{ZILLA_RUN_R2 + 3, SF_QUICK_CALL, &AF(DoZillaStomp), &s_ZillaRun[2][5]},
{ZILLA_RUN_R2 + 3, ZILLA_RATE, &AF(DoZillaMove), &s_ZillaRun[2][0]}
},
{
{ZILLA_RUN_R3 + 0, ZILLA_RATE, &AF(DoZillaMove), &s_ZillaRun[3][1]},
{ZILLA_RUN_R3 + 1, SF_QUICK_CALL, &AF(DoZillaStomp), &s_ZillaRun[3][2]},
{ZILLA_RUN_R3 + 1, ZILLA_RATE, &AF(DoZillaMove), &s_ZillaRun[3][3]},
{ZILLA_RUN_R3 + 2, ZILLA_RATE, &AF(DoZillaMove), &s_ZillaRun[3][4]},
{ZILLA_RUN_R3 + 3, SF_QUICK_CALL, &AF(DoZillaStomp), &s_ZillaRun[3][5]},
{ZILLA_RUN_R3 + 3, ZILLA_RATE, &AF(DoZillaMove), &s_ZillaRun[3][0]}
},
{
{ZILLA_RUN_R4 + 0, ZILLA_RATE, &AF(DoZillaMove), &s_ZillaRun[4][1]},
{ZILLA_RUN_R4 + 1, SF_QUICK_CALL, &AF(DoZillaStomp), &s_ZillaRun[4][2]},
{ZILLA_RUN_R4 + 1, ZILLA_RATE, &AF(DoZillaMove), &s_ZillaRun[4][3]},
{ZILLA_RUN_R4 + 2, ZILLA_RATE, &AF(DoZillaMove), &s_ZillaRun[4][4]},
{ZILLA_RUN_R4 + 3, SF_QUICK_CALL, &AF(DoZillaStomp), &s_ZillaRun[4][5]},
{ZILLA_RUN_R4 + 3, ZILLA_RATE, &AF(DoZillaMove), &s_ZillaRun[4][0]}
}
};
STATE* sg_ZillaRun[] =
{
&s_ZillaRun[0][0],
&s_ZillaRun[1][0],
&s_ZillaRun[2][0],
&s_ZillaRun[3][0],
&s_ZillaRun[4][0]
};
@ -176,32 +140,16 @@ STATE* sg_ZillaRun[] =
//
//////////////////////
STATE s_ZillaStand[5][1] =
STATE s_ZillaStand[1][1] =
{
{
{ZILLA_RUN_R0 + 0, ZILLA_RATE, &AF(DoZillaMove), &s_ZillaStand[0][0]}
{SPR_ZILLA_RUN, 'A', ZILLA_RATE, &AF(DoZillaMove), &s_ZillaStand[0][0]}
},
{
{ZILLA_RUN_R1 + 0, ZILLA_RATE, &AF(DoZillaMove), &s_ZillaStand[1][0]}
},
{
{ZILLA_RUN_R2 + 0, ZILLA_RATE, &AF(DoZillaMove), &s_ZillaStand[2][0]}
},
{
{ZILLA_RUN_R3 + 0, ZILLA_RATE, &AF(DoZillaMove), &s_ZillaStand[3][0]}
},
{
{ZILLA_RUN_R4 + 0, ZILLA_RATE, &AF(DoZillaMove), &s_ZillaStand[4][0]}
}
};
STATE* sg_ZillaStand[] =
{
&s_ZillaStand[0][0],
&s_ZillaStand[1][0],
&s_ZillaStand[2][0],
&s_ZillaStand[3][0],
&s_ZillaStand[4][0]
};
//////////////////////
@ -212,37 +160,17 @@ STATE* sg_ZillaStand[] =
#define ZILLA_PAIN_RATE 30
STATE s_ZillaPain[5][2] =
STATE s_ZillaPain[1][2] =
{
{
{ZILLA_PAIN_R0 + 0, ZILLA_PAIN_RATE, &AF(NullZilla), &s_ZillaPain[0][1]},
{ZILLA_PAIN_R0 + 0, 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_ZillaPain[0][0]}
{SPR_ZILLA_PAIN, 'A', ZILLA_PAIN_RATE, &AF(NullZilla), &s_ZillaPain[0][1]},
{SPR_ZILLA_PAIN, 'A', 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_ZillaPain[0][0]}
},
{
{ZILLA_PAIN_R1 + 0, ZILLA_PAIN_RATE, &AF(NullZilla), &s_ZillaPain[1][1]},
{ZILLA_PAIN_R1 + 0, 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_ZillaPain[1][0]}
},
{
{ZILLA_PAIN_R2 + 0, ZILLA_PAIN_RATE, &AF(NullZilla), &s_ZillaPain[2][1]},
{ZILLA_PAIN_R2 + 0, 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_ZillaPain[2][0]}
},
{
{ZILLA_PAIN_R3 + 0, ZILLA_PAIN_RATE, &AF(NullZilla), &s_ZillaPain[3][1]},
{ZILLA_PAIN_R3 + 0, 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_ZillaPain[3][0]}
},
{
{ZILLA_PAIN_R4 + 0, ZILLA_PAIN_RATE, &AF(NullZilla), &s_ZillaPain[4][1]},
{ZILLA_PAIN_R4 + 0, 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_ZillaPain[4][0]}
}
};
STATE* sg_ZillaPain[] =
{
&s_ZillaPain[0][0],
&s_ZillaPain[1][0],
&s_ZillaPain[2][0],
&s_ZillaPain[3][0],
&s_ZillaPain[4][0]
};
//////////////////////
@ -253,97 +181,29 @@ STATE* sg_ZillaPain[] =
#define ZILLA_RAIL_RATE 12
STATE s_ZillaRail[5][14] =
STATE s_ZillaRail[1][14] =
{
{
{ZILLA_RAIL_R0 + 0, ZILLA_RAIL_RATE, &AF(NullZilla), &s_ZillaRail[0][1]},
{ZILLA_RAIL_R0 + 1, ZILLA_RAIL_RATE, &AF(NullZilla), &s_ZillaRail[0][2]},
{ZILLA_RAIL_R0 + 2, ZILLA_RAIL_RATE, &AF(NullZilla), &s_ZillaRail[0][3]},
{ZILLA_RAIL_R0 + 3, SF_QUICK_CALL, &AF(InitZillaRail), &s_ZillaRail[0][4]},
{ZILLA_RAIL_R0 + 0, ZILLA_RAIL_RATE, &AF(NullZilla), &s_ZillaRail[0][5]},
{ZILLA_RAIL_R0 + 1, ZILLA_RAIL_RATE, &AF(NullZilla), &s_ZillaRail[0][6]},
{ZILLA_RAIL_R0 + 2, ZILLA_RAIL_RATE, &AF(NullZilla), &s_ZillaRail[0][7]},
{ZILLA_RAIL_R0 + 3, SF_QUICK_CALL, &AF(InitZillaRail), &s_ZillaRail[0][8]},
{ZILLA_RAIL_R0 + 0, ZILLA_RAIL_RATE, &AF(NullZilla), &s_ZillaRail[0][9]},
{ZILLA_RAIL_R0 + 1, ZILLA_RAIL_RATE, &AF(NullZilla), &s_ZillaRail[0][10]},
{ZILLA_RAIL_R0 + 2, ZILLA_RAIL_RATE, &AF(NullZilla), &s_ZillaRail[0][11]},
{ZILLA_RAIL_R0 + 3, SF_QUICK_CALL, &AF(InitZillaRail), &s_ZillaRail[0][12]},
{ZILLA_RAIL_R0 + 3, ZILLA_RAIL_RATE, &AF(NullZilla), &s_ZillaRail[0][13]},
{ZILLA_RAIL_R0 + 3, SF_QUICK_CALL, &AF(InitActorDecide), &s_ZillaRail[0][0]}
{SPR_ZILLA_RAIL, 'A', ZILLA_RAIL_RATE, &AF(NullZilla), &s_ZillaRail[0][1]},
{SPR_ZILLA_RAIL, 'B', ZILLA_RAIL_RATE, &AF(NullZilla), &s_ZillaRail[0][2]},
{SPR_ZILLA_RAIL, 'C', ZILLA_RAIL_RATE, &AF(NullZilla), &s_ZillaRail[0][3]},
{SPR_ZILLA_RAIL, 'D', SF_QUICK_CALL, &AF(InitZillaRail), &s_ZillaRail[0][4]},
{SPR_ZILLA_RAIL, 'A', ZILLA_RAIL_RATE, &AF(NullZilla), &s_ZillaRail[0][5]},
{SPR_ZILLA_RAIL, 'B', ZILLA_RAIL_RATE, &AF(NullZilla), &s_ZillaRail[0][6]},
{SPR_ZILLA_RAIL, 'C', ZILLA_RAIL_RATE, &AF(NullZilla), &s_ZillaRail[0][7]},
{SPR_ZILLA_RAIL, 'D', SF_QUICK_CALL, &AF(InitZillaRail), &s_ZillaRail[0][8]},
{SPR_ZILLA_RAIL, 'A', ZILLA_RAIL_RATE, &AF(NullZilla), &s_ZillaRail[0][9]},
{SPR_ZILLA_RAIL, 'B', ZILLA_RAIL_RATE, &AF(NullZilla), &s_ZillaRail[0][10]},
{SPR_ZILLA_RAIL, 'C', ZILLA_RAIL_RATE, &AF(NullZilla), &s_ZillaRail[0][11]},
{SPR_ZILLA_RAIL, 'D', SF_QUICK_CALL, &AF(InitZillaRail), &s_ZillaRail[0][12]},
{SPR_ZILLA_RAIL, 'D', ZILLA_RAIL_RATE, &AF(NullZilla), &s_ZillaRail[0][13]},
{SPR_ZILLA_RAIL, 'D', SF_QUICK_CALL, &AF(InitActorDecide), &s_ZillaRail[0][0]}
},
{
{ZILLA_RAIL_R1 + 0, ZILLA_RAIL_RATE, &AF(NullZilla), &s_ZillaRail[1][1]},
{ZILLA_RAIL_R1 + 1, ZILLA_RAIL_RATE, &AF(NullZilla), &s_ZillaRail[1][2]},
{ZILLA_RAIL_R1 + 2, ZILLA_RAIL_RATE, &AF(NullZilla), &s_ZillaRail[1][3]},
{ZILLA_RAIL_R1 + 3, SF_QUICK_CALL, &AF(InitZillaRail), &s_ZillaRail[1][4]},
{ZILLA_RAIL_R1 + 0, ZILLA_RAIL_RATE, &AF(NullZilla), &s_ZillaRail[1][5]},
{ZILLA_RAIL_R1 + 1, ZILLA_RAIL_RATE, &AF(NullZilla), &s_ZillaRail[1][6]},
{ZILLA_RAIL_R1 + 2, ZILLA_RAIL_RATE, &AF(NullZilla), &s_ZillaRail[1][7]},
{ZILLA_RAIL_R1 + 3, SF_QUICK_CALL, &AF(InitZillaRail), &s_ZillaRail[1][8]},
{ZILLA_RAIL_R1 + 0, ZILLA_RAIL_RATE, &AF(NullZilla), &s_ZillaRail[1][9]},
{ZILLA_RAIL_R1 + 1, ZILLA_RAIL_RATE, &AF(NullZilla), &s_ZillaRail[1][10]},
{ZILLA_RAIL_R1 + 2, ZILLA_RAIL_RATE, &AF(NullZilla), &s_ZillaRail[1][11]},
{ZILLA_RAIL_R1 + 3, SF_QUICK_CALL, &AF(InitZillaRail), &s_ZillaRail[1][12]},
{ZILLA_RAIL_R1 + 3, ZILLA_RAIL_RATE, &AF(NullZilla), &s_ZillaRail[1][13]},
{ZILLA_RAIL_R1 + 3, SF_QUICK_CALL, &AF(InitActorDecide), &s_ZillaRail[1][0]}
},
{
{ZILLA_RAIL_R2 + 0, ZILLA_RAIL_RATE, &AF(NullZilla), &s_ZillaRail[2][1]},
{ZILLA_RAIL_R2 + 1, ZILLA_RAIL_RATE, &AF(NullZilla), &s_ZillaRail[2][2]},
{ZILLA_RAIL_R2 + 2, ZILLA_RAIL_RATE, &AF(NullZilla), &s_ZillaRail[2][3]},
{ZILLA_RAIL_R2 + 3, SF_QUICK_CALL, &AF(InitZillaRail), &s_ZillaRail[2][4]},
{ZILLA_RAIL_R2 + 0, ZILLA_RAIL_RATE, &AF(NullZilla), &s_ZillaRail[2][5]},
{ZILLA_RAIL_R2 + 1, ZILLA_RAIL_RATE, &AF(NullZilla), &s_ZillaRail[2][6]},
{ZILLA_RAIL_R2 + 2, ZILLA_RAIL_RATE, &AF(NullZilla), &s_ZillaRail[2][7]},
{ZILLA_RAIL_R2 + 3, SF_QUICK_CALL, &AF(InitZillaRail), &s_ZillaRail[2][8]},
{ZILLA_RAIL_R2 + 0, ZILLA_RAIL_RATE, &AF(NullZilla), &s_ZillaRail[2][9]},
{ZILLA_RAIL_R2 + 1, ZILLA_RAIL_RATE, &AF(NullZilla), &s_ZillaRail[2][10]},
{ZILLA_RAIL_R2 + 2, ZILLA_RAIL_RATE, &AF(NullZilla), &s_ZillaRail[2][11]},
{ZILLA_RAIL_R2 + 3, SF_QUICK_CALL, &AF(InitZillaRail), &s_ZillaRail[2][12]},
{ZILLA_RAIL_R2 + 3, ZILLA_RAIL_RATE, &AF(NullZilla), &s_ZillaRail[2][13]},
{ZILLA_RAIL_R2 + 3, SF_QUICK_CALL, &AF(InitActorDecide), &s_ZillaRail[2][0]}
},
{
{ZILLA_RAIL_R3 + 0, ZILLA_RAIL_RATE, &AF(NullZilla), &s_ZillaRail[3][1]},
{ZILLA_RAIL_R3 + 1, ZILLA_RAIL_RATE, &AF(NullZilla), &s_ZillaRail[3][2]},
{ZILLA_RAIL_R3 + 2, ZILLA_RAIL_RATE, &AF(NullZilla), &s_ZillaRail[3][3]},
{ZILLA_RAIL_R3 + 3, SF_QUICK_CALL, &AF(InitZillaRail), &s_ZillaRail[3][4]},
{ZILLA_RAIL_R3 + 0, ZILLA_RAIL_RATE, &AF(NullZilla), &s_ZillaRail[3][5]},
{ZILLA_RAIL_R3 + 1, ZILLA_RAIL_RATE, &AF(NullZilla), &s_ZillaRail[3][6]},
{ZILLA_RAIL_R3 + 2, ZILLA_RAIL_RATE, &AF(NullZilla), &s_ZillaRail[3][7]},
{ZILLA_RAIL_R3 + 3, SF_QUICK_CALL, &AF(InitZillaRail), &s_ZillaRail[3][8]},
{ZILLA_RAIL_R3 + 0, ZILLA_RAIL_RATE, &AF(NullZilla), &s_ZillaRail[3][9]},
{ZILLA_RAIL_R3 + 1, ZILLA_RAIL_RATE, &AF(NullZilla), &s_ZillaRail[3][10]},
{ZILLA_RAIL_R3 + 2, ZILLA_RAIL_RATE, &AF(NullZilla), &s_ZillaRail[3][11]},
{ZILLA_RAIL_R3 + 3, SF_QUICK_CALL, &AF(InitZillaRail), &s_ZillaRail[3][12]},
{ZILLA_RAIL_R3 + 3, ZILLA_RAIL_RATE, &AF(NullZilla), &s_ZillaRail[3][13]},
{ZILLA_RAIL_R3 + 3, SF_QUICK_CALL, &AF(InitActorDecide), &s_ZillaRail[3][0]}
},
{
{ZILLA_RAIL_R4 + 0, ZILLA_RAIL_RATE, &AF(NullZilla), &s_ZillaRail[4][1]},
{ZILLA_RAIL_R4 + 1, ZILLA_RAIL_RATE, &AF(NullZilla), &s_ZillaRail[4][2]},
{ZILLA_RAIL_R4 + 2, ZILLA_RAIL_RATE, &AF(NullZilla), &s_ZillaRail[4][3]},
{ZILLA_RAIL_R4 + 3, SF_QUICK_CALL, &AF(InitZillaRail), &s_ZillaRail[4][4]},
{ZILLA_RAIL_R4 + 0, ZILLA_RAIL_RATE, &AF(NullZilla), &s_ZillaRail[4][5]},
{ZILLA_RAIL_R4 + 1, ZILLA_RAIL_RATE, &AF(NullZilla), &s_ZillaRail[4][6]},
{ZILLA_RAIL_R4 + 2, ZILLA_RAIL_RATE, &AF(NullZilla), &s_ZillaRail[4][7]},
{ZILLA_RAIL_R4 + 3, SF_QUICK_CALL, &AF(InitZillaRail), &s_ZillaRail[4][8]},
{ZILLA_RAIL_R4 + 0, ZILLA_RAIL_RATE, &AF(NullZilla), &s_ZillaRail[4][9]},
{ZILLA_RAIL_R4 + 1, ZILLA_RAIL_RATE, &AF(NullZilla), &s_ZillaRail[4][10]},
{ZILLA_RAIL_R4 + 2, ZILLA_RAIL_RATE, &AF(NullZilla), &s_ZillaRail[4][11]},
{ZILLA_RAIL_R4 + 3, SF_QUICK_CALL, &AF(InitZillaRail), &s_ZillaRail[4][12]},
{ZILLA_RAIL_R4 + 3, ZILLA_RAIL_RATE, &AF(NullZilla), &s_ZillaRail[4][13]},
{ZILLA_RAIL_R4 + 3, SF_QUICK_CALL, &AF(InitActorDecide), &s_ZillaRail[4][0]}
}
};
STATE* sg_ZillaRail[] =
{
&s_ZillaRail[0][0],
&s_ZillaRail[1][0],
&s_ZillaRail[2][0],
&s_ZillaRail[3][0],
&s_ZillaRail[4][0]
};
//////////////////////
@ -354,62 +214,22 @@ STATE* sg_ZillaRail[] =
#define ZILLA_ROCKET_RATE 12
STATE s_ZillaRocket[5][7] =
STATE s_ZillaRocket[1][7] =
{
{
{ZILLA_ROCKET_R0 + 0, ZILLA_ROCKET_RATE, &AF(NullZilla), &s_ZillaRocket[0][1]},
{ZILLA_ROCKET_R0 + 1, ZILLA_ROCKET_RATE, &AF(NullZilla), &s_ZillaRocket[0][2]},
{ZILLA_ROCKET_R0 + 2, ZILLA_ROCKET_RATE*4, &AF(NullZilla), &s_ZillaRocket[0][3]},
{ZILLA_ROCKET_R0 + 2, SF_QUICK_CALL, &AF(InitZillaRocket), &s_ZillaRocket[0][4]},
{ZILLA_ROCKET_R0 + 2, ZILLA_ROCKET_RATE*4, &AF(NullZilla), &s_ZillaRocket[0][5]},
{ZILLA_ROCKET_R0 + 3, SF_QUICK_CALL, &AF(InitActorDecide), &s_ZillaRocket[0][6]},
{ZILLA_ROCKET_R0 + 3, ZILLA_ROCKET_RATE*10, &AF(NullZilla), &s_ZillaRocket[0][5]}
{SPR_ZILLA_ROCKET, 'A', ZILLA_ROCKET_RATE, &AF(NullZilla), &s_ZillaRocket[0][1]},
{SPR_ZILLA_ROCKET, 'B', ZILLA_ROCKET_RATE, &AF(NullZilla), &s_ZillaRocket[0][2]},
{SPR_ZILLA_ROCKET, 'C', ZILLA_ROCKET_RATE*4, &AF(NullZilla), &s_ZillaRocket[0][3]},
{SPR_ZILLA_ROCKET, 'C', SF_QUICK_CALL, &AF(InitZillaRocket), &s_ZillaRocket[0][4]},
{SPR_ZILLA_ROCKET, 'C', ZILLA_ROCKET_RATE*4, &AF(NullZilla), &s_ZillaRocket[0][5]},
{SPR_ZILLA_ROCKET, 'D', SF_QUICK_CALL, &AF(InitActorDecide), &s_ZillaRocket[0][6]},
{SPR_ZILLA_ROCKET, 'D', ZILLA_ROCKET_RATE*10, &AF(NullZilla), &s_ZillaRocket[0][5]}
},
{
{ZILLA_ROCKET_R1 + 0, ZILLA_ROCKET_RATE, &AF(NullZilla), &s_ZillaRocket[1][1]},
{ZILLA_ROCKET_R1 + 1, ZILLA_ROCKET_RATE, &AF(NullZilla), &s_ZillaRocket[1][2]},
{ZILLA_ROCKET_R1 + 2, ZILLA_ROCKET_RATE*4, &AF(NullZilla), &s_ZillaRocket[1][3]},
{ZILLA_ROCKET_R1 + 2, SF_QUICK_CALL, &AF(InitZillaRocket), &s_ZillaRocket[1][4]},
{ZILLA_ROCKET_R1 + 2, ZILLA_ROCKET_RATE*4, &AF(NullZilla), &s_ZillaRocket[1][5]},
{ZILLA_ROCKET_R1 + 3, SF_QUICK_CALL, &AF(InitActorDecide), &s_ZillaRocket[1][6]},
{ZILLA_ROCKET_R1 + 3, ZILLA_ROCKET_RATE*10, &AF(NullZilla), &s_ZillaRocket[1][5]}
},
{
{ZILLA_ROCKET_R2 + 0, ZILLA_ROCKET_RATE, &AF(NullZilla), &s_ZillaRocket[2][1]},
{ZILLA_ROCKET_R2 + 1, ZILLA_ROCKET_RATE, &AF(NullZilla), &s_ZillaRocket[2][2]},
{ZILLA_ROCKET_R2 + 2, ZILLA_ROCKET_RATE*4, &AF(NullZilla), &s_ZillaRocket[2][3]},
{ZILLA_ROCKET_R2 + 2, SF_QUICK_CALL, &AF(InitZillaRocket), &s_ZillaRocket[2][4]},
{ZILLA_ROCKET_R2 + 2, ZILLA_ROCKET_RATE*4, &AF(NullZilla), &s_ZillaRocket[2][5]},
{ZILLA_ROCKET_R2 + 3, SF_QUICK_CALL, &AF(InitActorDecide), &s_ZillaRocket[2][6]},
{ZILLA_ROCKET_R2 + 3, ZILLA_ROCKET_RATE*10, &AF(NullZilla), &s_ZillaRocket[2][5]}
},
{
{ZILLA_ROCKET_R3 + 0, ZILLA_ROCKET_RATE, &AF(NullZilla), &s_ZillaRocket[3][1]},
{ZILLA_ROCKET_R3 + 1, ZILLA_ROCKET_RATE, &AF(NullZilla), &s_ZillaRocket[3][2]},
{ZILLA_ROCKET_R3 + 2, ZILLA_ROCKET_RATE*4, &AF(NullZilla), &s_ZillaRocket[3][3]},
{ZILLA_ROCKET_R3 + 2, SF_QUICK_CALL, &AF(InitZillaRocket), &s_ZillaRocket[3][4]},
{ZILLA_ROCKET_R3 + 2, ZILLA_ROCKET_RATE*4, &AF(NullZilla), &s_ZillaRocket[3][5]},
{ZILLA_ROCKET_R3 + 3, SF_QUICK_CALL, &AF(InitActorDecide), &s_ZillaRocket[3][6]},
{ZILLA_ROCKET_R3 + 3, ZILLA_ROCKET_RATE*10, &AF(NullZilla), &s_ZillaRocket[3][5]}
},
{
{ZILLA_ROCKET_R4 + 0, ZILLA_ROCKET_RATE, &AF(NullZilla), &s_ZillaRocket[4][1]},
{ZILLA_ROCKET_R4 + 1, ZILLA_ROCKET_RATE, &AF(NullZilla), &s_ZillaRocket[4][2]},
{ZILLA_ROCKET_R4 + 2, ZILLA_ROCKET_RATE*4, &AF(NullZilla), &s_ZillaRocket[4][3]},
{ZILLA_ROCKET_R4 + 2, SF_QUICK_CALL, &AF(InitZillaRocket), &s_ZillaRocket[4][4]},
{ZILLA_ROCKET_R4 + 2, ZILLA_ROCKET_RATE*4, &AF(NullZilla), &s_ZillaRocket[4][5]},
{ZILLA_ROCKET_R4 + 3, SF_QUICK_CALL, &AF(InitActorDecide), &s_ZillaRocket[4][6]},
{ZILLA_ROCKET_R4 + 3, ZILLA_ROCKET_RATE*10, &AF(NullZilla), &s_ZillaRocket[4][5]}
}
};
STATE* sg_ZillaRocket[] =
{
&s_ZillaRocket[0][0],
&s_ZillaRocket[1][0],
&s_ZillaRocket[2][0],
&s_ZillaRocket[3][0],
&s_ZillaRocket[4][0]
};
//////////////////////
@ -420,102 +240,26 @@ STATE* sg_ZillaRocket[] =
#define ZILLA_UZI_RATE 8
STATE s_ZillaUzi[5][17] =
STATE s_ZillaUzi[1][17] =
{
{
{ZILLA_SHOOT_R0 + 0, ZILLA_UZI_RATE, &AF(NullZilla), &s_ZillaUzi[0][1]},
{ZILLA_SHOOT_R0 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZillaUzi[0][2]},
{ZILLA_SHOOT_R0 + 0, ZILLA_UZI_RATE, &AF(NullZilla), &s_ZillaUzi[0][3]},
{ZILLA_SHOOT_R0 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZillaUzi[0][4]},
{ZILLA_SHOOT_R0 + 0, ZILLA_UZI_RATE, &AF(NullZilla), &s_ZillaUzi[0][5]},
{ZILLA_SHOOT_R0 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZillaUzi[0][6]},
{ZILLA_SHOOT_R0 + 0, ZILLA_UZI_RATE, &AF(NullZilla), &s_ZillaUzi[0][7]},
{ZILLA_SHOOT_R0 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZillaUzi[0][8]},
{ZILLA_SHOOT_R0 + 0, ZILLA_UZI_RATE, &AF(NullZilla), &s_ZillaUzi[0][9]},
{ZILLA_SHOOT_R0 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZillaUzi[0][10]},
{ZILLA_SHOOT_R0 + 0, ZILLA_UZI_RATE, &AF(NullZilla), &s_ZillaUzi[0][11]},
{ZILLA_SHOOT_R0 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZillaUzi[0][12]},
{ZILLA_SHOOT_R0 + 0, ZILLA_UZI_RATE, &AF(NullZilla), &s_ZillaUzi[0][13]},
{ZILLA_SHOOT_R0 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZillaUzi[0][14]},
{ZILLA_SHOOT_R0 + 0, ZILLA_UZI_RATE, &AF(NullZilla), &s_ZillaUzi[0][15]},
{ZILLA_SHOOT_R0 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZillaUzi[0][16]},
{ZILLA_SHOOT_R0 + 0, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_ZillaUzi[0][16]},
},
{
{ZILLA_SHOOT_R1 + 0, ZILLA_UZI_RATE, &AF(NullZilla), &s_ZillaUzi[1][1]},
{ZILLA_SHOOT_R1 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZillaUzi[1][2]},
{ZILLA_SHOOT_R1 + 0, ZILLA_UZI_RATE, &AF(NullZilla), &s_ZillaUzi[1][3]},
{ZILLA_SHOOT_R1 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZillaUzi[1][4]},
{ZILLA_SHOOT_R1 + 0, ZILLA_UZI_RATE, &AF(NullZilla), &s_ZillaUzi[1][5]},
{ZILLA_SHOOT_R1 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZillaUzi[1][6]},
{ZILLA_SHOOT_R1 + 0, ZILLA_UZI_RATE, &AF(NullZilla), &s_ZillaUzi[1][7]},
{ZILLA_SHOOT_R1 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZillaUzi[1][8]},
{ZILLA_SHOOT_R1 + 0, ZILLA_UZI_RATE, &AF(NullZilla), &s_ZillaUzi[1][9]},
{ZILLA_SHOOT_R1 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZillaUzi[1][10]},
{ZILLA_SHOOT_R1 + 0, ZILLA_UZI_RATE, &AF(NullZilla), &s_ZillaUzi[1][11]},
{ZILLA_SHOOT_R1 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZillaUzi[1][12]},
{ZILLA_SHOOT_R1 + 0, ZILLA_UZI_RATE, &AF(NullZilla), &s_ZillaUzi[1][13]},
{ZILLA_SHOOT_R1 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZillaUzi[1][14]},
{ZILLA_SHOOT_R1 + 0, ZILLA_UZI_RATE, &AF(NullZilla), &s_ZillaUzi[1][15]},
{ZILLA_SHOOT_R1 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZillaUzi[1][16]},
{ZILLA_SHOOT_R1 + 0, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_ZillaUzi[1][16]},
},
{
{ZILLA_SHOOT_R2 + 0, ZILLA_UZI_RATE, &AF(NullZilla), &s_ZillaUzi[2][1]},
{ZILLA_SHOOT_R2 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZillaUzi[2][2]},
{ZILLA_SHOOT_R2 + 0, ZILLA_UZI_RATE, &AF(NullZilla), &s_ZillaUzi[2][3]},
{ZILLA_SHOOT_R2 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZillaUzi[2][4]},
{ZILLA_SHOOT_R2 + 0, ZILLA_UZI_RATE, &AF(NullZilla), &s_ZillaUzi[2][5]},
{ZILLA_SHOOT_R2 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZillaUzi[2][6]},
{ZILLA_SHOOT_R2 + 0, ZILLA_UZI_RATE, &AF(NullZilla), &s_ZillaUzi[2][7]},
{ZILLA_SHOOT_R2 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZillaUzi[2][8]},
{ZILLA_SHOOT_R2 + 0, ZILLA_UZI_RATE, &AF(NullZilla), &s_ZillaUzi[2][9]},
{ZILLA_SHOOT_R2 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZillaUzi[2][10]},
{ZILLA_SHOOT_R2 + 0, ZILLA_UZI_RATE, &AF(NullZilla), &s_ZillaUzi[2][11]},
{ZILLA_SHOOT_R2 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZillaUzi[2][12]},
{ZILLA_SHOOT_R2 + 0, ZILLA_UZI_RATE, &AF(NullZilla), &s_ZillaUzi[2][13]},
{ZILLA_SHOOT_R2 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZillaUzi[2][14]},
{ZILLA_SHOOT_R2 + 0, ZILLA_UZI_RATE, &AF(NullZilla), &s_ZillaUzi[2][15]},
{ZILLA_SHOOT_R2 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZillaUzi[2][16]},
{ZILLA_SHOOT_R2 + 0, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_ZillaUzi[2][16]},
},
{
{ZILLA_SHOOT_R3 + 0, ZILLA_UZI_RATE, &AF(NullZilla), &s_ZillaUzi[3][1]},
{ZILLA_SHOOT_R3 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZillaUzi[3][2]},
{ZILLA_SHOOT_R3 + 0, ZILLA_UZI_RATE, &AF(NullZilla), &s_ZillaUzi[3][3]},
{ZILLA_SHOOT_R3 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZillaUzi[3][4]},
{ZILLA_SHOOT_R3 + 0, ZILLA_UZI_RATE, &AF(NullZilla), &s_ZillaUzi[3][5]},
{ZILLA_SHOOT_R3 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZillaUzi[3][6]},
{ZILLA_SHOOT_R3 + 0, ZILLA_UZI_RATE, &AF(NullZilla), &s_ZillaUzi[3][7]},
{ZILLA_SHOOT_R3 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZillaUzi[3][8]},
{ZILLA_SHOOT_R3 + 0, ZILLA_UZI_RATE, &AF(NullZilla), &s_ZillaUzi[3][9]},
{ZILLA_SHOOT_R3 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZillaUzi[3][10]},
{ZILLA_SHOOT_R3 + 0, ZILLA_UZI_RATE, &AF(NullZilla), &s_ZillaUzi[3][11]},
{ZILLA_SHOOT_R3 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZillaUzi[3][12]},
{ZILLA_SHOOT_R3 + 0, ZILLA_UZI_RATE, &AF(NullZilla), &s_ZillaUzi[3][13]},
{ZILLA_SHOOT_R3 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZillaUzi[3][14]},
{ZILLA_SHOOT_R3 + 0, ZILLA_UZI_RATE, &AF(NullZilla), &s_ZillaUzi[3][15]},
{ZILLA_SHOOT_R3 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZillaUzi[3][16]},
{ZILLA_SHOOT_R3 + 0, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_ZillaUzi[3][16]},
},
{
{ZILLA_SHOOT_R4 + 0, ZILLA_UZI_RATE, &AF(NullZilla), &s_ZillaUzi[4][1]},
{ZILLA_SHOOT_R4 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZillaUzi[4][2]},
{ZILLA_SHOOT_R4 + 0, ZILLA_UZI_RATE, &AF(NullZilla), &s_ZillaUzi[4][3]},
{ZILLA_SHOOT_R4 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZillaUzi[4][4]},
{ZILLA_SHOOT_R4 + 0, ZILLA_UZI_RATE, &AF(NullZilla), &s_ZillaUzi[4][5]},
{ZILLA_SHOOT_R4 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZillaUzi[4][6]},
{ZILLA_SHOOT_R4 + 0, ZILLA_UZI_RATE, &AF(NullZilla), &s_ZillaUzi[4][7]},
{ZILLA_SHOOT_R4 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZillaUzi[4][8]},
{ZILLA_SHOOT_R4 + 0, ZILLA_UZI_RATE, &AF(NullZilla), &s_ZillaUzi[4][9]},
{ZILLA_SHOOT_R4 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZillaUzi[4][10]},
{ZILLA_SHOOT_R4 + 0, ZILLA_UZI_RATE, &AF(NullZilla), &s_ZillaUzi[4][11]},
{ZILLA_SHOOT_R4 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZillaUzi[4][12]},
{ZILLA_SHOOT_R4 + 0, ZILLA_UZI_RATE, &AF(NullZilla), &s_ZillaUzi[4][13]},
{ZILLA_SHOOT_R4 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZillaUzi[4][14]},
{ZILLA_SHOOT_R4 + 0, ZILLA_UZI_RATE, &AF(NullZilla), &s_ZillaUzi[4][15]},
{ZILLA_SHOOT_R4 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZillaUzi[4][16]},
{ZILLA_SHOOT_R4 + 0, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_ZillaUzi[4][16]},
{SPR_ZILLA_SHOOT, 'A', ZILLA_UZI_RATE, &AF(NullZilla), &s_ZillaUzi[0][1]},
{SPR_ZILLA_SHOOT, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZillaUzi[0][2]},
{SPR_ZILLA_SHOOT, 'A', ZILLA_UZI_RATE, &AF(NullZilla), &s_ZillaUzi[0][3]},
{SPR_ZILLA_SHOOT, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZillaUzi[0][4]},
{SPR_ZILLA_SHOOT, 'A', ZILLA_UZI_RATE, &AF(NullZilla), &s_ZillaUzi[0][5]},
{SPR_ZILLA_SHOOT, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZillaUzi[0][6]},
{SPR_ZILLA_SHOOT, 'A', ZILLA_UZI_RATE, &AF(NullZilla), &s_ZillaUzi[0][7]},
{SPR_ZILLA_SHOOT, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZillaUzi[0][8]},
{SPR_ZILLA_SHOOT, 'A', ZILLA_UZI_RATE, &AF(NullZilla), &s_ZillaUzi[0][9]},
{SPR_ZILLA_SHOOT, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZillaUzi[0][10]},
{SPR_ZILLA_SHOOT, 'A', ZILLA_UZI_RATE, &AF(NullZilla), &s_ZillaUzi[0][11]},
{SPR_ZILLA_SHOOT, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZillaUzi[0][12]},
{SPR_ZILLA_SHOOT, 'A', ZILLA_UZI_RATE, &AF(NullZilla), &s_ZillaUzi[0][13]},
{SPR_ZILLA_SHOOT, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZillaUzi[0][14]},
{SPR_ZILLA_SHOOT, 'A', ZILLA_UZI_RATE, &AF(NullZilla), &s_ZillaUzi[0][15]},
{SPR_ZILLA_SHOOT, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZillaUzi[0][16]},
{SPR_ZILLA_SHOOT, 'A', 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_ZillaUzi[0][16]},
},
};
@ -540,15 +284,15 @@ STATE* sg_ZillaUzi[] =
STATE s_ZillaDie[] =
{
{ZILLA_DIE + 0, ZILLA_DIE_RATE*15, &AF(DoZillaDeathMelt), &s_ZillaDie[1]},
{ZILLA_DIE + 1, ZILLA_DIE_RATE, &AF(NullZilla), &s_ZillaDie[2]},
{ZILLA_DIE + 2, ZILLA_DIE_RATE, &AF(NullZilla), &s_ZillaDie[3]},
{ZILLA_DIE + 3, ZILLA_DIE_RATE, &AF(NullZilla), &s_ZillaDie[4]},
{ZILLA_DIE + 4, ZILLA_DIE_RATE, &AF(NullZilla), &s_ZillaDie[5]},
{ZILLA_DIE + 5, ZILLA_DIE_RATE, &AF(NullZilla), &s_ZillaDie[6]},
{ZILLA_DIE + 6, ZILLA_DIE_RATE, &AF(NullZilla), &s_ZillaDie[7]},
{ZILLA_DIE + 7, ZILLA_DIE_RATE*3, &AF(NullZilla), &s_ZillaDie[8]},
{ZILLA_DEAD, ZILLA_DIE_RATE, &AF(DoActorDebris), &s_ZillaDie[8]}
{SPR_ZILLA_DIE, 'A', ZILLA_DIE_RATE*15, &AF(DoZillaDeathMelt), &s_ZillaDie[1]},
{SPR_ZILLA_DIE, 'B', ZILLA_DIE_RATE, &AF(NullZilla), &s_ZillaDie[2]},
{SPR_ZILLA_DIE, 'C', ZILLA_DIE_RATE, &AF(NullZilla), &s_ZillaDie[3]},
{SPR_ZILLA_DIE, 'D', ZILLA_DIE_RATE, &AF(NullZilla), &s_ZillaDie[4]},
{SPR_ZILLA_DIE, 'E', ZILLA_DIE_RATE, &AF(NullZilla), &s_ZillaDie[5]},
{SPR_ZILLA_DIE, 'F', ZILLA_DIE_RATE, &AF(NullZilla), &s_ZillaDie[6]},
{SPR_ZILLA_DIE, 'G', ZILLA_DIE_RATE, &AF(NullZilla), &s_ZillaDie[7]},
{SPR_ZILLA_DIE, 'H', ZILLA_DIE_RATE*3, &AF(NullZilla), &s_ZillaDie[8]},
{SPR_ZILLA_DEAD, 'A', ZILLA_DIE_RATE, &AF(DoActorDebris), &s_ZillaDie[8]}
};
STATE* sg_ZillaDie[] =
@ -558,7 +302,7 @@ STATE* sg_ZillaDie[] =
STATE s_ZillaDead[] =
{
{ZILLA_DEAD, ZILLA_DIE_RATE, &AF(DoActorDebris), &s_ZillaDead[0]},
{SPR_ZILLA_DEAD, 'A', ZILLA_DIE_RATE, &AF(DoActorDebris), &s_ZillaDead[0]},
};
STATE* sg_ZillaDead[] =

446
source/games/sw/src/zombie.cpp
View file

@ -117,47 +117,19 @@ ATTRIBUTE ZombieAttrib =
#define ZOMBIE_RATE 32
STATE s_ZombieRun[5][4] =
STATE s_ZombieRun[1][4] =
{
{
{PLAYER_NINJA_RUN_R0 + 0, ZOMBIE_RATE | SF_TIC_ADJUST, &AF(DoZombieMove), &s_ZombieRun[0][1]},
{PLAYER_NINJA_RUN_R0 + 1, ZOMBIE_RATE | SF_TIC_ADJUST, &AF(DoZombieMove), &s_ZombieRun[0][2]},
{PLAYER_NINJA_RUN_R0 + 2, ZOMBIE_RATE | SF_TIC_ADJUST, &AF(DoZombieMove), &s_ZombieRun[0][3]},
{PLAYER_NINJA_RUN_R0 + 3, ZOMBIE_RATE | SF_TIC_ADJUST, &AF(DoZombieMove), &s_ZombieRun[0][0]},
},
{
{PLAYER_NINJA_RUN_R1 + 0, ZOMBIE_RATE | SF_TIC_ADJUST, &AF(DoZombieMove), &s_ZombieRun[1][1]},
{PLAYER_NINJA_RUN_R1 + 1, ZOMBIE_RATE | SF_TIC_ADJUST, &AF(DoZombieMove), &s_ZombieRun[1][2]},
{PLAYER_NINJA_RUN_R1 + 2, ZOMBIE_RATE | SF_TIC_ADJUST, &AF(DoZombieMove), &s_ZombieRun[1][3]},
{PLAYER_NINJA_RUN_R1 + 3, ZOMBIE_RATE | SF_TIC_ADJUST, &AF(DoZombieMove), &s_ZombieRun[1][0]},
},
{
{PLAYER_NINJA_RUN_R2 + 0, ZOMBIE_RATE | SF_TIC_ADJUST, &AF(DoZombieMove), &s_ZombieRun[2][1]},
{PLAYER_NINJA_RUN_R2 + 1, ZOMBIE_RATE | SF_TIC_ADJUST, &AF(DoZombieMove), &s_ZombieRun[2][2]},
{PLAYER_NINJA_RUN_R2 + 2, ZOMBIE_RATE | SF_TIC_ADJUST, &AF(DoZombieMove), &s_ZombieRun[2][3]},
{PLAYER_NINJA_RUN_R2 + 3, ZOMBIE_RATE | SF_TIC_ADJUST, &AF(DoZombieMove), &s_ZombieRun[2][0]},
},
{
{PLAYER_NINJA_RUN_R3 + 0, ZOMBIE_RATE | SF_TIC_ADJUST, &AF(DoZombieMove), &s_ZombieRun[3][1]},
{PLAYER_NINJA_RUN_R3 + 1, ZOMBIE_RATE | SF_TIC_ADJUST, &AF(DoZombieMove), &s_ZombieRun[3][2]},
{PLAYER_NINJA_RUN_R3 + 2, ZOMBIE_RATE | SF_TIC_ADJUST, &AF(DoZombieMove), &s_ZombieRun[3][3]},
{PLAYER_NINJA_RUN_R3 + 3, ZOMBIE_RATE | SF_TIC_ADJUST, &AF(DoZombieMove), &s_ZombieRun[3][0]},
},
{
{PLAYER_NINJA_RUN_R4 + 0, ZOMBIE_RATE | SF_TIC_ADJUST, &AF(DoZombieMove), &s_ZombieRun[4][1]},
{PLAYER_NINJA_RUN_R4 + 1, ZOMBIE_RATE | SF_TIC_ADJUST, &AF(DoZombieMove), &s_ZombieRun[4][2]},
{PLAYER_NINJA_RUN_R4 + 2, ZOMBIE_RATE | SF_TIC_ADJUST, &AF(DoZombieMove), &s_ZombieRun[4][3]},
{PLAYER_NINJA_RUN_R4 + 3, ZOMBIE_RATE | SF_TIC_ADJUST, &AF(DoZombieMove), &s_ZombieRun[4][0]},
{SPR_PLAYER_NINJA_RUN, 'A', ZOMBIE_RATE | SF_TIC_ADJUST, &AF(DoZombieMove), &s_ZombieRun[0][1]},
{SPR_PLAYER_NINJA_RUN, 'B', ZOMBIE_RATE | SF_TIC_ADJUST, &AF(DoZombieMove), &s_ZombieRun[0][2]},
{SPR_PLAYER_NINJA_RUN, 'C', ZOMBIE_RATE | SF_TIC_ADJUST, &AF(DoZombieMove), &s_ZombieRun[0][3]},
{SPR_PLAYER_NINJA_RUN, 'D', ZOMBIE_RATE | SF_TIC_ADJUST, &AF(DoZombieMove), &s_ZombieRun[0][0]},
},
};
STATE* sg_ZombieRun[] =
{
s_ZombieRun[0],
s_ZombieRun[1],
s_ZombieRun[2],
s_ZombieRun[3],
s_ZombieRun[4]
};
//////////////////////
@ -168,32 +140,16 @@ STATE* sg_ZombieRun[] =
#define ZOMBIE_STAND_RATE 10
STATE s_ZombieStand[5][1] =
STATE s_ZombieStand[1][1] =
{
{
{PLAYER_NINJA_STAND_R0 + 0, ZOMBIE_STAND_RATE, &AF(NullZombie), &s_ZombieStand[0][0]},
},
{
{PLAYER_NINJA_STAND_R1 + 0, ZOMBIE_STAND_RATE, &AF(NullZombie), &s_ZombieStand[1][0]},
},
{
{PLAYER_NINJA_STAND_R2 + 0, ZOMBIE_STAND_RATE, &AF(NullZombie), &s_ZombieStand[2][0]},
},
{
{PLAYER_NINJA_STAND_R3 + 0, ZOMBIE_STAND_RATE, &AF(NullZombie), &s_ZombieStand[3][0]},
},
{
{PLAYER_NINJA_STAND_R4 + 0, ZOMBIE_STAND_RATE, &AF(NullZombie), &s_ZombieStand[4][0]},
{SPR_PLAYER_NINJA_STAND, 'A', ZOMBIE_STAND_RATE, &AF(NullZombie), &s_ZombieStand[0][0]},
},
};
STATE* sg_ZombieStand[] =
{
s_ZombieStand[0],
s_ZombieStand[1],
s_ZombieStand[2],
s_ZombieStand[3],
s_ZombieStand[4]
};
//////////////////////
@ -204,37 +160,17 @@ STATE* sg_ZombieStand[] =
#define ZOMBIE_PAIN_RATE 15
STATE s_ZombiePain[5][2] =
STATE s_ZombiePain[1][2] =
{
{
{PLAYER_NINJA_STAND_R0 + 0, ZOMBIE_PAIN_RATE, &AF(DoZombiePain), &s_ZombiePain[0][1]},
{PLAYER_NINJA_STAND_R0 + 1, ZOMBIE_PAIN_RATE, &AF(DoZombiePain), &s_ZombiePain[0][1]},
},
{
{PLAYER_NINJA_STAND_R1 + 0, ZOMBIE_PAIN_RATE, &AF(DoZombiePain), &s_ZombiePain[1][1]},
{PLAYER_NINJA_STAND_R1 + 0, ZOMBIE_PAIN_RATE, &AF(DoZombiePain), &s_ZombiePain[1][1]},
},
{
{PLAYER_NINJA_STAND_R2 + 0, ZOMBIE_PAIN_RATE, &AF(DoZombiePain), &s_ZombiePain[2][1]},
{PLAYER_NINJA_STAND_R2 + 0, ZOMBIE_PAIN_RATE, &AF(DoZombiePain), &s_ZombiePain[2][1]},
},
{
{PLAYER_NINJA_STAND_R3 + 0, ZOMBIE_PAIN_RATE, &AF(DoZombiePain), &s_ZombiePain[3][1]},
{PLAYER_NINJA_STAND_R3 + 0, ZOMBIE_PAIN_RATE, &AF(DoZombiePain), &s_ZombiePain[3][1]},
},
{
{PLAYER_NINJA_STAND_R4 + 0, ZOMBIE_PAIN_RATE, &AF(DoZombiePain), &s_ZombiePain[4][1]},
{PLAYER_NINJA_STAND_R4 + 0, ZOMBIE_PAIN_RATE, &AF(DoZombiePain), &s_ZombiePain[4][1]},
{SPR_PLAYER_NINJA_STAND, 'A', ZOMBIE_PAIN_RATE, &AF(DoZombiePain), &s_ZombiePain[0][1]},
{SPR_PLAYER_NINJA_STAND, 'B', ZOMBIE_PAIN_RATE, &AF(DoZombiePain), &s_ZombiePain[0][1]},
},
};
STATE* sg_ZombiePain[] =
{
s_ZombiePain[0],
s_ZombiePain[1],
s_ZombiePain[2],
s_ZombiePain[3],
s_ZombiePain[4]
};
//////////////////////
@ -245,57 +181,21 @@ STATE* sg_ZombiePain[] =
#define ZOMBIE_NUKE_RATE 18
STATE s_ZombieNuke[5][6] =
STATE s_ZombieNuke[1][6] =
{
{
{PLAYER_NINJA_SHOOT_R0 + 0, ZOMBIE_NUKE_RATE * 2, &AF(NullZombie), &s_ZombieNuke[0][1]},
{PLAYER_NINJA_SHOOT_R0 + 0, ZOMBIE_NUKE_RATE, &AF(NullZombie), &s_ZombieNuke[0][2]},
{PLAYER_NINJA_SHOOT_R0 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyNuke), &s_ZombieNuke[0][3]},
{PLAYER_NINJA_SHOOT_R0 + 0, ZOMBIE_NUKE_RATE * 2, &AF(NullZombie), &s_ZombieNuke[0][4]},
{PLAYER_NINJA_SHOOT_R0 + 0, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_ZombieNuke[0][5]},
{PLAYER_NINJA_SHOOT_R0 + 0, ZOMBIE_NUKE_RATE, &AF(DoZombieMove), &s_ZombieNuke[0][5]},
},
{
{PLAYER_NINJA_SHOOT_R1 + 0, ZOMBIE_NUKE_RATE * 2, &AF(NullZombie), &s_ZombieNuke[1][1]},
{PLAYER_NINJA_SHOOT_R1 + 0, ZOMBIE_NUKE_RATE, &AF(NullZombie), &s_ZombieNuke[1][2]},
{PLAYER_NINJA_SHOOT_R1 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyNuke), &s_ZombieNuke[1][3]},
{PLAYER_NINJA_SHOOT_R1 + 0, ZOMBIE_NUKE_RATE * 2, &AF(NullZombie), &s_ZombieNuke[1][4]},
{PLAYER_NINJA_SHOOT_R1 + 0, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_ZombieNuke[1][5]},
{PLAYER_NINJA_SHOOT_R1 + 0, ZOMBIE_NUKE_RATE, &AF(DoZombieMove), &s_ZombieNuke[1][5]},
},
{
{PLAYER_NINJA_SHOOT_R2 + 0, ZOMBIE_NUKE_RATE * 2, &AF(NullZombie), &s_ZombieNuke[2][1]},
{PLAYER_NINJA_SHOOT_R2 + 0, ZOMBIE_NUKE_RATE, &AF(NullZombie), &s_ZombieNuke[2][2]},
{PLAYER_NINJA_SHOOT_R2 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyNuke), &s_ZombieNuke[2][3]},
{PLAYER_NINJA_SHOOT_R2 + 0, ZOMBIE_NUKE_RATE * 2, &AF(NullZombie), &s_ZombieNuke[2][4]},
{PLAYER_NINJA_SHOOT_R2 + 0, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_ZombieNuke[2][5]},
{PLAYER_NINJA_SHOOT_R2 + 0, ZOMBIE_NUKE_RATE, &AF(DoZombieMove), &s_ZombieNuke[2][5]},
},
{
{PLAYER_NINJA_SHOOT_R2 + 0, ZOMBIE_NUKE_RATE * 2, &AF(NullZombie), &s_ZombieNuke[3][1]},
{PLAYER_NINJA_SHOOT_R2 + 0, ZOMBIE_NUKE_RATE, &AF(NullZombie), &s_ZombieNuke[3][2]},
{PLAYER_NINJA_SHOOT_R2 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyNuke), &s_ZombieNuke[3][3]},
{PLAYER_NINJA_SHOOT_R2 + 0, ZOMBIE_NUKE_RATE * 2, &AF(NullZombie), &s_ZombieNuke[3][4]},
{PLAYER_NINJA_SHOOT_R2 + 0, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_ZombieNuke[3][5]},
{PLAYER_NINJA_SHOOT_R2 + 0, ZOMBIE_NUKE_RATE, &AF(DoZombieMove), &s_ZombieNuke[3][5]},
},
{
{PLAYER_NINJA_SHOOT_R2 + 0, ZOMBIE_NUKE_RATE * 2, &AF(NullZombie), &s_ZombieNuke[4][1]},
{PLAYER_NINJA_SHOOT_R2 + 0, ZOMBIE_NUKE_RATE, &AF(NullZombie), &s_ZombieNuke[4][2]},
{PLAYER_NINJA_SHOOT_R2 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyNuke), &s_ZombieNuke[4][3]},
{PLAYER_NINJA_SHOOT_R2 + 0, ZOMBIE_NUKE_RATE * 2, &AF(NullZombie), &s_ZombieNuke[4][4]},
{PLAYER_NINJA_SHOOT_R2 + 0, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_ZombieNuke[4][5]},
{PLAYER_NINJA_SHOOT_R2 + 0, ZOMBIE_NUKE_RATE, &AF(DoZombieMove), &s_ZombieNuke[4][5]},
{SPR_PLAYER_NINJA_SHOOT, 'A', ZOMBIE_NUKE_RATE * 2, &AF(NullZombie), &s_ZombieNuke[0][1]},
{SPR_PLAYER_NINJA_SHOOT, 'A', ZOMBIE_NUKE_RATE, &AF(NullZombie), &s_ZombieNuke[0][2]},
{SPR_PLAYER_NINJA_SHOOT, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyNuke), &s_ZombieNuke[0][3]},
{SPR_PLAYER_NINJA_SHOOT, 'A', ZOMBIE_NUKE_RATE * 2, &AF(NullZombie), &s_ZombieNuke[0][4]},
{SPR_PLAYER_NINJA_SHOOT, 'A', 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_ZombieNuke[0][5]},
{SPR_PLAYER_NINJA_SHOOT, 'A', ZOMBIE_NUKE_RATE, &AF(DoZombieMove), &s_ZombieNuke[0][5]},
},
};
STATE* sg_ZombieNuke[] =
{
s_ZombieNuke[0],
s_ZombieNuke[1],
s_ZombieNuke[2],
s_ZombieNuke[3],
s_ZombieNuke[4]
};
@ -307,42 +207,14 @@ STATE* sg_ZombieNuke[] =
#define ZOMBIE_ROCKET_RATE 14
STATE s_ZombieRocket[5][5] =
STATE s_ZombieRocket[1][5] =
{
{
{PLAYER_NINJA_STAND_R0 + 0, ZOMBIE_ROCKET_RATE * 2, &AF(NullZombie), &s_ZombieRocket[0][1]},
{PLAYER_NINJA_STAND_R0 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyRocket), &s_ZombieRocket[0][2]},
{PLAYER_NINJA_STAND_R0 + 0, ZOMBIE_ROCKET_RATE, &AF(NullZombie), &s_ZombieRocket[0][3]},
{PLAYER_NINJA_STAND_R0 + 0, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_ZombieRocket[0][4]},
{PLAYER_NINJA_STAND_R0 + 0, ZOMBIE_ROCKET_RATE, &AF(DoZombieMove), &s_ZombieRocket[0][4]},
},
{
{PLAYER_NINJA_STAND_R1 + 0, ZOMBIE_ROCKET_RATE * 2, &AF(NullZombie), &s_ZombieRocket[1][1]},
{PLAYER_NINJA_STAND_R1 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyRocket), &s_ZombieRocket[1][2]},
{PLAYER_NINJA_STAND_R1 + 0, ZOMBIE_ROCKET_RATE, &AF(NullZombie), &s_ZombieRocket[1][3]},
{PLAYER_NINJA_STAND_R1 + 0, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_ZombieRocket[1][4]},
{PLAYER_NINJA_STAND_R1 + 0, ZOMBIE_ROCKET_RATE, &AF(DoZombieMove), &s_ZombieRocket[1][4]},
},
{
{PLAYER_NINJA_STAND_R2 + 0, ZOMBIE_ROCKET_RATE * 2, &AF(NullZombie), &s_ZombieRocket[2][1]},
{PLAYER_NINJA_STAND_R2 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyRocket), &s_ZombieRocket[2][2]},
{PLAYER_NINJA_STAND_R2 + 0, ZOMBIE_ROCKET_RATE, &AF(NullZombie), &s_ZombieRocket[2][3]},
{PLAYER_NINJA_STAND_R2 + 0, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_ZombieRocket[2][4]},
{PLAYER_NINJA_STAND_R2 + 0, ZOMBIE_ROCKET_RATE, &AF(DoZombieMove), &s_ZombieRocket[2][4]},
},
{
{PLAYER_NINJA_STAND_R3 + 0, ZOMBIE_ROCKET_RATE * 2, &AF(NullZombie), &s_ZombieRocket[3][1]},
{PLAYER_NINJA_STAND_R3 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyRocket), &s_ZombieRocket[3][2]},
{PLAYER_NINJA_STAND_R3 + 0, ZOMBIE_ROCKET_RATE, &AF(NullZombie), &s_ZombieRocket[3][3]},
{PLAYER_NINJA_STAND_R3 + 0, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_ZombieRocket[3][4]},
{PLAYER_NINJA_STAND_R3 + 0, ZOMBIE_ROCKET_RATE, &AF(DoZombieMove), &s_ZombieRocket[3][4]},
},
{
{PLAYER_NINJA_STAND_R4 + 0, ZOMBIE_ROCKET_RATE * 2, &AF(NullZombie), &s_ZombieRocket[4][1]},
{PLAYER_NINJA_STAND_R4 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyRocket), &s_ZombieRocket[4][2]},
{PLAYER_NINJA_STAND_R4 + 0, ZOMBIE_ROCKET_RATE, &AF(NullZombie), &s_ZombieRocket[4][3]},
{PLAYER_NINJA_STAND_R4 + 0, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_ZombieRocket[4][4]},
{PLAYER_NINJA_STAND_R4 + 0, ZOMBIE_ROCKET_RATE, &AF(DoZombieMove), &s_ZombieRocket[4][4]},
{SPR_PLAYER_NINJA_STAND, 'A', ZOMBIE_ROCKET_RATE * 2, &AF(NullZombie), &s_ZombieRocket[0][1]},
{SPR_PLAYER_NINJA_STAND, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyRocket), &s_ZombieRocket[0][2]},
{SPR_PLAYER_NINJA_STAND, 'A', ZOMBIE_ROCKET_RATE, &AF(NullZombie), &s_ZombieRocket[0][3]},
{SPR_PLAYER_NINJA_STAND, 'A', 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_ZombieRocket[0][4]},
{SPR_PLAYER_NINJA_STAND, 'A', ZOMBIE_ROCKET_RATE, &AF(DoZombieMove), &s_ZombieRocket[0][4]},
},
};
@ -350,10 +222,6 @@ STATE s_ZombieRocket[5][5] =
STATE* sg_ZombieRocket[] =
{
s_ZombieRocket[0],
s_ZombieRocket[1],
s_ZombieRocket[2],
s_ZombieRocket[3],
s_ZombieRocket[4]
};
//////////////////////
@ -364,42 +232,14 @@ STATE* sg_ZombieRocket[] =
#define ZOMBIE_RAIL_RATE 14
STATE s_ZombieRail[5][5] =
STATE s_ZombieRail[1][5] =
{
{
{PLAYER_NINJA_STAND_R0 + 0, ZOMBIE_RAIL_RATE * 2, &AF(NullZombie), &s_ZombieRail[0][1]},
{PLAYER_NINJA_STAND_R0 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyRail), &s_ZombieRail[0][2]},
{PLAYER_NINJA_STAND_R0 + 0, ZOMBIE_RAIL_RATE, &AF(NullZombie), &s_ZombieRail[0][3]},
{PLAYER_NINJA_STAND_R0 + 0, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_ZombieRail[0][4]},
{PLAYER_NINJA_STAND_R0 + 0, ZOMBIE_RAIL_RATE, &AF(DoZombieMove), &s_ZombieRail[0][4]},
},
{
{PLAYER_NINJA_STAND_R1 + 0, ZOMBIE_RAIL_RATE * 2, &AF(NullZombie), &s_ZombieRail[1][1]},
{PLAYER_NINJA_STAND_R1 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyRail), &s_ZombieRail[1][2]},
{PLAYER_NINJA_STAND_R1 + 0, ZOMBIE_RAIL_RATE, &AF(NullZombie), &s_ZombieRail[1][3]},
{PLAYER_NINJA_STAND_R1 + 0, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_ZombieRail[1][4]},
{PLAYER_NINJA_STAND_R1 + 0, ZOMBIE_RAIL_RATE, &AF(DoZombieMove), &s_ZombieRail[1][4]},
},
{
{PLAYER_NINJA_STAND_R2 + 0, ZOMBIE_RAIL_RATE * 2, &AF(NullZombie), &s_ZombieRail[2][1]},
{PLAYER_NINJA_STAND_R2 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyRail), &s_ZombieRail[2][2]},
{PLAYER_NINJA_STAND_R2 + 0, ZOMBIE_RAIL_RATE, &AF(NullZombie), &s_ZombieRail[2][3]},
{PLAYER_NINJA_STAND_R2 + 0, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_ZombieRail[2][4]},
{PLAYER_NINJA_STAND_R2 + 0, ZOMBIE_RAIL_RATE, &AF(DoZombieMove), &s_ZombieRail[2][4]},
},
{
{PLAYER_NINJA_STAND_R3 + 0, ZOMBIE_RAIL_RATE * 2, &AF(NullZombie), &s_ZombieRail[3][1]},
{PLAYER_NINJA_STAND_R3 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyRail), &s_ZombieRail[3][2]},
{PLAYER_NINJA_STAND_R3 + 0, ZOMBIE_RAIL_RATE, &AF(NullZombie), &s_ZombieRail[3][3]},
{PLAYER_NINJA_STAND_R3 + 0, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_ZombieRail[3][4]},
{PLAYER_NINJA_STAND_R3 + 0, ZOMBIE_RAIL_RATE, &AF(DoZombieMove), &s_ZombieRail[3][4]},
},
{
{PLAYER_NINJA_STAND_R4 + 0, ZOMBIE_RAIL_RATE * 2, &AF(NullZombie), &s_ZombieRail[4][1]},
{PLAYER_NINJA_STAND_R4 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyRail), &s_ZombieRail[4][2]},
{PLAYER_NINJA_STAND_R4 + 0, ZOMBIE_RAIL_RATE, &AF(NullZombie), &s_ZombieRail[4][3]},
{PLAYER_NINJA_STAND_R4 + 0, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_ZombieRail[4][4]},
{PLAYER_NINJA_STAND_R4 + 0, ZOMBIE_RAIL_RATE, &AF(DoZombieMove), &s_ZombieRail[4][4]},
{SPR_PLAYER_NINJA_STAND, 'A', ZOMBIE_RAIL_RATE * 2, &AF(NullZombie), &s_ZombieRail[0][1]},
{SPR_PLAYER_NINJA_STAND, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyRail), &s_ZombieRail[0][2]},
{SPR_PLAYER_NINJA_STAND, 'A', ZOMBIE_RAIL_RATE, &AF(NullZombie), &s_ZombieRail[0][3]},
{SPR_PLAYER_NINJA_STAND, 'A', 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_ZombieRail[0][4]},
{SPR_PLAYER_NINJA_STAND, 'A', ZOMBIE_RAIL_RATE, &AF(DoZombieMove), &s_ZombieRail[0][4]},
},
};
@ -407,10 +247,6 @@ STATE s_ZombieRail[5][5] =
STATE* sg_ZombieRail[] =
{
s_ZombieRail[0],
s_ZombieRail[1],
s_ZombieRail[2],
s_ZombieRail[3],
s_ZombieRail[4]
};
//////////////////////
@ -421,42 +257,14 @@ STATE* sg_ZombieRail[] =
#define ZOMBIE_ROCKET_RATE 14
STATE s_ZombieGrenade[5][5] =
STATE s_ZombieGrenade[1][5] =
{
{
{PLAYER_NINJA_STAND_R0 + 0, ZOMBIE_ROCKET_RATE * 2, &AF(NullZombie), &s_ZombieGrenade[0][1]},
{PLAYER_NINJA_STAND_R0 + 0, 0 | SF_QUICK_CALL, &AF(InitSpriteGrenade), &s_ZombieGrenade[0][2]},
{PLAYER_NINJA_STAND_R0 + 0, ZOMBIE_ROCKET_RATE, &AF(NullZombie), &s_ZombieGrenade[0][3]},
{PLAYER_NINJA_STAND_R0 + 0, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_ZombieGrenade[0][4]},
{PLAYER_NINJA_STAND_R0 + 0, ZOMBIE_ROCKET_RATE, &AF(DoZombieMove), &s_ZombieGrenade[0][4]},
},
{
{PLAYER_NINJA_STAND_R1 + 0, ZOMBIE_ROCKET_RATE * 2, &AF(NullZombie), &s_ZombieGrenade[1][1]},
{PLAYER_NINJA_STAND_R1 + 0, 0 | SF_QUICK_CALL, &AF(InitSpriteGrenade), &s_ZombieGrenade[1][2]},
{PLAYER_NINJA_STAND_R1 + 0, ZOMBIE_ROCKET_RATE, &AF(NullZombie), &s_ZombieGrenade[1][3]},
{PLAYER_NINJA_STAND_R1 + 0, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_ZombieGrenade[1][4]},
{PLAYER_NINJA_STAND_R1 + 0, ZOMBIE_ROCKET_RATE, &AF(DoZombieMove), &s_ZombieGrenade[1][4]},
},
{
{PLAYER_NINJA_STAND_R2 + 0, ZOMBIE_ROCKET_RATE * 2, &AF(NullZombie), &s_ZombieGrenade[2][1]},
{PLAYER_NINJA_STAND_R2 + 0, 0 | SF_QUICK_CALL, &AF(InitSpriteGrenade), &s_ZombieGrenade[2][2]},
{PLAYER_NINJA_STAND_R2 + 0, ZOMBIE_ROCKET_RATE, &AF(NullZombie), &s_ZombieGrenade[2][3]},
{PLAYER_NINJA_STAND_R2 + 0, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_ZombieGrenade[2][4]},
{PLAYER_NINJA_STAND_R2 + 0, ZOMBIE_ROCKET_RATE, &AF(DoZombieMove), &s_ZombieGrenade[2][4]},
},
{
{PLAYER_NINJA_STAND_R3 + 0, ZOMBIE_ROCKET_RATE * 2, &AF(NullZombie), &s_ZombieGrenade[3][1]},
{PLAYER_NINJA_STAND_R3 + 0, 0 | SF_QUICK_CALL, &AF(InitSpriteGrenade), &s_ZombieGrenade[3][2]},
{PLAYER_NINJA_STAND_R3 + 0, ZOMBIE_ROCKET_RATE, &AF(NullZombie), &s_ZombieGrenade[3][3]},
{PLAYER_NINJA_STAND_R3 + 0, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_ZombieGrenade[3][4]},
{PLAYER_NINJA_STAND_R3 + 0, ZOMBIE_ROCKET_RATE, &AF(DoZombieMove), &s_ZombieGrenade[3][4]},
},
{
{PLAYER_NINJA_STAND_R4 + 0, ZOMBIE_ROCKET_RATE * 2, &AF(NullZombie), &s_ZombieGrenade[4][1]},
{PLAYER_NINJA_STAND_R4 + 0, 0 | SF_QUICK_CALL, &AF(InitSpriteGrenade), &s_ZombieGrenade[4][2]},
{PLAYER_NINJA_STAND_R4 + 0, ZOMBIE_ROCKET_RATE, &AF(NullZombie), &s_ZombieGrenade[4][3]},
{PLAYER_NINJA_STAND_R4 + 0, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_ZombieGrenade[4][4]},
{PLAYER_NINJA_STAND_R4 + 0, ZOMBIE_ROCKET_RATE, &AF(DoZombieMove), &s_ZombieGrenade[4][4]},
{SPR_PLAYER_NINJA_STAND, 'A', ZOMBIE_ROCKET_RATE * 2, &AF(NullZombie), &s_ZombieGrenade[0][1]},
{SPR_PLAYER_NINJA_STAND, 'A', 0 | SF_QUICK_CALL, &AF(InitSpriteGrenade), &s_ZombieGrenade[0][2]},
{SPR_PLAYER_NINJA_STAND, 'A', ZOMBIE_ROCKET_RATE, &AF(NullZombie), &s_ZombieGrenade[0][3]},
{SPR_PLAYER_NINJA_STAND, 'A', 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_ZombieGrenade[0][4]},
{SPR_PLAYER_NINJA_STAND, 'A', ZOMBIE_ROCKET_RATE, &AF(DoZombieMove), &s_ZombieGrenade[0][4]},
},
};
@ -464,10 +272,6 @@ STATE s_ZombieGrenade[5][5] =
STATE* sg_ZombieGrenade[] =
{
s_ZombieGrenade[0],
s_ZombieGrenade[1],
s_ZombieGrenade[2],
s_ZombieGrenade[3],
s_ZombieGrenade[4]
};
@ -479,42 +283,14 @@ STATE* sg_ZombieGrenade[] =
#define ZOMBIE_FLASHBOMB_RATE 14
STATE s_ZombieFlashBomb[5][5] =
STATE s_ZombieFlashBomb[1][5] =
{
{
{PLAYER_NINJA_STAND_R0 + 0, ZOMBIE_FLASHBOMB_RATE * 2, &AF(NullZombie), &s_ZombieFlashBomb[0][1]},
{PLAYER_NINJA_STAND_R0 + 0, 0 | SF_QUICK_CALL, &AF(InitFlashBomb), &s_ZombieFlashBomb[0][2]},
{PLAYER_NINJA_STAND_R0 + 0, ZOMBIE_FLASHBOMB_RATE, &AF(NullZombie), &s_ZombieFlashBomb[0][3]},
{PLAYER_NINJA_STAND_R0 + 0, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_ZombieFlashBomb[0][4]},
{PLAYER_NINJA_STAND_R0 + 0, ZOMBIE_FLASHBOMB_RATE, &AF(DoZombieMove), &s_ZombieFlashBomb[0][4]},
},
{
{PLAYER_NINJA_STAND_R1 + 0, ZOMBIE_FLASHBOMB_RATE * 2, &AF(NullZombie), &s_ZombieFlashBomb[1][1]},
{PLAYER_NINJA_STAND_R1 + 0, 0 | SF_QUICK_CALL, &AF(InitFlashBomb), &s_ZombieFlashBomb[1][2]},
{PLAYER_NINJA_STAND_R1 + 0, ZOMBIE_FLASHBOMB_RATE, &AF(NullZombie), &s_ZombieFlashBomb[1][3]},
{PLAYER_NINJA_STAND_R1 + 0, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_ZombieFlashBomb[1][4]},
{PLAYER_NINJA_STAND_R1 + 0, ZOMBIE_FLASHBOMB_RATE, &AF(DoZombieMove), &s_ZombieFlashBomb[1][4]},
},
{
{PLAYER_NINJA_STAND_R2 + 0, ZOMBIE_FLASHBOMB_RATE * 2, &AF(NullZombie), &s_ZombieFlashBomb[2][1]},
{PLAYER_NINJA_STAND_R2 + 0, 0 | SF_QUICK_CALL, &AF(InitFlashBomb), &s_ZombieFlashBomb[2][2]},
{PLAYER_NINJA_STAND_R2 + 0, ZOMBIE_FLASHBOMB_RATE, &AF(NullZombie), &s_ZombieFlashBomb[2][3]},
{PLAYER_NINJA_STAND_R2 + 0, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_ZombieFlashBomb[2][4]},
{PLAYER_NINJA_STAND_R2 + 0, ZOMBIE_FLASHBOMB_RATE, &AF(DoZombieMove), &s_ZombieFlashBomb[2][4]},
},
{
{PLAYER_NINJA_STAND_R3 + 0, ZOMBIE_FLASHBOMB_RATE * 2, &AF(NullZombie), &s_ZombieFlashBomb[3][1]},
{PLAYER_NINJA_STAND_R3 + 0, 0 | SF_QUICK_CALL, &AF(InitFlashBomb), &s_ZombieFlashBomb[3][2]},
{PLAYER_NINJA_STAND_R3 + 0, ZOMBIE_FLASHBOMB_RATE, &AF(NullZombie), &s_ZombieFlashBomb[3][3]},
{PLAYER_NINJA_STAND_R3 + 0, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_ZombieFlashBomb[3][4]},
{PLAYER_NINJA_STAND_R3 + 0, ZOMBIE_FLASHBOMB_RATE, &AF(DoZombieMove), &s_ZombieFlashBomb[3][4]},
},
{
{PLAYER_NINJA_STAND_R4 + 0, ZOMBIE_FLASHBOMB_RATE * 2, &AF(NullZombie), &s_ZombieFlashBomb[4][1]},
{PLAYER_NINJA_STAND_R4 + 0, 0 | SF_QUICK_CALL, &AF(InitFlashBomb), &s_ZombieFlashBomb[4][2]},
{PLAYER_NINJA_STAND_R4 + 0, ZOMBIE_FLASHBOMB_RATE, &AF(NullZombie), &s_ZombieFlashBomb[4][3]},
{PLAYER_NINJA_STAND_R4 + 0, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_ZombieFlashBomb[4][4]},
{PLAYER_NINJA_STAND_R4 + 0, ZOMBIE_FLASHBOMB_RATE, &AF(DoZombieMove), &s_ZombieFlashBomb[4][4]},
{SPR_PLAYER_NINJA_STAND, 'A', ZOMBIE_FLASHBOMB_RATE * 2, &AF(NullZombie), &s_ZombieFlashBomb[0][1]},
{SPR_PLAYER_NINJA_STAND, 'A', 0 | SF_QUICK_CALL, &AF(InitFlashBomb), &s_ZombieFlashBomb[0][2]},
{SPR_PLAYER_NINJA_STAND, 'A', ZOMBIE_FLASHBOMB_RATE, &AF(NullZombie), &s_ZombieFlashBomb[0][3]},
{SPR_PLAYER_NINJA_STAND, 'A', 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_ZombieFlashBomb[0][4]},
{SPR_PLAYER_NINJA_STAND, 'A', ZOMBIE_FLASHBOMB_RATE, &AF(DoZombieMove), &s_ZombieFlashBomb[0][4]},
},
};
@ -522,10 +298,6 @@ STATE s_ZombieFlashBomb[5][5] =
STATE* sg_ZombieFlashBomb[] =
{
s_ZombieFlashBomb[0],
s_ZombieFlashBomb[1],
s_ZombieFlashBomb[2],
s_ZombieFlashBomb[3],
s_ZombieFlashBomb[4]
};
//////////////////////
@ -536,102 +308,26 @@ STATE* sg_ZombieFlashBomb[] =
#define ZOMBIE_UZI_RATE 8
STATE s_ZombieUzi[5][17] =
STATE s_ZombieUzi[1][17] =
{
{
{PLAYER_NINJA_SHOOT_R0 + 0, ZOMBIE_UZI_RATE, &AF(NullZombie), &s_ZombieUzi[0][1]},
{PLAYER_NINJA_SHOOT_R0 + 0, 0 | SF_QUICK_CALL, &AF(CheckFire), &s_ZombieUzi[0][2]},
{PLAYER_NINJA_SHOOT_R0 + 0, ZOMBIE_UZI_RATE, &AF(NullZombie), &s_ZombieUzi[0][3]},
{PLAYER_NINJA_SHOOT_R0 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZombieUzi[0][4]},
{PLAYER_NINJA_SHOOT_R0 + 0, ZOMBIE_UZI_RATE, &AF(NullZombie), &s_ZombieUzi[0][5]},
{PLAYER_NINJA_SHOOT_R0 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZombieUzi[0][6]},
{PLAYER_NINJA_SHOOT_R0 + 0, ZOMBIE_UZI_RATE, &AF(NullZombie), &s_ZombieUzi[0][7]},
{PLAYER_NINJA_SHOOT_R0 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZombieUzi[0][8]},
{PLAYER_NINJA_SHOOT_R0 + 0, ZOMBIE_UZI_RATE, &AF(NullZombie), &s_ZombieUzi[0][9]},
{PLAYER_NINJA_SHOOT_R0 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZombieUzi[0][10]},
{PLAYER_NINJA_SHOOT_R0 + 0, ZOMBIE_UZI_RATE, &AF(NullZombie), &s_ZombieUzi[0][11]},
{PLAYER_NINJA_SHOOT_R0 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZombieUzi[0][12]},
{PLAYER_NINJA_SHOOT_R0 + 0, ZOMBIE_UZI_RATE, &AF(NullZombie), &s_ZombieUzi[0][13]},
{PLAYER_NINJA_SHOOT_R0 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZombieUzi[0][14]},
{PLAYER_NINJA_SHOOT_R0 + 0, ZOMBIE_UZI_RATE, &AF(NullZombie), &s_ZombieUzi[0][15]},
{PLAYER_NINJA_SHOOT_R0 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZombieUzi[0][16]},
{PLAYER_NINJA_SHOOT_R0 + 0, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_ZombieUzi[0][16]},
},
{
{PLAYER_NINJA_SHOOT_R1 + 0, ZOMBIE_UZI_RATE, &AF(NullZombie), &s_ZombieUzi[1][1]},
{PLAYER_NINJA_SHOOT_R1 + 0, 0 | SF_QUICK_CALL, &AF(CheckFire), &s_ZombieUzi[1][2]},
{PLAYER_NINJA_SHOOT_R1 + 0, ZOMBIE_UZI_RATE, &AF(NullZombie), &s_ZombieUzi[1][3]},
{PLAYER_NINJA_SHOOT_R1 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZombieUzi[1][4]},
{PLAYER_NINJA_SHOOT_R1 + 0, ZOMBIE_UZI_RATE, &AF(NullZombie), &s_ZombieUzi[1][5]},
{PLAYER_NINJA_SHOOT_R1 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZombieUzi[1][6]},
{PLAYER_NINJA_SHOOT_R1 + 0, ZOMBIE_UZI_RATE, &AF(NullZombie), &s_ZombieUzi[1][7]},
{PLAYER_NINJA_SHOOT_R1 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZombieUzi[1][8]},
{PLAYER_NINJA_SHOOT_R1 + 0, ZOMBIE_UZI_RATE, &AF(NullZombie), &s_ZombieUzi[1][9]},
{PLAYER_NINJA_SHOOT_R1 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZombieUzi[1][10]},
{PLAYER_NINJA_SHOOT_R1 + 0, ZOMBIE_UZI_RATE, &AF(NullZombie), &s_ZombieUzi[1][11]},
{PLAYER_NINJA_SHOOT_R1 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZombieUzi[1][12]},
{PLAYER_NINJA_SHOOT_R1 + 0, ZOMBIE_UZI_RATE, &AF(NullZombie), &s_ZombieUzi[1][13]},
{PLAYER_NINJA_SHOOT_R1 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZombieUzi[1][14]},
{PLAYER_NINJA_SHOOT_R1 + 0, ZOMBIE_UZI_RATE, &AF(NullZombie), &s_ZombieUzi[1][15]},
{PLAYER_NINJA_SHOOT_R1 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZombieUzi[1][16]},
{PLAYER_NINJA_SHOOT_R1 + 0, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_ZombieUzi[1][16]},
},
{
{PLAYER_NINJA_SHOOT_R2 + 0, ZOMBIE_UZI_RATE, &AF(NullZombie), &s_ZombieUzi[2][1]},
{PLAYER_NINJA_SHOOT_R2 + 0, 0 | SF_QUICK_CALL, &AF(CheckFire), &s_ZombieUzi[2][2]},
{PLAYER_NINJA_SHOOT_R2 + 0, ZOMBIE_UZI_RATE, &AF(NullZombie), &s_ZombieUzi[2][3]},
{PLAYER_NINJA_SHOOT_R2 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZombieUzi[2][4]},
{PLAYER_NINJA_SHOOT_R2 + 0, ZOMBIE_UZI_RATE, &AF(NullZombie), &s_ZombieUzi[2][5]},
{PLAYER_NINJA_SHOOT_R2 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZombieUzi[2][6]},
{PLAYER_NINJA_SHOOT_R2 + 0, ZOMBIE_UZI_RATE, &AF(NullZombie), &s_ZombieUzi[2][7]},
{PLAYER_NINJA_SHOOT_R2 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZombieUzi[2][8]},
{PLAYER_NINJA_SHOOT_R2 + 0, ZOMBIE_UZI_RATE, &AF(NullZombie), &s_ZombieUzi[2][9]},
{PLAYER_NINJA_SHOOT_R2 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZombieUzi[2][10]},
{PLAYER_NINJA_SHOOT_R2 + 0, ZOMBIE_UZI_RATE, &AF(NullZombie), &s_ZombieUzi[2][11]},
{PLAYER_NINJA_SHOOT_R2 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZombieUzi[2][12]},
{PLAYER_NINJA_SHOOT_R2 + 0, ZOMBIE_UZI_RATE, &AF(NullZombie), &s_ZombieUzi[2][13]},
{PLAYER_NINJA_SHOOT_R2 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZombieUzi[2][14]},
{PLAYER_NINJA_SHOOT_R2 + 0, ZOMBIE_UZI_RATE, &AF(NullZombie), &s_ZombieUzi[2][15]},
{PLAYER_NINJA_SHOOT_R2 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZombieUzi[2][16]},
{PLAYER_NINJA_SHOOT_R2 + 0, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_ZombieUzi[2][16]},
},
{
{PLAYER_NINJA_SHOOT_R3 + 0, ZOMBIE_UZI_RATE, &AF(NullZombie), &s_ZombieUzi[3][1]},
{PLAYER_NINJA_SHOOT_R3 + 0, 0 | SF_QUICK_CALL, &AF(CheckFire), &s_ZombieUzi[3][2]},
{PLAYER_NINJA_SHOOT_R3 + 0, ZOMBIE_UZI_RATE, &AF(NullZombie), &s_ZombieUzi[3][3]},
{PLAYER_NINJA_SHOOT_R3 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZombieUzi[3][4]},
{PLAYER_NINJA_SHOOT_R3 + 0, ZOMBIE_UZI_RATE, &AF(NullZombie), &s_ZombieUzi[3][5]},
{PLAYER_NINJA_SHOOT_R3 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZombieUzi[3][6]},
{PLAYER_NINJA_SHOOT_R3 + 0, ZOMBIE_UZI_RATE, &AF(NullZombie), &s_ZombieUzi[3][7]},
{PLAYER_NINJA_SHOOT_R3 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZombieUzi[3][8]},
{PLAYER_NINJA_SHOOT_R3 + 0, ZOMBIE_UZI_RATE, &AF(NullZombie), &s_ZombieUzi[3][9]},
{PLAYER_NINJA_SHOOT_R3 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZombieUzi[3][10]},
{PLAYER_NINJA_SHOOT_R3 + 0, ZOMBIE_UZI_RATE, &AF(NullZombie), &s_ZombieUzi[3][11]},
{PLAYER_NINJA_SHOOT_R3 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZombieUzi[3][12]},
{PLAYER_NINJA_SHOOT_R3 + 0, ZOMBIE_UZI_RATE, &AF(NullZombie), &s_ZombieUzi[3][13]},
{PLAYER_NINJA_SHOOT_R3 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZombieUzi[3][14]},
{PLAYER_NINJA_SHOOT_R3 + 0, ZOMBIE_UZI_RATE, &AF(NullZombie), &s_ZombieUzi[3][15]},
{PLAYER_NINJA_SHOOT_R3 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZombieUzi[3][16]},
{PLAYER_NINJA_SHOOT_R3 + 0, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_ZombieUzi[3][16]},
},
{
{PLAYER_NINJA_SHOOT_R4 + 0, ZOMBIE_UZI_RATE, &AF(NullZombie), &s_ZombieUzi[4][1]},
{PLAYER_NINJA_SHOOT_R4 + 0, 0 | SF_QUICK_CALL, &AF(CheckFire), &s_ZombieUzi[4][2]},
{PLAYER_NINJA_SHOOT_R4 + 0, ZOMBIE_UZI_RATE, &AF(NullZombie), &s_ZombieUzi[4][3]},
{PLAYER_NINJA_SHOOT_R4 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZombieUzi[4][4]},
{PLAYER_NINJA_SHOOT_R4 + 0, ZOMBIE_UZI_RATE, &AF(NullZombie), &s_ZombieUzi[4][5]},
{PLAYER_NINJA_SHOOT_R4 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZombieUzi[4][6]},
{PLAYER_NINJA_SHOOT_R4 + 0, ZOMBIE_UZI_RATE, &AF(NullZombie), &s_ZombieUzi[4][7]},
{PLAYER_NINJA_SHOOT_R4 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZombieUzi[4][8]},
{PLAYER_NINJA_SHOOT_R4 + 0, ZOMBIE_UZI_RATE, &AF(NullZombie), &s_ZombieUzi[4][9]},
{PLAYER_NINJA_SHOOT_R4 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZombieUzi[4][10]},
{PLAYER_NINJA_SHOOT_R4 + 0, ZOMBIE_UZI_RATE, &AF(NullZombie), &s_ZombieUzi[4][11]},
{PLAYER_NINJA_SHOOT_R4 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZombieUzi[4][12]},
{PLAYER_NINJA_SHOOT_R4 + 0, ZOMBIE_UZI_RATE, &AF(NullZombie), &s_ZombieUzi[4][13]},
{PLAYER_NINJA_SHOOT_R4 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZombieUzi[4][14]},
{PLAYER_NINJA_SHOOT_R4 + 0, ZOMBIE_UZI_RATE, &AF(NullZombie), &s_ZombieUzi[4][15]},
{PLAYER_NINJA_SHOOT_R4 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZombieUzi[4][16]},
{PLAYER_NINJA_SHOOT_R4 + 0, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_ZombieUzi[4][16]},
{SPR_PLAYER_NINJA_SHOOT, 'A', ZOMBIE_UZI_RATE, &AF(NullZombie), &s_ZombieUzi[0][1]},
{SPR_PLAYER_NINJA_SHOOT, 'A', 0 | SF_QUICK_CALL, &AF(CheckFire), &s_ZombieUzi[0][2]},
{SPR_PLAYER_NINJA_SHOOT, 'A', ZOMBIE_UZI_RATE, &AF(NullZombie), &s_ZombieUzi[0][3]},
{SPR_PLAYER_NINJA_SHOOT, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZombieUzi[0][4]},
{SPR_PLAYER_NINJA_SHOOT, 'A', ZOMBIE_UZI_RATE, &AF(NullZombie), &s_ZombieUzi[0][5]},
{SPR_PLAYER_NINJA_SHOOT, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZombieUzi[0][6]},
{SPR_PLAYER_NINJA_SHOOT, 'A', ZOMBIE_UZI_RATE, &AF(NullZombie), &s_ZombieUzi[0][7]},
{SPR_PLAYER_NINJA_SHOOT, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZombieUzi[0][8]},
{SPR_PLAYER_NINJA_SHOOT, 'A', ZOMBIE_UZI_RATE, &AF(NullZombie), &s_ZombieUzi[0][9]},
{SPR_PLAYER_NINJA_SHOOT, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZombieUzi[0][10]},
{SPR_PLAYER_NINJA_SHOOT, 'A', ZOMBIE_UZI_RATE, &AF(NullZombie), &s_ZombieUzi[0][11]},
{SPR_PLAYER_NINJA_SHOOT, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZombieUzi[0][12]},
{SPR_PLAYER_NINJA_SHOOT, 'A', ZOMBIE_UZI_RATE, &AF(NullZombie), &s_ZombieUzi[0][13]},
{SPR_PLAYER_NINJA_SHOOT, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZombieUzi[0][14]},
{SPR_PLAYER_NINJA_SHOOT, 'A', ZOMBIE_UZI_RATE, &AF(NullZombie), &s_ZombieUzi[0][15]},
{SPR_PLAYER_NINJA_SHOOT, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZombieUzi[0][16]},
{SPR_PLAYER_NINJA_SHOOT, 'A', 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_ZombieUzi[0][16]},
},
};
@ -639,10 +335,6 @@ STATE s_ZombieUzi[5][17] =
STATE* sg_ZombieUzi[] =
{
s_ZombieUzi[0],
s_ZombieUzi[1],
s_ZombieUzi[2],
s_ZombieUzi[3],
s_ZombieUzi[4]
};
//////////////////////
@ -653,33 +345,17 @@ STATE* sg_ZombieUzi[] =
#define ZOMBIE_FALL_RATE 25
STATE s_ZombieFall[5][1] =
STATE s_ZombieFall[1][1] =
{
{
{PLAYER_NINJA_JUMP_R0 + 3, ZOMBIE_FALL_RATE, &AF(DoZombieMove), &s_ZombieFall[0][0]},
{SPR_PLAYER_NINJA_JUMP, 'D', ZOMBIE_FALL_RATE, &AF(DoZombieMove), &s_ZombieFall[0][0]},
},
{
{PLAYER_NINJA_JUMP_R1 + 3, ZOMBIE_FALL_RATE, &AF(DoZombieMove), &s_ZombieFall[1][0]},
},
{
{PLAYER_NINJA_JUMP_R2 + 3, ZOMBIE_FALL_RATE, &AF(DoZombieMove), &s_ZombieFall[2][0]},
},
{
{PLAYER_NINJA_JUMP_R3 + 3, ZOMBIE_FALL_RATE, &AF(DoZombieMove), &s_ZombieFall[3][0]},
},
{
{PLAYER_NINJA_JUMP_R4 + 3, ZOMBIE_FALL_RATE, &AF(DoZombieMove), &s_ZombieFall[4][0]},
}
};
STATE* sg_ZombieFall[] =
{
&s_ZombieFall[0][0],
&s_ZombieFall[1][0],
&s_ZombieFall[2][0],
&s_ZombieFall[3][0],
&s_ZombieFall[4][0]
};
/*