diff --git a/source/games/sw/src/bunny.cpp b/source/games/sw/src/bunny.cpp index 046a9433bb..88328af98e 100644 --- a/source/games/sw/src/bunny.cpp +++ b/source/games/sw/src/bunny.cpp @@ -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]}, - }, - { - {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]}, + {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_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]}, - }, - { - {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]}, + {SPR_BUNNY_SWIPE, 'A', BUNNY_HEART_RATE, &AF(DoBunnyStandKill), &s_BunnyHeart[0][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]}, - }, - { - {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]}, + {SPR_BUNNY_SWIPE, 'A', BUNNY_PAIN_RATE, &AF(DoBunnyPain), &s_BunnyPain[0][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]}, - }, - { - {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]}, + {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_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]}, - }, - { - {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]}, + {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_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[] = diff --git a/source/games/sw/src/coolg.cpp b/source/games/sw/src/coolg.cpp index 1deb2742a5..e46ed728a6 100644 --- a/source/games/sw/src/coolg.cpp +++ b/source/games/sw/src/coolg.cpp @@ -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]}, - }, - { - {COOLG_RUN_R1 + 0, COOLG_RUN_RATE, &AF(DoCoolgMove), &s_CoolgStand[1][0]}, + {SPR_COOLG_RUN, 'A', COOLG_RUN_RATE, &AF(DoCoolgMove), &s_CoolgStand[0][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]} - }, - { - {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]} + {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_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]} - }, - { - {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]} + {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_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[] = diff --git a/source/games/sw/src/coolie.cpp b/source/games/sw/src/coolie.cpp index 4b4ef0756b..467f4b4a3b 100644 --- a/source/games/sw/src/coolie.cpp +++ b/source/games/sw/src/coolie.cpp @@ -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[] = @@ -409,7 +321,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; diff --git a/source/games/sw/src/draw.cpp b/source/games/sw/src/draw.cpp index 9ba6f26f3c..1dfee17443 100644 --- a/source/games/sw/src/draw.cpp +++ b/source/games/sw/src/draw.cpp @@ -205,7 +205,7 @@ int SetActorRotation(tspriteArray& tsprites, int tSpriteNum, const DVector2& vie // set the picnum here - may be redundant, but we just changed states and // thats a big deal - tsp->picnum = State->Pic; + //tsp->p icnum = State->Pic; return 0; } @@ -512,9 +512,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); diff --git a/source/games/sw/src/eel.cpp b/source/games/sw/src/eel.cpp index 7e2ab9bf8a..3666756cd2 100644 --- a/source/games/sw/src/eel.cpp +++ b/source/games/sw/src/eel.cpp @@ -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]}, - }, - { - {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]}, + {SPR_EEL_RUN, 'A', EEL_RUN_RATE, &AF(DoEelMove), &s_EelStand[0][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]} - }, - { - {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]} + {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_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[] = diff --git a/source/games/sw/src/game.h b/source/games/sw/src/game.h index 8c69c3ed2c..499da9e28c 100644 --- a/source/games/sw/src/game.h +++ b/source/games/sw/src/game.h @@ -348,9 +348,332 @@ typedef void (*soANIMATORp) (SECTOR_OBJECT*); } #define AF(func) DSWActor_##func##_VMPtr +enum spriteindex_t +{ + SPR_NULL = 0, + SPR_BUNNY_RUN, + SPR_BUNNY_STAND, + SPR_BUNNY_SWIPE, + SPR_BUNNY_DIE, + SPR_BUNNY_DEAD, + + SPR_COOLG_RUN, + SPR_COOLG_CLUB, + SPR_COOLG_FIRE, + SPR_COOLG_PAIN, + SPR_COOLG_DIE, + SPR_COOLG_DEAD, + SPR_COOLG_BIRTH, + + SPR_COOLIE_CHARGE, + SPR_COOLIE_RUN, + SPR_COOLIE_PAIN, + SPR_COOLIE_DEAD_NOHEAD, + SPR_COOLIE_DEAD_HEAD, + SPR_COOLIE_DIE, + SPR_COOLIE_DEAD, + + SPR_EEL_RUN, + SPR_EEL_FIRE, + SPR_EEL_DIE, + SPR_EEL_DEAD, + + SPR_GIRLNINJA_RUN, + SPR_GIRLNINJA_STAND, + SPR_GIRLNINJA_CRAWL, + SPR_GIRLNINJA_THROW, + SPR_GIRLNINJA_PAIN, + SPR_GIRLNINJA_JUMP, + SPR_GIRLNINJA_KNEEL, + SPR_GIRLNINJA_FIRE, + SPR_GIRLNINJA_STAB, + SPR_GIRLNINJA_DIE, + SPR_GIRLNINJA_DEAD, + SPR_GIRLNINJA_SLICED, + SPR_GIRLNINJA_DEAD_SLICED, + + SPR_GORO_RUN, + SPR_GORO_CHOP, + SPR_GORO_STAND, + SPR_GORO_SPELL, + SPR_GORO_DIE, + SPR_GORO_DEAD, + + SPR_HORNET_RUN, + SPR_HORNET_DIE, + SPR_HORNET_DEAD, + + SPR_GOREDrip, + SPR_EXP, + SPR_RADIATION_CLOUD, + SPR_MUSHROOM_CLOUD, + SPR_CHEMBOMB, + SPR_CALTROPSR, + SPR_FLAG, + SPR_PHOSPHORUS, + SPR_CHUNK1, + SPR_DRIP, + + SPR_LAVA_RUN, + SPR_LAVA_THROW, + SPR_LAVA_FLAME, + SPR_LAVA_DIE, + SPR_LAVA_DEAD, + + SPR_TRASHCAN, + SPR_PACHINKOLIGHT, + SPR_PACHINKO1, + SPR_PACHINKO2, + SPR_PACHINKO3, + SPR_PACHINKO4, + SPR_TOILETGIRL, + SPR_TOILETGIRL_FIRE, + SPR_WASHGIRL, + SPR_WASHGIRL_FIRE, + SPR_CARGIRL, + SPR_CARGIRL_FIRE, + SPR_MECHANICGIRL, + SPR_MECHANICGIRL_DRILL, + SPR_SAILORGIRL, + SPR_SAILORGIRL_FIRE, + SPR_PRUNEGIRL, + + SPR_NINJA_RUN, + SPR_NINJA_STAND, + SPR_NINJA_CRAWL, + SPR_NINJA_SWIM, + SPR_NINJA_HARI_KARI, + SPR_NINJA_CLIMB, + SPR_NINJA_THROW, + SPR_NINJA_PAIN, + SPR_NINJA_JUMP, + SPR_NINJA_FLY, + SPR_NINJA_FIRE, + SPR_NINJA_DIE, + SPR_NINJA_SLICED, + SPR_NINJA_SLICED_HACK, + SPR_NINJA_GRAB_THROAT, + + SPR_PLAYER_NINJA_RUN, + SPR_PLAYER_NINJA_SHOOT, + SPR_PLAYER_NINJA_STAND, + SPR_PLAYER_NINJA_JUMP, + SPR_PLAYER_NINJA_CLIMB, + SPR_PLAYER_NINJA_CRAWL, + SPR_PLAYER_NINJA_SWIM, + SPR_PLAYER_NINJA_SWORD, + SPR_PLAYER_NINJA_PUNCH, + SPR_PLAYER_NINJA_KICK, + SPR_PLAYER_NINJA_DIE, + SPR_PLAYER_NINJA_FLY, + SPR_NINJA_Head, + SPR_NINJA_HeadHurl, + SPR_NINJA_HeadFly, + SPR_RIPPER_RUN, + SPR_RIPPER_JUMP, + SPR_RIPPER_FALL, + SPR_RIPPER_STAND, + SPR_RIPPER_SWIPE, + SPR_RIPPER_HEART, + SPR_RIPPER_DIE, + SPR_RIPPER_DEAD, + SPR_RIPPER_HANG, + + SPR_RIPPER2_RUN, + SPR_RIPPER2_RUNFAST, + SPR_RIPPER2_JUMP, + SPR_RIPPER2_FALL, + SPR_RIPPER2_STAND, + SPR_RIPPER2_HANG, + SPR_RIPPER2_SWIPE, + SPR_RIPPER2_MEKONG, + SPR_RIPPER2_HEART, + SPR_RIPPER2_DIE, + SPR_RIPPER2_DEAD, + + SPR_SERP_RUN, + SPR_SERP_SLASH, + SPR_SERP_SPELL, + SPR_SERP_DIE, + SPR_SERP_DEAD, + + SPR_SKEL_RUN, + SPR_SKEL_SLASH, + SPR_SKEL_SPELL, + SPR_SKEL_PAIN, + SPR_SKEL_TELEPORT, + SPR_SKEL_DIE, + + SPR_SKULL, + SPR_SKULL_EXPLODE, + SPR_BETTY, + + SPR_RAT_DEBRIS, + SPR_CRAB_DEBRIS, + SPR_STARFISH_DEBRIS, + SPR_ICON_REPAIR_KIT, + SPR_GOLD_SKELKEY, + SPR_BLUE_KEY, + SPR_BLUE_CARD, + SPR_SILVER_SKELKEY, + SPR_RED_KEY, + SPR_RED_CARD, + SPR_BRONZE_SKELKEY, + SPR_GREEN_KEY, + SPR_GREEN_CARD, + SPR_RED_SKELKEY, + SPR_YELLOW_KEY, + SPR_YELLOW_CARD, + SPR_Red_COIN, + SPR_Yellow_COIN, + SPR_Green_COIN, + SPR_FIRE_FLY0, + SPR_ICON_STAR, + SPR_ICON_UZI, + SPR_ICON_LG_UZI_AMMO, + SPR_ICON_UZIFLOOR, + SPR_ICON_ROCKET, + SPR_ICON_LG_ROCKET, + SPR_ICON_SHOTGUN, + SPR_ICON_LG_SHOTSHELL, + SPR_ICON_AUTORIOT, + SPR_ICON_GRENADE_LAUNCHER, + SPR_ICON_LG_GRENADE, + SPR_ICON_LG_MINE, + SPR_ICON_GUARD_HEAD, + SPR_ICON_FIREBALL_LG_AMMO, + SPR_ICON_HEART, + SPR_ICON_HEART_LG_AMMO, + SPR_ICON_MICRO_GUN, + SPR_ICON_MICRO_BATTERY, + SPR_ICON_RAIL_GUN, + SPR_ICON_RAIL_AMMO, + SPR_ICON_ELECTRO, + SPR_ICON_SPELL, + SPR_ICON_ARMOR, + SPR_ICON_MEDKIT, + SPR_ICON_CHEMBOMB, + SPR_ICON_FLASHBOMB, + SPR_ICON_NUKE, + SPR_ICON_CALTROPS, + SPR_ICON_SM_MEDKIT, + SPR_ICON_BOOSTER, + SPR_ICON_HEAT_CARD, + SPR_ICON_CLOAK, + SPR_ICON_FLY, + SPR_ICON_NIGHT_VISION, + SPR_ICON_FLAG, + + SPR_SUMO_RUN, + SPR_SUMO_PAIN, + SPR_SUMO_STOMP, + SPR_SUMO_CLAP, + SPR_SUMO_FART, + SPR_SUMO_DIE, + SPR_SUMO_DEAD, + + SPR_NOTRESTORED, + SPR_SUICIDES, + SPR_DEADLOWANG, + SPR_BREAK_LIGHT_ANIM, + SPR_BREAK_BARREL, + SPR_BREAK_PEDISTAL, + SPR_BREAK_BOTTLE1, + SPR_BREAK_BOTTLE2, + SPR_PUFF, + SPR_LASER_PUFF, + SPR_RAIL_PUFF, + + SPR_TRACER, + SPR_EMP, + SPR_UZI_SMOKE, + SPR_UZI_BULLET, + SPR_UZI_SPARK, + SPR_BUBBLE, + SPR_SPLASH, + SPR_CROSSBOLT, + SPR_STAR, + SPR_STAR_DOWN, + SPR_LAVA_BOULDER, + SPR_GRENADE, + SPR_MINE, + SPR_METEOR, + SPR_METEOR_EXP, + SPR_SERP_METEOR, + SPR_SPEAR, + SPR_ROCKET, + SPR_BUNNYROCKET, + SPR_MICRO, + SPR_BOLT_THINMAN, + SPR_BOLT_FATMAN, + SPR_BOLT_SHRAPNEL, + SPR_COOLG_FIRE_DONE, + SPR_COOLG_DRIP, + SPR_GORE_FLOOR_SPLASH, + SPR_GORE_SPLASH, + SPR_PLASMA, + SPR_PLASMA_Drip, + SPR_TELEPORT_EFFECT, + SPR_ELECTRO, + SPR_GRENADE_EXP, + SPR_FIREBALL_DISS, + SPR_NAP_EXP, + SPR_FIREBALL_FLAMES, + SPR_FIREBALL, + SPR_BLOOD_WORM, + SPR_Vomit1, + SPR_Vomit2, + SPR_VomitSplash, + SPR_GORE_Head, + SPR_GORE_Leg, + SPR_GORE_Eye, + SPR_GORE_Torso, + SPR_GORE_Arm, + SPR_GORE_Lung, + SPR_GORE_Liver, + SPR_GORE_SkullCap, + SPR_GORE_ChunkS, + SPR_GORE_Drip, + SPR_GORE_Flame, + SPR_UZI_SHELL, + SPR_SHOT_SHELL, + SPR_GORE_FlameChunkA, + SPR_GORE_FlameChunkB, + SPR_COIN_SHRAP, + SPR_MARBEL, + SPR_GLASS_SHRAP_A, + SPR_GLASS_SHRAP_B, + SPR_GLASS_SHRAP_C, + SPR_WOOD_SHRAP_A, + SPR_WOOD_SHRAP_B, + SPR_WOOD_SHRAP_C, + SPR_STONE_SHRAP_A, + SPR_STONE_SHRAP_B, + SPR_STONE_SHRAP_C, + SPR_METAL_SHRAP_A, + SPR_METAL_SHRAP_B, + SPR_METAL_SHRAP_C, + SPR_PAPER_SHRAP_A, + SPR_PAPER_SHRAP_B, + SPR_PAPER_SHRAP_C, + SPR_FLOORBLOOD1, + SPR_FOOTPRINT1, + SPR_FOOTPRINT2, + SPR_FOOTPRINT3, + SPR_WALLBLOOD1, + SPR_WALLBLOOD2, + SPR_WALLBLOOD3, + SPR_WALLBLOOD4, + + + + SPR_MAX, +}; + struct STATE { - short Pic; + spriteindex_t Sprite; + char Frame; int Tics; VMNativeFunction** Animator; // go through the scripting interface diff --git a/source/games/sw/src/girlninj.cpp b/source/games/sw/src/girlninj.cpp index c2f0934a3f..4ecd548696 100644 --- a/source/games/sw/src/girlninj.cpp +++ b/source/games/sw/src/girlninj.cpp @@ -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]}, }; /* diff --git a/source/games/sw/src/goro.cpp b/source/games/sw/src/goro.cpp index f7c3f04a6a..c3b61c93c2 100644 --- a/source/games/sw/src/goro.cpp +++ b/source/games/sw/src/goro.cpp @@ -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]}, - }, - { - {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]}, + {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_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]}, - }, - { - {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]}, + {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_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]}, - }, - { - {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]}, + {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_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[] = diff --git a/source/games/sw/src/hornet.cpp b/source/games/sw/src/hornet.cpp index eaffc95bee..8f730afd22 100644 --- a/source/games/sw/src/hornet.cpp +++ b/source/games/sw/src/hornet.cpp @@ -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[] = diff --git a/source/games/sw/src/jweapon.cpp b/source/games/sw/src/jweapon.cpp index 60af035979..8ab04acc09 100644 --- a/source/games/sw/src/jweapon.cpp +++ b/source/games/sw/src/jweapon.cpp @@ -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(PLAYER* pp) // Spawn a shot // Inserting and setting up variables - auto actorNew = SpawnActor(STAT_MISSILE, CHEMBOMB, s_ChemBomb, pp->cursector, pos, pp->actor->spr.Angles.Yaw, CHEMBOMB_VELOCITY); + auto actorNew = SpawnActor(STAT_MISSILE, CHEMBOMB_R0, s_ChemBomb, pp->cursector, pos, pp->actor->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); diff --git a/source/games/sw/src/lava.cpp b/source/games/sw/src/lava.cpp index 8f26ee2316..6e82b1d2ef 100644 --- a/source/games/sw/src/lava.cpp +++ b/source/games/sw/src/lava.cpp @@ -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[] = diff --git a/source/games/sw/src/miscactr.cpp b/source/games/sw/src/miscactr.cpp index 53c2fb9f87..4e3277a9a7 100644 --- a/source/games/sw/src/miscactr.cpp +++ b/source/games/sw/src/miscactr.cpp @@ -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]}, }; //--------------------------------------------------------------------------- @@ -299,15 +297,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]} }; ////////////////////// @@ -317,12 +315,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]} }; @@ -333,26 +330,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]}, }; //--------------------------------------------------------------------------- @@ -557,7 +553,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]} }; ////////////////////// @@ -567,17 +563,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]} }; //--------------------------------------------------------------------------- @@ -673,21 +668,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]}, }; //--------------------------------------------------------------------------- @@ -762,34 +756,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]} }; //--------------------------------------------------------------------------- @@ -932,34 +926,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]} }; //--------------------------------------------------------------------------- @@ -1014,34 +1008,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]} }; //--------------------------------------------------------------------------- @@ -1097,34 +1091,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]} }; //--------------------------------------------------------------------------- @@ -1185,8 +1179,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]} }; ////////////////////// @@ -1200,8 +1194,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]} }; ////////////////////// @@ -1211,26 +1205,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]}, }; //--------------------------------------------------------------------------- @@ -1426,8 +1419,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]} }; ////////////////////// @@ -1437,12 +1430,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]} }; ////////////////////// @@ -1452,12 +1444,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]}, }; @@ -1653,8 +1644,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]} }; ////////////////////// @@ -1664,12 +1655,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]} }; ////////////////////// @@ -1679,11 +1669,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; @@ -1892,8 +1881,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]} }; ////////////////////// @@ -1903,12 +1892,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]} }; //--------------------------------------------------------------------------- diff --git a/source/games/sw/src/names2.h b/source/games/sw/src/names2.h index e65d6849ba..d1235e6c22 100644 --- a/source/games/sw/src/names2.h +++ b/source/games/sw/src/names2.h @@ -202,34 +202,62 @@ enum ETimers //****************************************************************************** -enum ECounters +enum EPicnums { - 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, + CALTROPS = 2218, -}; + // 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, + 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, + + + + -enum EPicnums -{ SWITCH_ON = 562, SWITCH_OFF = 561, @@ -261,6 +289,8 @@ enum EPicnums // ////////////////////// + CROSSBOLT = 2230, + STAR = 2039, ELECTRO = 2025, @@ -286,22 +316,21 @@ 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, + STAR1 = 2049, - 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, ////////////////////// // @@ -330,407 +359,16 @@ enum EPicnums FIRE_FLY_RATE = 50, BREAK_LIGHT = 443, - BREAK_LIGHT_ANIM = 447, BREAK_BARREL = 453, BREAK_PEDISTAL = 463, BREAK_BOTTLE1 = 468, BREAK_BOTTLE2 = 475, BREAK_MUSHROOM = 666, - ////////////////////// - // - // COOLIE - // - ////////////////////// - - 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, -}; - - - - + LAVA_BOULDER = 2196, + }; -////////////////////// -// -// 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 ////////////////////// // @@ -745,374 +383,9 @@ 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 @@ -1165,7 +438,6 @@ enum EPicnums #define ZILLA_DEAD 5518 //////////////////////////////////// -#define TRASHCAN 2540 #define SCROLL 516 #define SCROLL_FIRE 524 diff --git a/source/games/sw/src/ninja.cpp b/source/games/sw/src/ninja.cpp index ffb1f578a7..1defc23c87 100644 --- a/source/games/sw/src/ninja.cpp +++ b/source/games/sw/src/ninja.cpp @@ -185,50 +185,21 @@ ATTRIBUTE InvisibleNinjaAttrib = #define NINJA_RATE 18 -STATE s_NinjaRun[5][4] = +STATE s_NinjaRun[1][4] = { { - {NINJA_RUN_R0 + 0, NINJA_RATE | SF_TIC_ADJUST, &AF(DoNinjaMove), &s_NinjaRun[0][1]}, - {NINJA_RUN_R0 + 1, NINJA_RATE | SF_TIC_ADJUST, &AF(DoNinjaMove), &s_NinjaRun[0][2]}, - {NINJA_RUN_R0 + 2, NINJA_RATE | SF_TIC_ADJUST, &AF(DoNinjaMove), &s_NinjaRun[0][3]}, - {NINJA_RUN_R0 + 3, NINJA_RATE | SF_TIC_ADJUST, &AF(DoNinjaMove), &s_NinjaRun[0][0]}, + {SPR_NINJA_RUN, 'A', NINJA_RATE | SF_TIC_ADJUST, &AF(DoNinjaMove), &s_NinjaRun[0][1]}, + {SPR_NINJA_RUN, 'B', NINJA_RATE | SF_TIC_ADJUST, &AF(DoNinjaMove), &s_NinjaRun[0][2]}, + {SPR_NINJA_RUN, 'C', NINJA_RATE | SF_TIC_ADJUST, &AF(DoNinjaMove), &s_NinjaRun[0][3]}, + {SPR_NINJA_RUN, 'D', NINJA_RATE | SF_TIC_ADJUST, &AF(DoNinjaMove), &s_NinjaRun[0][0]}, }, - { - {NINJA_RUN_R1 + 0, NINJA_RATE | SF_TIC_ADJUST, &AF(DoNinjaMove), &s_NinjaRun[1][1]}, - {NINJA_RUN_R1 + 1, NINJA_RATE | SF_TIC_ADJUST, &AF(DoNinjaMove), &s_NinjaRun[1][2]}, - {NINJA_RUN_R1 + 2, NINJA_RATE | SF_TIC_ADJUST, &AF(DoNinjaMove), &s_NinjaRun[1][3]}, - {NINJA_RUN_R1 + 3, NINJA_RATE | SF_TIC_ADJUST, &AF(DoNinjaMove), &s_NinjaRun[1][0]}, - }, - { - {NINJA_RUN_R2 + 0, NINJA_RATE | SF_TIC_ADJUST, &AF(DoNinjaMove), &s_NinjaRun[2][1]}, - {NINJA_RUN_R2 + 1, NINJA_RATE | SF_TIC_ADJUST, &AF(DoNinjaMove), &s_NinjaRun[2][2]}, - {NINJA_RUN_R2 + 2, NINJA_RATE | SF_TIC_ADJUST, &AF(DoNinjaMove), &s_NinjaRun[2][3]}, - {NINJA_RUN_R2 + 3, NINJA_RATE | SF_TIC_ADJUST, &AF(DoNinjaMove), &s_NinjaRun[2][0]}, - }, - { - {NINJA_RUN_R3 + 0, NINJA_RATE | SF_TIC_ADJUST, &AF(DoNinjaMove), &s_NinjaRun[3][1]}, - {NINJA_RUN_R3 + 1, NINJA_RATE | SF_TIC_ADJUST, &AF(DoNinjaMove), &s_NinjaRun[3][2]}, - {NINJA_RUN_R3 + 2, NINJA_RATE | SF_TIC_ADJUST, &AF(DoNinjaMove), &s_NinjaRun[3][3]}, - {NINJA_RUN_R3 + 3, NINJA_RATE | SF_TIC_ADJUST, &AF(DoNinjaMove), &s_NinjaRun[3][0]}, - }, - { - {NINJA_RUN_R4 + 0, NINJA_RATE | SF_TIC_ADJUST, &AF(DoNinjaMove), &s_NinjaRun[4][1]}, - {NINJA_RUN_R4 + 1, NINJA_RATE | SF_TIC_ADJUST, &AF(DoNinjaMove), &s_NinjaRun[4][2]}, - {NINJA_RUN_R4 + 2, NINJA_RATE | SF_TIC_ADJUST, &AF(DoNinjaMove), &s_NinjaRun[4][3]}, - {NINJA_RUN_R4 + 3, NINJA_RATE | SF_TIC_ADJUST, &AF(DoNinjaMove), &s_NinjaRun[4][0]}, - }, - }; STATE* sg_NinjaRun[] = { s_NinjaRun[0], - s_NinjaRun[1], - s_NinjaRun[2], - s_NinjaRun[3], - s_NinjaRun[4] }; ////////////////////// @@ -239,22 +210,10 @@ STATE* sg_NinjaRun[] = #define NINJA_STAND_RATE 10 -STATE s_NinjaStand[5][1] = +STATE s_NinjaStand[1][1] = { { - {NINJA_STAND_R0 + 0, NINJA_STAND_RATE, &AF(DoNinjaMove), &s_NinjaStand[0][0]}, - }, - { - {NINJA_STAND_R1 + 0, NINJA_STAND_RATE, &AF(DoNinjaMove), &s_NinjaStand[1][0]}, - }, - { - {NINJA_STAND_R2 + 0, NINJA_STAND_RATE, &AF(DoNinjaMove), &s_NinjaStand[2][0]}, - }, - { - {NINJA_STAND_R3 + 0, NINJA_STAND_RATE, &AF(DoNinjaMove), &s_NinjaStand[3][0]}, - }, - { - {NINJA_STAND_R4 + 0, NINJA_STAND_RATE, &AF(DoNinjaMove), &s_NinjaStand[4][0]}, + {SPR_NINJA_STAND, 'A', NINJA_STAND_RATE, &AF(DoNinjaMove), &s_NinjaStand[0][0]}, }, }; @@ -262,10 +221,6 @@ STATE s_NinjaStand[5][1] = STATE* sg_NinjaStand[] = { s_NinjaStand[0], - s_NinjaStand[1], - s_NinjaStand[2], - s_NinjaStand[3], - s_NinjaStand[4] }; ////////////////////// @@ -276,32 +231,12 @@ STATE* sg_NinjaStand[] = #define NINJA_RISE_RATE 10 -STATE s_NinjaRise[5][3] = +STATE s_NinjaRise[1][3] = { { - {NINJA_KNEEL_R0 + 0, NINJA_RISE_RATE, &AF(NullNinja), &s_NinjaRise[0][1]}, - {NINJA_STAND_R0 + 0, NINJA_STAND_RATE, &AF(NullNinja), &s_NinjaRise[0][2]}, - {0, 0, nullptr, (STATE*)sg_NinjaRun}, - }, - { - {NINJA_KNEEL_R1 + 0, NINJA_RISE_RATE, &AF(NullNinja), &s_NinjaRise[1][1]}, - {NINJA_STAND_R1 + 0, NINJA_STAND_RATE, &AF(NullNinja), &s_NinjaRise[1][2]}, - {0, 0, nullptr, (STATE*)sg_NinjaRun}, - }, - { - {NINJA_KNEEL_R2 + 0, NINJA_RISE_RATE, &AF(NullNinja), &s_NinjaRise[2][1]}, - {NINJA_STAND_R2 + 0, NINJA_STAND_RATE, &AF(NullNinja), &s_NinjaRise[2][2]}, - {0, 0, nullptr, (STATE*)sg_NinjaRun}, - }, - { - {NINJA_KNEEL_R3 + 0, NINJA_RISE_RATE, &AF(NullNinja), &s_NinjaRise[3][1]}, - {NINJA_STAND_R3 + 0, NINJA_STAND_RATE, &AF(NullNinja), &s_NinjaRise[3][2]}, - {0, 0, nullptr, (STATE*)sg_NinjaRun}, - }, - { - {NINJA_KNEEL_R4 + 0, NINJA_RISE_RATE, &AF(NullNinja), &s_NinjaRise[4][1]}, - {NINJA_STAND_R4 + 0, NINJA_STAND_RATE, &AF(NullNinja), &s_NinjaRise[4][2]}, - {0, 0, nullptr, (STATE*)sg_NinjaRun}, + {SPR_NINJA_CRAWL, 'A', NINJA_RISE_RATE, &AF(NullNinja), &s_NinjaRise[0][1]}, + {SPR_NINJA_STAND, 'A', NINJA_STAND_RATE, &AF(NullNinja), &s_NinjaRise[0][2]}, + {SPR_NULL, 0, 0, nullptr, (STATE*)sg_NinjaRun}, }, }; @@ -309,10 +244,6 @@ STATE s_NinjaRise[5][3] = STATE* sg_NinjaRise[] = { s_NinjaRise[0], - s_NinjaRise[1], - s_NinjaRise[2], - s_NinjaRise[3], - s_NinjaRise[4] }; @@ -324,37 +255,13 @@ STATE* sg_NinjaRise[] = #define NINJA_CRAWL_RATE 14 -STATE s_NinjaCrawl[5][4] = +STATE s_NinjaCrawl[1][4] = { { - {NINJA_CRAWL_R0 + 0, NINJA_CRAWL_RATE, &AF(DoNinjaMove), &s_NinjaCrawl[0][1]}, - {NINJA_CRAWL_R0 + 1, NINJA_CRAWL_RATE, &AF(DoNinjaMove), &s_NinjaCrawl[0][2]}, - {NINJA_CRAWL_R0 + 2, NINJA_CRAWL_RATE, &AF(DoNinjaMove), &s_NinjaCrawl[0][3]}, - {NINJA_CRAWL_R0 + 1, NINJA_CRAWL_RATE, &AF(DoNinjaMove), &s_NinjaCrawl[0][0]}, - }, - { - {NINJA_CRAWL_R1 + 0, NINJA_CRAWL_RATE, &AF(DoNinjaMove), &s_NinjaCrawl[1][1]}, - {NINJA_CRAWL_R1 + 1, NINJA_CRAWL_RATE, &AF(DoNinjaMove), &s_NinjaCrawl[1][2]}, - {NINJA_CRAWL_R1 + 2, NINJA_CRAWL_RATE, &AF(DoNinjaMove), &s_NinjaCrawl[1][3]}, - {NINJA_CRAWL_R1 + 1, NINJA_CRAWL_RATE, &AF(DoNinjaMove), &s_NinjaCrawl[1][0]}, - }, - { - {NINJA_CRAWL_R2 + 0, NINJA_CRAWL_RATE, &AF(DoNinjaMove), &s_NinjaCrawl[2][1]}, - {NINJA_CRAWL_R2 + 1, NINJA_CRAWL_RATE, &AF(DoNinjaMove), &s_NinjaCrawl[2][2]}, - {NINJA_CRAWL_R2 + 2, NINJA_CRAWL_RATE, &AF(DoNinjaMove), &s_NinjaCrawl[2][3]}, - {NINJA_CRAWL_R2 + 1, NINJA_CRAWL_RATE, &AF(DoNinjaMove), &s_NinjaCrawl[2][0]}, - }, - { - {NINJA_CRAWL_R3 + 0, NINJA_CRAWL_RATE, &AF(DoNinjaMove), &s_NinjaCrawl[3][1]}, - {NINJA_CRAWL_R3 + 1, NINJA_CRAWL_RATE, &AF(DoNinjaMove), &s_NinjaCrawl[3][2]}, - {NINJA_CRAWL_R3 + 2, NINJA_CRAWL_RATE, &AF(DoNinjaMove), &s_NinjaCrawl[3][3]}, - {NINJA_CRAWL_R3 + 1, NINJA_CRAWL_RATE, &AF(DoNinjaMove), &s_NinjaCrawl[3][0]}, - }, - { - {NINJA_CRAWL_R4 + 0, NINJA_CRAWL_RATE, &AF(DoNinjaMove), &s_NinjaCrawl[4][1]}, - {NINJA_CRAWL_R4 + 1, NINJA_CRAWL_RATE, &AF(DoNinjaMove), &s_NinjaCrawl[4][2]}, - {NINJA_CRAWL_R4 + 2, NINJA_CRAWL_RATE, &AF(DoNinjaMove), &s_NinjaCrawl[4][3]}, - {NINJA_CRAWL_R4 + 1, NINJA_CRAWL_RATE, &AF(DoNinjaMove), &s_NinjaCrawl[4][0]}, + {SPR_NINJA_CRAWL, 'A', NINJA_CRAWL_RATE, &AF(DoNinjaMove), &s_NinjaCrawl[0][1]}, + {SPR_NINJA_CRAWL, 'B', NINJA_CRAWL_RATE, &AF(DoNinjaMove), &s_NinjaCrawl[0][2]}, + {SPR_NINJA_CRAWL, 'C', NINJA_CRAWL_RATE, &AF(DoNinjaMove), &s_NinjaCrawl[0][3]}, + {SPR_NINJA_CRAWL, 'B', NINJA_CRAWL_RATE, &AF(DoNinjaMove), &s_NinjaCrawl[0][0]}, }, }; @@ -362,10 +269,6 @@ STATE s_NinjaCrawl[5][4] = STATE* sg_NinjaCrawl[] = { s_NinjaCrawl[0], - s_NinjaCrawl[1], - s_NinjaCrawl[2], - s_NinjaCrawl[3], - s_NinjaCrawl[4] }; ////////////////////// @@ -376,42 +279,14 @@ STATE* sg_NinjaCrawl[] = #define NINJA_KNEEL_CRAWL_RATE 20 -STATE s_NinjaKneelCrawl[5][5] = +STATE s_NinjaKneelCrawl[1][5] = { { - {NINJA_KNEEL_R0 + 0, NINJA_KNEEL_CRAWL_RATE, &AF(NullNinja), &s_NinjaKneelCrawl[0][1]}, - {NINJA_CRAWL_R0 + 0, NINJA_CRAWL_RATE, &AF(DoNinjaMove), &s_NinjaKneelCrawl[0][2]}, - {NINJA_CRAWL_R0 + 1, NINJA_CRAWL_RATE, &AF(DoNinjaMove), &s_NinjaKneelCrawl[0][3]}, - {NINJA_CRAWL_R0 + 2, NINJA_CRAWL_RATE, &AF(DoNinjaMove), &s_NinjaKneelCrawl[0][4]}, - {NINJA_CRAWL_R0 + 1, NINJA_CRAWL_RATE, &AF(DoNinjaMove), &s_NinjaKneelCrawl[0][1]}, - }, - { - {NINJA_KNEEL_R1 + 0, NINJA_KNEEL_CRAWL_RATE, &AF(NullNinja), &s_NinjaKneelCrawl[1][1]}, - {NINJA_CRAWL_R1 + 0, NINJA_CRAWL_RATE, &AF(DoNinjaMove), &s_NinjaKneelCrawl[1][2]}, - {NINJA_CRAWL_R1 + 1, NINJA_CRAWL_RATE, &AF(DoNinjaMove), &s_NinjaKneelCrawl[1][3]}, - {NINJA_CRAWL_R1 + 2, NINJA_CRAWL_RATE, &AF(DoNinjaMove), &s_NinjaKneelCrawl[1][4]}, - {NINJA_CRAWL_R1 + 1, NINJA_CRAWL_RATE, &AF(DoNinjaMove), &s_NinjaKneelCrawl[1][1]}, - }, - { - {NINJA_KNEEL_R2 + 0, NINJA_KNEEL_CRAWL_RATE, &AF(NullNinja), &s_NinjaKneelCrawl[2][1]}, - {NINJA_CRAWL_R2 + 0, NINJA_CRAWL_RATE, &AF(DoNinjaMove), &s_NinjaKneelCrawl[2][2]}, - {NINJA_CRAWL_R2 + 1, NINJA_CRAWL_RATE, &AF(DoNinjaMove), &s_NinjaKneelCrawl[2][3]}, - {NINJA_CRAWL_R2 + 2, NINJA_CRAWL_RATE, &AF(DoNinjaMove), &s_NinjaKneelCrawl[2][4]}, - {NINJA_CRAWL_R2 + 1, NINJA_CRAWL_RATE, &AF(DoNinjaMove), &s_NinjaKneelCrawl[2][1]}, - }, - { - {NINJA_KNEEL_R3 + 0, NINJA_KNEEL_CRAWL_RATE, &AF(NullNinja), &s_NinjaKneelCrawl[3][1]}, - {NINJA_CRAWL_R3 + 0, NINJA_CRAWL_RATE, &AF(DoNinjaMove), &s_NinjaKneelCrawl[3][2]}, - {NINJA_CRAWL_R3 + 1, NINJA_CRAWL_RATE, &AF(DoNinjaMove), &s_NinjaKneelCrawl[3][3]}, - {NINJA_CRAWL_R3 + 2, NINJA_CRAWL_RATE, &AF(DoNinjaMove), &s_NinjaKneelCrawl[3][4]}, - {NINJA_CRAWL_R3 + 1, NINJA_CRAWL_RATE, &AF(DoNinjaMove), &s_NinjaKneelCrawl[3][1]}, - }, - { - {NINJA_KNEEL_R4 + 0, NINJA_KNEEL_CRAWL_RATE, &AF(NullNinja), &s_NinjaKneelCrawl[4][1]}, - {NINJA_CRAWL_R4 + 0, NINJA_CRAWL_RATE, &AF(DoNinjaMove), &s_NinjaKneelCrawl[4][2]}, - {NINJA_CRAWL_R4 + 1, NINJA_CRAWL_RATE, &AF(DoNinjaMove), &s_NinjaKneelCrawl[4][3]}, - {NINJA_CRAWL_R4 + 2, NINJA_CRAWL_RATE, &AF(DoNinjaMove), &s_NinjaKneelCrawl[4][4]}, - {NINJA_CRAWL_R4 + 1, NINJA_CRAWL_RATE, &AF(DoNinjaMove), &s_NinjaKneelCrawl[4][1]}, + {SPR_NINJA_CRAWL, 'A', NINJA_KNEEL_CRAWL_RATE, &AF(NullNinja), &s_NinjaKneelCrawl[0][1]}, + {SPR_NINJA_CRAWL, 'A', NINJA_CRAWL_RATE, &AF(DoNinjaMove), &s_NinjaKneelCrawl[0][2]}, + {SPR_NINJA_CRAWL, 'B', NINJA_CRAWL_RATE, &AF(DoNinjaMove), &s_NinjaKneelCrawl[0][3]}, + {SPR_NINJA_CRAWL, 'C', NINJA_CRAWL_RATE, &AF(DoNinjaMove), &s_NinjaKneelCrawl[0][4]}, + {SPR_NINJA_CRAWL, 'B', NINJA_CRAWL_RATE, &AF(DoNinjaMove), &s_NinjaKneelCrawl[0][1]}, }, }; @@ -419,10 +294,6 @@ STATE s_NinjaKneelCrawl[5][5] = STATE* sg_NinjaKneelCrawl[] = { s_NinjaKneelCrawl[0], - s_NinjaKneelCrawl[1], - s_NinjaKneelCrawl[2], - s_NinjaKneelCrawl[3], - s_NinjaKneelCrawl[4] }; @@ -434,27 +305,11 @@ STATE* sg_NinjaKneelCrawl[] = #define NINJA_DUCK_RATE 10 -STATE s_NinjaDuck[5][2] = +STATE s_NinjaDuck[1][2] = { { - {NINJA_KNEEL_R0 + 0, NINJA_DUCK_RATE, &AF(NullNinja), &s_NinjaDuck[0][1]}, - {NINJA_CRAWL_R0 + 0, NINJA_CRAWL_RATE, &AF(DoNinjaMove), &s_NinjaDuck[0][1]}, - }, - { - {NINJA_KNEEL_R1 + 0, NINJA_DUCK_RATE, &AF(NullNinja), &s_NinjaDuck[1][1]}, - {NINJA_CRAWL_R1 + 0, NINJA_CRAWL_RATE, &AF(DoNinjaMove), &s_NinjaDuck[1][1]}, - }, - { - {NINJA_KNEEL_R2 + 0, NINJA_DUCK_RATE, &AF(NullNinja), &s_NinjaDuck[2][1]}, - {NINJA_CRAWL_R2 + 0, NINJA_CRAWL_RATE, &AF(DoNinjaMove), &s_NinjaDuck[2][1]}, - }, - { - {NINJA_KNEEL_R3 + 0, NINJA_DUCK_RATE, &AF(NullNinja), &s_NinjaDuck[3][1]}, - {NINJA_CRAWL_R3 + 0, NINJA_CRAWL_RATE, &AF(DoNinjaMove), &s_NinjaDuck[3][1]}, - }, - { - {NINJA_KNEEL_R4 + 0, NINJA_DUCK_RATE, &AF(NullNinja), &s_NinjaDuck[4][1]}, - {NINJA_CRAWL_R4 + 0, NINJA_CRAWL_RATE, &AF(DoNinjaMove), &s_NinjaDuck[4][1]}, + {SPR_NINJA_CRAWL, 'A', NINJA_DUCK_RATE, &AF(NullNinja), &s_NinjaDuck[0][1]}, + {SPR_NINJA_CRAWL, 'A', NINJA_CRAWL_RATE, &AF(DoNinjaMove), &s_NinjaDuck[0][1]}, }, }; @@ -462,10 +317,6 @@ STATE s_NinjaDuck[5][2] = STATE* sg_NinjaDuck[] = { s_NinjaDuck[0], - s_NinjaDuck[1], - s_NinjaDuck[2], - s_NinjaDuck[3], - s_NinjaDuck[4] }; @@ -475,22 +326,10 @@ STATE* sg_NinjaDuck[] = // ////////////////////// -STATE s_NinjaSit[5][1] = +STATE s_NinjaSit[1][1] = { { - {NINJA_KNEEL_R0 + 0, NINJA_RISE_RATE, &AF(DoNinjaMove), &s_NinjaSit[0][0]}, - }, - { - {NINJA_KNEEL_R1 + 0, NINJA_RISE_RATE, &AF(DoNinjaMove), &s_NinjaSit[1][0]}, - }, - { - {NINJA_KNEEL_R2 + 0, NINJA_RISE_RATE, &AF(DoNinjaMove), &s_NinjaSit[2][0]}, - }, - { - {NINJA_KNEEL_R3 + 0, NINJA_RISE_RATE, &AF(DoNinjaMove), &s_NinjaSit[3][0]}, - }, - { - {NINJA_KNEEL_R4 + 0, NINJA_RISE_RATE, &AF(DoNinjaMove), &s_NinjaSit[4][0]}, + {SPR_NINJA_CRAWL, 'A', NINJA_RISE_RATE, &AF(DoNinjaMove), &s_NinjaSit[0][0]}, }, }; @@ -498,10 +337,6 @@ STATE s_NinjaSit[5][1] = STATE* sg_NinjaSit[] = { s_NinjaSit[0], - s_NinjaSit[1], - s_NinjaSit[2], - s_NinjaSit[3], - s_NinjaSit[4] }; ////////////////////// @@ -510,22 +345,10 @@ STATE* sg_NinjaSit[] = // ////////////////////// -STATE s_NinjaCeiling[5][1] = +STATE s_NinjaCeiling[1][1] = { { - {NINJA_KNEEL_R0 + 0, NINJA_RISE_RATE, &AF(DoNinjaCeiling), &s_NinjaCeiling[0][0]}, - }, - { - {NINJA_KNEEL_R1 + 0, NINJA_RISE_RATE, &AF(DoNinjaCeiling), &s_NinjaCeiling[1][0]}, - }, - { - {NINJA_KNEEL_R2 + 0, NINJA_RISE_RATE, &AF(DoNinjaCeiling), &s_NinjaCeiling[2][0]}, - }, - { - {NINJA_KNEEL_R3 + 0, NINJA_RISE_RATE, &AF(DoNinjaCeiling), &s_NinjaCeiling[3][0]}, - }, - { - {NINJA_KNEEL_R4 + 0, NINJA_RISE_RATE, &AF(DoNinjaCeiling), &s_NinjaCeiling[4][0]}, + {SPR_NINJA_CRAWL, 'A', NINJA_RISE_RATE, &AF(DoNinjaCeiling), &s_NinjaCeiling[0][0]}, }, }; @@ -533,10 +356,6 @@ STATE s_NinjaCeiling[5][1] = STATE* sg_NinjaCeiling[] = { s_NinjaCeiling[0], - s_NinjaCeiling[1], - s_NinjaCeiling[2], - s_NinjaCeiling[3], - s_NinjaCeiling[4] }; @@ -548,27 +367,11 @@ STATE* sg_NinjaCeiling[] = #define NINJA_JUMP_RATE 24 -STATE s_NinjaJump[5][2] = +STATE s_NinjaJump[1][2] = { { - {NINJA_JUMP_R0 + 0, NINJA_JUMP_RATE, &AF(DoNinjaMove), &s_NinjaJump[0][1]}, - {NINJA_JUMP_R0 + 1, NINJA_JUMP_RATE, &AF(DoNinjaMove), &s_NinjaJump[0][1]}, - }, - { - {NINJA_JUMP_R1 + 0, NINJA_JUMP_RATE, &AF(DoNinjaMove), &s_NinjaJump[1][1]}, - {NINJA_JUMP_R1 + 1, NINJA_JUMP_RATE, &AF(DoNinjaMove), &s_NinjaJump[1][1]}, - }, - { - {NINJA_JUMP_R2 + 0, NINJA_JUMP_RATE, &AF(DoNinjaMove), &s_NinjaJump[2][1]}, - {NINJA_JUMP_R2 + 1, NINJA_JUMP_RATE, &AF(DoNinjaMove), &s_NinjaJump[2][1]}, - }, - { - {NINJA_JUMP_R3 + 0, NINJA_JUMP_RATE, &AF(DoNinjaMove), &s_NinjaJump[3][1]}, - {NINJA_JUMP_R3 + 1, NINJA_JUMP_RATE, &AF(DoNinjaMove), &s_NinjaJump[3][1]}, - }, - { - {NINJA_JUMP_R4 + 0, NINJA_JUMP_RATE, &AF(DoNinjaMove), &s_NinjaJump[4][1]}, - {NINJA_JUMP_R4 + 1, NINJA_JUMP_RATE, &AF(DoNinjaMove), &s_NinjaJump[4][1]}, + {SPR_NINJA_JUMP, 'A', NINJA_JUMP_RATE, &AF(DoNinjaMove), &s_NinjaJump[0][1]}, + {SPR_NINJA_JUMP, 'B', NINJA_JUMP_RATE, &AF(DoNinjaMove), &s_NinjaJump[0][1]}, }, }; @@ -576,10 +379,6 @@ STATE s_NinjaJump[5][2] = STATE* sg_NinjaJump[] = { s_NinjaJump[0], - s_NinjaJump[1], - s_NinjaJump[2], - s_NinjaJump[3], - s_NinjaJump[4] }; @@ -591,27 +390,11 @@ STATE* sg_NinjaJump[] = #define NINJA_FALL_RATE 16 -STATE s_NinjaFall[5][2] = +STATE s_NinjaFall[1][2] = { { - {NINJA_JUMP_R0 + 1, NINJA_FALL_RATE, &AF(DoNinjaMove), &s_NinjaFall[0][1]}, - {NINJA_JUMP_R0 + 2, NINJA_FALL_RATE, &AF(DoNinjaMove), &s_NinjaFall[0][1]}, - }, - { - {NINJA_JUMP_R1 + 1, NINJA_FALL_RATE, &AF(DoNinjaMove), &s_NinjaFall[1][1]}, - {NINJA_JUMP_R1 + 2, NINJA_FALL_RATE, &AF(DoNinjaMove), &s_NinjaFall[1][1]}, - }, - { - {NINJA_JUMP_R2 + 1, NINJA_FALL_RATE, &AF(DoNinjaMove), &s_NinjaFall[2][1]}, - {NINJA_JUMP_R2 + 2, NINJA_FALL_RATE, &AF(DoNinjaMove), &s_NinjaFall[2][1]}, - }, - { - {NINJA_JUMP_R3 + 1, NINJA_FALL_RATE, &AF(DoNinjaMove), &s_NinjaFall[3][1]}, - {NINJA_JUMP_R3 + 2, NINJA_FALL_RATE, &AF(DoNinjaMove), &s_NinjaFall[3][1]}, - }, - { - {NINJA_JUMP_R4 + 1, NINJA_FALL_RATE, &AF(DoNinjaMove), &s_NinjaFall[4][1]}, - {NINJA_JUMP_R4 + 2, NINJA_FALL_RATE, &AF(DoNinjaMove), &s_NinjaFall[4][1]}, + {SPR_NINJA_JUMP, 'B', NINJA_FALL_RATE, &AF(DoNinjaMove), &s_NinjaFall[0][1]}, + {SPR_NINJA_JUMP, 'C', NINJA_FALL_RATE, &AF(DoNinjaMove), &s_NinjaFall[0][1]}, }, }; @@ -619,10 +402,6 @@ STATE s_NinjaFall[5][2] = STATE* sg_NinjaFall[] = { s_NinjaFall[0], - s_NinjaFall[1], - s_NinjaFall[2], - s_NinjaFall[3], - s_NinjaFall[4] }; ////////////////////// @@ -633,32 +412,12 @@ STATE* sg_NinjaFall[] = #define NINJA_SWIM_RATE 18 -STATE s_NinjaSwim[5][3] = +STATE s_NinjaSwim[1][3] = { { - {NINJA_SWIM_R0 + 1, NINJA_SWIM_RATE, &AF(DoNinjaMove), &s_NinjaSwim[0][1]}, - {NINJA_SWIM_R0 + 2, NINJA_SWIM_RATE, &AF(DoNinjaMove), &s_NinjaSwim[0][2]}, - {NINJA_SWIM_R0 + 3, NINJA_SWIM_RATE, &AF(DoNinjaMove), &s_NinjaSwim[0][0]}, - }, - { - {NINJA_SWIM_R1 + 1, NINJA_SWIM_RATE, &AF(DoNinjaMove), &s_NinjaSwim[1][1]}, - {NINJA_SWIM_R1 + 2, NINJA_SWIM_RATE, &AF(DoNinjaMove), &s_NinjaSwim[1][2]}, - {NINJA_SWIM_R1 + 3, NINJA_SWIM_RATE, &AF(DoNinjaMove), &s_NinjaSwim[1][0]}, - }, - { - {NINJA_SWIM_R2 + 1, NINJA_SWIM_RATE, &AF(DoNinjaMove), &s_NinjaSwim[2][1]}, - {NINJA_SWIM_R2 + 2, NINJA_SWIM_RATE, &AF(DoNinjaMove), &s_NinjaSwim[2][2]}, - {NINJA_SWIM_R2 + 3, NINJA_SWIM_RATE, &AF(DoNinjaMove), &s_NinjaSwim[2][0]}, - }, - { - {NINJA_SWIM_R3 + 1, NINJA_SWIM_RATE, &AF(DoNinjaMove), &s_NinjaSwim[3][1]}, - {NINJA_SWIM_R3 + 2, NINJA_SWIM_RATE, &AF(DoNinjaMove), &s_NinjaSwim[3][2]}, - {NINJA_SWIM_R3 + 3, NINJA_SWIM_RATE, &AF(DoNinjaMove), &s_NinjaSwim[3][0]}, - }, - { - {NINJA_SWIM_R4 + 1, NINJA_SWIM_RATE, &AF(DoNinjaMove), &s_NinjaSwim[4][1]}, - {NINJA_SWIM_R4 + 2, NINJA_SWIM_RATE, &AF(DoNinjaMove), &s_NinjaSwim[4][2]}, - {NINJA_SWIM_R4 + 3, NINJA_SWIM_RATE, &AF(DoNinjaMove), &s_NinjaSwim[4][0]}, + {SPR_NINJA_SWIM, 'B', NINJA_SWIM_RATE, &AF(DoNinjaMove), &s_NinjaSwim[0][1]}, + {SPR_NINJA_SWIM, 'C', NINJA_SWIM_RATE, &AF(DoNinjaMove), &s_NinjaSwim[0][2]}, + {SPR_NINJA_SWIM, 'D', NINJA_SWIM_RATE, &AF(DoNinjaMove), &s_NinjaSwim[0][0]}, }, }; @@ -666,10 +425,6 @@ STATE s_NinjaSwim[5][3] = STATE* sg_NinjaSwim[] = { s_NinjaSwim[0], - s_NinjaSwim[1], - s_NinjaSwim[2], - s_NinjaSwim[3], - s_NinjaSwim[4] }; ////////////////////// @@ -681,47 +436,19 @@ STATE* sg_NinjaSwim[] = #define NINJA_DIVE_RATE 23 -STATE s_NinjaDive[5][4] = +STATE s_NinjaDive[1][4] = { { - {NINJA_SWIM_R0 + 0, NINJA_DIVE_RATE, &AF(DoNinjaMove), &s_NinjaDive[0][1]}, - {NINJA_SWIM_R0 + 1, NINJA_DIVE_RATE, &AF(DoNinjaMove), &s_NinjaDive[0][2]}, - {NINJA_SWIM_R0 + 2, NINJA_DIVE_RATE, &AF(DoNinjaMove), &s_NinjaDive[0][3]}, - {NINJA_SWIM_R0 + 3, NINJA_DIVE_RATE, &AF(DoNinjaMove), &s_NinjaDive[0][0]}, - }, - { - {NINJA_SWIM_R1 + 0, NINJA_DIVE_RATE, &AF(DoNinjaMove), &s_NinjaDive[1][1]}, - {NINJA_SWIM_R1 + 1, NINJA_DIVE_RATE, &AF(DoNinjaMove), &s_NinjaDive[1][2]}, - {NINJA_SWIM_R1 + 2, NINJA_DIVE_RATE, &AF(DoNinjaMove), &s_NinjaDive[1][3]}, - {NINJA_SWIM_R1 + 3, NINJA_DIVE_RATE, &AF(DoNinjaMove), &s_NinjaDive[1][0]}, - }, - { - {NINJA_SWIM_R2 + 0, NINJA_DIVE_RATE, &AF(DoNinjaMove), &s_NinjaDive[2][1]}, - {NINJA_SWIM_R2 + 1, NINJA_DIVE_RATE, &AF(DoNinjaMove), &s_NinjaDive[2][2]}, - {NINJA_SWIM_R2 + 2, NINJA_DIVE_RATE, &AF(DoNinjaMove), &s_NinjaDive[2][3]}, - {NINJA_SWIM_R2 + 3, NINJA_DIVE_RATE, &AF(DoNinjaMove), &s_NinjaDive[2][0]}, - }, - { - {NINJA_SWIM_R3 + 0, NINJA_DIVE_RATE, &AF(DoNinjaMove), &s_NinjaDive[3][1]}, - {NINJA_SWIM_R3 + 1, NINJA_DIVE_RATE, &AF(DoNinjaMove), &s_NinjaDive[3][2]}, - {NINJA_SWIM_R3 + 2, NINJA_DIVE_RATE, &AF(DoNinjaMove), &s_NinjaDive[3][3]}, - {NINJA_SWIM_R3 + 3, NINJA_DIVE_RATE, &AF(DoNinjaMove), &s_NinjaDive[3][0]}, - }, - { - {NINJA_SWIM_R4 + 0, NINJA_DIVE_RATE, &AF(DoNinjaMove), &s_NinjaDive[4][1]}, - {NINJA_SWIM_R4 + 1, NINJA_DIVE_RATE, &AF(DoNinjaMove), &s_NinjaDive[4][2]}, - {NINJA_SWIM_R4 + 2, NINJA_DIVE_RATE, &AF(DoNinjaMove), &s_NinjaDive[4][3]}, - {NINJA_SWIM_R4 + 3, NINJA_DIVE_RATE, &AF(DoNinjaMove), &s_NinjaDive[4][0]}, + {SPR_NINJA_SWIM, 'A', NINJA_DIVE_RATE, &AF(DoNinjaMove), &s_NinjaDive[0][1]}, + {SPR_NINJA_SWIM, 'B', NINJA_DIVE_RATE, &AF(DoNinjaMove), &s_NinjaDive[0][2]}, + {SPR_NINJA_SWIM, 'C', NINJA_DIVE_RATE, &AF(DoNinjaMove), &s_NinjaDive[0][3]}, + {SPR_NINJA_SWIM, 'D', NINJA_DIVE_RATE, &AF(DoNinjaMove), &s_NinjaDive[0][0]}, }, }; STATE* sg_NinjaDive[] = { s_NinjaDive[0], - s_NinjaDive[1], - s_NinjaDive[2], - s_NinjaDive[3], - s_NinjaDive[4] }; ////////////////////// @@ -732,47 +459,19 @@ STATE* sg_NinjaDive[] = #define NINJA_CLIMB_RATE 20 -STATE s_NinjaClimb[5][4] = +STATE s_NinjaClimb[1][4] = { { - {NINJA_CLIMB_R0 + 0, NINJA_CLIMB_RATE, &AF(DoNinjaMove), &s_NinjaClimb[0][1]}, - {NINJA_CLIMB_R0 + 1, NINJA_CLIMB_RATE, &AF(DoNinjaMove), &s_NinjaClimb[0][2]}, - {NINJA_CLIMB_R0 + 2, NINJA_CLIMB_RATE, &AF(DoNinjaMove), &s_NinjaClimb[0][3]}, - {NINJA_CLIMB_R0 + 3, NINJA_CLIMB_RATE, &AF(DoNinjaMove), &s_NinjaClimb[0][0]}, - }, - { - {NINJA_CLIMB_R1 + 0, NINJA_CLIMB_RATE, &AF(DoNinjaMove), &s_NinjaClimb[1][1]}, - {NINJA_CLIMB_R1 + 1, NINJA_CLIMB_RATE, &AF(DoNinjaMove), &s_NinjaClimb[1][2]}, - {NINJA_CLIMB_R1 + 2, NINJA_CLIMB_RATE, &AF(DoNinjaMove), &s_NinjaClimb[1][3]}, - {NINJA_CLIMB_R1 + 3, NINJA_CLIMB_RATE, &AF(DoNinjaMove), &s_NinjaClimb[1][0]}, - }, - { - {NINJA_CLIMB_R4 + 0, NINJA_CLIMB_RATE, &AF(DoNinjaMove), &s_NinjaClimb[2][1]}, - {NINJA_CLIMB_R4 + 1, NINJA_CLIMB_RATE, &AF(DoNinjaMove), &s_NinjaClimb[2][2]}, - {NINJA_CLIMB_R4 + 2, NINJA_CLIMB_RATE, &AF(DoNinjaMove), &s_NinjaClimb[2][3]}, - {NINJA_CLIMB_R4 + 3, NINJA_CLIMB_RATE, &AF(DoNinjaMove), &s_NinjaClimb[2][0]}, - }, - { - {NINJA_CLIMB_R3 + 0, NINJA_CLIMB_RATE, &AF(DoNinjaMove), &s_NinjaClimb[3][1]}, - {NINJA_CLIMB_R3 + 1, NINJA_CLIMB_RATE, &AF(DoNinjaMove), &s_NinjaClimb[3][2]}, - {NINJA_CLIMB_R3 + 2, NINJA_CLIMB_RATE, &AF(DoNinjaMove), &s_NinjaClimb[3][3]}, - {NINJA_CLIMB_R3 + 3, NINJA_CLIMB_RATE, &AF(DoNinjaMove), &s_NinjaClimb[3][0]}, - }, - { - {NINJA_CLIMB_R2 + 0, NINJA_CLIMB_RATE, &AF(DoNinjaMove), &s_NinjaClimb[4][1]}, - {NINJA_CLIMB_R2 + 1, NINJA_CLIMB_RATE, &AF(DoNinjaMove), &s_NinjaClimb[4][2]}, - {NINJA_CLIMB_R2 + 2, NINJA_CLIMB_RATE, &AF(DoNinjaMove), &s_NinjaClimb[4][3]}, - {NINJA_CLIMB_R2 + 3, NINJA_CLIMB_RATE, &AF(DoNinjaMove), &s_NinjaClimb[4][0]}, + {SPR_NINJA_CLIMB, 'A', NINJA_CLIMB_RATE, &AF(DoNinjaMove), &s_NinjaClimb[0][1]}, + {SPR_NINJA_CLIMB, 'B', NINJA_CLIMB_RATE, &AF(DoNinjaMove), &s_NinjaClimb[0][2]}, + {SPR_NINJA_CLIMB, 'C', NINJA_CLIMB_RATE, &AF(DoNinjaMove), &s_NinjaClimb[0][3]}, + {SPR_NINJA_CLIMB, 'D', NINJA_CLIMB_RATE, &AF(DoNinjaMove), &s_NinjaClimb[0][0]}, }, }; STATE* sg_NinjaClimb[] = { s_NinjaClimb[0], - s_NinjaClimb[1], - s_NinjaClimb[2], - s_NinjaClimb[3], - s_NinjaClimb[4] }; @@ -784,32 +483,16 @@ STATE* sg_NinjaClimb[] = #define NINJA_FLY_RATE 12 -STATE s_NinjaFly[5][1] = +STATE s_NinjaFly[1][1] = { { - {NINJA_FLY_R0 + 0, NINJA_FLY_RATE, &AF(DoNinjaMove), &s_NinjaFly[0][0]}, - }, - { - {NINJA_FLY_R1 + 0, NINJA_FLY_RATE, &AF(DoNinjaMove), &s_NinjaFly[1][0]}, - }, - { - {NINJA_FLY_R2 + 0, NINJA_FLY_RATE, &AF(DoNinjaMove), &s_NinjaFly[2][0]}, - }, - { - {NINJA_FLY_R3 + 0, NINJA_FLY_RATE, &AF(DoNinjaMove), &s_NinjaFly[3][0]}, - }, - { - {NINJA_FLY_R4 + 0, NINJA_FLY_RATE, &AF(DoNinjaMove), &s_NinjaFly[4][0]}, + {SPR_NINJA_FLY, 'A', NINJA_FLY_RATE, &AF(DoNinjaMove), &s_NinjaFly[0][0]}, }, }; STATE* sg_NinjaFly[] = { s_NinjaFly[0], - s_NinjaFly[1], - s_NinjaFly[2], - s_NinjaFly[3], - s_NinjaFly[4] }; ////////////////////// @@ -820,37 +503,17 @@ STATE* sg_NinjaFly[] = #define NINJA_PAIN_RATE 15 -STATE s_NinjaPain[5][2] = +STATE s_NinjaPain[1][2] = { { - {NINJA_PAIN_R0 + 0, NINJA_PAIN_RATE, &AF(DoNinjaPain), &s_NinjaPain[0][1]}, - {NINJA_PAIN_R0 + 1, NINJA_PAIN_RATE, &AF(DoNinjaPain), &s_NinjaPain[0][1]}, - }, - { - {NINJA_STAND_R1 + 0, NINJA_PAIN_RATE, &AF(DoNinjaPain), &s_NinjaPain[1][1]}, - {NINJA_STAND_R1 + 0, NINJA_PAIN_RATE, &AF(DoNinjaPain), &s_NinjaPain[1][1]}, - }, - { - {NINJA_STAND_R2 + 0, NINJA_PAIN_RATE, &AF(DoNinjaPain), &s_NinjaPain[2][1]}, - {NINJA_STAND_R2 + 0, NINJA_PAIN_RATE, &AF(DoNinjaPain), &s_NinjaPain[2][1]}, - }, - { - {NINJA_STAND_R3 + 0, NINJA_PAIN_RATE, &AF(DoNinjaPain), &s_NinjaPain[3][1]}, - {NINJA_STAND_R3 + 0, NINJA_PAIN_RATE, &AF(DoNinjaPain), &s_NinjaPain[3][1]}, - }, - { - {NINJA_STAND_R4 + 0, NINJA_PAIN_RATE, &AF(DoNinjaPain), &s_NinjaPain[4][1]}, - {NINJA_STAND_R4 + 0, NINJA_PAIN_RATE, &AF(DoNinjaPain), &s_NinjaPain[4][1]}, + {SPR_NINJA_PAIN, 'A', NINJA_PAIN_RATE, &AF(DoNinjaPain), &s_NinjaPain[0][1]}, + {SPR_NINJA_PAIN, 'B', NINJA_PAIN_RATE, &AF(DoNinjaPain), &s_NinjaPain[0][1]}, }, }; STATE* sg_NinjaPain[] = { s_NinjaPain[0], - s_NinjaPain[1], - s_NinjaPain[2], - s_NinjaPain[3], - s_NinjaPain[4] }; ////////////////////// @@ -861,57 +524,21 @@ STATE* sg_NinjaPain[] = #define NINJA_STAR_RATE 18 -STATE s_NinjaStar[5][6] = +STATE s_NinjaStar[1][6] = { { - {NINJA_THROW_R0 + 0, NINJA_STAR_RATE * 2, &AF(NullNinja), &s_NinjaStar[0][1]}, - {NINJA_THROW_R0 + 0, NINJA_STAR_RATE, &AF(NullNinja), &s_NinjaStar[0][2]}, - {NINJA_THROW_R0 + 1, 0 | SF_QUICK_CALL, &AF(InitEnemyStar), &s_NinjaStar[0][3]}, - {NINJA_THROW_R0 + 1, NINJA_STAR_RATE * 2, &AF(NullNinja), &s_NinjaStar[0][4]}, - {NINJA_THROW_R0 + 2, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_NinjaStar[0][5]}, - {NINJA_THROW_R0 + 2, NINJA_STAR_RATE, &AF(DoNinjaMove), &s_NinjaStar[0][5]}, - }, - { - {NINJA_THROW_R1 + 0, NINJA_STAR_RATE * 2, &AF(NullNinja), &s_NinjaStar[1][1]}, - {NINJA_THROW_R1 + 0, NINJA_STAR_RATE, &AF(NullNinja), &s_NinjaStar[1][2]}, - {NINJA_THROW_R1 + 1, 0 | SF_QUICK_CALL, &AF(InitEnemyStar), &s_NinjaStar[1][3]}, - {NINJA_THROW_R1 + 1, NINJA_STAR_RATE * 2, &AF(NullNinja), &s_NinjaStar[1][4]}, - {NINJA_THROW_R1 + 2, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_NinjaStar[1][5]}, - {NINJA_THROW_R1 + 2, NINJA_STAR_RATE, &AF(DoNinjaMove), &s_NinjaStar[1][5]}, - }, - { - {NINJA_THROW_R2 + 0, NINJA_STAR_RATE * 2, &AF(NullNinja), &s_NinjaStar[2][1]}, - {NINJA_THROW_R2 + 0, NINJA_STAR_RATE, &AF(NullNinja), &s_NinjaStar[2][2]}, - {NINJA_THROW_R2 + 1, 0 | SF_QUICK_CALL, &AF(InitEnemyStar), &s_NinjaStar[2][3]}, - {NINJA_THROW_R2 + 1, NINJA_STAR_RATE * 2, &AF(NullNinja), &s_NinjaStar[2][4]}, - {NINJA_THROW_R2 + 2, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_NinjaStar[2][5]}, - {NINJA_THROW_R2 + 2, NINJA_STAR_RATE, &AF(DoNinjaMove), &s_NinjaStar[2][5]}, - }, - { - {NINJA_THROW_R2 + 0, NINJA_STAR_RATE * 2, &AF(NullNinja), &s_NinjaStar[3][1]}, - {NINJA_THROW_R2 + 0, NINJA_STAR_RATE, &AF(NullNinja), &s_NinjaStar[3][2]}, - {NINJA_THROW_R2 + 1, 0 | SF_QUICK_CALL, &AF(InitEnemyStar), &s_NinjaStar[3][3]}, - {NINJA_THROW_R2 + 1, NINJA_STAR_RATE * 2, &AF(NullNinja), &s_NinjaStar[3][4]}, - {NINJA_THROW_R2 + 2, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_NinjaStar[3][5]}, - {NINJA_THROW_R2 + 2, NINJA_STAR_RATE, &AF(DoNinjaMove), &s_NinjaStar[3][5]}, - }, - { - {NINJA_THROW_R2 + 0, NINJA_STAR_RATE * 2, &AF(NullNinja), &s_NinjaStar[4][1]}, - {NINJA_THROW_R2 + 0, NINJA_STAR_RATE, &AF(NullNinja), &s_NinjaStar[4][2]}, - {NINJA_THROW_R2 + 1, 0 | SF_QUICK_CALL, &AF(InitEnemyStar), &s_NinjaStar[4][3]}, - {NINJA_THROW_R2 + 1, NINJA_STAR_RATE * 2, &AF(NullNinja), &s_NinjaStar[4][4]}, - {NINJA_THROW_R2 + 2, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_NinjaStar[4][5]}, - {NINJA_THROW_R2 + 2, NINJA_STAR_RATE, &AF(DoNinjaMove), &s_NinjaStar[4][5]}, + {SPR_NINJA_THROW, 'A', NINJA_STAR_RATE * 2, &AF(NullNinja), &s_NinjaStar[0][1]}, + {SPR_NINJA_THROW, 'A', NINJA_STAR_RATE, &AF(NullNinja), &s_NinjaStar[0][2]}, + {SPR_NINJA_THROW, 'B', 0 | SF_QUICK_CALL, &AF(InitEnemyStar), &s_NinjaStar[0][3]}, + {SPR_NINJA_THROW, 'B', NINJA_STAR_RATE * 2, &AF(NullNinja), &s_NinjaStar[0][4]}, + {SPR_NINJA_THROW, 'C', 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_NinjaStar[0][5]}, + {SPR_NINJA_THROW, 'C', NINJA_STAR_RATE, &AF(DoNinjaMove), &s_NinjaStar[0][5]}, }, }; STATE* sg_NinjaStar[] = { s_NinjaStar[0], - s_NinjaStar[1], - s_NinjaStar[2], - s_NinjaStar[3], - s_NinjaStar[4] }; ////////////////////// @@ -922,47 +549,15 @@ STATE* sg_NinjaStar[] = #define NINJA_MIRV_RATE 18 -STATE s_NinjaMirv[5][6] = +STATE s_NinjaMirv[1][6] = { { - {NINJA_THROW_R0 + 0, NINJA_MIRV_RATE * 2, &AF(NullNinja), &s_NinjaMirv[0][1]}, - {NINJA_THROW_R0 + 1, NINJA_MIRV_RATE, &AF(NullNinja), &s_NinjaMirv[0][2]}, - {NINJA_THROW_R0 + 2, 0 | SF_QUICK_CALL, &AF(InitEnemyMirv), &s_NinjaMirv[0][3]}, - {NINJA_THROW_R0 + 2, NINJA_MIRV_RATE * 2, &AF(NullNinja), &s_NinjaMirv[0][4]}, - {NINJA_THROW_R0 + 2, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_NinjaMirv[0][5]}, - {NINJA_THROW_R0 + 2, NINJA_MIRV_RATE, &AF(DoNinjaMove), &s_NinjaMirv[0][5]}, - }, - { - {NINJA_THROW_R1 + 0, NINJA_MIRV_RATE * 2, &AF(NullNinja), &s_NinjaMirv[1][1]}, - {NINJA_THROW_R1 + 1, NINJA_MIRV_RATE, &AF(NullNinja), &s_NinjaMirv[1][2]}, - {NINJA_THROW_R1 + 2, 0 | SF_QUICK_CALL, &AF(InitEnemyMirv), &s_NinjaMirv[1][3]}, - {NINJA_THROW_R1 + 2, NINJA_MIRV_RATE * 2, &AF(NullNinja), &s_NinjaMirv[1][4]}, - {NINJA_THROW_R1 + 2, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_NinjaMirv[1][5]}, - {NINJA_THROW_R1 + 2, NINJA_MIRV_RATE, &AF(DoNinjaMove), &s_NinjaMirv[1][5]}, - }, - { - {NINJA_THROW_R2 + 0, NINJA_MIRV_RATE * 2, &AF(NullNinja), &s_NinjaMirv[2][1]}, - {NINJA_THROW_R2 + 1, NINJA_MIRV_RATE, &AF(NullNinja), &s_NinjaMirv[2][2]}, - {NINJA_THROW_R2 + 2, 0 | SF_QUICK_CALL, &AF(InitEnemyMirv), &s_NinjaMirv[2][3]}, - {NINJA_THROW_R2 + 2, NINJA_MIRV_RATE * 2, &AF(NullNinja), &s_NinjaMirv[2][4]}, - {NINJA_THROW_R2 + 2, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_NinjaMirv[2][5]}, - {NINJA_THROW_R2 + 2, NINJA_MIRV_RATE, &AF(DoNinjaMove), &s_NinjaMirv[2][5]}, - }, - { - {NINJA_THROW_R2 + 0, NINJA_MIRV_RATE * 2, &AF(NullNinja), &s_NinjaMirv[3][1]}, - {NINJA_THROW_R2 + 1, NINJA_MIRV_RATE, &AF(NullNinja), &s_NinjaMirv[3][2]}, - {NINJA_THROW_R2 + 2, 0 | SF_QUICK_CALL, &AF(InitEnemyMirv), &s_NinjaMirv[3][3]}, - {NINJA_THROW_R2 + 2, NINJA_MIRV_RATE * 2, &AF(NullNinja), &s_NinjaMirv[3][4]}, - {NINJA_THROW_R2 + 2, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_NinjaMirv[3][5]}, - {NINJA_THROW_R2 + 2, NINJA_MIRV_RATE, &AF(DoNinjaMove), &s_NinjaMirv[3][5]}, - }, - { - {NINJA_THROW_R2 + 0, NINJA_MIRV_RATE * 2, &AF(NullNinja), &s_NinjaMirv[4][1]}, - {NINJA_THROW_R2 + 1, NINJA_MIRV_RATE, &AF(NullNinja), &s_NinjaMirv[4][2]}, - {NINJA_THROW_R2 + 2, 0 | SF_QUICK_CALL, &AF(InitEnemyMirv), &s_NinjaMirv[4][3]}, - {NINJA_THROW_R2 + 2, NINJA_MIRV_RATE * 2, &AF(NullNinja), &s_NinjaMirv[4][4]}, - {NINJA_THROW_R2 + 2, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_NinjaMirv[4][5]}, - {NINJA_THROW_R2 + 2, NINJA_MIRV_RATE, &AF(DoNinjaMove), &s_NinjaStar[4][5]}, + {SPR_NINJA_THROW, 'A', NINJA_MIRV_RATE * 2, &AF(NullNinja), &s_NinjaMirv[0][1]}, + {SPR_NINJA_THROW, 'B', NINJA_MIRV_RATE, &AF(NullNinja), &s_NinjaMirv[0][2]}, + {SPR_NINJA_THROW, 'C', 0 | SF_QUICK_CALL, &AF(InitEnemyMirv), &s_NinjaMirv[0][3]}, + {SPR_NINJA_THROW, 'C', NINJA_MIRV_RATE * 2, &AF(NullNinja), &s_NinjaMirv[0][4]}, + {SPR_NINJA_THROW, 'C', 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_NinjaMirv[0][5]}, + {SPR_NINJA_THROW, 'C', NINJA_MIRV_RATE, &AF(DoNinjaMove), &s_NinjaMirv[0][5]}, }, }; @@ -970,10 +565,6 @@ STATE s_NinjaMirv[5][6] = STATE* sg_NinjaMirv[] = { s_NinjaMirv[0], - s_NinjaMirv[1], - s_NinjaMirv[2], - s_NinjaMirv[3], - s_NinjaMirv[4] }; ////////////////////// @@ -984,47 +575,15 @@ STATE* sg_NinjaMirv[] = #define NINJA_NAPALM_RATE 18 -STATE s_NinjaNapalm[5][6] = +STATE s_NinjaNapalm[1][6] = { { - {NINJA_THROW_R0 + 0, NINJA_NAPALM_RATE * 2, &AF(NullNinja), &s_NinjaNapalm[0][1]}, - {NINJA_THROW_R0 + 1, NINJA_NAPALM_RATE, &AF(NullNinja), &s_NinjaNapalm[0][2]}, - {NINJA_THROW_R0 + 2, 0 | SF_QUICK_CALL, &AF(InitEnemyNapalm), &s_NinjaNapalm[0][3]}, - {NINJA_THROW_R0 + 2, NINJA_NAPALM_RATE * 2, &AF(NullNinja), &s_NinjaNapalm[0][4]}, - {NINJA_THROW_R0 + 2, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_NinjaNapalm[0][5]}, - {NINJA_THROW_R0 + 2, NINJA_NAPALM_RATE, &AF(DoNinjaMove), &s_NinjaNapalm[0][5]}, - }, - { - {NINJA_THROW_R1 + 0, NINJA_NAPALM_RATE * 2, &AF(NullNinja), &s_NinjaNapalm[1][1]}, - {NINJA_THROW_R1 + 1, NINJA_NAPALM_RATE, &AF(NullNinja), &s_NinjaNapalm[1][2]}, - {NINJA_THROW_R1 + 2, 0 | SF_QUICK_CALL, &AF(InitEnemyNapalm), &s_NinjaNapalm[1][3]}, - {NINJA_THROW_R1 + 2, NINJA_NAPALM_RATE * 2, &AF(NullNinja), &s_NinjaNapalm[1][4]}, - {NINJA_THROW_R1 + 2, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_NinjaNapalm[1][5]}, - {NINJA_THROW_R1 + 2, NINJA_NAPALM_RATE, &AF(DoNinjaMove), &s_NinjaNapalm[1][5]}, - }, - { - {NINJA_THROW_R2 + 0, NINJA_NAPALM_RATE * 2, &AF(NullNinja), &s_NinjaNapalm[2][1]}, - {NINJA_THROW_R2 + 1, NINJA_NAPALM_RATE, &AF(NullNinja), &s_NinjaNapalm[2][2]}, - {NINJA_THROW_R2 + 2, 0 | SF_QUICK_CALL, &AF(InitEnemyNapalm), &s_NinjaNapalm[2][3]}, - {NINJA_THROW_R2 + 2, NINJA_NAPALM_RATE * 2, &AF(NullNinja), &s_NinjaNapalm[2][4]}, - {NINJA_THROW_R2 + 2, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_NinjaNapalm[2][5]}, - {NINJA_THROW_R2 + 2, NINJA_NAPALM_RATE, &AF(DoNinjaMove), &s_NinjaNapalm[2][5]}, - }, - { - {NINJA_THROW_R2 + 0, NINJA_NAPALM_RATE * 2, &AF(NullNinja), &s_NinjaNapalm[3][1]}, - {NINJA_THROW_R2 + 1, NINJA_NAPALM_RATE, &AF(NullNinja), &s_NinjaNapalm[3][2]}, - {NINJA_THROW_R2 + 2, 0 | SF_QUICK_CALL, &AF(InitEnemyNapalm), &s_NinjaNapalm[3][3]}, - {NINJA_THROW_R2 + 2, NINJA_NAPALM_RATE * 2, &AF(NullNinja), &s_NinjaNapalm[3][4]}, - {NINJA_THROW_R2 + 2, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_NinjaNapalm[3][5]}, - {NINJA_THROW_R2 + 2, NINJA_NAPALM_RATE, &AF(DoNinjaMove), &s_NinjaNapalm[3][5]}, - }, - { - {NINJA_THROW_R2 + 0, NINJA_NAPALM_RATE * 2, &AF(NullNinja), &s_NinjaNapalm[4][1]}, - {NINJA_THROW_R2 + 1, NINJA_NAPALM_RATE, &AF(NullNinja), &s_NinjaNapalm[4][2]}, - {NINJA_THROW_R2 + 2, 0 | SF_QUICK_CALL, &AF(InitEnemyNapalm), &s_NinjaNapalm[4][3]}, - {NINJA_THROW_R2 + 2, NINJA_NAPALM_RATE * 2, &AF(NullNinja), &s_NinjaNapalm[4][4]}, - {NINJA_THROW_R2 + 2, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_NinjaNapalm[4][5]}, - {NINJA_THROW_R2 + 2, NINJA_NAPALM_RATE, &AF(DoNinjaMove), &s_NinjaNapalm[4][5]}, + {SPR_NINJA_THROW, 'A', NINJA_NAPALM_RATE * 2, &AF(NullNinja), &s_NinjaNapalm[0][1]}, + {SPR_NINJA_THROW, 'B', NINJA_NAPALM_RATE, &AF(NullNinja), &s_NinjaNapalm[0][2]}, + {SPR_NINJA_THROW, 'C', 0 | SF_QUICK_CALL, &AF(InitEnemyNapalm), &s_NinjaNapalm[0][3]}, + {SPR_NINJA_THROW, 'C', NINJA_NAPALM_RATE * 2, &AF(NullNinja), &s_NinjaNapalm[0][4]}, + {SPR_NINJA_THROW, 'C', 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_NinjaNapalm[0][5]}, + {SPR_NINJA_THROW, 'C', NINJA_NAPALM_RATE, &AF(DoNinjaMove), &s_NinjaNapalm[0][5]}, }, }; @@ -1032,10 +591,6 @@ STATE s_NinjaNapalm[5][6] = STATE* sg_NinjaNapalm[] = { s_NinjaNapalm[0], - s_NinjaNapalm[1], - s_NinjaNapalm[2], - s_NinjaNapalm[3], - s_NinjaNapalm[4] }; @@ -1047,42 +602,14 @@ STATE* sg_NinjaNapalm[] = #define NINJA_ROCKET_RATE 14 -STATE s_NinjaRocket[5][5] = +STATE s_NinjaRocket[1][5] = { { - {NINJA_STAND_R0 + 0, NINJA_ROCKET_RATE * 2, &AF(NullNinja), &s_NinjaRocket[0][1]}, - {NINJA_STAND_R0 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyRocket), &s_NinjaRocket[0][2]}, - {NINJA_STAND_R0 + 0, NINJA_ROCKET_RATE, &AF(NullNinja), &s_NinjaRocket[0][3]}, - {NINJA_STAND_R0 + 0, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_NinjaRocket[0][4]}, - {NINJA_STAND_R0 + 0, NINJA_ROCKET_RATE, &AF(DoNinjaMove), &s_NinjaRocket[0][4]}, - }, - { - {NINJA_STAND_R1 + 0, NINJA_ROCKET_RATE * 2, &AF(NullNinja), &s_NinjaRocket[1][1]}, - {NINJA_STAND_R1 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyRocket), &s_NinjaRocket[1][2]}, - {NINJA_STAND_R1 + 0, NINJA_ROCKET_RATE, &AF(NullNinja), &s_NinjaRocket[1][3]}, - {NINJA_STAND_R1 + 0, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_NinjaRocket[1][4]}, - {NINJA_STAND_R1 + 0, NINJA_ROCKET_RATE, &AF(DoNinjaMove), &s_NinjaRocket[1][4]}, - }, - { - {NINJA_STAND_R2 + 0, NINJA_ROCKET_RATE * 2, &AF(NullNinja), &s_NinjaRocket[2][1]}, - {NINJA_STAND_R2 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyRocket), &s_NinjaRocket[2][2]}, - {NINJA_STAND_R2 + 0, NINJA_ROCKET_RATE, &AF(NullNinja), &s_NinjaRocket[2][3]}, - {NINJA_STAND_R2 + 0, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_NinjaRocket[2][4]}, - {NINJA_STAND_R2 + 0, NINJA_ROCKET_RATE, &AF(DoNinjaMove), &s_NinjaRocket[2][4]}, - }, - { - {NINJA_STAND_R3 + 0, NINJA_ROCKET_RATE * 2, &AF(NullNinja), &s_NinjaRocket[3][1]}, - {NINJA_STAND_R3 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyRocket), &s_NinjaRocket[3][2]}, - {NINJA_STAND_R3 + 0, NINJA_ROCKET_RATE, &AF(NullNinja), &s_NinjaRocket[3][3]}, - {NINJA_STAND_R3 + 0, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_NinjaRocket[3][4]}, - {NINJA_STAND_R3 + 0, NINJA_ROCKET_RATE, &AF(DoNinjaMove), &s_NinjaRocket[3][4]}, - }, - { - {NINJA_STAND_R4 + 0, NINJA_ROCKET_RATE * 2, &AF(NullNinja), &s_NinjaRocket[4][1]}, - {NINJA_STAND_R4 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyRocket), &s_NinjaRocket[4][2]}, - {NINJA_STAND_R4 + 0, NINJA_ROCKET_RATE, &AF(NullNinja), &s_NinjaRocket[4][3]}, - {NINJA_STAND_R4 + 0, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_NinjaRocket[4][4]}, - {NINJA_STAND_R4 + 0, NINJA_ROCKET_RATE, &AF(DoNinjaMove), &s_NinjaRocket[4][4]}, + {SPR_NINJA_STAND, 'A', NINJA_ROCKET_RATE * 2, &AF(NullNinja), &s_NinjaRocket[0][1]}, + {SPR_NINJA_STAND, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyRocket), &s_NinjaRocket[0][2]}, + {SPR_NINJA_STAND, 'A', NINJA_ROCKET_RATE, &AF(NullNinja), &s_NinjaRocket[0][3]}, + {SPR_NINJA_STAND, 'A', 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_NinjaRocket[0][4]}, + {SPR_NINJA_STAND, 'A', NINJA_ROCKET_RATE, &AF(DoNinjaMove), &s_NinjaRocket[0][4]}, }, }; @@ -1090,10 +617,6 @@ STATE s_NinjaRocket[5][5] = STATE* sg_NinjaRocket[] = { s_NinjaRocket[0], - s_NinjaRocket[1], - s_NinjaRocket[2], - s_NinjaRocket[3], - s_NinjaRocket[4] }; ////////////////////// @@ -1104,42 +627,14 @@ STATE* sg_NinjaRocket[] = #define NINJA_ROCKET_RATE 14 -STATE s_NinjaGrenade[5][5] = +STATE s_NinjaGrenade[1][5] = { { - {NINJA_STAND_R0 + 0, NINJA_ROCKET_RATE * 2, &AF(NullNinja), &s_NinjaGrenade[0][1]}, - {NINJA_STAND_R0 + 0, 0 | SF_QUICK_CALL, &AF(InitSpriteGrenade), &s_NinjaGrenade[0][2]}, - {NINJA_STAND_R0 + 0, NINJA_ROCKET_RATE, &AF(NullNinja), &s_NinjaGrenade[0][3]}, - {NINJA_STAND_R0 + 0, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_NinjaGrenade[0][4]}, - {NINJA_STAND_R0 + 0, NINJA_ROCKET_RATE, &AF(DoNinjaMove), &s_NinjaGrenade[0][4]}, - }, - { - {NINJA_STAND_R1 + 0, NINJA_ROCKET_RATE * 2, &AF(NullNinja), &s_NinjaGrenade[1][1]}, - {NINJA_STAND_R1 + 0, 0 | SF_QUICK_CALL, &AF(InitSpriteGrenade), &s_NinjaGrenade[1][2]}, - {NINJA_STAND_R1 + 0, NINJA_ROCKET_RATE, &AF(NullNinja), &s_NinjaGrenade[1][3]}, - {NINJA_STAND_R1 + 0, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_NinjaGrenade[1][4]}, - {NINJA_STAND_R1 + 0, NINJA_ROCKET_RATE, &AF(DoNinjaMove), &s_NinjaGrenade[1][4]}, - }, - { - {NINJA_STAND_R2 + 0, NINJA_ROCKET_RATE * 2, &AF(NullNinja), &s_NinjaGrenade[2][1]}, - {NINJA_STAND_R2 + 0, 0 | SF_QUICK_CALL, &AF(InitSpriteGrenade), &s_NinjaGrenade[2][2]}, - {NINJA_STAND_R2 + 0, NINJA_ROCKET_RATE, &AF(NullNinja), &s_NinjaGrenade[2][3]}, - {NINJA_STAND_R2 + 0, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_NinjaGrenade[2][4]}, - {NINJA_STAND_R2 + 0, NINJA_ROCKET_RATE, &AF(DoNinjaMove), &s_NinjaGrenade[2][4]}, - }, - { - {NINJA_STAND_R3 + 0, NINJA_ROCKET_RATE * 2, &AF(NullNinja), &s_NinjaGrenade[3][1]}, - {NINJA_STAND_R3 + 0, 0 | SF_QUICK_CALL, &AF(InitSpriteGrenade), &s_NinjaGrenade[3][2]}, - {NINJA_STAND_R3 + 0, NINJA_ROCKET_RATE, &AF(NullNinja), &s_NinjaGrenade[3][3]}, - {NINJA_STAND_R3 + 0, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_NinjaGrenade[3][4]}, - {NINJA_STAND_R3 + 0, NINJA_ROCKET_RATE, &AF(DoNinjaMove), &s_NinjaGrenade[3][4]}, - }, - { - {NINJA_STAND_R4 + 0, NINJA_ROCKET_RATE * 2, &AF(NullNinja), &s_NinjaGrenade[4][1]}, - {NINJA_STAND_R4 + 0, 0 | SF_QUICK_CALL, &AF(InitSpriteGrenade), &s_NinjaGrenade[4][2]}, - {NINJA_STAND_R4 + 0, NINJA_ROCKET_RATE, &AF(NullNinja), &s_NinjaGrenade[4][3]}, - {NINJA_STAND_R4 + 0, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_NinjaGrenade[4][4]}, - {NINJA_STAND_R4 + 0, NINJA_ROCKET_RATE, &AF(DoNinjaMove), &s_NinjaGrenade[4][4]}, + {SPR_NINJA_STAND, 'A', NINJA_ROCKET_RATE * 2, &AF(NullNinja), &s_NinjaGrenade[0][1]}, + {SPR_NINJA_STAND, 'A', 0 | SF_QUICK_CALL, &AF(InitSpriteGrenade), &s_NinjaGrenade[0][2]}, + {SPR_NINJA_STAND, 'A', NINJA_ROCKET_RATE, &AF(NullNinja), &s_NinjaGrenade[0][3]}, + {SPR_NINJA_STAND, 'A', 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_NinjaGrenade[0][4]}, + {SPR_NINJA_STAND, 'A', NINJA_ROCKET_RATE, &AF(DoNinjaMove), &s_NinjaGrenade[0][4]}, }, }; @@ -1147,10 +642,6 @@ STATE s_NinjaGrenade[5][5] = STATE* sg_NinjaGrenade[] = { s_NinjaGrenade[0], - s_NinjaGrenade[1], - s_NinjaGrenade[2], - s_NinjaGrenade[3], - s_NinjaGrenade[4] }; @@ -1162,42 +653,14 @@ STATE* sg_NinjaGrenade[] = #define NINJA_FLASHBOMB_RATE 14 -STATE s_NinjaFlashBomb[5][5] = +STATE s_NinjaFlashBomb[1][5] = { { - {NINJA_STAND_R0 + 0, NINJA_FLASHBOMB_RATE * 2, &AF(NullNinja), &s_NinjaFlashBomb[0][1]}, - {NINJA_STAND_R0 + 0, 0 | SF_QUICK_CALL, &AF(InitFlashBomb), &s_NinjaFlashBomb[0][2]}, - {NINJA_STAND_R0 + 0, NINJA_FLASHBOMB_RATE, &AF(NullNinja), &s_NinjaFlashBomb[0][3]}, - {NINJA_STAND_R0 + 0, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_NinjaFlashBomb[0][4]}, - {NINJA_STAND_R0 + 0, NINJA_FLASHBOMB_RATE, &AF(DoNinjaMove), &s_NinjaFlashBomb[0][4]}, - }, - { - {NINJA_STAND_R1 + 0, NINJA_FLASHBOMB_RATE * 2, &AF(NullNinja), &s_NinjaFlashBomb[1][1]}, - {NINJA_STAND_R1 + 0, 0 | SF_QUICK_CALL, &AF(InitFlashBomb), &s_NinjaFlashBomb[1][2]}, - {NINJA_STAND_R1 + 0, NINJA_FLASHBOMB_RATE, &AF(NullNinja), &s_NinjaFlashBomb[1][3]}, - {NINJA_STAND_R1 + 0, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_NinjaFlashBomb[1][4]}, - {NINJA_STAND_R1 + 0, NINJA_FLASHBOMB_RATE, &AF(DoNinjaMove), &s_NinjaFlashBomb[1][4]}, - }, - { - {NINJA_STAND_R2 + 0, NINJA_FLASHBOMB_RATE * 2, &AF(NullNinja), &s_NinjaFlashBomb[2][1]}, - {NINJA_STAND_R2 + 0, 0 | SF_QUICK_CALL, &AF(InitFlashBomb), &s_NinjaFlashBomb[2][2]}, - {NINJA_STAND_R2 + 0, NINJA_FLASHBOMB_RATE, &AF(NullNinja), &s_NinjaFlashBomb[2][3]}, - {NINJA_STAND_R2 + 0, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_NinjaFlashBomb[2][4]}, - {NINJA_STAND_R2 + 0, NINJA_FLASHBOMB_RATE, &AF(DoNinjaMove), &s_NinjaFlashBomb[2][4]}, - }, - { - {NINJA_STAND_R3 + 0, NINJA_FLASHBOMB_RATE * 2, &AF(NullNinja), &s_NinjaFlashBomb[3][1]}, - {NINJA_STAND_R3 + 0, 0 | SF_QUICK_CALL, &AF(InitFlashBomb), &s_NinjaFlashBomb[3][2]}, - {NINJA_STAND_R3 + 0, NINJA_FLASHBOMB_RATE, &AF(NullNinja), &s_NinjaFlashBomb[3][3]}, - {NINJA_STAND_R3 + 0, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_NinjaFlashBomb[3][4]}, - {NINJA_STAND_R3 + 0, NINJA_FLASHBOMB_RATE, &AF(DoNinjaMove), &s_NinjaFlashBomb[3][4]}, - }, - { - {NINJA_STAND_R4 + 0, NINJA_FLASHBOMB_RATE * 2, &AF(NullNinja), &s_NinjaFlashBomb[4][1]}, - {NINJA_STAND_R4 + 0, 0 | SF_QUICK_CALL, &AF(InitFlashBomb), &s_NinjaFlashBomb[4][2]}, - {NINJA_STAND_R4 + 0, NINJA_FLASHBOMB_RATE, &AF(NullNinja), &s_NinjaFlashBomb[4][3]}, - {NINJA_STAND_R4 + 0, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_NinjaFlashBomb[4][4]}, - {NINJA_STAND_R4 + 0, NINJA_FLASHBOMB_RATE, &AF(DoNinjaMove), &s_NinjaFlashBomb[4][4]}, + {SPR_NINJA_STAND, 'A', NINJA_FLASHBOMB_RATE * 2, &AF(NullNinja), &s_NinjaFlashBomb[0][1]}, + {SPR_NINJA_STAND, 'A', 0 | SF_QUICK_CALL, &AF(InitFlashBomb), &s_NinjaFlashBomb[0][2]}, + {SPR_NINJA_STAND, 'A', NINJA_FLASHBOMB_RATE, &AF(NullNinja), &s_NinjaFlashBomb[0][3]}, + {SPR_NINJA_STAND, 'A', 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_NinjaFlashBomb[0][4]}, + {SPR_NINJA_STAND, 'A', NINJA_FLASHBOMB_RATE, &AF(DoNinjaMove), &s_NinjaFlashBomb[0][4]}, }, }; @@ -1205,10 +668,6 @@ STATE s_NinjaFlashBomb[5][5] = STATE* sg_NinjaFlashBomb[] = { s_NinjaFlashBomb[0], - s_NinjaFlashBomb[1], - s_NinjaFlashBomb[2], - s_NinjaFlashBomb[3], - s_NinjaFlashBomb[4] }; ////////////////////// @@ -1219,102 +678,26 @@ STATE* sg_NinjaFlashBomb[] = #define NINJA_UZI_RATE 8 -STATE s_NinjaUzi[5][17] = +STATE s_NinjaUzi[1][17] = { { - {NINJA_FIRE_R0 + 0, NINJA_UZI_RATE, &AF(NullNinja), &s_NinjaUzi[0][1]}, - {NINJA_FIRE_R0 + 0, 0 | SF_QUICK_CALL, &AF(CheckFire), &s_NinjaUzi[0][2]}, - {NINJA_FIRE_R0 + 1, NINJA_UZI_RATE, &AF(NullNinja), &s_NinjaUzi[0][3]}, - {NINJA_FIRE_R0 + 1, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_NinjaUzi[0][4]}, - {NINJA_FIRE_R0 + 0, NINJA_UZI_RATE, &AF(NullNinja), &s_NinjaUzi[0][5]}, - {NINJA_FIRE_R0 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_NinjaUzi[0][6]}, - {NINJA_FIRE_R0 + 1, NINJA_UZI_RATE, &AF(NullNinja), &s_NinjaUzi[0][7]}, - {NINJA_FIRE_R0 + 1, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_NinjaUzi[0][8]}, - {NINJA_FIRE_R0 + 0, NINJA_UZI_RATE, &AF(NullNinja), &s_NinjaUzi[0][9]}, - {NINJA_FIRE_R0 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_NinjaUzi[0][10]}, - {NINJA_FIRE_R0 + 1, NINJA_UZI_RATE, &AF(NullNinja), &s_NinjaUzi[0][11]}, - {NINJA_FIRE_R0 + 1, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_NinjaUzi[0][12]}, - {NINJA_FIRE_R0 + 0, NINJA_UZI_RATE, &AF(NullNinja), &s_NinjaUzi[0][13]}, - {NINJA_FIRE_R0 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_NinjaUzi[0][14]}, - {NINJA_FIRE_R0 + 1, NINJA_UZI_RATE, &AF(NullNinja), &s_NinjaUzi[0][15]}, - {NINJA_FIRE_R0 + 1, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_NinjaUzi[0][16]}, - {NINJA_FIRE_R0 + 0, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_NinjaUzi[0][16]}, - }, - { - {NINJA_FIRE_R1 + 0, NINJA_UZI_RATE, &AF(NullNinja), &s_NinjaUzi[1][1]}, - {NINJA_FIRE_R1 + 0, 0 | SF_QUICK_CALL, &AF(CheckFire), &s_NinjaUzi[1][2]}, - {NINJA_FIRE_R1 + 1, NINJA_UZI_RATE, &AF(NullNinja), &s_NinjaUzi[1][3]}, - {NINJA_FIRE_R1 + 1, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_NinjaUzi[1][4]}, - {NINJA_FIRE_R1 + 0, NINJA_UZI_RATE, &AF(NullNinja), &s_NinjaUzi[1][5]}, - {NINJA_FIRE_R1 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_NinjaUzi[1][6]}, - {NINJA_FIRE_R1 + 1, NINJA_UZI_RATE, &AF(NullNinja), &s_NinjaUzi[1][7]}, - {NINJA_FIRE_R1 + 1, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_NinjaUzi[1][8]}, - {NINJA_FIRE_R1 + 0, NINJA_UZI_RATE, &AF(NullNinja), &s_NinjaUzi[1][9]}, - {NINJA_FIRE_R1 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_NinjaUzi[1][10]}, - {NINJA_FIRE_R1 + 1, NINJA_UZI_RATE, &AF(NullNinja), &s_NinjaUzi[1][11]}, - {NINJA_FIRE_R1 + 1, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_NinjaUzi[1][12]}, - {NINJA_FIRE_R1 + 0, NINJA_UZI_RATE, &AF(NullNinja), &s_NinjaUzi[1][13]}, - {NINJA_FIRE_R1 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_NinjaUzi[1][14]}, - {NINJA_FIRE_R1 + 1, NINJA_UZI_RATE, &AF(NullNinja), &s_NinjaUzi[1][15]}, - {NINJA_FIRE_R1 + 1, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_NinjaUzi[1][16]}, - {NINJA_FIRE_R1 + 0, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_NinjaUzi[1][16]}, - }, - { - {NINJA_FIRE_R2 + 0, NINJA_UZI_RATE, &AF(NullNinja), &s_NinjaUzi[2][1]}, - {NINJA_FIRE_R2 + 0, 0 | SF_QUICK_CALL, &AF(CheckFire), &s_NinjaUzi[2][2]}, - {NINJA_FIRE_R2 + 1, NINJA_UZI_RATE, &AF(NullNinja), &s_NinjaUzi[2][3]}, - {NINJA_FIRE_R2 + 1, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_NinjaUzi[2][4]}, - {NINJA_FIRE_R2 + 0, NINJA_UZI_RATE, &AF(NullNinja), &s_NinjaUzi[2][5]}, - {NINJA_FIRE_R2 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_NinjaUzi[2][6]}, - {NINJA_FIRE_R2 + 1, NINJA_UZI_RATE, &AF(NullNinja), &s_NinjaUzi[2][7]}, - {NINJA_FIRE_R2 + 1, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_NinjaUzi[2][8]}, - {NINJA_FIRE_R2 + 0, NINJA_UZI_RATE, &AF(NullNinja), &s_NinjaUzi[2][9]}, - {NINJA_FIRE_R2 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_NinjaUzi[2][10]}, - {NINJA_FIRE_R2 + 1, NINJA_UZI_RATE, &AF(NullNinja), &s_NinjaUzi[2][11]}, - {NINJA_FIRE_R2 + 1, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_NinjaUzi[2][12]}, - {NINJA_FIRE_R2 + 0, NINJA_UZI_RATE, &AF(NullNinja), &s_NinjaUzi[2][13]}, - {NINJA_FIRE_R2 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_NinjaUzi[2][14]}, - {NINJA_FIRE_R2 + 1, NINJA_UZI_RATE, &AF(NullNinja), &s_NinjaUzi[2][15]}, - {NINJA_FIRE_R2 + 1, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_NinjaUzi[2][16]}, - {NINJA_FIRE_R2 + 0, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_NinjaUzi[2][16]}, - }, - { - {NINJA_FIRE_R3 + 0, NINJA_UZI_RATE, &AF(NullNinja), &s_NinjaUzi[3][1]}, - {NINJA_FIRE_R3 + 0, 0 | SF_QUICK_CALL, &AF(CheckFire), &s_NinjaUzi[3][2]}, - {NINJA_FIRE_R3 + 1, NINJA_UZI_RATE, &AF(NullNinja), &s_NinjaUzi[3][3]}, - {NINJA_FIRE_R3 + 1, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_NinjaUzi[3][4]}, - {NINJA_FIRE_R3 + 0, NINJA_UZI_RATE, &AF(NullNinja), &s_NinjaUzi[3][5]}, - {NINJA_FIRE_R3 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_NinjaUzi[3][6]}, - {NINJA_FIRE_R3 + 1, NINJA_UZI_RATE, &AF(NullNinja), &s_NinjaUzi[3][7]}, - {NINJA_FIRE_R3 + 1, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_NinjaUzi[3][8]}, - {NINJA_FIRE_R3 + 0, NINJA_UZI_RATE, &AF(NullNinja), &s_NinjaUzi[3][9]}, - {NINJA_FIRE_R3 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_NinjaUzi[3][10]}, - {NINJA_FIRE_R3 + 1, NINJA_UZI_RATE, &AF(NullNinja), &s_NinjaUzi[3][11]}, - {NINJA_FIRE_R3 + 1, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_NinjaUzi[3][12]}, - {NINJA_FIRE_R3 + 0, NINJA_UZI_RATE, &AF(NullNinja), &s_NinjaUzi[3][13]}, - {NINJA_FIRE_R3 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_NinjaUzi[3][14]}, - {NINJA_FIRE_R3 + 1, NINJA_UZI_RATE, &AF(NullNinja), &s_NinjaUzi[3][15]}, - {NINJA_FIRE_R3 + 1, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_NinjaUzi[3][16]}, - {NINJA_FIRE_R3 + 0, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_NinjaUzi[3][16]}, - }, - { - {NINJA_FIRE_R4 + 0, NINJA_UZI_RATE, &AF(NullNinja), &s_NinjaUzi[4][1]}, - {NINJA_FIRE_R4 + 0, 0 | SF_QUICK_CALL, &AF(CheckFire), &s_NinjaUzi[4][2]}, - {NINJA_FIRE_R4 + 1, NINJA_UZI_RATE, &AF(NullNinja), &s_NinjaUzi[4][3]}, - {NINJA_FIRE_R4 + 1, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_NinjaUzi[4][4]}, - {NINJA_FIRE_R4 + 0, NINJA_UZI_RATE, &AF(NullNinja), &s_NinjaUzi[4][5]}, - {NINJA_FIRE_R4 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_NinjaUzi[4][6]}, - {NINJA_FIRE_R4 + 1, NINJA_UZI_RATE, &AF(NullNinja), &s_NinjaUzi[4][7]}, - {NINJA_FIRE_R4 + 1, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_NinjaUzi[4][8]}, - {NINJA_FIRE_R4 + 0, NINJA_UZI_RATE, &AF(NullNinja), &s_NinjaUzi[4][9]}, - {NINJA_FIRE_R4 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_NinjaUzi[4][10]}, - {NINJA_FIRE_R4 + 1, NINJA_UZI_RATE, &AF(NullNinja), &s_NinjaUzi[4][11]}, - {NINJA_FIRE_R4 + 1, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_NinjaUzi[4][12]}, - {NINJA_FIRE_R4 + 0, NINJA_UZI_RATE, &AF(NullNinja), &s_NinjaUzi[4][13]}, - {NINJA_FIRE_R4 + 0, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_NinjaUzi[4][14]}, - {NINJA_FIRE_R4 + 1, NINJA_UZI_RATE, &AF(NullNinja), &s_NinjaUzi[4][15]}, - {NINJA_FIRE_R4 + 1, 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_NinjaUzi[4][16]}, - {NINJA_FIRE_R4 + 0, 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_NinjaUzi[4][16]}, + {SPR_NINJA_FIRE, 'A', NINJA_UZI_RATE, &AF(NullNinja), &s_NinjaUzi[0][1]}, + {SPR_NINJA_FIRE, 'A', 0 | SF_QUICK_CALL, &AF(CheckFire), &s_NinjaUzi[0][2]}, + {SPR_NINJA_FIRE, 'B', NINJA_UZI_RATE, &AF(NullNinja), &s_NinjaUzi[0][3]}, + {SPR_NINJA_FIRE, 'B', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_NinjaUzi[0][4]}, + {SPR_NINJA_FIRE, 'A', NINJA_UZI_RATE, &AF(NullNinja), &s_NinjaUzi[0][5]}, + {SPR_NINJA_FIRE, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_NinjaUzi[0][6]}, + {SPR_NINJA_FIRE, 'B', NINJA_UZI_RATE, &AF(NullNinja), &s_NinjaUzi[0][7]}, + {SPR_NINJA_FIRE, 'B', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_NinjaUzi[0][8]}, + {SPR_NINJA_FIRE, 'A', NINJA_UZI_RATE, &AF(NullNinja), &s_NinjaUzi[0][9]}, + {SPR_NINJA_FIRE, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_NinjaUzi[0][10]}, + {SPR_NINJA_FIRE, 'B', NINJA_UZI_RATE, &AF(NullNinja), &s_NinjaUzi[0][11]}, + {SPR_NINJA_FIRE, 'B', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_NinjaUzi[0][12]}, + {SPR_NINJA_FIRE, 'A', NINJA_UZI_RATE, &AF(NullNinja), &s_NinjaUzi[0][13]}, + {SPR_NINJA_FIRE, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_NinjaUzi[0][14]}, + {SPR_NINJA_FIRE, 'B', NINJA_UZI_RATE, &AF(NullNinja), &s_NinjaUzi[0][15]}, + {SPR_NINJA_FIRE, 'B', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_NinjaUzi[0][16]}, + {SPR_NINJA_FIRE, 'A', 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_NinjaUzi[0][16]}, }, }; @@ -1322,10 +705,6 @@ STATE s_NinjaUzi[5][17] = STATE* sg_NinjaUzi[] = { s_NinjaUzi[0], - s_NinjaUzi[1], - s_NinjaUzi[2], - s_NinjaUzi[3], - s_NinjaUzi[4] }; @@ -1340,26 +719,22 @@ STATE* sg_NinjaUzi[] = STATE s_NinjaHariKari[] = { - {NINJA_HARI_KARI_R0 + 0, NINJA_HARI_KARI_FALL_RATE, &AF(NullNinja), &s_NinjaHariKari[1]}, - {NINJA_HARI_KARI_R0 + 0, SF_QUICK_CALL, &AF(DoNinjaSpecial), &s_NinjaHariKari[2]}, - {NINJA_HARI_KARI_R0 + 1, NINJA_HARI_KARI_WAIT_RATE, &AF(NullNinja), &s_NinjaHariKari[3]}, - {NINJA_HARI_KARI_R0 + 2, SF_QUICK_CALL, &AF(DoNinjaHariKari), &s_NinjaHariKari[4]}, - {NINJA_HARI_KARI_R0 + 2, NINJA_HARI_KARI_FALL_RATE, nullptr, &s_NinjaHariKari[5]}, - {NINJA_HARI_KARI_R0 + 3, NINJA_HARI_KARI_FALL_RATE, nullptr, &s_NinjaHariKari[6]}, - {NINJA_HARI_KARI_R0 + 4, NINJA_HARI_KARI_FALL_RATE, nullptr, &s_NinjaHariKari[7]}, - {NINJA_HARI_KARI_R0 + 5, NINJA_HARI_KARI_FALL_RATE, nullptr, &s_NinjaHariKari[8]}, - {NINJA_HARI_KARI_R0 + 6, NINJA_HARI_KARI_FALL_RATE, nullptr, &s_NinjaHariKari[9]}, - {NINJA_HARI_KARI_R0 + 7, NINJA_HARI_KARI_FALL_RATE, nullptr, &s_NinjaHariKari[10]}, - {NINJA_HARI_KARI_R0 + 7, NINJA_HARI_KARI_FALL_RATE, nullptr, &s_NinjaHariKari[10]}, + {SPR_NINJA_HARI_KARI, 'A', NINJA_HARI_KARI_FALL_RATE, &AF(NullNinja), &s_NinjaHariKari[1]}, + {SPR_NINJA_HARI_KARI, 'A', SF_QUICK_CALL, &AF(DoNinjaSpecial), &s_NinjaHariKari[2]}, + {SPR_NINJA_HARI_KARI, 'B', NINJA_HARI_KARI_WAIT_RATE, &AF(NullNinja), &s_NinjaHariKari[3]}, + {SPR_NINJA_HARI_KARI, 'C', SF_QUICK_CALL, &AF(DoNinjaHariKari), &s_NinjaHariKari[4]}, + {SPR_NINJA_HARI_KARI, 'C', NINJA_HARI_KARI_FALL_RATE, nullptr, &s_NinjaHariKari[5]}, + {SPR_NINJA_HARI_KARI, 'D', NINJA_HARI_KARI_FALL_RATE, nullptr, &s_NinjaHariKari[6]}, + {SPR_NINJA_HARI_KARI, 'E', NINJA_HARI_KARI_FALL_RATE, nullptr, &s_NinjaHariKari[7]}, + {SPR_NINJA_HARI_KARI, 'F', NINJA_HARI_KARI_FALL_RATE, nullptr, &s_NinjaHariKari[8]}, + {SPR_NINJA_HARI_KARI, 'G', NINJA_HARI_KARI_FALL_RATE, nullptr, &s_NinjaHariKari[9]}, + {SPR_NINJA_HARI_KARI, 'H', NINJA_HARI_KARI_FALL_RATE, nullptr, &s_NinjaHariKari[10]}, + {SPR_NINJA_HARI_KARI, 'H', NINJA_HARI_KARI_FALL_RATE, nullptr, &s_NinjaHariKari[10]}, }; STATE* sg_NinjaHariKari[] = { s_NinjaHariKari, - s_NinjaHariKari, - s_NinjaHariKari, - s_NinjaHariKari, - s_NinjaHariKari }; @@ -1370,25 +745,20 @@ STATE* sg_NinjaHariKari[] = ////////////////////// #define NINJA_GRAB_THROAT_RATE 32 -#define NINJA_GRAB_THROAT_R0 4237 STATE s_NinjaGrabThroat[] = { - {NINJA_GRAB_THROAT_R0 + 0, NINJA_GRAB_THROAT_RATE, &AF(NullNinja), &s_NinjaGrabThroat[1]}, - {NINJA_GRAB_THROAT_R0 + 0, SF_QUICK_CALL, &AF(DoNinjaSpecial), &s_NinjaGrabThroat[2]}, - {NINJA_GRAB_THROAT_R0 + 1, NINJA_GRAB_THROAT_RATE, &AF(NullNinja), &s_NinjaGrabThroat[3]}, - {NINJA_GRAB_THROAT_R0 + 2, SF_QUICK_CALL, &AF(DoNinjaGrabThroat), &s_NinjaGrabThroat[4]}, - {NINJA_GRAB_THROAT_R0 + 2, NINJA_GRAB_THROAT_RATE, &AF(NullNinja), &s_NinjaGrabThroat[5]}, - {NINJA_GRAB_THROAT_R0 + 1, NINJA_GRAB_THROAT_RATE, &AF(NullNinja), &s_NinjaGrabThroat[0]}, + {SPR_NINJA_GRAB_THROAT, 'A', NINJA_GRAB_THROAT_RATE, &AF(NullNinja), &s_NinjaGrabThroat[1]}, + {SPR_NINJA_GRAB_THROAT, 'A', SF_QUICK_CALL, &AF(DoNinjaSpecial), &s_NinjaGrabThroat[2]}, + {SPR_NINJA_GRAB_THROAT, 'B', NINJA_GRAB_THROAT_RATE, &AF(NullNinja), &s_NinjaGrabThroat[3]}, + {SPR_NINJA_GRAB_THROAT, 'C', SF_QUICK_CALL, &AF(DoNinjaGrabThroat), &s_NinjaGrabThroat[4]}, + {SPR_NINJA_GRAB_THROAT, 'C', NINJA_GRAB_THROAT_RATE, &AF(NullNinja), &s_NinjaGrabThroat[5]}, + {SPR_NINJA_GRAB_THROAT, 'B', NINJA_GRAB_THROAT_RATE, &AF(NullNinja), &s_NinjaGrabThroat[0]}, }; STATE* sg_NinjaGrabThroat[] = { s_NinjaGrabThroat, - s_NinjaGrabThroat, - s_NinjaGrabThroat, - s_NinjaGrabThroat, - s_NinjaGrabThroat }; @@ -1402,17 +772,17 @@ STATE* sg_NinjaGrabThroat[] = STATE s_NinjaDie[] = { - {NINJA_DIE + 0, NINJA_DIE_RATE, &AF(NullNinja), &s_NinjaDie[1]}, - {NINJA_DIE + 1, NINJA_DIE_RATE, &AF(NullNinja), &s_NinjaDie[2]}, - {NINJA_DIE + 2, NINJA_DIE_RATE, &AF(NullNinja), &s_NinjaDie[3]}, - {NINJA_DIE + 3, NINJA_DIE_RATE, &AF(NullNinja), &s_NinjaDie[4]}, - {NINJA_DIE + 4, NINJA_DIE_RATE, &AF(NullNinja), &s_NinjaDie[5]}, - {NINJA_DIE + 5, NINJA_DIE_RATE-4, &AF(NullNinja), &s_NinjaDie[6]}, - {NINJA_DIE + 6, NINJA_DIE_RATE-6, &AF(NullNinja), &s_NinjaDie[7]}, - {NINJA_DIE + 6, SF_QUICK_CALL, &AF(DoNinjaSpecial), &s_NinjaDie[8]}, - {NINJA_DIE + 6, NINJA_DIE_RATE-10, &AF(NullNinja), &s_NinjaDie[9]}, - {NINJA_DIE + 7, SF_QUICK_CALL, &AF(QueueFloorBlood), &s_NinjaDie[10]}, - {NINJA_DIE + 7, NINJA_DIE_RATE-12, &AF(DoActorDebris), &s_NinjaDie[10]}, + {SPR_NINJA_DIE, 'A', NINJA_DIE_RATE, &AF(NullNinja), &s_NinjaDie[1]}, + {SPR_NINJA_DIE, 'B', NINJA_DIE_RATE, &AF(NullNinja), &s_NinjaDie[2]}, + {SPR_NINJA_DIE, 'C', NINJA_DIE_RATE, &AF(NullNinja), &s_NinjaDie[3]}, + {SPR_NINJA_DIE, 'D', NINJA_DIE_RATE, &AF(NullNinja), &s_NinjaDie[4]}, + {SPR_NINJA_DIE, 'E', NINJA_DIE_RATE, &AF(NullNinja), &s_NinjaDie[5]}, + {SPR_NINJA_DIE, 'F', NINJA_DIE_RATE-4, &AF(NullNinja), &s_NinjaDie[6]}, + {SPR_NINJA_DIE, 'G', NINJA_DIE_RATE-6, &AF(NullNinja), &s_NinjaDie[7]}, + {SPR_NINJA_DIE, 'G', SF_QUICK_CALL, &AF(DoNinjaSpecial), &s_NinjaDie[8]}, + {SPR_NINJA_DIE, 'G', NINJA_DIE_RATE-10, &AF(NullNinja), &s_NinjaDie[9]}, + {SPR_NINJA_DIE, 'H', SF_QUICK_CALL, &AF(QueueFloorBlood), &s_NinjaDie[10]}, + {SPR_NINJA_DIE, 'H', NINJA_DIE_RATE-12, &AF(DoActorDebris), &s_NinjaDie[10]}, }; @@ -1420,57 +790,57 @@ STATE s_NinjaDie[] = STATE s_NinjaDieSliced[] = { - {NINJA_SLICED + 0, NINJA_DIESLICED_RATE*6, &AF(NullNinja), &s_NinjaDieSliced[1]}, - {NINJA_SLICED + 1, NINJA_DIESLICED_RATE, &AF(NullNinja), &s_NinjaDieSliced[2]}, - {NINJA_SLICED + 2, NINJA_DIESLICED_RATE, &AF(NullNinja), &s_NinjaDieSliced[3]}, - {NINJA_SLICED + 3, NINJA_DIESLICED_RATE, &AF(NullNinja), &s_NinjaDieSliced[4]}, - {NINJA_SLICED + 4, NINJA_DIESLICED_RATE-1, &AF(NullNinja), &s_NinjaDieSliced[5]}, - {NINJA_SLICED + 5, NINJA_DIESLICED_RATE-2, &AF(NullNinja), &s_NinjaDieSliced[6]}, - {NINJA_SLICED + 6, NINJA_DIESLICED_RATE-3, &AF(NullNinja), &s_NinjaDieSliced[7]}, - {NINJA_SLICED + 7, NINJA_DIESLICED_RATE-4, &AF(NullNinja), &s_NinjaDieSliced[8]}, - {NINJA_SLICED + 7, SF_QUICK_CALL, &AF(DoNinjaSpecial), &s_NinjaDieSliced[9]}, - {NINJA_SLICED + 8, NINJA_DIESLICED_RATE-5, &AF(NullNinja), &s_NinjaDieSliced[10]}, - {NINJA_SLICED + 9, SF_QUICK_CALL, &AF(QueueFloorBlood), &s_NinjaDieSliced[11]}, - {NINJA_SLICED + 9, NINJA_DIESLICED_RATE, &AF(DoActorDebris), &s_NinjaDieSliced[11]}, + {SPR_NINJA_SLICED, 'A', NINJA_DIESLICED_RATE*6, &AF(NullNinja), &s_NinjaDieSliced[1]}, + {SPR_NINJA_SLICED, 'B', NINJA_DIESLICED_RATE, &AF(NullNinja), &s_NinjaDieSliced[2]}, + {SPR_NINJA_SLICED, 'C', NINJA_DIESLICED_RATE, &AF(NullNinja), &s_NinjaDieSliced[3]}, + {SPR_NINJA_SLICED, 'D', NINJA_DIESLICED_RATE, &AF(NullNinja), &s_NinjaDieSliced[4]}, + {SPR_NINJA_SLICED, 'E', NINJA_DIESLICED_RATE-1, &AF(NullNinja), &s_NinjaDieSliced[5]}, + {SPR_NINJA_SLICED, 'F', NINJA_DIESLICED_RATE-2, &AF(NullNinja), &s_NinjaDieSliced[6]}, + {SPR_NINJA_SLICED, 'G', NINJA_DIESLICED_RATE-3, &AF(NullNinja), &s_NinjaDieSliced[7]}, + {SPR_NINJA_SLICED, 'H', NINJA_DIESLICED_RATE-4, &AF(NullNinja), &s_NinjaDieSliced[8]}, + {SPR_NINJA_SLICED, 'H', SF_QUICK_CALL, &AF(DoNinjaSpecial), &s_NinjaDieSliced[9]}, + {SPR_NINJA_SLICED, 'I', NINJA_DIESLICED_RATE-5, &AF(NullNinja), &s_NinjaDieSliced[10]}, + {SPR_NINJA_SLICED, 'J', SF_QUICK_CALL, &AF(QueueFloorBlood), &s_NinjaDieSliced[11]}, + {SPR_NINJA_SLICED, 'J', NINJA_DIESLICED_RATE, &AF(DoActorDebris), &s_NinjaDieSliced[11]}, }; STATE s_NinjaDieSlicedHack[] = { - {NINJA_SLICED_HACK + 0, NINJA_DIESLICED_RATE*6, &AF(NullNinja), &s_NinjaDieSlicedHack[1]}, - {NINJA_SLICED_HACK + 1, NINJA_DIESLICED_RATE, &AF(NullNinja), &s_NinjaDieSlicedHack[2]}, - {NINJA_SLICED_HACK + 2, NINJA_DIESLICED_RATE, &AF(NullNinja), &s_NinjaDieSlicedHack[3]}, - {NINJA_SLICED_HACK + 3, NINJA_DIESLICED_RATE, &AF(NullNinja), &s_NinjaDieSlicedHack[4]}, - {NINJA_SLICED_HACK + 4, NINJA_DIESLICED_RATE-1, &AF(NullNinja), &s_NinjaDieSlicedHack[5]}, - {NINJA_SLICED_HACK + 4, NINJA_DIESLICED_RATE-2, &AF(NullNinja), &s_NinjaDieSlicedHack[6]}, - {NINJA_SLICED_HACK + 5, NINJA_DIESLICED_RATE-3, &AF(NullNinja), &s_NinjaDieSlicedHack[7]}, - {NINJA_SLICED_HACK + 5, NINJA_DIESLICED_RATE-4, &AF(NullNinja), &s_NinjaDieSlicedHack[8]}, - {NINJA_SLICED_HACK + 6, SF_QUICK_CALL , &AF(DoNinjaSpecial), &s_NinjaDieSlicedHack[9]}, - {NINJA_SLICED_HACK + 6, NINJA_DIESLICED_RATE-5, &AF(NullNinja), &s_NinjaDieSlicedHack[10]}, - {NINJA_SLICED_HACK + 7, SF_QUICK_CALL , &AF(QueueFloorBlood), &s_NinjaDieSlicedHack[11]}, - {NINJA_SLICED_HACK + 7, NINJA_DIESLICED_RATE-6, &AF(DoActorDebris), &s_NinjaDieSlicedHack[11]}, + {SPR_NINJA_SLICED_HACK, 'A', NINJA_DIESLICED_RATE*6, &AF(NullNinja), &s_NinjaDieSlicedHack[1]}, + {SPR_NINJA_SLICED_HACK, 'B', NINJA_DIESLICED_RATE, &AF(NullNinja), &s_NinjaDieSlicedHack[2]}, + {SPR_NINJA_SLICED_HACK, 'C', NINJA_DIESLICED_RATE, &AF(NullNinja), &s_NinjaDieSlicedHack[3]}, + {SPR_NINJA_SLICED_HACK, 'D', NINJA_DIESLICED_RATE, &AF(NullNinja), &s_NinjaDieSlicedHack[4]}, + {SPR_NINJA_SLICED_HACK, 'E', NINJA_DIESLICED_RATE-1, &AF(NullNinja), &s_NinjaDieSlicedHack[5]}, + {SPR_NINJA_SLICED_HACK, 'E', NINJA_DIESLICED_RATE-2, &AF(NullNinja), &s_NinjaDieSlicedHack[6]}, + {SPR_NINJA_SLICED_HACK, 'F', NINJA_DIESLICED_RATE-3, &AF(NullNinja), &s_NinjaDieSlicedHack[7]}, + {SPR_NINJA_SLICED_HACK, 'F', NINJA_DIESLICED_RATE-4, &AF(NullNinja), &s_NinjaDieSlicedHack[8]}, + {SPR_NINJA_SLICED_HACK, 'G', SF_QUICK_CALL , &AF(DoNinjaSpecial), &s_NinjaDieSlicedHack[9]}, + {SPR_NINJA_SLICED_HACK, 'G', NINJA_DIESLICED_RATE-5, &AF(NullNinja), &s_NinjaDieSlicedHack[10]}, + {SPR_NINJA_SLICED_HACK, 'H', SF_QUICK_CALL , &AF(QueueFloorBlood), &s_NinjaDieSlicedHack[11]}, + {SPR_NINJA_SLICED_HACK, 'H', NINJA_DIESLICED_RATE-6, &AF(DoActorDebris), &s_NinjaDieSlicedHack[11]}, }; STATE s_NinjaDead[] = { - {NINJA_DIE + 5, NINJA_DIE_RATE, &AF(DoActorDebris), &s_NinjaDead[1]}, - {NINJA_DIE + 6, SF_QUICK_CALL, &AF(DoNinjaSpecial), &s_NinjaDead[2]}, - {NINJA_DIE + 6, NINJA_DIE_RATE, &AF(DoActorDebris), &s_NinjaDead[3]}, - {NINJA_DIE + 7, SF_QUICK_CALL, &AF(QueueFloorBlood),&s_NinjaDead[4]}, - {NINJA_DIE + 7, NINJA_DIE_RATE, &AF(DoActorDebris), &s_NinjaDead[4]}, + {SPR_NINJA_DIE, 'F', NINJA_DIE_RATE, &AF(DoActorDebris), &s_NinjaDead[1]}, + {SPR_NINJA_DIE, 'G', SF_QUICK_CALL, &AF(DoNinjaSpecial), &s_NinjaDead[2]}, + {SPR_NINJA_DIE, 'G', NINJA_DIE_RATE, &AF(DoActorDebris), &s_NinjaDead[3]}, + {SPR_NINJA_DIE, 'H', SF_QUICK_CALL, &AF(QueueFloorBlood),&s_NinjaDead[4]}, + {SPR_NINJA_DIE, 'H', NINJA_DIE_RATE, &AF(DoActorDebris), &s_NinjaDead[4]}, }; STATE s_NinjaDeathJump[] = { - {NINJA_DIE + 0, NINJA_DIE_RATE, &AF(DoActorDeathMove), &s_NinjaDeathJump[1]}, - {NINJA_DIE + 1, NINJA_DIE_RATE, &AF(DoActorDeathMove), &s_NinjaDeathJump[2]}, - {NINJA_DIE + 2, NINJA_DIE_RATE, &AF(DoActorDeathMove), &s_NinjaDeathJump[2]}, + {SPR_NINJA_DIE, 'A', NINJA_DIE_RATE, &AF(DoActorDeathMove), &s_NinjaDeathJump[1]}, + {SPR_NINJA_DIE, 'B', NINJA_DIE_RATE, &AF(DoActorDeathMove), &s_NinjaDeathJump[2]}, + {SPR_NINJA_DIE, 'C', NINJA_DIE_RATE, &AF(DoActorDeathMove), &s_NinjaDeathJump[2]}, }; STATE s_NinjaDeathFall[] = { - {NINJA_DIE + 3, NINJA_DIE_RATE, &AF(DoActorDeathMove), &s_NinjaDeathFall[1]}, - {NINJA_DIE + 4, NINJA_DIE_RATE, &AF(DoActorDeathMove), &s_NinjaDeathFall[1]}, + {SPR_NINJA_DIE, 'D', NINJA_DIE_RATE, &AF(DoActorDeathMove), &s_NinjaDeathFall[1]}, + {SPR_NINJA_DIE, 'E', NINJA_DIE_RATE, &AF(DoActorDeathMove), &s_NinjaDeathFall[1]}, }; /* @@ -2356,7 +1726,7 @@ void InitPlayerSprite(PLAYER* pp, const DVector3& spawnpos, const DAngle startan actor->user.Flags |= (SPR_XFLIP_TOGGLE); - actor->spr.picnum = actor->user.__legacyState.State->Pic; + actor->setPicFromState(); actor->spr.shade = -60; // was 15 actor->clipdist = 16; diff --git a/source/games/sw/src/player.cpp b/source/games/sw/src/player.cpp index e5a3d98ba1..cb4420b168 100644 --- a/source/games/sw/src/player.cpp +++ b/source/games/sw/src/player.cpp @@ -187,48 +187,16 @@ extern short target_ang; #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]}, }, }; @@ -236,10 +204,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 @@ -251,31 +215,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] }; @@ -286,37 +234,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 @@ -324,10 +248,6 @@ STATE s_PlayerNinjaThrow[5][4] = STATE* sg_PlayerNinjaThrow[] = { s_PlayerNinjaThrow[0], - s_PlayerNinjaThrow[1], - s_PlayerNinjaThrow[2], - s_PlayerNinjaThrow[3], - s_PlayerNinjaThrow[4] }; ////////////////////// @@ -338,37 +258,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]}, }, }; @@ -376,10 +272,6 @@ STATE s_PlayerNinjaJump[5][4] = STATE* sg_PlayerNinjaJump[] = { s_PlayerNinjaJump[0], - s_PlayerNinjaJump[1], - s_PlayerNinjaJump[2], - s_PlayerNinjaJump[3], - s_PlayerNinjaJump[4] }; @@ -391,27 +283,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]}, }, }; @@ -419,10 +295,6 @@ STATE s_PlayerNinjaFall[5][2] = STATE* sg_PlayerNinjaFall[] = { s_PlayerNinjaFall[0], - s_PlayerNinjaFall[1], - s_PlayerNinjaFall[2], - s_PlayerNinjaFall[3], - s_PlayerNinjaFall[4] }; ////////////////////// @@ -433,47 +305,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] }; ////////////////////// @@ -484,47 +328,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]}, }, }; @@ -532,10 +344,6 @@ STATE s_PlayerNinjaCrawl[5][6] = STATE* sg_PlayerNinjaCrawl[] = { s_PlayerNinjaCrawl[0], - s_PlayerNinjaCrawl[1], - s_PlayerNinjaCrawl[2], - s_PlayerNinjaCrawl[3], - s_PlayerNinjaCrawl[4] }; ////////////////////// @@ -546,37 +354,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]}, }, }; @@ -584,224 +368,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] }; ////////////////////// @@ -812,37 +450,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]}, }, }; @@ -850,10 +464,6 @@ STATE s_PlayerNinjaSword[5][4] = STATE* sg_PlayerNinjaSword[] = { s_PlayerNinjaSword[0], - s_PlayerNinjaSword[1], - s_PlayerNinjaSword[2], - s_PlayerNinjaSword[3], - s_PlayerNinjaSword[4] }; ////////////////////// @@ -864,32 +474,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]}, }, }; @@ -897,10 +487,6 @@ STATE s_PlayerNinjaPunch[5][4] = STATE* sg_PlayerNinjaPunch[] = { s_PlayerNinjaPunch[0], - s_PlayerNinjaPunch[1], - s_PlayerNinjaPunch[2], - s_PlayerNinjaPunch[3], - s_PlayerNinjaPunch[4] }; ////////////////////// @@ -911,28 +497,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]}, }, }; @@ -940,10 +509,6 @@ STATE s_PlayerNinjaFly[5][4] = STATE* sg_PlayerNinjaFly[] = { s_PlayerNinjaFly[0], - s_PlayerNinjaFly[1], - s_PlayerNinjaFly[2], - s_PlayerNinjaFly[3], - s_PlayerNinjaFly[4] }; //--------------------------------------------------------------------------- @@ -5870,7 +5435,7 @@ void DoPlayerDeathCheckKeys(PLAYER* pp) } plActor->setStateGroup(NAME_Stand); - plActor->spr.picnum = plActor->user.__legacyState.State->Pic; + plActor->setPicFromState(); plActor->spr.cstat &= ~(CSTAT_SPRITE_YCENTER); //DoSpawnTeleporterEffect(plActor); @@ -6507,17 +6072,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)) diff --git a/source/games/sw/src/ripper.cpp b/source/games/sw/src/ripper.cpp index 8889f70b31..4ae5b43674 100644 --- a/source/games/sw/src/ripper.cpp +++ b/source/games/sw/src/ripper.cpp @@ -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]}, - }, - { - {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]}, + {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_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]}, - }, - { - {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]}, + {SPR_RIPPER_HEART, 'A', RIPPER_HEART_RATE, &AF(DoRipperStandHeart), &s_RipperHeart[0][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]}, - }, - { - {RIPPER_HANG_R1 + 0, RIPPER_HANG_RATE, &AF(DoRipperHang), &s_RipperHang[1][0]}, + {SPR_RIPPER_HANG, 'A', RIPPER_HANG_RATE, &AF(DoRipperHang), &s_RipperHang[0][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]}, - }, - { - {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]}, + {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_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]}, - }, - { - {RIPPER_FALL_R1 + 0, RIPPER_FALL_RATE, &AF(DoRipperMoveJump), &s_RipperFall[1][0]}, + {SPR_RIPPER_FALL, 'A', RIPPER_FALL_RATE, &AF(DoRipperMoveJump), &s_RipperFall[0][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]}, - }, - { - {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]}, + {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_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]}, - }, - { - {RIPPER_FALL_R1 + 0, RIPPER_FALL_RATE, &AF(DoRipperHangJF), &s_RipperHangFall[1][0]}, + {SPR_RIPPER_FALL, 'A', RIPPER_FALL_RATE, &AF(DoRipperHangJF), &s_RipperHangFall[0][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]} }; diff --git a/source/games/sw/src/ripper2.cpp b/source/games/sw/src/ripper2.cpp index 531db7997c..30aadd4292 100644 --- a/source/games/sw/src/ripper2.cpp +++ b/source/games/sw/src/ripper2.cpp @@ -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]}, - }, - { - {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]}, + {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_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]}, - }, - { - {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]}, + {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_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]}, - }, - { - {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]}, + {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_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]}, - }, - { - {RIPPER2_HANG_R1, RIPPER2_HANG_RATE, &AF(DoRipper2Hang), &s_Ripper2Hang[1][0]}, - }, - { - {RIPPER2_HANG_R2, RIPPER2_HANG_RATE, &AF(DoRipper2Hang), &s_Ripper2Hang[2][0]}, + {SPR_RIPPER2_HANG, 'A', RIPPER2_HANG_RATE, &AF(DoRipper2Hang), &s_Ripper2Hang[0][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]}, - }, - { - {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]}, + {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_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]}, - }, - { - {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]}, + {SPR_RIPPER2_FALL, 'A', RIPPER2_FALL_RATE, &AF(DoRipper2MoveJump), &s_Ripper2Fall[0][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]}, - }, - { - {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]}, + {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_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]}, - }, - { - {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]}, + {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_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]}, - }, - { - {RIPPER2_FALL_R1 + 0, RIPPER2_FALL_RATE, &AF(DoRipper2HangJF), &s_Ripper2HangFall[1][0]}, + {SPR_RIPPER2_FALL, 'A', RIPPER2_FALL_RATE, &AF(DoRipper2HangJF), &s_Ripper2HangFall[0][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]} }; diff --git a/source/games/sw/src/serp.cpp b/source/games/sw/src/serp.cpp index 9b9c29b834..c06c29b8dd 100644 --- a/source/games/sw/src/serp.cpp +++ b/source/games/sw/src/serp.cpp @@ -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]}, - }, - { - {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]}, + {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_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]}, - }, - { - {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]}, + {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_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]}, - }, - { - {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]}, + {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_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]}, - }, - { - {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]}, + {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_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]}, - }, - { - {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]}, + {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_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[] = diff --git a/source/games/sw/src/skel.cpp b/source/games/sw/src/skel.cpp index 455fb8a9b8..f6f138a54e 100644 --- a/source/games/sw/src/skel.cpp +++ b/source/games/sw/src/skel.cpp @@ -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]}, - }, - { - {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]}, + {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_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]}, - }, - { - {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]}, + {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_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]}, - }, - { - {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]}, + {SPR_SKEL_PAIN, 'A', SKEL_PAIN_RATE, &AF(DoSkelPain), &s_SkelPain[0][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[] = diff --git a/source/games/sw/src/skull.cpp b/source/games/sw/src/skull.cpp index 3ecc293f55..f2fd123b8f 100644 --- a/source/games/sw/src/skull.cpp +++ b/source/games/sw/src/skull.cpp @@ -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]}, - }, - { - {SKULL_R1 + 0, SKULL_RATE, &AF(DoSerpRing), &s_SkullRing[1][0]}, + {SPR_SKULL, 'A', SKULL_RATE, &AF(DoSerpRing), &s_SkullRing[0][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]}, - }, - { - {SKULL_R1 + 0, SKULL_RATE, &AF(DoSkullJump), &s_SkullJump[1][0]}, - }, - { - {SKULL_R2 + 0, SKULL_RATE, &AF(DoSkullJump), &s_SkullJump[2][0]}, + {SPR_SKULL, 'A', SKULL_RATE, &AF(DoSkullJump), &s_SkullJump[0][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[] = @@ -505,43 +457,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]}, - }, - { - {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]}, + {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_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 = @@ -558,33 +486,17 @@ ATTRIBUTE BettyAttrib = // ////////////////////// -STATE s_BettyJump[5][1] = +STATE s_BettyJump[1][1] = { { - {BETTY_R0 + 0, 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]}, + {SPR_BETTY, 'A', BETTY_RATE, &AF(DoBettyJump), &s_BettyJump[0][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] }; @@ -599,8 +511,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[] = diff --git a/source/games/sw/src/sprite.cpp b/source/games/sw/src/sprite.cpp index c80318bffc..4f0d9f75d1 100644 --- a/source/games/sw/src/sprite.cpp +++ b/source/games/sw/src/sprite.cpp @@ -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 } @@ -4145,12 +4141,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 @@ -4186,8 +4184,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; @@ -5958,7 +5956,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); } @@ -5968,17 +5966,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 diff --git a/source/games/sw/src/sumo.cpp b/source/games/sw/src/sumo.cpp index c83f91d76f..2c02f43953 100644 --- a/source/games/sw/src/sumo.cpp +++ b/source/games/sw/src/sumo.cpp @@ -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]} - }, - { - {SUMO_RUN_R1 + 0, SUMO_RATE, &AF(DoSumoMove), &s_SumoStand[1][0]} - }, - { - {SUMO_RUN_R2 + 0, SUMO_RATE, &AF(DoSumoMove), &s_SumoStand[2][0]} + {SPR_SUMO_RUN, 'A', SUMO_RATE, &AF(DoSumoMove), &s_SumoStand[0][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]} - }, - { - {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]} + {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_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]} - }, - { - {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]} + {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_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]} - }, - { - {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]} + {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_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[] = diff --git a/source/games/sw/src/swactor.h b/source/games/sw/src/swactor.h index 03aec3a49c..4994fd9f59 100644 --- a/source/games/sw/src/swactor.h +++ b/source/games/sw/src/swactor.h @@ -6,6 +6,13 @@ BEGIN_SW_NS struct Personality; +FTextureID picFromState(STATE* s) +{ + // todo + return FNullTextureID(); +} + + class DSWActor : public DCoreActor { DECLARE_CLASS(DSWActor, DCoreActor) @@ -55,8 +62,7 @@ class DSWActor : public DCoreActor void callAction(); void callStateAction(); int callFunction(VMFunction* func); - - + void setPicFromState() { spr.setspritetexture(picFromState(user.__legacyState.State)); } }; inline void UpdateChangeXY(DSWActor* actor) diff --git a/source/games/sw/src/weapon.cpp b/source/games/sw/src/weapon.cpp index dc85472559..586421d366 100644 --- a/source/games/sw/src/weapon.cpp +++ b/source/games/sw/src/weapon.cpp @@ -154,17 +154,17 @@ short StatDamageList[STAT_DAMAGE_LIST_SIZE] = // state for sprites that are not restored STATE s_NotRestored[] = { - {2323, 100, nullptr, &s_NotRestored[0]} + {SPR_NOTRESTORED, 'A', 100, nullptr, &s_NotRestored[0]} }; STATE s_Suicide[] = { - {1, 100, &AF(DoSuicide), &s_Suicide[0]} + {SPR_SUICIDES, 'A', 100, &AF(DoSuicide), &s_Suicide[0]} }; STATE s_DeadLoWang[] = { - {1160, 100, nullptr, &s_DeadLoWang[0]}, + {SPR_DEADLOWANG, 'A', 100, nullptr, &s_DeadLoWang[0]}, }; ////////////////////// @@ -176,191 +176,141 @@ STATE s_DeadLoWang[] = #define BREAK_LIGHT_RATE 18 STATE s_BreakLight[] = { - {BREAK_LIGHT_ANIM + 0, BREAK_LIGHT_RATE, nullptr, &s_BreakLight[1]}, - {BREAK_LIGHT_ANIM + 1, BREAK_LIGHT_RATE, nullptr, &s_BreakLight[2]}, - {BREAK_LIGHT_ANIM + 2, BREAK_LIGHT_RATE, nullptr, &s_BreakLight[3]}, - {BREAK_LIGHT_ANIM + 3, BREAK_LIGHT_RATE, nullptr, &s_BreakLight[4]}, - {BREAK_LIGHT_ANIM + 4, BREAK_LIGHT_RATE, nullptr, &s_BreakLight[5]}, - {BREAK_LIGHT_ANIM + 5, BREAK_LIGHT_RATE, nullptr, &s_BreakLight[5]} + {SPR_BREAK_LIGHT_ANIM, 'A', BREAK_LIGHT_RATE, nullptr, &s_BreakLight[1]}, + {SPR_BREAK_LIGHT_ANIM, 'B', BREAK_LIGHT_RATE, nullptr, &s_BreakLight[2]}, + {SPR_BREAK_LIGHT_ANIM, 'C', BREAK_LIGHT_RATE, nullptr, &s_BreakLight[3]}, + {SPR_BREAK_LIGHT_ANIM, 'D', BREAK_LIGHT_RATE, nullptr, &s_BreakLight[4]}, + {SPR_BREAK_LIGHT_ANIM, 'E', BREAK_LIGHT_RATE, nullptr, &s_BreakLight[5]}, + {SPR_BREAK_LIGHT_ANIM, 'F', BREAK_LIGHT_RATE, nullptr, &s_BreakLight[5]} }; #define BREAK_BARREL_RATE 18 STATE s_BreakBarrel[] = { - {BREAK_BARREL + 4, BREAK_BARREL_RATE, nullptr, &s_BreakBarrel[1]}, - {BREAK_BARREL + 5, BREAK_BARREL_RATE, nullptr, &s_BreakBarrel[2]}, - {BREAK_BARREL + 6, BREAK_BARREL_RATE, nullptr, &s_BreakBarrel[3]}, - {BREAK_BARREL + 7, BREAK_BARREL_RATE, nullptr, &s_BreakBarrel[4]}, - {BREAK_BARREL + 8, BREAK_BARREL_RATE, nullptr, &s_BreakBarrel[5]}, - {BREAK_BARREL + 9, BREAK_BARREL_RATE, &AF(DoDefaultStat), &s_BreakBarrel[5]}, + {SPR_BREAK_BARREL, 'E', BREAK_BARREL_RATE, nullptr, &s_BreakBarrel[1]}, + {SPR_BREAK_BARREL, 'F', BREAK_BARREL_RATE, nullptr, &s_BreakBarrel[2]}, + {SPR_BREAK_BARREL, 'G', BREAK_BARREL_RATE, nullptr, &s_BreakBarrel[3]}, + {SPR_BREAK_BARREL, 'H', BREAK_BARREL_RATE, nullptr, &s_BreakBarrel[4]}, + {SPR_BREAK_BARREL, 'I', BREAK_BARREL_RATE, nullptr, &s_BreakBarrel[5]}, + {SPR_BREAK_BARREL, 'J', BREAK_BARREL_RATE, &AF(DoDefaultStat), &s_BreakBarrel[5]}, }; #define BREAK_PEDISTAL_RATE 28 STATE s_BreakPedistal[] = { - {BREAK_PEDISTAL + 1, BREAK_PEDISTAL_RATE, nullptr, &s_BreakPedistal[1]}, - {BREAK_PEDISTAL + 2, BREAK_PEDISTAL_RATE, nullptr, &s_BreakPedistal[2]}, - {BREAK_PEDISTAL + 3, BREAK_PEDISTAL_RATE, nullptr, &s_BreakPedistal[3]}, - {BREAK_PEDISTAL + 4, BREAK_PEDISTAL_RATE, nullptr, &s_BreakPedistal[3]}, + {SPR_BREAK_PEDISTAL, 'B', BREAK_PEDISTAL_RATE, nullptr, &s_BreakPedistal[1]}, + {SPR_BREAK_PEDISTAL, 'C', BREAK_PEDISTAL_RATE, nullptr, &s_BreakPedistal[2]}, + {SPR_BREAK_PEDISTAL, 'D', BREAK_PEDISTAL_RATE, nullptr, &s_BreakPedistal[3]}, + {SPR_BREAK_PEDISTAL, 'E', BREAK_PEDISTAL_RATE, nullptr, &s_BreakPedistal[3]}, }; #define BREAK_BOTTLE1_RATE 18 STATE s_BreakBottle1[] = { - {BREAK_BOTTLE1 + 1, BREAK_BOTTLE1_RATE, nullptr, &s_BreakBottle1[1]}, - {BREAK_BOTTLE1 + 2, BREAK_BOTTLE1_RATE, nullptr, &s_BreakBottle1[2]}, - {BREAK_BOTTLE1 + 3, BREAK_BOTTLE1_RATE, nullptr, &s_BreakBottle1[3]}, - {BREAK_BOTTLE1 + 4, BREAK_BOTTLE1_RATE, nullptr, &s_BreakBottle1[4]}, - {BREAK_BOTTLE1 + 5, BREAK_BOTTLE1_RATE, nullptr, &s_BreakBottle1[5]}, - {BREAK_BOTTLE1 + 6, BREAK_BOTTLE1_RATE, nullptr, &s_BreakBottle1[5]}, + {SPR_BREAK_BOTTLE1, 'B', BREAK_BOTTLE1_RATE, nullptr, &s_BreakBottle1[1]}, + {SPR_BREAK_BOTTLE1, 'C', BREAK_BOTTLE1_RATE, nullptr, &s_BreakBottle1[2]}, + {SPR_BREAK_BOTTLE1, 'D', BREAK_BOTTLE1_RATE, nullptr, &s_BreakBottle1[3]}, + {SPR_BREAK_BOTTLE1, 'E', BREAK_BOTTLE1_RATE, nullptr, &s_BreakBottle1[4]}, + {SPR_BREAK_BOTTLE1, 'F', BREAK_BOTTLE1_RATE, nullptr, &s_BreakBottle1[5]}, + {SPR_BREAK_BOTTLE1, 'G', BREAK_BOTTLE1_RATE, nullptr, &s_BreakBottle1[5]}, }; #define BREAK_BOTTLE2_RATE 18 STATE s_BreakBottle2[] = { - {BREAK_BOTTLE2 + 1, BREAK_BOTTLE2_RATE, nullptr, &s_BreakBottle2[1]}, - {BREAK_BOTTLE2 + 2, BREAK_BOTTLE2_RATE, nullptr, &s_BreakBottle2[2]}, - {BREAK_BOTTLE2 + 3, BREAK_BOTTLE2_RATE, nullptr, &s_BreakBottle2[3]}, - {BREAK_BOTTLE2 + 4, BREAK_BOTTLE2_RATE, nullptr, &s_BreakBottle2[4]}, - {BREAK_BOTTLE2 + 5, BREAK_BOTTLE2_RATE, nullptr, &s_BreakBottle2[5]}, - {BREAK_BOTTLE2 + 6, BREAK_BOTTLE2_RATE, nullptr, &s_BreakBottle2[5]}, + {SPR_BREAK_BOTTLE2, 'B', BREAK_BOTTLE2_RATE, nullptr, &s_BreakBottle2[1]}, + {SPR_BREAK_BOTTLE2, 'C', BREAK_BOTTLE2_RATE, nullptr, &s_BreakBottle2[2]}, + {SPR_BREAK_BOTTLE2, 'D', BREAK_BOTTLE2_RATE, nullptr, &s_BreakBottle2[3]}, + {SPR_BREAK_BOTTLE2, 'E', BREAK_BOTTLE2_RATE, nullptr, &s_BreakBottle2[4]}, + {SPR_BREAK_BOTTLE2, 'F', BREAK_BOTTLE2_RATE, nullptr, &s_BreakBottle2[5]}, + {SPR_BREAK_BOTTLE2, 'G', BREAK_BOTTLE2_RATE, nullptr, &s_BreakBottle2[5]}, }; #define PUFF_RATE 8 STATE s_Puff[] = { - {PUFF + 0, PUFF_RATE, &AF(DoPuff), &s_Puff[1]}, - {PUFF + 1, PUFF_RATE, &AF(DoPuff), &s_Puff[2]}, - {PUFF + 2, PUFF_RATE, &AF(DoPuff), &s_Puff[3]}, - {PUFF + 3, PUFF_RATE, &AF(DoPuff), &s_Puff[4]}, - {PUFF + 4, PUFF_RATE, &AF(DoPuff), &s_Puff[5]}, - {PUFF + 5, PUFF_RATE, &AF(DoPuff), &s_Puff[6]}, - {PUFF + 5, 100, &AF(DoSuicide), &s_Puff[0]} + {SPR_PUFF, 'A', PUFF_RATE, &AF(DoPuff), &s_Puff[1]}, + {SPR_PUFF, 'B', PUFF_RATE, &AF(DoPuff), &s_Puff[2]}, + {SPR_PUFF, 'C', PUFF_RATE, &AF(DoPuff), &s_Puff[3]}, + {SPR_PUFF, 'D', PUFF_RATE, &AF(DoPuff), &s_Puff[4]}, + {SPR_PUFF, 'E', PUFF_RATE, &AF(DoPuff), &s_Puff[5]}, + {SPR_PUFF, 'F', PUFF_RATE, &AF(DoPuff), &s_Puff[6]}, + {SPR_PUFF, 'F', 100, &AF(DoSuicide), &s_Puff[0]} }; -#define RAIL_PUFF_R0 3969 -#define RAIL_PUFF_R1 3985 -#define RAIL_PUFF_R2 4001 #define RAIL_PUFF_RATE 6 STATE s_RailPuff[3][17] = { { - {RAIL_PUFF_R0 + 0, RAIL_PUFF_RATE, &AF(DoRailPuff), &s_RailPuff[0][1]}, - {RAIL_PUFF_R0 + 1, RAIL_PUFF_RATE, &AF(DoRailPuff), &s_RailPuff[0][2]}, - {RAIL_PUFF_R0 + 2, RAIL_PUFF_RATE, &AF(DoRailPuff), &s_RailPuff[0][3]}, - {RAIL_PUFF_R0 + 3, RAIL_PUFF_RATE, &AF(DoRailPuff), &s_RailPuff[0][4]}, - {RAIL_PUFF_R0 + 4, RAIL_PUFF_RATE, &AF(DoRailPuff), &s_RailPuff[0][5]}, - {RAIL_PUFF_R0 + 5, RAIL_PUFF_RATE, &AF(DoRailPuff), &s_RailPuff[0][6]}, - {RAIL_PUFF_R0 + 6, RAIL_PUFF_RATE, &AF(DoRailPuff), &s_RailPuff[0][7]}, - {RAIL_PUFF_R0 + 7, RAIL_PUFF_RATE, &AF(DoRailPuff), &s_RailPuff[0][8]}, - {RAIL_PUFF_R0 + 8, RAIL_PUFF_RATE, &AF(DoRailPuff), &s_RailPuff[0][9]}, - {RAIL_PUFF_R0 + 9, RAIL_PUFF_RATE, &AF(DoRailPuff), &s_RailPuff[0][10]}, - {RAIL_PUFF_R0 + 10, RAIL_PUFF_RATE, &AF(DoRailPuff), &s_RailPuff[0][11]}, - {RAIL_PUFF_R0 + 11, RAIL_PUFF_RATE, &AF(DoRailPuff), &s_RailPuff[0][12]}, - {RAIL_PUFF_R0 + 12, RAIL_PUFF_RATE, &AF(DoRailPuff), &s_RailPuff[0][13]}, - {RAIL_PUFF_R0 + 13, RAIL_PUFF_RATE, &AF(DoRailPuff), &s_RailPuff[0][14]}, - {RAIL_PUFF_R0 + 14, RAIL_PUFF_RATE, &AF(DoRailPuff), &s_RailPuff[0][15]}, - {RAIL_PUFF_R0 + 15, RAIL_PUFF_RATE, &AF(DoRailPuff), &s_RailPuff[0][16]}, - {RAIL_PUFF_R0 + 15, 100, &AF(DoSuicide), &s_RailPuff[0][0]}, + {SPR_RAIL_PUFF, 'A', RAIL_PUFF_RATE, &AF(DoRailPuff), &s_RailPuff[0][1]}, + {SPR_RAIL_PUFF, 'B', RAIL_PUFF_RATE, &AF(DoRailPuff), &s_RailPuff[0][2]}, + {SPR_RAIL_PUFF, 'C', RAIL_PUFF_RATE, &AF(DoRailPuff), &s_RailPuff[0][3]}, + {SPR_RAIL_PUFF, 'D', RAIL_PUFF_RATE, &AF(DoRailPuff), &s_RailPuff[0][4]}, + {SPR_RAIL_PUFF, 'E', RAIL_PUFF_RATE, &AF(DoRailPuff), &s_RailPuff[0][5]}, + {SPR_RAIL_PUFF, 'F', RAIL_PUFF_RATE, &AF(DoRailPuff), &s_RailPuff[0][6]}, + {SPR_RAIL_PUFF, 'G', RAIL_PUFF_RATE, &AF(DoRailPuff), &s_RailPuff[0][7]}, + {SPR_RAIL_PUFF, 'H', RAIL_PUFF_RATE, &AF(DoRailPuff), &s_RailPuff[0][8]}, + {SPR_RAIL_PUFF, 'I', RAIL_PUFF_RATE, &AF(DoRailPuff), &s_RailPuff[0][9]}, + {SPR_RAIL_PUFF, 'J', RAIL_PUFF_RATE, &AF(DoRailPuff), &s_RailPuff[0][10]}, + {SPR_RAIL_PUFF, 'K', RAIL_PUFF_RATE, &AF(DoRailPuff), &s_RailPuff[0][11]}, + {SPR_RAIL_PUFF, 'L', RAIL_PUFF_RATE, &AF(DoRailPuff), &s_RailPuff[0][12]}, + {SPR_RAIL_PUFF, 'M', RAIL_PUFF_RATE, &AF(DoRailPuff), &s_RailPuff[0][13]}, + {SPR_RAIL_PUFF, 'N', RAIL_PUFF_RATE, &AF(DoRailPuff), &s_RailPuff[0][14]}, + {SPR_RAIL_PUFF, 'O', RAIL_PUFF_RATE, &AF(DoRailPuff), &s_RailPuff[0][15]}, + {SPR_RAIL_PUFF, 'P', RAIL_PUFF_RATE, &AF(DoRailPuff), &s_RailPuff[0][16]}, + {SPR_RAIL_PUFF, 'P', 100, &AF(DoSuicide), &s_RailPuff[0][0]}, }, - { - {RAIL_PUFF_R1 + 0, RAIL_PUFF_RATE, &AF(DoRailPuff), &s_RailPuff[1][1]}, - {RAIL_PUFF_R1 + 1, RAIL_PUFF_RATE, &AF(DoRailPuff), &s_RailPuff[1][2]}, - {RAIL_PUFF_R1 + 2, RAIL_PUFF_RATE, &AF(DoRailPuff), &s_RailPuff[1][3]}, - {RAIL_PUFF_R1 + 3, RAIL_PUFF_RATE, &AF(DoRailPuff), &s_RailPuff[1][4]}, - {RAIL_PUFF_R1 + 4, RAIL_PUFF_RATE, &AF(DoRailPuff), &s_RailPuff[1][5]}, - {RAIL_PUFF_R1 + 5, RAIL_PUFF_RATE, &AF(DoRailPuff), &s_RailPuff[1][6]}, - {RAIL_PUFF_R1 + 6, RAIL_PUFF_RATE, &AF(DoRailPuff), &s_RailPuff[1][7]}, - {RAIL_PUFF_R1 + 7, RAIL_PUFF_RATE, &AF(DoRailPuff), &s_RailPuff[1][8]}, - {RAIL_PUFF_R1 + 8, RAIL_PUFF_RATE, &AF(DoRailPuff), &s_RailPuff[1][9]}, - {RAIL_PUFF_R1 + 9, RAIL_PUFF_RATE, &AF(DoRailPuff), &s_RailPuff[1][10]}, - {RAIL_PUFF_R1 + 10, RAIL_PUFF_RATE, &AF(DoRailPuff), &s_RailPuff[1][11]}, - {RAIL_PUFF_R1 + 11, RAIL_PUFF_RATE, &AF(DoRailPuff), &s_RailPuff[1][12]}, - {RAIL_PUFF_R1 + 12, RAIL_PUFF_RATE, &AF(DoRailPuff), &s_RailPuff[1][13]}, - {RAIL_PUFF_R1 + 13, RAIL_PUFF_RATE, &AF(DoRailPuff), &s_RailPuff[1][14]}, - {RAIL_PUFF_R1 + 14, RAIL_PUFF_RATE, &AF(DoRailPuff), &s_RailPuff[1][15]}, - {RAIL_PUFF_R1 + 15, RAIL_PUFF_RATE, &AF(DoRailPuff), &s_RailPuff[1][16]}, - {RAIL_PUFF_R1 + 15, 100, &AF(DoSuicide), &s_RailPuff[1][0]}, - }, - { - {RAIL_PUFF_R2 + 0, RAIL_PUFF_RATE, &AF(DoRailPuff), &s_RailPuff[2][1]}, - {RAIL_PUFF_R2 + 1, RAIL_PUFF_RATE, &AF(DoRailPuff), &s_RailPuff[2][2]}, - {RAIL_PUFF_R2 + 2, RAIL_PUFF_RATE, &AF(DoRailPuff), &s_RailPuff[2][3]}, - {RAIL_PUFF_R2 + 3, RAIL_PUFF_RATE, &AF(DoRailPuff), &s_RailPuff[2][4]}, - {RAIL_PUFF_R2 + 4, RAIL_PUFF_RATE, &AF(DoRailPuff), &s_RailPuff[2][5]}, - {RAIL_PUFF_R2 + 5, RAIL_PUFF_RATE, &AF(DoRailPuff), &s_RailPuff[2][6]}, - {RAIL_PUFF_R2 + 6, RAIL_PUFF_RATE, &AF(DoRailPuff), &s_RailPuff[2][7]}, - {RAIL_PUFF_R2 + 7, RAIL_PUFF_RATE, &AF(DoRailPuff), &s_RailPuff[2][8]}, - {RAIL_PUFF_R2 + 8, RAIL_PUFF_RATE, &AF(DoRailPuff), &s_RailPuff[2][9]}, - {RAIL_PUFF_R2 + 9, RAIL_PUFF_RATE, &AF(DoRailPuff), &s_RailPuff[2][10]}, - {RAIL_PUFF_R2 + 10, RAIL_PUFF_RATE, &AF(DoRailPuff), &s_RailPuff[2][11]}, - {RAIL_PUFF_R2 + 11, RAIL_PUFF_RATE, &AF(DoRailPuff), &s_RailPuff[2][12]}, - {RAIL_PUFF_R2 + 12, RAIL_PUFF_RATE, &AF(DoRailPuff), &s_RailPuff[2][13]}, - {RAIL_PUFF_R2 + 13, RAIL_PUFF_RATE, &AF(DoRailPuff), &s_RailPuff[2][14]}, - {RAIL_PUFF_R2 + 14, RAIL_PUFF_RATE, &AF(DoRailPuff), &s_RailPuff[2][15]}, - {RAIL_PUFF_R2 + 15, RAIL_PUFF_RATE, &AF(DoRailPuff), &s_RailPuff[2][16]}, - {RAIL_PUFF_R2 + 15, 100, &AF(DoSuicide), &s_RailPuff[2][0]}, - } }; STATE* sg_RailPuff[] = { &s_RailPuff[0][0], - &s_RailPuff[1][0], - &s_RailPuff[2][0], - &s_RailPuff[1][0], - &s_RailPuff[0][0] }; -#define LASER_PUFF 3201 #define LASER_PUFF_RATE 8 STATE s_LaserPuff[] = { - {LASER_PUFF + 0, LASER_PUFF_RATE, nullptr, &s_LaserPuff[1]}, - //{LASER_PUFF + 1, LASER_PUFF_RATE, nullptr, &s_LaserPuff[2]}, - //{LASER_PUFF + 2, LASER_PUFF_RATE, nullptr, &s_LaserPuff[3]}, - {LASER_PUFF + 0, 100, &AF(DoSuicide), &s_LaserPuff[0]} + {SPR_LASER_PUFF, 'A', LASER_PUFF_RATE, nullptr, &s_LaserPuff[1]}, + {SPR_LASER_PUFF, 'A', 100, &AF(DoSuicide), &s_LaserPuff[0]} }; -#define TRACER 3201 #define TRACER_RATE 6 STATE s_Tracer[] = { - {TRACER + 0, TRACER_RATE, &AF(DoTracer), &s_Tracer[1]}, - {TRACER + 1, TRACER_RATE, &AF(DoTracer), &s_Tracer[2]}, - {TRACER + 2, TRACER_RATE, &AF(DoTracer), &s_Tracer[3]}, - {TRACER + 3, TRACER_RATE, &AF(DoTracer), &s_Tracer[4]}, - {TRACER + 4, TRACER_RATE, &AF(DoTracer), &s_Tracer[5]}, - {TRACER + 5, TRACER_RATE, &AF(DoTracer), &s_Tracer[0]} + {SPR_TRACER, 'A', TRACER_RATE, &AF(DoTracer), &s_Tracer[1]}, + {SPR_TRACER, 'B', TRACER_RATE, &AF(DoTracer), &s_Tracer[2]}, + {SPR_TRACER, 'C', TRACER_RATE, &AF(DoTracer), &s_Tracer[3]}, + {SPR_TRACER, 'D', TRACER_RATE, &AF(DoTracer), &s_Tracer[4]}, + {SPR_TRACER, 'E', TRACER_RATE, &AF(DoTracer), &s_Tracer[5]}, + {SPR_TRACER, 'F', TRACER_RATE, &AF(DoTracer), &s_Tracer[0]} }; -#define EMP 2058 #define EMP_RATE 6 STATE s_EMP[] = { - {EMP + 0, EMP_RATE, &AF(DoEMP), &s_EMP[1]}, - {EMP + 1, EMP_RATE, &AF(DoEMP), &s_EMP[2]}, - {EMP + 2, EMP_RATE, &AF(DoEMP), &s_EMP[0]} + {SPR_EMP, 'A', EMP_RATE, &AF(DoEMP), &s_EMP[1]}, + {SPR_EMP, 'B', EMP_RATE, &AF(DoEMP), &s_EMP[2]}, + {SPR_EMP, 'C', EMP_RATE, &AF(DoEMP), &s_EMP[0]} }; STATE s_EMPBurst[] = { - {EMP + 0, EMP_RATE, &AF(DoEMPBurst), &s_EMPBurst[1]}, - {EMP + 1, EMP_RATE, &AF(DoEMPBurst), &s_EMPBurst[2]}, - {EMP + 2, EMP_RATE, &AF(DoEMPBurst), &s_EMPBurst[0]} + {SPR_EMP, 'A', EMP_RATE, &AF(DoEMPBurst), &s_EMPBurst[1]}, + {SPR_EMP, 'B', EMP_RATE, &AF(DoEMPBurst), &s_EMPBurst[2]}, + {SPR_EMP, 'C', EMP_RATE, &AF(DoEMPBurst), &s_EMPBurst[0]} }; STATE s_EMPShrap[] = { - {EMP + 0, EMP_RATE, &AF(DoFastShrapJumpFall), &s_EMPShrap[1]}, - {EMP + 1, EMP_RATE, &AF(DoFastShrapJumpFall), &s_EMPShrap[2]}, - {EMP + 2, EMP_RATE, &AF(DoFastShrapJumpFall), &s_EMPShrap[0]}, + {SPR_EMP, 'A', EMP_RATE, &AF(DoFastShrapJumpFall), &s_EMPShrap[1]}, + {SPR_EMP, 'B', EMP_RATE, &AF(DoFastShrapJumpFall), &s_EMPShrap[2]}, + {SPR_EMP, 'C', EMP_RATE, &AF(DoFastShrapJumpFall), &s_EMPShrap[0]}, }; @@ -369,33 +319,33 @@ STATE s_EMPShrap[] = STATE s_TankShell[] = { - {TRACER + 0, 200, &AF(DoTankShell), &s_TankShell[0]} + {SPR_TRACER, 'A', 200, &AF(DoTankShell), &s_TankShell[0]} }; #define VEHICLE_SMOKE_RATE 18 STATE s_VehicleSmoke[] = { - {PUFF + 0, VEHICLE_SMOKE_RATE, &AF(DoVehicleSmoke), &s_VehicleSmoke[1]}, - {PUFF + 1, VEHICLE_SMOKE_RATE, &AF(DoVehicleSmoke), &s_VehicleSmoke[2]}, - {PUFF + 2, VEHICLE_SMOKE_RATE, &AF(DoVehicleSmoke), &s_VehicleSmoke[3]}, - {PUFF + 3, VEHICLE_SMOKE_RATE, &AF(DoVehicleSmoke), &s_VehicleSmoke[4]}, - {PUFF + 4, VEHICLE_SMOKE_RATE, &AF(DoVehicleSmoke), &s_VehicleSmoke[5]}, - {PUFF + 5, VEHICLE_SMOKE_RATE, &AF(DoVehicleSmoke), &s_VehicleSmoke[6]}, - {PUFF + 5, 100, &AF(DoSuicide), &s_VehicleSmoke[6]} + {SPR_PUFF, 'A', VEHICLE_SMOKE_RATE, &AF(DoVehicleSmoke), &s_VehicleSmoke[1]}, + {SPR_PUFF, 'B', VEHICLE_SMOKE_RATE, &AF(DoVehicleSmoke), &s_VehicleSmoke[2]}, + {SPR_PUFF, 'C', VEHICLE_SMOKE_RATE, &AF(DoVehicleSmoke), &s_VehicleSmoke[3]}, + {SPR_PUFF, 'D', VEHICLE_SMOKE_RATE, &AF(DoVehicleSmoke), &s_VehicleSmoke[4]}, + {SPR_PUFF, 'E', VEHICLE_SMOKE_RATE, &AF(DoVehicleSmoke), &s_VehicleSmoke[5]}, + {SPR_PUFF, 'F', VEHICLE_SMOKE_RATE, &AF(DoVehicleSmoke), &s_VehicleSmoke[6]}, + {SPR_PUFF, 'F', 100, &AF(DoSuicide), &s_VehicleSmoke[6]} }; #define WATER_SMOKE_RATE 18 STATE s_WaterSmoke[] = { - {PUFF + 0, WATER_SMOKE_RATE, &AF(DoWaterSmoke), &s_WaterSmoke[1]}, - {PUFF + 1, WATER_SMOKE_RATE, &AF(DoWaterSmoke), &s_WaterSmoke[2]}, - {PUFF + 2, WATER_SMOKE_RATE, &AF(DoWaterSmoke), &s_WaterSmoke[3]}, - {PUFF + 3, WATER_SMOKE_RATE, &AF(DoWaterSmoke), &s_WaterSmoke[4]}, - {PUFF + 4, WATER_SMOKE_RATE, &AF(DoWaterSmoke), &s_WaterSmoke[5]}, - {PUFF + 5, WATER_SMOKE_RATE, &AF(DoWaterSmoke), &s_WaterSmoke[6]}, - {PUFF + 5, 100, &AF(DoSuicide), &s_WaterSmoke[6]} + {SPR_PUFF, 'A', WATER_SMOKE_RATE, &AF(DoWaterSmoke), &s_WaterSmoke[1]}, + {SPR_PUFF, 'B', WATER_SMOKE_RATE, &AF(DoWaterSmoke), &s_WaterSmoke[2]}, + {SPR_PUFF, 'C', WATER_SMOKE_RATE, &AF(DoWaterSmoke), &s_WaterSmoke[3]}, + {SPR_PUFF, 'D', WATER_SMOKE_RATE, &AF(DoWaterSmoke), &s_WaterSmoke[4]}, + {SPR_PUFF, 'E', WATER_SMOKE_RATE, &AF(DoWaterSmoke), &s_WaterSmoke[5]}, + {SPR_PUFF, 'F', WATER_SMOKE_RATE, &AF(DoWaterSmoke), &s_WaterSmoke[6]}, + {SPR_PUFF, 'F', 100, &AF(DoSuicide), &s_WaterSmoke[6]} }; constexpr double UZI_SPARK_REPEAT = 0.375; @@ -403,105 +353,85 @@ constexpr double UZI_SMOKE_REPEAT = 0.375; #define UZI_SMOKE_RATE 16 // Was 9 STATE s_UziSmoke[] = { - {UZI_SMOKE + 0, UZI_SMOKE_RATE, &AF(DoUziSmoke), &s_UziSmoke[1]}, - {UZI_SMOKE + 1, UZI_SMOKE_RATE, &AF(DoUziSmoke), &s_UziSmoke[2]}, - {UZI_SMOKE + 2, UZI_SMOKE_RATE, &AF(DoUziSmoke), &s_UziSmoke[3]}, - {UZI_SMOKE + 3, UZI_SMOKE_RATE, &AF(DoUziSmoke), &s_UziSmoke[4]}, - {UZI_SMOKE + 3, 100, &AF(DoSuicide), &s_UziSmoke[0]}, + {SPR_UZI_SMOKE, 'A', UZI_SMOKE_RATE, &AF(DoUziSmoke), &s_UziSmoke[1]}, + {SPR_UZI_SMOKE, 'B', UZI_SMOKE_RATE, &AF(DoUziSmoke), &s_UziSmoke[2]}, + {SPR_UZI_SMOKE, 'C', UZI_SMOKE_RATE, &AF(DoUziSmoke), &s_UziSmoke[3]}, + {SPR_UZI_SMOKE, 'D', UZI_SMOKE_RATE, &AF(DoUziSmoke), &s_UziSmoke[4]}, + {SPR_UZI_SMOKE, 'D', 100, &AF(DoSuicide), &s_UziSmoke[0]}, }; #define SHOTGUN_SMOKE_RATE 16 #define SHOTGUN_SMOKE UZI_SMOKE+1 STATE s_ShotgunSmoke[] = { - {UZI_SMOKE + 0, SHOTGUN_SMOKE_RATE, &AF(DoShotgunSmoke), &s_ShotgunSmoke[1]}, - {UZI_SMOKE + 1, SHOTGUN_SMOKE_RATE, &AF(DoShotgunSmoke), &s_ShotgunSmoke[2]}, - {UZI_SMOKE + 2, SHOTGUN_SMOKE_RATE, &AF(DoShotgunSmoke), &s_ShotgunSmoke[3]}, - {UZI_SMOKE + 3, SHOTGUN_SMOKE_RATE, &AF(DoShotgunSmoke), &s_ShotgunSmoke[4]}, - {UZI_SMOKE + 3, 100, &AF(DoSuicide), &s_ShotgunSmoke[0]}, + {SPR_UZI_SMOKE, 'A', SHOTGUN_SMOKE_RATE, &AF(DoShotgunSmoke), &s_ShotgunSmoke[1]}, + {SPR_UZI_SMOKE, 'B', SHOTGUN_SMOKE_RATE, &AF(DoShotgunSmoke), &s_ShotgunSmoke[2]}, + {SPR_UZI_SMOKE, 'C', SHOTGUN_SMOKE_RATE, &AF(DoShotgunSmoke), &s_ShotgunSmoke[3]}, + {SPR_UZI_SMOKE, 'D', SHOTGUN_SMOKE_RATE, &AF(DoShotgunSmoke), &s_ShotgunSmoke[4]}, + {SPR_UZI_SMOKE, 'D', 100, &AF(DoSuicide), &s_ShotgunSmoke[0]}, }; #define UZI_BULLET_RATE 100 -#define UZI_BULLET 717 // actually a bubble STATE s_UziBullet[] = { - {UZI_BULLET + 0, UZI_BULLET_RATE, &AF(DoUziBullet), &s_UziBullet[0]}, + {SPR_UZI_BULLET, 'A', UZI_BULLET_RATE, &AF(DoUziBullet), &s_UziBullet[0]}, }; #define UZI_SPARK_RATE 8 STATE s_UziSpark[] = { - {UZI_SPARK + 0, UZI_SPARK_RATE, nullptr, &s_UziSpark[1]}, - {UZI_SPARK + 1, UZI_SPARK_RATE, nullptr, &s_UziSpark[2]}, - {UZI_SPARK + 2, UZI_SPARK_RATE, nullptr, &s_UziSpark[3]}, - {UZI_SPARK + 3, UZI_SPARK_RATE, nullptr, &s_UziSpark[4]}, - {UZI_SPARK + 4, UZI_SPARK_RATE, nullptr, &s_UziSpark[5]}, - {UZI_SPARK + 4, 100, &AF(DoSuicide), &s_UziSpark[0]}, + {SPR_UZI_SPARK, 'A', UZI_SPARK_RATE, nullptr, &s_UziSpark[1]}, + {SPR_UZI_SPARK, 'B', UZI_SPARK_RATE, nullptr, &s_UziSpark[2]}, + {SPR_UZI_SPARK, 'C', UZI_SPARK_RATE, nullptr, &s_UziSpark[3]}, + {SPR_UZI_SPARK, 'D', UZI_SPARK_RATE, nullptr, &s_UziSpark[4]}, + {SPR_UZI_SPARK, 'E', UZI_SPARK_RATE, nullptr, &s_UziSpark[5]}, + {SPR_UZI_SPARK, 'E', 100, &AF(DoSuicide), &s_UziSpark[0]}, }; STATE s_UziPowerSpark[] = { - {UZI_SPARK + 0, UZI_SPARK_RATE, &AF(DoUziSmoke), &s_UziSpark[1]}, - {UZI_SPARK + 1, UZI_SPARK_RATE, &AF(DoUziSmoke), &s_UziSpark[2]}, - {UZI_SPARK + 2, UZI_SPARK_RATE, &AF(DoUziSmoke), &s_UziSpark[3]}, - {UZI_SPARK + 3, UZI_SPARK_RATE, &AF(DoUziSmoke), &s_UziSpark[4]}, - {UZI_SPARK + 4, UZI_SPARK_RATE, &AF(DoUziSmoke), &s_UziSpark[5]}, - {UZI_SPARK + 4, 100, &AF(DoSuicide), &s_UziSpark[0]}, + {SPR_UZI_SPARK, 'A', UZI_SPARK_RATE, &AF(DoUziSmoke), &s_UziSpark[1]}, + {SPR_UZI_SPARK, 'B', UZI_SPARK_RATE, &AF(DoUziSmoke), &s_UziSpark[2]}, + {SPR_UZI_SPARK, 'C', UZI_SPARK_RATE, &AF(DoUziSmoke), &s_UziSpark[3]}, + {SPR_UZI_SPARK, 'D', UZI_SPARK_RATE, &AF(DoUziSmoke), &s_UziSpark[4]}, + {SPR_UZI_SPARK, 'E', UZI_SPARK_RATE, &AF(DoUziSmoke), &s_UziSpark[5]}, + {SPR_UZI_SPARK, 'E', 100, &AF(DoSuicide), &s_UziSpark[0]}, }; -#define BUBBLE 716 #define BUBBLE_RATE 100 STATE s_Bubble[] = { - {BUBBLE + 0, BUBBLE_RATE, &AF(DoBubble), &s_Bubble[0]} + {SPR_BUBBLE, 'A', BUBBLE_RATE, &AF(DoBubble), &s_Bubble[0]} }; //#define SPLASH 2190 -#define SPLASH 772 #define SPLASH_RATE 10 STATE s_Splash[] = { - {SPLASH + 0, SPLASH_RATE, nullptr, &s_Splash[1]}, - {SPLASH + 1, SPLASH_RATE, nullptr, &s_Splash[2]}, - {SPLASH + 2, SPLASH_RATE, nullptr, &s_Splash[3]}, - {SPLASH + 3, SPLASH_RATE, nullptr, &s_Splash[4]}, - {SPLASH + 4, SPLASH_RATE, nullptr, &s_Splash[5]}, - {SPLASH + 4, 100, &AF(DoSuicide), &s_Splash[0]} + {SPR_SPLASH, 'A', SPLASH_RATE, nullptr, &s_Splash[1]}, + {SPR_SPLASH, 'B', SPLASH_RATE, nullptr, &s_Splash[2]}, + {SPR_SPLASH, 'C', SPLASH_RATE, nullptr, &s_Splash[3]}, + {SPR_SPLASH, 'D', SPLASH_RATE, nullptr, &s_Splash[4]}, + {SPR_SPLASH, 'E', SPLASH_RATE, nullptr, &s_Splash[5]}, + {SPR_SPLASH, 'E', 100, &AF(DoSuicide), &s_Splash[0]} }; -#define CROSSBOLT 2230 #define CROSSBOLT_RATE 100 -STATE s_CrossBolt[5][1] = +STATE s_CrossBolt[1][1] = { { - {CROSSBOLT + 0, CROSSBOLT_RATE, &AF(DoCrossBolt), &s_CrossBolt[0][0]}, - }, - { - {CROSSBOLT + 2, CROSSBOLT_RATE, &AF(DoCrossBolt), &s_CrossBolt[1][0]}, - }, - { - {CROSSBOLT + 3, CROSSBOLT_RATE, &AF(DoCrossBolt), &s_CrossBolt[2][0]}, + {SPR_CROSSBOLT, 'A', CROSSBOLT_RATE, &AF(DoCrossBolt), &s_CrossBolt[0][0]}, }, - { - {CROSSBOLT + 4, CROSSBOLT_RATE, &AF(DoCrossBolt), &s_CrossBolt[3][0]}, - }, - { - {CROSSBOLT + 1, CROSSBOLT_RATE, &AF(DoCrossBolt), &s_CrossBolt[4][0]}, - } }; STATE* sg_CrossBolt[] = { &s_CrossBolt[0][0], - &s_CrossBolt[1][0], - &s_CrossBolt[2][0], - &s_CrossBolt[3][0], - &s_CrossBolt[4][0] }; #undef STAR @@ -509,29 +439,28 @@ STATE* sg_CrossBolt[] = #define STAR_RATE 6 STATE s_Star[] = { - {STAR + 0, STAR_RATE, &AF(DoStar), &s_Star[1]}, - {STAR + 1, STAR_RATE, &AF(DoStar), &s_Star[2]}, - {STAR + 2, STAR_RATE, &AF(DoStar), &s_Star[3]}, - {STAR + 3, STAR_RATE, &AF(DoStar), &s_Star[0]} + {SPR_STAR, 'A', STAR_RATE, &AF(DoStar), &s_Star[1]}, + {SPR_STAR, 'B', STAR_RATE, &AF(DoStar), &s_Star[2]}, + {SPR_STAR, 'C', STAR_RATE, &AF(DoStar), &s_Star[3]}, + {SPR_STAR, 'D', STAR_RATE, &AF(DoStar), &s_Star[0]} }; STATE s_StarStuck[] = { - {STAR + 0, STAR_RATE, nullptr, &s_StarStuck[0]}, + {SPR_STAR, 'A', STAR_RATE, nullptr, &s_StarStuck[0]}, }; -#define STAR_DOWN 2066 STATE s_StarDown[] = { - {STAR_DOWN + 0, STAR_RATE, &AF(DoStar), &s_StarDown[1]}, - {STAR_DOWN + 1, STAR_RATE, &AF(DoStar), &s_StarDown[2]}, - {STAR_DOWN + 2, STAR_RATE, &AF(DoStar), &s_StarDown[3]}, - {STAR_DOWN + 3, STAR_RATE, &AF(DoStar), &s_StarDown[0]} + {SPR_STAR_DOWN, 'A', STAR_RATE, &AF(DoStar), &s_StarDown[1]}, + {SPR_STAR_DOWN, 'B', STAR_RATE, &AF(DoStar), &s_StarDown[2]}, + {SPR_STAR_DOWN, 'C', STAR_RATE, &AF(DoStar), &s_StarDown[3]}, + {SPR_STAR_DOWN, 'D', STAR_RATE, &AF(DoStar), &s_StarDown[0]} }; STATE s_StarDownStuck[] = { - {STAR + 0, STAR_RATE, nullptr, &s_StarDownStuck[0]}, + {SPR_STAR, 'A', STAR_RATE, nullptr, &s_StarDownStuck[0]}, }; ////////////////////// @@ -544,40 +473,40 @@ STATE s_StarDownStuck[] = STATE s_LavaBoulder[] = { - {LAVA_BOULDER + 1, LAVA_BOULDER_RATE, &AF(DoLavaBoulder), &s_LavaBoulder[1]}, - {LAVA_BOULDER + 2, LAVA_BOULDER_RATE, &AF(DoLavaBoulder), &s_LavaBoulder[2]}, - {LAVA_BOULDER + 3, LAVA_BOULDER_RATE, &AF(DoLavaBoulder), &s_LavaBoulder[3]}, - {LAVA_BOULDER + 4, LAVA_BOULDER_RATE, &AF(DoLavaBoulder), &s_LavaBoulder[4]}, - {LAVA_BOULDER + 5, LAVA_BOULDER_RATE, &AF(DoLavaBoulder), &s_LavaBoulder[5]}, - {LAVA_BOULDER + 6, LAVA_BOULDER_RATE, &AF(DoLavaBoulder), &s_LavaBoulder[6]}, - {LAVA_BOULDER + 7, LAVA_BOULDER_RATE, &AF(DoLavaBoulder), &s_LavaBoulder[7]}, - {LAVA_BOULDER + 8, LAVA_BOULDER_RATE, &AF(DoLavaBoulder), &s_LavaBoulder[0]}, + {SPR_LAVA_BOULDER, 'B', LAVA_BOULDER_RATE, &AF(DoLavaBoulder), &s_LavaBoulder[1]}, + {SPR_LAVA_BOULDER, 'C', LAVA_BOULDER_RATE, &AF(DoLavaBoulder), &s_LavaBoulder[2]}, + {SPR_LAVA_BOULDER, 'D', LAVA_BOULDER_RATE, &AF(DoLavaBoulder), &s_LavaBoulder[3]}, + {SPR_LAVA_BOULDER, 'E', LAVA_BOULDER_RATE, &AF(DoLavaBoulder), &s_LavaBoulder[4]}, + {SPR_LAVA_BOULDER, 'F', LAVA_BOULDER_RATE, &AF(DoLavaBoulder), &s_LavaBoulder[5]}, + {SPR_LAVA_BOULDER, 'G', LAVA_BOULDER_RATE, &AF(DoLavaBoulder), &s_LavaBoulder[6]}, + {SPR_LAVA_BOULDER, 'H', LAVA_BOULDER_RATE, &AF(DoLavaBoulder), &s_LavaBoulder[7]}, + {SPR_LAVA_BOULDER, 'I', LAVA_BOULDER_RATE, &AF(DoLavaBoulder), &s_LavaBoulder[0]}, }; #define LAVA_SHARD (LAVA_BOULDER+1) STATE s_LavaShard[] = { - {LAVA_BOULDER + 1, LAVA_BOULDER_RATE, &AF(DoShrapDamage), &s_LavaShard[1]}, - {LAVA_BOULDER + 2, LAVA_BOULDER_RATE, &AF(DoShrapDamage), &s_LavaShard[2]}, - {LAVA_BOULDER + 3, LAVA_BOULDER_RATE, &AF(DoShrapDamage), &s_LavaShard[3]}, - {LAVA_BOULDER + 4, LAVA_BOULDER_RATE, &AF(DoShrapDamage), &s_LavaShard[4]}, - {LAVA_BOULDER + 5, LAVA_BOULDER_RATE, &AF(DoShrapDamage), &s_LavaShard[5]}, - {LAVA_BOULDER + 6, LAVA_BOULDER_RATE, &AF(DoShrapDamage), &s_LavaShard[6]}, - {LAVA_BOULDER + 7, LAVA_BOULDER_RATE, &AF(DoShrapDamage), &s_LavaShard[7]}, - {LAVA_BOULDER + 8, LAVA_BOULDER_RATE, &AF(DoShrapDamage), &s_LavaShard[0]}, + {SPR_LAVA_BOULDER, 'B', LAVA_BOULDER_RATE, &AF(DoShrapDamage), &s_LavaShard[1]}, + {SPR_LAVA_BOULDER, 'C', LAVA_BOULDER_RATE, &AF(DoShrapDamage), &s_LavaShard[2]}, + {SPR_LAVA_BOULDER, 'D', LAVA_BOULDER_RATE, &AF(DoShrapDamage), &s_LavaShard[3]}, + {SPR_LAVA_BOULDER, 'E', LAVA_BOULDER_RATE, &AF(DoShrapDamage), &s_LavaShard[4]}, + {SPR_LAVA_BOULDER, 'F', LAVA_BOULDER_RATE, &AF(DoShrapDamage), &s_LavaShard[5]}, + {SPR_LAVA_BOULDER, 'G', LAVA_BOULDER_RATE, &AF(DoShrapDamage), &s_LavaShard[6]}, + {SPR_LAVA_BOULDER, 'H', LAVA_BOULDER_RATE, &AF(DoShrapDamage), &s_LavaShard[7]}, + {SPR_LAVA_BOULDER, 'I', LAVA_BOULDER_RATE, &AF(DoShrapDamage), &s_LavaShard[0]}, }; STATE s_VulcanBoulder[] = { - {LAVA_BOULDER + 1, LAVA_BOULDER_RATE, &AF(DoVulcanBoulder), &s_VulcanBoulder[1]}, - {LAVA_BOULDER + 2, LAVA_BOULDER_RATE, &AF(DoVulcanBoulder), &s_VulcanBoulder[2]}, - {LAVA_BOULDER + 3, LAVA_BOULDER_RATE, &AF(DoVulcanBoulder), &s_VulcanBoulder[3]}, - {LAVA_BOULDER + 4, LAVA_BOULDER_RATE, &AF(DoVulcanBoulder), &s_VulcanBoulder[4]}, - {LAVA_BOULDER + 5, LAVA_BOULDER_RATE, &AF(DoVulcanBoulder), &s_VulcanBoulder[5]}, - {LAVA_BOULDER + 6, LAVA_BOULDER_RATE, &AF(DoVulcanBoulder), &s_VulcanBoulder[6]}, - {LAVA_BOULDER + 7, LAVA_BOULDER_RATE, &AF(DoVulcanBoulder), &s_VulcanBoulder[7]}, - {LAVA_BOULDER + 8, LAVA_BOULDER_RATE, &AF(DoVulcanBoulder), &s_VulcanBoulder[0]}, + {SPR_LAVA_BOULDER, 'B', LAVA_BOULDER_RATE, &AF(DoVulcanBoulder), &s_VulcanBoulder[1]}, + {SPR_LAVA_BOULDER, 'C', LAVA_BOULDER_RATE, &AF(DoVulcanBoulder), &s_VulcanBoulder[2]}, + {SPR_LAVA_BOULDER, 'D', LAVA_BOULDER_RATE, &AF(DoVulcanBoulder), &s_VulcanBoulder[3]}, + {SPR_LAVA_BOULDER, 'E', LAVA_BOULDER_RATE, &AF(DoVulcanBoulder), &s_VulcanBoulder[4]}, + {SPR_LAVA_BOULDER, 'F', LAVA_BOULDER_RATE, &AF(DoVulcanBoulder), &s_VulcanBoulder[5]}, + {SPR_LAVA_BOULDER, 'G', LAVA_BOULDER_RATE, &AF(DoVulcanBoulder), &s_VulcanBoulder[6]}, + {SPR_LAVA_BOULDER, 'H', LAVA_BOULDER_RATE, &AF(DoVulcanBoulder), &s_VulcanBoulder[7]}, + {SPR_LAVA_BOULDER, 'I', LAVA_BOULDER_RATE, &AF(DoVulcanBoulder), &s_VulcanBoulder[0]}, }; ////////////////////// @@ -588,44 +517,23 @@ STATE s_VulcanBoulder[] = #if 0 #else -#define GRENADE_FRAMES 1 #define GRENADE_R0 2110 -#define GRENADE_R1 GRENADE_R0 + (GRENADE_FRAMES * 1) -#define GRENADE_R2 GRENADE_R0 + (GRENADE_FRAMES * 2) -#define GRENADE_R3 GRENADE_R0 + (GRENADE_FRAMES * 3) -#define GRENADE_R4 GRENADE_R0 + (GRENADE_FRAMES * 4) #undef GRENADE #define GRENADE GRENADE_R0 #define GRENADE_RATE 8 -STATE s_Grenade[5][1] = +STATE s_Grenade[1][1] = { { - {GRENADE_R0 + 0, GRENADE_RATE, &AF(DoGrenade), &s_Grenade[0][0]}, - }, - { - {GRENADE_R1 + 0, GRENADE_RATE, &AF(DoGrenade), &s_Grenade[1][0]}, - }, - { - {GRENADE_R2 + 0, GRENADE_RATE, &AF(DoGrenade), &s_Grenade[2][0]}, - }, - { - {GRENADE_R3 + 0, GRENADE_RATE, &AF(DoGrenade), &s_Grenade[3][0]}, + {SPR_GRENADE, 'A', GRENADE_RATE, &AF(DoGrenade), &s_Grenade[0][0]}, }, - { - {GRENADE_R4 + 0, GRENADE_RATE, &AF(DoGrenade), &s_Grenade[4][0]}, - } }; STATE* sg_Grenade[] = { &s_Grenade[0][0], - &s_Grenade[1][0], - &s_Grenade[2][0], - &s_Grenade[3][0], - &s_Grenade[4][0] }; #endif @@ -642,24 +550,24 @@ STATE* sg_Grenade[] = STATE s_MineStuck[] = { - {MINE + 0, MINE_RATE, &AF(DoMineStuck), &s_MineStuck[0]}, + {SPR_MINE, 'A', MINE_RATE, &AF(DoMineStuck), &s_MineStuck[0]}, }; STATE s_Mine[] = { - {MINE + 0, MINE_RATE, &AF(DoMine), &s_Mine[1]}, - {MINE + 1, MINE_RATE, &AF(DoMine), &s_Mine[0]}, + {SPR_MINE, 'A', MINE_RATE, &AF(DoMine), &s_Mine[1]}, + {SPR_MINE, 'B', MINE_RATE, &AF(DoMine), &s_Mine[0]}, }; STATE s_MineSpark[] = { - {UZI_SPARK + 0, UZI_SPARK_RATE, &AF(DoMineSpark), &s_MineSpark[1]}, - {UZI_SPARK + 1, UZI_SPARK_RATE, &AF(DoMineSpark), &s_MineSpark[2]}, - {UZI_SPARK + 2, UZI_SPARK_RATE, &AF(DoMineSpark), &s_MineSpark[3]}, - {UZI_SPARK + 3, UZI_SPARK_RATE, &AF(DoMineSpark), &s_MineSpark[4]}, - {UZI_SPARK + 4, UZI_SPARK_RATE, &AF(DoMineSpark), &s_MineSpark[5]}, - {UZI_SPARK + 4, 100, &AF(DoSuicide), &s_MineSpark[0]}, + {SPR_UZI_SPARK, 'A', UZI_SPARK_RATE, &AF(DoMineSpark), &s_MineSpark[1]}, + {SPR_UZI_SPARK, 'B', UZI_SPARK_RATE, &AF(DoMineSpark), &s_MineSpark[2]}, + {SPR_UZI_SPARK, 'C', UZI_SPARK_RATE, &AF(DoMineSpark), &s_MineSpark[3]}, + {SPR_UZI_SPARK, 'D', UZI_SPARK_RATE, &AF(DoMineSpark), &s_MineSpark[4]}, + {SPR_UZI_SPARK, 'E', UZI_SPARK_RATE, &AF(DoMineSpark), &s_MineSpark[5]}, + {SPR_UZI_SPARK, 'E', 100, &AF(DoSuicide), &s_MineSpark[0]}, }; ////////////////////// @@ -668,59 +576,26 @@ STATE s_MineSpark[] = // ////////////////////// -#define METEOR_R0 2098 -#define METEOR_R1 2090 -#define METEOR_R2 2094 -#define METEOR_R3 2090 -#define METEOR_R4 2098 #define METEOR STAR #define METEOR_RATE 8 -STATE s_Meteor[5][4] = +STATE s_Meteor[1][4] = { { - {METEOR_R0 + 0, METEOR_RATE, &AF(DoMeteor), &s_Meteor[0][1]}, - {METEOR_R0 + 1, METEOR_RATE, &AF(DoMeteor), &s_Meteor[0][2]}, - {METEOR_R0 + 2, METEOR_RATE, &AF(DoMeteor), &s_Meteor[0][3]}, - {METEOR_R0 + 3, METEOR_RATE, &AF(DoMeteor), &s_Meteor[0][0]}, - }, - { - {METEOR_R1 + 0, METEOR_RATE, &AF(DoMeteor), &s_Meteor[1][1]}, - {METEOR_R1 + 1, METEOR_RATE, &AF(DoMeteor), &s_Meteor[1][2]}, - {METEOR_R1 + 2, METEOR_RATE, &AF(DoMeteor), &s_Meteor[1][3]}, - {METEOR_R1 + 3, METEOR_RATE, &AF(DoMeteor), &s_Meteor[1][0]}, + {SPR_METEOR, 'A', METEOR_RATE, &AF(DoMeteor), &s_Meteor[0][1]}, + {SPR_METEOR, 'B', METEOR_RATE, &AF(DoMeteor), &s_Meteor[0][2]}, + {SPR_METEOR, 'C', METEOR_RATE, &AF(DoMeteor), &s_Meteor[0][3]}, + {SPR_METEOR, 'D', METEOR_RATE, &AF(DoMeteor), &s_Meteor[0][0]}, }, - { - {METEOR_R2 + 0, METEOR_RATE, &AF(DoMeteor), &s_Meteor[2][1]}, - {METEOR_R2 + 1, METEOR_RATE, &AF(DoMeteor), &s_Meteor[2][2]}, - {METEOR_R2 + 2, METEOR_RATE, &AF(DoMeteor), &s_Meteor[2][3]}, - {METEOR_R2 + 3, METEOR_RATE, &AF(DoMeteor), &s_Meteor[2][0]}, - }, - { - {METEOR_R3 + 0, METEOR_RATE, &AF(DoMeteor), &s_Meteor[3][1]}, - {METEOR_R3 + 1, METEOR_RATE, &AF(DoMeteor), &s_Meteor[3][2]}, - {METEOR_R3 + 2, METEOR_RATE, &AF(DoMeteor), &s_Meteor[3][3]}, - {METEOR_R3 + 3, METEOR_RATE, &AF(DoMeteor), &s_Meteor[3][0]}, - }, - { - {METEOR_R4 + 0, METEOR_RATE, &AF(DoMeteor), &s_Meteor[4][1]}, - {METEOR_R4 + 1, METEOR_RATE, &AF(DoMeteor), &s_Meteor[4][2]}, - {METEOR_R4 + 2, METEOR_RATE, &AF(DoMeteor), &s_Meteor[4][3]}, - {METEOR_R4 + 3, METEOR_RATE, &AF(DoMeteor), &s_Meteor[4][0]}, - } }; STATE* sg_Meteor[] = { &s_Meteor[0][0], - &s_Meteor[1][0], - &s_Meteor[2][0], - &s_Meteor[3][0], - &s_Meteor[4][0] }; #define METEOR_EXP 2115 @@ -728,128 +603,72 @@ STATE* sg_Meteor[] = STATE s_MeteorExp[] = { - {METEOR_EXP + 0, METEOR_EXP_RATE, nullptr, &s_MeteorExp[1]}, - {METEOR_EXP + 1, METEOR_EXP_RATE, nullptr, &s_MeteorExp[2]}, - {METEOR_EXP + 2, METEOR_EXP_RATE, nullptr, &s_MeteorExp[3]}, - {METEOR_EXP + 3, METEOR_EXP_RATE, nullptr, &s_MeteorExp[4]}, - {METEOR_EXP + 4, METEOR_EXP_RATE, nullptr, &s_MeteorExp[5]}, - {METEOR_EXP + 5, METEOR_EXP_RATE, nullptr, &s_MeteorExp[6]}, - {METEOR_EXP + 5, METEOR_EXP_RATE, &AF(DoSuicide), &s_MeteorExp[6]} + {SPR_METEOR_EXP, 'A', METEOR_EXP_RATE, nullptr, &s_MeteorExp[1]}, + {SPR_METEOR_EXP, 'B', METEOR_EXP_RATE, nullptr, &s_MeteorExp[2]}, + {SPR_METEOR_EXP, 'C', METEOR_EXP_RATE, nullptr, &s_MeteorExp[3]}, + {SPR_METEOR_EXP, 'D', METEOR_EXP_RATE, nullptr, &s_MeteorExp[4]}, + {SPR_METEOR_EXP, 'E', METEOR_EXP_RATE, nullptr, &s_MeteorExp[5]}, + {SPR_METEOR_EXP, 'F', METEOR_EXP_RATE, nullptr, &s_MeteorExp[6]}, + {SPR_METEOR_EXP, 'F', METEOR_EXP_RATE, &AF(DoSuicide), &s_MeteorExp[6]} }; -#define MIRV_METEOR METEOR_R0 +#define MIRV_METEOR 2098 //METEOR_R0 -STATE s_MirvMeteor[5][4] = +STATE s_MirvMeteor[1][4] = { { - {METEOR_R0 + 0, METEOR_RATE, &AF(DoMirvMissile), &s_MirvMeteor[0][1]}, - {METEOR_R0 + 1, METEOR_RATE, &AF(DoMirvMissile), &s_MirvMeteor[0][2]}, - {METEOR_R0 + 2, METEOR_RATE, &AF(DoMirvMissile), &s_MirvMeteor[0][3]}, - {METEOR_R0 + 3, METEOR_RATE, &AF(DoMirvMissile), &s_MirvMeteor[0][0]}, - }, - { - {METEOR_R1 + 0, METEOR_RATE, &AF(DoMirvMissile), &s_MirvMeteor[1][1]}, - {METEOR_R1 + 1, METEOR_RATE, &AF(DoMirvMissile), &s_MirvMeteor[1][2]}, - {METEOR_R1 + 2, METEOR_RATE, &AF(DoMirvMissile), &s_MirvMeteor[1][3]}, - {METEOR_R1 + 3, METEOR_RATE, &AF(DoMirvMissile), &s_MirvMeteor[1][0]}, + {SPR_METEOR, 'A', METEOR_RATE, &AF(DoMirvMissile), &s_MirvMeteor[0][1]}, + {SPR_METEOR, 'B', METEOR_RATE, &AF(DoMirvMissile), &s_MirvMeteor[0][2]}, + {SPR_METEOR, 'C', METEOR_RATE, &AF(DoMirvMissile), &s_MirvMeteor[0][3]}, + {SPR_METEOR, 'D', METEOR_RATE, &AF(DoMirvMissile), &s_MirvMeteor[0][0]}, }, - { - {METEOR_R2 + 0, METEOR_RATE, &AF(DoMirvMissile), &s_MirvMeteor[2][1]}, - {METEOR_R2 + 1, METEOR_RATE, &AF(DoMirvMissile), &s_MirvMeteor[2][2]}, - {METEOR_R2 + 2, METEOR_RATE, &AF(DoMirvMissile), &s_MirvMeteor[2][3]}, - {METEOR_R2 + 3, METEOR_RATE, &AF(DoMirvMissile), &s_MirvMeteor[2][0]}, - }, - { - {METEOR_R3 + 0, METEOR_RATE, &AF(DoMirvMissile), &s_MirvMeteor[3][1]}, - {METEOR_R3 + 1, METEOR_RATE, &AF(DoMirvMissile), &s_MirvMeteor[3][2]}, - {METEOR_R3 + 2, METEOR_RATE, &AF(DoMirvMissile), &s_MirvMeteor[3][3]}, - {METEOR_R3 + 3, METEOR_RATE, &AF(DoMirvMissile), &s_MirvMeteor[3][0]}, - }, - { - {METEOR_R4 + 0, METEOR_RATE, &AF(DoMirvMissile), &s_MirvMeteor[4][1]}, - {METEOR_R4 + 1, METEOR_RATE, &AF(DoMirvMissile), &s_MirvMeteor[4][2]}, - {METEOR_R4 + 2, METEOR_RATE, &AF(DoMirvMissile), &s_MirvMeteor[4][3]}, - {METEOR_R4 + 3, METEOR_RATE, &AF(DoMirvMissile), &s_MirvMeteor[4][0]}, - } }; STATE* sg_MirvMeteor[] = { &s_MirvMeteor[0][0], - &s_MirvMeteor[1][0], - &s_MirvMeteor[2][0], - &s_MirvMeteor[3][0], - &s_MirvMeteor[4][0] }; STATE s_MirvMeteorExp[] = { - {METEOR_EXP + 0, METEOR_EXP_RATE, nullptr, &s_MirvMeteorExp[1]}, - {METEOR_EXP + 1, METEOR_EXP_RATE, nullptr, &s_MirvMeteorExp[2]}, - {METEOR_EXP + 2, METEOR_EXP_RATE, nullptr, &s_MirvMeteorExp[3]}, - {METEOR_EXP + 3, METEOR_EXP_RATE, nullptr, &s_MirvMeteorExp[4]}, - {METEOR_EXP + 4, METEOR_EXP_RATE, nullptr, &s_MirvMeteorExp[5]}, - {METEOR_EXP + 5, METEOR_EXP_RATE, nullptr, &s_MirvMeteorExp[6]}, - {METEOR_EXP + 5, METEOR_EXP_RATE, &AF(DoSuicide), &s_MirvMeteorExp[6]} + {SPR_METEOR_EXP, 'A', METEOR_EXP_RATE, nullptr, &s_MirvMeteorExp[1]}, + {SPR_METEOR_EXP, 'B', METEOR_EXP_RATE, nullptr, &s_MirvMeteorExp[2]}, + {SPR_METEOR_EXP, 'C', METEOR_EXP_RATE, nullptr, &s_MirvMeteorExp[3]}, + {SPR_METEOR_EXP, 'D', METEOR_EXP_RATE, nullptr, &s_MirvMeteorExp[4]}, + {SPR_METEOR_EXP, 'E', METEOR_EXP_RATE, nullptr, &s_MirvMeteorExp[5]}, + {SPR_METEOR_EXP, 'F', METEOR_EXP_RATE, nullptr, &s_MirvMeteorExp[6]}, + {SPR_METEOR_EXP, 'F', METEOR_EXP_RATE, &AF(DoSuicide), &s_MirvMeteorExp[6]} }; -#define SERP_METEOR METEOR_R0+1 +#define SERP_METEOR 2099// METEOR_R0+1 -STATE s_SerpMeteor[5][4] = +STATE s_SerpMeteor[1][4] = { { - {2031 + 0, METEOR_RATE, &AF(DoSerpMeteor), &s_SerpMeteor[0][1]}, - {2031 + 1, METEOR_RATE, &AF(DoSerpMeteor), &s_SerpMeteor[0][2]}, - {2031 + 2, METEOR_RATE, &AF(DoSerpMeteor), &s_SerpMeteor[0][3]}, - {2031 + 3, METEOR_RATE, &AF(DoSerpMeteor), &s_SerpMeteor[0][0]}, - }, - { - {2031 + 0, METEOR_RATE, &AF(DoSerpMeteor), &s_SerpMeteor[1][1]}, - {2031 + 1, METEOR_RATE, &AF(DoSerpMeteor), &s_SerpMeteor[1][2]}, - {2031 + 2, METEOR_RATE, &AF(DoSerpMeteor), &s_SerpMeteor[1][3]}, - {2031 + 3, METEOR_RATE, &AF(DoSerpMeteor), &s_SerpMeteor[1][0]}, + {SPR_SERP_METEOR, 'A', METEOR_RATE, &AF(DoSerpMeteor), &s_SerpMeteor[0][1]}, + {SPR_SERP_METEOR, 'B', METEOR_RATE, &AF(DoSerpMeteor), &s_SerpMeteor[0][2]}, + {SPR_SERP_METEOR, 'C', METEOR_RATE, &AF(DoSerpMeteor), &s_SerpMeteor[0][3]}, + {SPR_SERP_METEOR, 'D', METEOR_RATE, &AF(DoSerpMeteor), &s_SerpMeteor[0][0]}, }, - { - {2031 + 0, METEOR_RATE, &AF(DoSerpMeteor), &s_SerpMeteor[2][1]}, - {2031 + 1, METEOR_RATE, &AF(DoSerpMeteor), &s_SerpMeteor[2][2]}, - {2031 + 2, METEOR_RATE, &AF(DoSerpMeteor), &s_SerpMeteor[2][3]}, - {2031 + 3, METEOR_RATE, &AF(DoSerpMeteor), &s_SerpMeteor[2][0]}, - }, - { - {2031 + 0, METEOR_RATE, &AF(DoSerpMeteor), &s_SerpMeteor[3][1]}, - {2031 + 1, METEOR_RATE, &AF(DoSerpMeteor), &s_SerpMeteor[3][2]}, - {2031 + 2, METEOR_RATE, &AF(DoSerpMeteor), &s_SerpMeteor[3][3]}, - {2031 + 3, METEOR_RATE, &AF(DoSerpMeteor), &s_SerpMeteor[3][0]}, - }, - { - {2031 + 0, METEOR_RATE, &AF(DoSerpMeteor), &s_SerpMeteor[4][1]}, - {2031 + 1, METEOR_RATE, &AF(DoSerpMeteor), &s_SerpMeteor[4][2]}, - {2031 + 2, METEOR_RATE, &AF(DoSerpMeteor), &s_SerpMeteor[4][3]}, - {2031 + 3, METEOR_RATE, &AF(DoSerpMeteor), &s_SerpMeteor[4][0]}, - } }; STATE* sg_SerpMeteor[] = { &s_SerpMeteor[0][0], - &s_SerpMeteor[1][0], - &s_SerpMeteor[2][0], - &s_SerpMeteor[3][0], - &s_SerpMeteor[4][0] }; STATE s_SerpMeteorExp[] = { - {METEOR_EXP + 0, METEOR_EXP_RATE, nullptr, &s_SerpMeteorExp[1]}, - {METEOR_EXP + 1, METEOR_EXP_RATE, nullptr, &s_SerpMeteorExp[2]}, - {METEOR_EXP + 2, METEOR_EXP_RATE, nullptr, &s_SerpMeteorExp[3]}, - {METEOR_EXP + 3, METEOR_EXP_RATE, nullptr, &s_SerpMeteorExp[4]}, - {METEOR_EXP + 4, METEOR_EXP_RATE, nullptr, &s_SerpMeteorExp[5]}, - {METEOR_EXP + 5, METEOR_EXP_RATE, nullptr, &s_SerpMeteorExp[6]}, - {METEOR_EXP + 5, METEOR_EXP_RATE, &AF(DoSuicide), &s_SerpMeteorExp[6]} + {SPR_METEOR_EXP, 'A', METEOR_EXP_RATE, nullptr, &s_SerpMeteorExp[1]}, + {SPR_METEOR_EXP, 'B', METEOR_EXP_RATE, nullptr, &s_SerpMeteorExp[2]}, + {SPR_METEOR_EXP, 'C', METEOR_EXP_RATE, nullptr, &s_SerpMeteorExp[3]}, + {SPR_METEOR_EXP, 'D', METEOR_EXP_RATE, nullptr, &s_SerpMeteorExp[4]}, + {SPR_METEOR_EXP, 'E', METEOR_EXP_RATE, nullptr, &s_SerpMeteorExp[5]}, + {SPR_METEOR_EXP, 'F', METEOR_EXP_RATE, nullptr, &s_SerpMeteorExp[6]}, + {SPR_METEOR_EXP, 'F', METEOR_EXP_RATE, &AF(DoSuicide), &s_SerpMeteorExp[6]} }; ////////////////////// @@ -861,32 +680,16 @@ STATE s_SerpMeteorExp[] = #define SPEAR_RATE 8 -STATE s_Spear[5][1] = +STATE s_Spear[1][1] = { { - {SPEAR_R0 + 0, SPEAR_RATE, &AF(DoSpear), s_Spear[0]}, + {SPR_SPEAR, 'A', SPEAR_RATE, &AF(DoSpear), s_Spear[0]}, }, - { - {SPEAR_R1 + 0, SPEAR_RATE, &AF(DoSpear), s_Spear[1]}, - }, - { - {SPEAR_R2 + 0, SPEAR_RATE, &AF(DoSpear), s_Spear[2]}, - }, - { - {SPEAR_R3 + 0, SPEAR_RATE, &AF(DoSpear), s_Spear[3]}, - }, - { - {SPEAR_R4 + 0, SPEAR_RATE, &AF(DoSpear), s_Spear[4]}, - } }; STATE* sg_Spear[] = { s_Spear[0], - s_Spear[1], - s_Spear[2], - s_Spear[3], - s_Spear[4] }; ////////////////////// @@ -895,42 +698,18 @@ STATE* sg_Spear[] = // ////////////////////// -#define ROCKET_FRAMES 1 -#define ROCKET_R0 2206 -#define ROCKET_R1 ROCKET_R0 + (ROCKET_FRAMES * 2) -#define ROCKET_R2 ROCKET_R0 + (ROCKET_FRAMES * 3) -#define ROCKET_R3 ROCKET_R0 + (ROCKET_FRAMES * 4) -#define ROCKET_R4 ROCKET_R0 + (ROCKET_FRAMES * 1) - - #define ROCKET_RATE 8 -STATE s_Rocket[5][1] = +STATE s_Rocket[1][1] = { { - {ROCKET_R0 + 0, ROCKET_RATE, &AF(DoRocket), &s_Rocket[0][0]}, - }, - { - {ROCKET_R1 + 0, ROCKET_RATE, &AF(DoRocket), &s_Rocket[1][0]}, - }, - { - {ROCKET_R2 + 0, ROCKET_RATE, &AF(DoRocket), &s_Rocket[2][0]}, - }, - { - {ROCKET_R3 + 0, ROCKET_RATE, &AF(DoRocket), &s_Rocket[3][0]}, + {SPR_ROCKET, 'A', ROCKET_RATE, &AF(DoRocket), &s_Rocket[0][0]}, }, - { - {ROCKET_R4 + 0, ROCKET_RATE, &AF(DoRocket), &s_Rocket[4][0]}, - } }; STATE* sg_Rocket[] = { &s_Rocket[0][0], - &s_Rocket[1][0], - &s_Rocket[2][0], - &s_Rocket[3][0], - &s_Rocket[4][0] }; ////////////////////// @@ -939,73 +718,33 @@ STATE* sg_Rocket[] = // ////////////////////// -#define BUNNYROCKET_FRAMES 5 -#define BUNNYROCKET_R0 4550 -#define BUNNYROCKET_R1 BUNNYROCKET_R0 + (BUNNYROCKET_FRAMES * 1) -#define BUNNYROCKET_R2 BUNNYROCKET_R0 + (BUNNYROCKET_FRAMES * 2) -#define BUNNYROCKET_R3 BUNNYROCKET_R0 + (BUNNYROCKET_FRAMES * 3) -#define BUNNYROCKET_R4 BUNNYROCKET_R0 + (BUNNYROCKET_FRAMES * 4) - - #define BUNNYROCKET_RATE 8 -STATE s_BunnyRocket[5][1] = +STATE s_BunnyRocket[1][1] = { { - {BUNNYROCKET_R0 + 2, BUNNYROCKET_RATE, &AF(DoRocket), &s_BunnyRocket[0][0]}, - }, - { - {BUNNYROCKET_R1 + 2, BUNNYROCKET_RATE, &AF(DoRocket), &s_BunnyRocket[1][0]}, + {SPR_BUNNYROCKET, 'A', BUNNYROCKET_RATE, &AF(DoRocket), &s_BunnyRocket[0][0]}, }, - { - {BUNNYROCKET_R2 + 2, BUNNYROCKET_RATE, &AF(DoRocket), &s_BunnyRocket[2][0]}, - }, - { - {BUNNYROCKET_R3 + 2, BUNNYROCKET_RATE, &AF(DoRocket), &s_BunnyRocket[3][0]}, - }, - { - {BUNNYROCKET_R4 + 2, BUNNYROCKET_RATE, &AF(DoRocket), &s_BunnyRocket[4][0]}, - } }; STATE* sg_BunnyRocket[] = { &s_BunnyRocket[0][0], - &s_BunnyRocket[1][0], - &s_BunnyRocket[2][0], - &s_BunnyRocket[3][0], - &s_BunnyRocket[4][0] }; #define RAIL_RATE 8 -STATE s_Rail[5][1] = +STATE s_Rail[1][1] = { { - {ROCKET_R0 + 0, RAIL_RATE, &AF(DoRail), &s_Rail[0][0]}, - }, - { - {ROCKET_R1 + 0, RAIL_RATE, &AF(DoRail), &s_Rail[1][0]}, + {SPR_ROCKET, 'A', RAIL_RATE, &AF(DoRail), &s_Rail[0][0]}, }, - { - {ROCKET_R2 + 0, RAIL_RATE, &AF(DoRail), &s_Rail[2][0]}, - }, - { - {ROCKET_R3 + 0, RAIL_RATE, &AF(DoRail), &s_Rail[3][0]}, - }, - { - {ROCKET_R4 + 0, RAIL_RATE, &AF(DoRail), &s_Rail[4][0]}, - } }; STATE* sg_Rail[] = { &s_Rail[0][0], - &s_Rail[1][0], - &s_Rail[2][0], - &s_Rail[3][0], - &s_Rail[4][0] }; @@ -1013,7 +752,7 @@ STATE* sg_Rail[] = STATE s_Laser[] = { - {ROCKET_R0 + 0, LASER_RATE, &AF(DoLaser), &s_Laser[0]} + {SPR_ROCKET, 'A', LASER_RATE, &AF(DoLaser), &s_Laser[0]} }; ////////////////////// @@ -1022,71 +761,31 @@ STATE s_Laser[] = // ////////////////////// -#define MICRO_FRAMES 1 -#define MICRO_R0 2206 -#define MICRO_R1 MICRO_R0 + (MICRO_FRAMES * 2) -#define MICRO_R2 MICRO_R0 + (MICRO_FRAMES * 3) -#define MICRO_R3 MICRO_R0 + (MICRO_FRAMES * 4) -#define MICRO_R4 MICRO_R0 + (MICRO_FRAMES * 1) - - #define MICRO_RATE 8 -STATE s_Micro[5][1] = +STATE s_Micro[1][1] = { { - {MICRO_R0 + 0, MICRO_RATE, &AF(DoMicro), &s_Micro[0][0]}, + {SPR_MICRO, 'A', MICRO_RATE, &AF(DoMicro), &s_Micro[0][0]}, }, - { - {MICRO_R1 + 0, MICRO_RATE, &AF(DoMicro), &s_Micro[1][0]}, - }, - { - {MICRO_R2 + 0, MICRO_RATE, &AF(DoMicro), &s_Micro[2][0]}, - }, - { - {MICRO_R3 + 0, MICRO_RATE, &AF(DoMicro), &s_Micro[3][0]}, - }, - { - {MICRO_R4 + 0, MICRO_RATE, &AF(DoMicro), &s_Micro[4][0]}, - } }; STATE* sg_Micro[] = { &s_Micro[0][0], - &s_Micro[1][0], - &s_Micro[2][0], - &s_Micro[3][0], - &s_Micro[4][0] }; -STATE s_MicroMini[5][1] = +STATE s_MicroMini[1][1] = { { - {MICRO_R0 + 0, MICRO_RATE, &AF(DoMicroMini), &s_MicroMini[0][0]}, - }, - { - {MICRO_R1 + 0, MICRO_RATE, &AF(DoMicroMini), &s_MicroMini[1][0]}, - }, - { - {MICRO_R2 + 0, MICRO_RATE, &AF(DoMicroMini), &s_MicroMini[2][0]}, - }, - { - {MICRO_R3 + 0, MICRO_RATE, &AF(DoMicroMini), &s_MicroMini[3][0]}, + {SPR_MICRO, 'A', MICRO_RATE, &AF(DoMicroMini), &s_MicroMini[0][0]}, }, - { - {MICRO_R4 + 0, MICRO_RATE, &AF(DoMicroMini), &s_MicroMini[4][0]}, - } }; STATE* sg_MicroMini[] = { &s_MicroMini[0][0], - &s_MicroMini[1][0], - &s_MicroMini[2][0], - &s_MicroMini[3][0], - &s_MicroMini[4][0] }; ////////////////////// @@ -1098,89 +797,55 @@ STATE* sg_MicroMini[] = #define BOLT_THINMAN_RATE 8 -STATE s_BoltThinMan[5][1] = +STATE s_BoltThinMan[1][1] = { { - {BOLT_THINMAN_R0 + 0, BOLT_THINMAN_RATE, &AF(DoBoltThinMan), &s_BoltThinMan[0][0]}, - }, - { - {BOLT_THINMAN_R1 + 0, BOLT_THINMAN_RATE, &AF(DoBoltThinMan), &s_BoltThinMan[1][0]}, - }, - { - {BOLT_THINMAN_R2 + 0, BOLT_THINMAN_RATE, &AF(DoBoltThinMan), &s_BoltThinMan[2][0]}, - }, - { - {BOLT_THINMAN_R3 + 0, BOLT_THINMAN_RATE, &AF(DoBoltThinMan), &s_BoltThinMan[3][0]}, + {SPR_BOLT_THINMAN, 'A', BOLT_THINMAN_RATE, &AF(DoBoltThinMan), &s_BoltThinMan[0][0]}, }, - { - {BOLT_THINMAN_R4 + 0, BOLT_THINMAN_RATE, &AF(DoBoltThinMan), &s_BoltThinMan[4][0]}, - } }; STATE* sg_BoltThinMan[] = { &s_BoltThinMan[0][0], - &s_BoltThinMan[1][0], - &s_BoltThinMan[2][0], - &s_BoltThinMan[3][0], - &s_BoltThinMan[4][0] }; #define BOLT_SEEKER_RATE 8 -STATE s_BoltSeeker[5][1] = +STATE s_BoltSeeker[1][1] = { { - {BOLT_THINMAN_R0 + 0, BOLT_SEEKER_RATE, &AF(DoBoltSeeker), &s_BoltSeeker[0][0]}, - }, - { - {BOLT_THINMAN_R1 + 0, BOLT_SEEKER_RATE, &AF(DoBoltSeeker), &s_BoltSeeker[1][0]}, - }, - { - {BOLT_THINMAN_R2 + 0, BOLT_SEEKER_RATE, &AF(DoBoltSeeker), &s_BoltSeeker[2][0]}, - }, - { - {BOLT_THINMAN_R3 + 0, BOLT_SEEKER_RATE, &AF(DoBoltSeeker), &s_BoltSeeker[3][0]}, + {SPR_BOLT_THINMAN, 'A', BOLT_SEEKER_RATE, &AF(DoBoltSeeker), &s_BoltSeeker[0][0]}, }, - { - {BOLT_THINMAN_R4 + 0, BOLT_SEEKER_RATE, &AF(DoBoltSeeker), &s_BoltSeeker[4][0]}, - } }; STATE* sg_BoltSeeker[] = { &s_BoltSeeker[0][0], - &s_BoltSeeker[1][0], - &s_BoltSeeker[2][0], - &s_BoltSeeker[3][0], - &s_BoltSeeker[4][0] }; -#define BOLT_FATMAN STAR #define BOLT_FATMAN_RATE 8 STATE s_BoltFatMan[] = { - {BOLT_FATMAN + 0, BOLT_FATMAN_RATE, &AF(DoBoltFatMan), &s_BoltFatMan[1]}, - {BOLT_FATMAN + 1, BOLT_FATMAN_RATE, &AF(DoBoltFatMan), &s_BoltFatMan[2]}, - {BOLT_FATMAN + 2, BOLT_FATMAN_RATE, &AF(DoBoltFatMan), &s_BoltFatMan[3]}, - {BOLT_FATMAN + 3, BOLT_FATMAN_RATE, &AF(DoBoltFatMan), &s_BoltFatMan[0]} + {SPR_BOLT_FATMAN, 'A', BOLT_FATMAN_RATE, &AF(DoBoltFatMan), &s_BoltFatMan[1]}, + {SPR_BOLT_FATMAN, 'B', BOLT_FATMAN_RATE, &AF(DoBoltFatMan), &s_BoltFatMan[2]}, + {SPR_BOLT_FATMAN, 'C', BOLT_FATMAN_RATE, &AF(DoBoltFatMan), &s_BoltFatMan[3]}, + {SPR_BOLT_FATMAN, 'D', BOLT_FATMAN_RATE, &AF(DoBoltFatMan), &s_BoltFatMan[0]} }; -#define BOLT_SHRAPNEL STAR #define BOLT_SHRAPNEL_RATE 8 STATE s_BoltShrapnel[] = { - {BOLT_SHRAPNEL + 0, BOLT_SHRAPNEL_RATE, &AF(DoBoltShrapnel), &s_BoltShrapnel[1]}, - {BOLT_SHRAPNEL + 1, BOLT_SHRAPNEL_RATE, &AF(DoBoltShrapnel), &s_BoltShrapnel[2]}, - {BOLT_SHRAPNEL + 2, BOLT_SHRAPNEL_RATE, &AF(DoBoltShrapnel), &s_BoltShrapnel[3]}, - {BOLT_SHRAPNEL + 3, BOLT_SHRAPNEL_RATE, &AF(DoBoltShrapnel), &s_BoltShrapnel[0]} + {SPR_BOLT_SHRAPNEL, 'A', BOLT_SHRAPNEL_RATE, &AF(DoBoltShrapnel), &s_BoltShrapnel[1]}, + {SPR_BOLT_SHRAPNEL, 'B', BOLT_SHRAPNEL_RATE, &AF(DoBoltShrapnel), &s_BoltShrapnel[2]}, + {SPR_BOLT_SHRAPNEL, 'C', BOLT_SHRAPNEL_RATE, &AF(DoBoltShrapnel), &s_BoltShrapnel[3]}, + {SPR_BOLT_SHRAPNEL, 'D', BOLT_SHRAPNEL_RATE, &AF(DoBoltShrapnel), &s_BoltShrapnel[0]} }; #define COOLG_FIRE 2430 @@ -1190,58 +855,54 @@ STATE s_BoltShrapnel[] = STATE s_CoolgFire[] = { - {2031 + 0, COOLG_W_FIRE_RATE, &AF(DoCoolgFire), &s_CoolgFire[1]}, - {2031 + 1, COOLG_W_FIRE_RATE, &AF(DoCoolgFire), &s_CoolgFire[2]}, - {2031 + 2, COOLG_W_FIRE_RATE, &AF(DoCoolgFire), &s_CoolgFire[3]}, - {2031 + 3, COOLG_W_FIRE_RATE, &AF(DoCoolgFire), &s_CoolgFire[0]} + {SPR_SERP_METEOR, 'A', COOLG_W_FIRE_RATE, &AF(DoCoolgFire), &s_CoolgFire[1]}, + {SPR_SERP_METEOR, 'B', COOLG_W_FIRE_RATE, &AF(DoCoolgFire), &s_CoolgFire[2]}, + {SPR_SERP_METEOR, 'C', COOLG_W_FIRE_RATE, &AF(DoCoolgFire), &s_CoolgFire[3]}, + {SPR_SERP_METEOR, 'D', COOLG_W_FIRE_RATE, &AF(DoCoolgFire), &s_CoolgFire[0]} }; -#define COOLG_FIRE_DONE 2410 -//#define COOLG_FIRE_DONE 1466 -//#define COOLG_FIRE_DONE_RATE 8 #define COOLG_FIRE_DONE_RATE 3 STATE s_CoolgFireDone[] = { - {COOLG_FIRE_DONE + 0, COOLG_FIRE_DONE_RATE, nullptr, &s_CoolgFireDone[1]}, - {COOLG_FIRE_DONE + 1, COOLG_FIRE_DONE_RATE, nullptr, &s_CoolgFireDone[2]}, - {COOLG_FIRE_DONE + 2, COOLG_FIRE_DONE_RATE, nullptr, &s_CoolgFireDone[3]}, - {COOLG_FIRE_DONE + 3, COOLG_FIRE_DONE_RATE, nullptr, &s_CoolgFireDone[4]}, - {COOLG_FIRE_DONE + 4, COOLG_FIRE_DONE_RATE, nullptr, &s_CoolgFireDone[5]}, - {COOLG_FIRE_DONE + 4, COOLG_FIRE_DONE_RATE, &AF(DoSuicide), &s_CoolgFireDone[5]} + {SPR_COOLG_FIRE_DONE, 'A', COOLG_FIRE_DONE_RATE, nullptr, &s_CoolgFireDone[1]}, + {SPR_COOLG_FIRE_DONE, 'B', COOLG_FIRE_DONE_RATE, nullptr, &s_CoolgFireDone[2]}, + {SPR_COOLG_FIRE_DONE, 'C', COOLG_FIRE_DONE_RATE, nullptr, &s_CoolgFireDone[3]}, + {SPR_COOLG_FIRE_DONE, 'D', COOLG_FIRE_DONE_RATE, nullptr, &s_CoolgFireDone[4]}, + {SPR_COOLG_FIRE_DONE, 'E', COOLG_FIRE_DONE_RATE, nullptr, &s_CoolgFireDone[5]}, + {SPR_COOLG_FIRE_DONE, 'E', COOLG_FIRE_DONE_RATE, &AF(DoSuicide), &s_CoolgFireDone[5]} }; #define COOLG_DRIP 1720 STATE s_CoolgDrip[] = { - {COOLG_DRIP + 0, 100, &AF(DoCoolgDrip), &s_CoolgDrip[0]} + {SPR_COOLG_DRIP, 'A', 100, &AF(DoCoolgDrip), &s_CoolgDrip[0]} }; #define GORE_FLOOR_SPLASH_RATE 8 -#define GORE_FLOOR_SPLASH 1710 STATE s_GoreFloorSplash[] = { - {GORE_FLOOR_SPLASH + 0, GORE_FLOOR_SPLASH_RATE, nullptr, &s_GoreFloorSplash[1]}, - {GORE_FLOOR_SPLASH + 1, GORE_FLOOR_SPLASH_RATE, nullptr, &s_GoreFloorSplash[2]}, - {GORE_FLOOR_SPLASH + 2, GORE_FLOOR_SPLASH_RATE, nullptr, &s_GoreFloorSplash[3]}, - {GORE_FLOOR_SPLASH + 3, GORE_FLOOR_SPLASH_RATE, nullptr, &s_GoreFloorSplash[4]}, - {GORE_FLOOR_SPLASH + 4, GORE_FLOOR_SPLASH_RATE, nullptr, &s_GoreFloorSplash[5]}, - {GORE_FLOOR_SPLASH + 5, GORE_FLOOR_SPLASH_RATE, nullptr, &s_GoreFloorSplash[6]}, - {GORE_FLOOR_SPLASH + 5, GORE_FLOOR_SPLASH_RATE, &AF(DoSuicide), &s_GoreFloorSplash[6]} + {SPR_GORE_FLOOR_SPLASH, 'A', GORE_FLOOR_SPLASH_RATE, nullptr, &s_GoreFloorSplash[1]}, + {SPR_GORE_FLOOR_SPLASH, 'B', GORE_FLOOR_SPLASH_RATE, nullptr, &s_GoreFloorSplash[2]}, + {SPR_GORE_FLOOR_SPLASH, 'C', GORE_FLOOR_SPLASH_RATE, nullptr, &s_GoreFloorSplash[3]}, + {SPR_GORE_FLOOR_SPLASH, 'D', GORE_FLOOR_SPLASH_RATE, nullptr, &s_GoreFloorSplash[4]}, + {SPR_GORE_FLOOR_SPLASH, 'E', GORE_FLOOR_SPLASH_RATE, nullptr, &s_GoreFloorSplash[5]}, + {SPR_GORE_FLOOR_SPLASH, 'F', GORE_FLOOR_SPLASH_RATE, nullptr, &s_GoreFloorSplash[6]}, + {SPR_GORE_FLOOR_SPLASH, 'F', GORE_FLOOR_SPLASH_RATE, &AF(DoSuicide), &s_GoreFloorSplash[6]} }; #define GORE_SPLASH_RATE 8 -#define GORE_SPLASH 2410 + STATE s_GoreSplash[] = { - {GORE_SPLASH + 0, GORE_SPLASH_RATE, nullptr, &s_GoreSplash[1]}, - {GORE_SPLASH + 1, GORE_SPLASH_RATE, nullptr, &s_GoreSplash[2]}, - {GORE_SPLASH + 2, GORE_SPLASH_RATE, nullptr, &s_GoreSplash[3]}, - {GORE_SPLASH + 3, GORE_SPLASH_RATE, nullptr, &s_GoreSplash[4]}, - {GORE_SPLASH + 4, GORE_SPLASH_RATE, nullptr, &s_GoreSplash[5]}, - {GORE_SPLASH + 5, GORE_SPLASH_RATE, nullptr, &s_GoreSplash[6]}, - {GORE_SPLASH + 5, GORE_SPLASH_RATE, &AF(DoSuicide), &s_GoreSplash[6]} + {SPR_GORE_SPLASH, 'A', GORE_SPLASH_RATE, nullptr, &s_GoreSplash[1]}, + {SPR_GORE_SPLASH, 'B', GORE_SPLASH_RATE, nullptr, &s_GoreSplash[2]}, + {SPR_GORE_SPLASH, 'C', GORE_SPLASH_RATE, nullptr, &s_GoreSplash[3]}, + {SPR_GORE_SPLASH, 'D', GORE_SPLASH_RATE, nullptr, &s_GoreSplash[4]}, + {SPR_GORE_SPLASH, 'E', GORE_SPLASH_RATE, nullptr, &s_GoreSplash[5]}, + {SPR_GORE_SPLASH, 'F', GORE_SPLASH_RATE, nullptr, &s_GoreSplash[6]}, + {SPR_GORE_SPLASH, 'F', GORE_SPLASH_RATE, &AF(DoSuicide), &s_GoreSplash[6]} }; ////////////////////////////////////////////// @@ -1258,31 +919,31 @@ STATE s_GoreSplash[] = // regular bolt from heart STATE s_Plasma[] = { - {PLASMA + 0, PLASMA_RATE, &AF(DoPlasma), &s_Plasma[1]}, - {PLASMA + 1, PLASMA_RATE, &AF(DoPlasma), &s_Plasma[2]}, - {PLASMA + 2, PLASMA_RATE, &AF(DoPlasma), &s_Plasma[0]} + {SPR_PLASMA, 'A', PLASMA_RATE, &AF(DoPlasma), &s_Plasma[1]}, + {SPR_PLASMA, 'B', PLASMA_RATE, &AF(DoPlasma), &s_Plasma[2]}, + {SPR_PLASMA, 'C', PLASMA_RATE, &AF(DoPlasma), &s_Plasma[0]} }; // follows actor spewing blood #define PLASMA_Drip 1562 //2420 STATE s_PlasmaFountain[] = { - {PLASMA_Drip + 0, PLASMA_RATE, &AF(DoPlasmaFountain), &s_PlasmaFountain[1]}, - {PLASMA_Drip + 1, PLASMA_RATE, &AF(DoPlasmaFountain), &s_PlasmaFountain[2]}, - {PLASMA_Drip + 2, PLASMA_RATE, &AF(DoPlasmaFountain), &s_PlasmaFountain[3]}, - {PLASMA_Drip + 3, PLASMA_RATE, &AF(DoPlasmaFountain), &s_PlasmaFountain[0]}, + {SPR_PLASMA_Drip, 'A', PLASMA_RATE, &AF(DoPlasmaFountain), &s_PlasmaFountain[1]}, + {SPR_PLASMA_Drip, 'B', PLASMA_RATE, &AF(DoPlasmaFountain), &s_PlasmaFountain[2]}, + {SPR_PLASMA_Drip, 'C', PLASMA_RATE, &AF(DoPlasmaFountain), &s_PlasmaFountain[3]}, + {SPR_PLASMA_Drip, 'D', PLASMA_RATE, &AF(DoPlasmaFountain), &s_PlasmaFountain[0]}, }; #define PLASMA_Drip_RATE 12 STATE s_PlasmaDrip[] = { - {PLASMA_Drip + 0, PLASMA_Drip_RATE, &AF(DoShrapJumpFall), &s_PlasmaDrip[1]}, - {PLASMA_Drip + 1, PLASMA_Drip_RATE, &AF(DoShrapJumpFall), &s_PlasmaDrip[2]}, - {PLASMA_Drip + 2, PLASMA_Drip_RATE, &AF(DoShrapJumpFall), &s_PlasmaDrip[3]}, - {PLASMA_Drip + 3, PLASMA_Drip_RATE, &AF(DoShrapJumpFall), &s_PlasmaDrip[4]}, - {PLASMA_Drip + 4, PLASMA_Drip_RATE, &AF(DoShrapJumpFall), &s_PlasmaDrip[5]}, - {PLASMA_Drip + 5, PLASMA_Drip_RATE, &AF(DoShrapJumpFall), &s_PlasmaDrip[6]}, - {PLASMA_Drip + 7, PLASMA_Drip_RATE, &AF(DoSuicide), &s_PlasmaDrip[6]} + {SPR_PLASMA_Drip, 'A', PLASMA_Drip_RATE, &AF(DoShrapJumpFall), &s_PlasmaDrip[1]}, + {SPR_PLASMA_Drip, 'B', PLASMA_Drip_RATE, &AF(DoShrapJumpFall), &s_PlasmaDrip[2]}, + {SPR_PLASMA_Drip, 'C', PLASMA_Drip_RATE, &AF(DoShrapJumpFall), &s_PlasmaDrip[3]}, + {SPR_PLASMA_Drip, 'D', PLASMA_Drip_RATE, &AF(DoShrapJumpFall), &s_PlasmaDrip[4]}, + {SPR_PLASMA_Drip, 'E', PLASMA_Drip_RATE, &AF(DoShrapJumpFall), &s_PlasmaDrip[5]}, + {SPR_PLASMA_Drip, 'F', PLASMA_Drip_RATE, &AF(DoShrapJumpFall), &s_PlasmaDrip[6]}, + {SPR_PLASMA_Drip, 'H', PLASMA_Drip_RATE, &AF(DoSuicide), &s_PlasmaDrip[6]} }; #define PLASMA_DONE 2061 @@ -1291,59 +952,59 @@ STATE s_PlasmaDrip[] = STATE s_PlasmaDone[] = { - {PLASMA + 0, PLASMA_DONE_RATE, &AF(DoPlasmaDone), &s_PlasmaDone[1]}, - {PLASMA + 2, PLASMA_DONE_RATE, &AF(DoPlasmaDone), &s_PlasmaDone[2]}, - {PLASMA + 1, PLASMA_DONE_RATE, &AF(DoPlasmaDone), &s_PlasmaDone[0]} + {SPR_PLASMA, 'A', PLASMA_DONE_RATE, &AF(DoPlasmaDone), &s_PlasmaDone[1]}, + {SPR_PLASMA, 'C', PLASMA_DONE_RATE, &AF(DoPlasmaDone), &s_PlasmaDone[2]}, + {SPR_PLASMA, 'B', PLASMA_DONE_RATE, &AF(DoPlasmaDone), &s_PlasmaDone[0]} }; #define TELEPORT_EFFECT 3240 #define TELEPORT_EFFECT_RATE 6 STATE s_TeleportEffect[] = { - {TELEPORT_EFFECT + 0, TELEPORT_EFFECT_RATE, nullptr, &s_TeleportEffect[1]}, - {TELEPORT_EFFECT + 1, TELEPORT_EFFECT_RATE, nullptr, &s_TeleportEffect[2]}, - {TELEPORT_EFFECT + 2, TELEPORT_EFFECT_RATE, nullptr, &s_TeleportEffect[3]}, - {TELEPORT_EFFECT + 3, TELEPORT_EFFECT_RATE, nullptr, &s_TeleportEffect[4]}, - {TELEPORT_EFFECT + 4, TELEPORT_EFFECT_RATE, nullptr, &s_TeleportEffect[5]}, - {TELEPORT_EFFECT + 5, TELEPORT_EFFECT_RATE, nullptr, &s_TeleportEffect[6]}, - {TELEPORT_EFFECT + 6, TELEPORT_EFFECT_RATE, nullptr, &s_TeleportEffect[7]}, - {TELEPORT_EFFECT + 7, TELEPORT_EFFECT_RATE, nullptr, &s_TeleportEffect[8]}, - {TELEPORT_EFFECT + 8, TELEPORT_EFFECT_RATE, nullptr, &s_TeleportEffect[9]}, - {TELEPORT_EFFECT + 9, TELEPORT_EFFECT_RATE, nullptr, &s_TeleportEffect[10]}, - {TELEPORT_EFFECT + 10, TELEPORT_EFFECT_RATE, nullptr, &s_TeleportEffect[11]}, - {TELEPORT_EFFECT + 11, TELEPORT_EFFECT_RATE, nullptr, &s_TeleportEffect[12]}, - {TELEPORT_EFFECT + 12, TELEPORT_EFFECT_RATE, nullptr, &s_TeleportEffect[13]}, - {TELEPORT_EFFECT + 13, TELEPORT_EFFECT_RATE, nullptr, &s_TeleportEffect[14]}, - {TELEPORT_EFFECT + 14, TELEPORT_EFFECT_RATE, nullptr, &s_TeleportEffect[15]}, - {TELEPORT_EFFECT + 15, TELEPORT_EFFECT_RATE, nullptr, &s_TeleportEffect[16]}, - {TELEPORT_EFFECT + 16, TELEPORT_EFFECT_RATE, nullptr, &s_TeleportEffect[17]}, - {TELEPORT_EFFECT + 17, TELEPORT_EFFECT_RATE, nullptr, &s_TeleportEffect[18]}, - {TELEPORT_EFFECT + 17, TELEPORT_EFFECT_RATE, &AF(DoSuicide), &s_TeleportEffect[18]}, + {SPR_TELEPORT_EFFECT, 'A', TELEPORT_EFFECT_RATE, nullptr, &s_TeleportEffect[1]}, + {SPR_TELEPORT_EFFECT, 'B', TELEPORT_EFFECT_RATE, nullptr, &s_TeleportEffect[2]}, + {SPR_TELEPORT_EFFECT, 'C', TELEPORT_EFFECT_RATE, nullptr, &s_TeleportEffect[3]}, + {SPR_TELEPORT_EFFECT, 'D', TELEPORT_EFFECT_RATE, nullptr, &s_TeleportEffect[4]}, + {SPR_TELEPORT_EFFECT, 'E', TELEPORT_EFFECT_RATE, nullptr, &s_TeleportEffect[5]}, + {SPR_TELEPORT_EFFECT, 'F', TELEPORT_EFFECT_RATE, nullptr, &s_TeleportEffect[6]}, + {SPR_TELEPORT_EFFECT, 'G', TELEPORT_EFFECT_RATE, nullptr, &s_TeleportEffect[7]}, + {SPR_TELEPORT_EFFECT, 'H', TELEPORT_EFFECT_RATE, nullptr, &s_TeleportEffect[8]}, + {SPR_TELEPORT_EFFECT, 'I', TELEPORT_EFFECT_RATE, nullptr, &s_TeleportEffect[9]}, + {SPR_TELEPORT_EFFECT, 'J', TELEPORT_EFFECT_RATE, nullptr, &s_TeleportEffect[10]}, + {SPR_TELEPORT_EFFECT, 'K', TELEPORT_EFFECT_RATE, nullptr, &s_TeleportEffect[11]}, + {SPR_TELEPORT_EFFECT, 'L', TELEPORT_EFFECT_RATE, nullptr, &s_TeleportEffect[12]}, + {SPR_TELEPORT_EFFECT, 'M', TELEPORT_EFFECT_RATE, nullptr, &s_TeleportEffect[13]}, + {SPR_TELEPORT_EFFECT, 'N', TELEPORT_EFFECT_RATE, nullptr, &s_TeleportEffect[14]}, + {SPR_TELEPORT_EFFECT, 'O', TELEPORT_EFFECT_RATE, nullptr, &s_TeleportEffect[15]}, + {SPR_TELEPORT_EFFECT, 'P', TELEPORT_EFFECT_RATE, nullptr, &s_TeleportEffect[16]}, + {SPR_TELEPORT_EFFECT, 'Q', TELEPORT_EFFECT_RATE, nullptr, &s_TeleportEffect[17]}, + {SPR_TELEPORT_EFFECT, 'R', TELEPORT_EFFECT_RATE, nullptr, &s_TeleportEffect[18]}, + {SPR_TELEPORT_EFFECT, 'R', TELEPORT_EFFECT_RATE, &AF(DoSuicide), &s_TeleportEffect[18]}, }; // Spawn a RIPPER teleport effect STATE s_TeleportEffect2[] = { - {TELEPORT_EFFECT + 0, TELEPORT_EFFECT_RATE, nullptr, &s_TeleportEffect2[1]}, - {TELEPORT_EFFECT + 1, TELEPORT_EFFECT_RATE, nullptr, &s_TeleportEffect2[2]}, - {TELEPORT_EFFECT + 2, TELEPORT_EFFECT_RATE, nullptr, &s_TeleportEffect2[3]}, - {TELEPORT_EFFECT + 3, TELEPORT_EFFECT_RATE, nullptr, &s_TeleportEffect2[4]}, - {TELEPORT_EFFECT + 4, TELEPORT_EFFECT_RATE, nullptr, &s_TeleportEffect2[5]}, - {TELEPORT_EFFECT + 5, TELEPORT_EFFECT_RATE, nullptr, &s_TeleportEffect2[6]}, - {TELEPORT_EFFECT + 6, TELEPORT_EFFECT_RATE, nullptr, &s_TeleportEffect2[7]}, - {TELEPORT_EFFECT + 7, TELEPORT_EFFECT_RATE, nullptr, &s_TeleportEffect2[8]}, - {TELEPORT_EFFECT + 8, TELEPORT_EFFECT_RATE, nullptr, &s_TeleportEffect2[9]}, - {TELEPORT_EFFECT + 9, TELEPORT_EFFECT_RATE, nullptr, &s_TeleportEffect2[10]}, - {TELEPORT_EFFECT + 10, TELEPORT_EFFECT_RATE, nullptr, &s_TeleportEffect2[11]}, - {TELEPORT_EFFECT + 11, TELEPORT_EFFECT_RATE, nullptr, &s_TeleportEffect2[12]}, - {TELEPORT_EFFECT + 12, TELEPORT_EFFECT_RATE, nullptr, &s_TeleportEffect2[13]}, - {TELEPORT_EFFECT + 13, TELEPORT_EFFECT_RATE, nullptr, &s_TeleportEffect2[14]}, - {TELEPORT_EFFECT + 14, TELEPORT_EFFECT_RATE, nullptr, &s_TeleportEffect2[15]}, - {TELEPORT_EFFECT + 15, TELEPORT_EFFECT_RATE, nullptr, &s_TeleportEffect2[16]}, - {TELEPORT_EFFECT + 16, TELEPORT_EFFECT_RATE, nullptr, &s_TeleportEffect2[17]}, - {TELEPORT_EFFECT + 17, TELEPORT_EFFECT_RATE, nullptr, &s_TeleportEffect2[18]}, - {TELEPORT_EFFECT + 17, SF_QUICK_CALL, &AF(DoTeleRipper), &s_TeleportEffect2[19]}, - {TELEPORT_EFFECT + 17, TELEPORT_EFFECT_RATE, &AF(DoSuicide), &s_TeleportEffect2[19]}, + {SPR_TELEPORT_EFFECT, 'A', TELEPORT_EFFECT_RATE, nullptr, &s_TeleportEffect2[1]}, + {SPR_TELEPORT_EFFECT, 'B', TELEPORT_EFFECT_RATE, nullptr, &s_TeleportEffect2[2]}, + {SPR_TELEPORT_EFFECT, 'C', TELEPORT_EFFECT_RATE, nullptr, &s_TeleportEffect2[3]}, + {SPR_TELEPORT_EFFECT, 'D', TELEPORT_EFFECT_RATE, nullptr, &s_TeleportEffect2[4]}, + {SPR_TELEPORT_EFFECT, 'E', TELEPORT_EFFECT_RATE, nullptr, &s_TeleportEffect2[5]}, + {SPR_TELEPORT_EFFECT, 'F', TELEPORT_EFFECT_RATE, nullptr, &s_TeleportEffect2[6]}, + {SPR_TELEPORT_EFFECT, 'G', TELEPORT_EFFECT_RATE, nullptr, &s_TeleportEffect2[7]}, + {SPR_TELEPORT_EFFECT, 'H', TELEPORT_EFFECT_RATE, nullptr, &s_TeleportEffect2[8]}, + {SPR_TELEPORT_EFFECT, 'I', TELEPORT_EFFECT_RATE, nullptr, &s_TeleportEffect2[9]}, + {SPR_TELEPORT_EFFECT, 'J', TELEPORT_EFFECT_RATE, nullptr, &s_TeleportEffect2[10]}, + {SPR_TELEPORT_EFFECT, 'K', TELEPORT_EFFECT_RATE, nullptr, &s_TeleportEffect2[11]}, + {SPR_TELEPORT_EFFECT, 'L', TELEPORT_EFFECT_RATE, nullptr, &s_TeleportEffect2[12]}, + {SPR_TELEPORT_EFFECT, 'M', TELEPORT_EFFECT_RATE, nullptr, &s_TeleportEffect2[13]}, + {SPR_TELEPORT_EFFECT, 'N', TELEPORT_EFFECT_RATE, nullptr, &s_TeleportEffect2[14]}, + {SPR_TELEPORT_EFFECT, 'N', TELEPORT_EFFECT_RATE, nullptr, &s_TeleportEffect2[15]}, + {SPR_TELEPORT_EFFECT, 'O', TELEPORT_EFFECT_RATE, nullptr, &s_TeleportEffect2[16]}, + {SPR_TELEPORT_EFFECT, 'P', TELEPORT_EFFECT_RATE, nullptr, &s_TeleportEffect2[17]}, + {SPR_TELEPORT_EFFECT, 'Q', TELEPORT_EFFECT_RATE, nullptr, &s_TeleportEffect2[18]}, + {SPR_TELEPORT_EFFECT, 'R', SF_QUICK_CALL, &AF(DoTeleRipper), &s_TeleportEffect2[19]}, + {SPR_TELEPORT_EFFECT, 'R', TELEPORT_EFFECT_RATE, &AF(DoSuicide), &s_TeleportEffect2[19]}, }; @@ -1354,18 +1015,18 @@ STATE s_TeleportEffect2[] = STATE s_Electro[] = { - {ELECTRO + 0, 12, &AF(DoElectro), &s_Electro[1]}, - {ELECTRO + 1, 12, &AF(DoElectro), &s_Electro[2]}, - {ELECTRO + 2, 12, &AF(DoElectro), &s_Electro[3]}, - {ELECTRO + 3, 12, &AF(DoElectro), &s_Electro[0]} + {SPR_ELECTRO, 'A', 12, &AF(DoElectro), &s_Electro[1]}, + {SPR_ELECTRO, 'B', 12, &AF(DoElectro), &s_Electro[2]}, + {SPR_ELECTRO, 'C', 12, &AF(DoElectro), &s_Electro[3]}, + {SPR_ELECTRO, 'D', 12, &AF(DoElectro), &s_Electro[0]} }; STATE s_ElectroShrap[] = { - {ELECTRO + 0, 12, &AF(DoShrapDamage), &s_ElectroShrap[1]}, - {ELECTRO + 1, 12, &AF(DoShrapDamage), &s_ElectroShrap[2]}, - {ELECTRO + 2, 12, &AF(DoShrapDamage), &s_ElectroShrap[3]}, - {ELECTRO + 3, 12, &AF(DoShrapDamage), &s_ElectroShrap[0]} + {SPR_ELECTRO, 'A', 12, &AF(DoShrapDamage), &s_ElectroShrap[1]}, + {SPR_ELECTRO, 'B', 12, &AF(DoShrapDamage), &s_ElectroShrap[2]}, + {SPR_ELECTRO, 'C', 12, &AF(DoShrapDamage), &s_ElectroShrap[3]}, + {SPR_ELECTRO, 'D', 12, &AF(DoShrapDamage), &s_ElectroShrap[0]} }; ////////////////////// @@ -1381,90 +1042,90 @@ STATE s_ElectroShrap[] = #else STATE s_GrenadeSmallExp[] = { - {GRENADE_EXP + 0, GRENADE_EXP_RATE, nullptr, &s_GrenadeSmallExp[1]}, - {GRENADE_EXP + 1, GRENADE_EXP_RATE, nullptr, &s_GrenadeSmallExp[2]}, - {GRENADE_EXP + 2, GRENADE_EXP_RATE, nullptr, &s_GrenadeSmallExp[3]}, - {GRENADE_EXP + 3, GRENADE_EXP_RATE, nullptr, &s_GrenadeSmallExp[4]}, - {GRENADE_EXP + 4, GRENADE_EXP_RATE, nullptr, &s_GrenadeSmallExp[5]}, - {GRENADE_EXP + 5, GRENADE_EXP_RATE, nullptr, &s_GrenadeSmallExp[6]}, - {GRENADE_EXP + 6, GRENADE_EXP_RATE, nullptr, &s_GrenadeSmallExp[7]}, - {GRENADE_EXP + 7, GRENADE_EXP_RATE, nullptr, &s_GrenadeSmallExp[8]}, - {GRENADE_EXP + 8, GRENADE_EXP_RATE, nullptr, &s_GrenadeSmallExp[9]}, - {GRENADE_EXP + 9, GRENADE_EXP_RATE, nullptr, &s_GrenadeSmallExp[10]}, - {GRENADE_EXP + 10, GRENADE_EXP_RATE, nullptr, &s_GrenadeSmallExp[11]}, - {GRENADE_EXP + 11, GRENADE_EXP_RATE, nullptr, &s_GrenadeSmallExp[12]}, - {GRENADE_EXP + 12, GRENADE_EXP_RATE, nullptr, &s_GrenadeSmallExp[13]}, - {GRENADE_EXP + 13, GRENADE_EXP_RATE, nullptr, &s_GrenadeSmallExp[14]}, - {GRENADE_EXP + 14, GRENADE_EXP_RATE, nullptr, &s_GrenadeSmallExp[15]}, - {GRENADE_EXP + 15, GRENADE_EXP_RATE, nullptr, &s_GrenadeSmallExp[16]}, - {GRENADE_EXP + 16, GRENADE_EXP_RATE, nullptr, &s_GrenadeSmallExp[17]}, - {GRENADE_EXP + 17, GRENADE_EXP_RATE, nullptr, &s_GrenadeSmallExp[18]}, - {GRENADE_EXP + 18, GRENADE_EXP_RATE, nullptr, &s_GrenadeSmallExp[19]}, - {GRENADE_EXP + 19, GRENADE_EXP_RATE, nullptr, &s_GrenadeSmallExp[20]}, - {GRENADE_EXP + 20, GRENADE_EXP_RATE, nullptr, &s_GrenadeSmallExp[21]}, - {GRENADE_EXP + 21, GRENADE_EXP_RATE, nullptr, &s_GrenadeSmallExp[22]}, - {GRENADE_EXP + 21, 100, &AF(DoSuicide), &s_GrenadeSmallExp[22]} + {SPR_GRENADE_EXP, 'A', GRENADE_EXP_RATE, nullptr, &s_GrenadeSmallExp[1]}, + {SPR_GRENADE_EXP, 'B', GRENADE_EXP_RATE, nullptr, &s_GrenadeSmallExp[2]}, + {SPR_GRENADE_EXP, 'C', GRENADE_EXP_RATE, nullptr, &s_GrenadeSmallExp[3]}, + {SPR_GRENADE_EXP, 'D', GRENADE_EXP_RATE, nullptr, &s_GrenadeSmallExp[4]}, + {SPR_GRENADE_EXP, 'E', GRENADE_EXP_RATE, nullptr, &s_GrenadeSmallExp[5]}, + {SPR_GRENADE_EXP, 'F', GRENADE_EXP_RATE, nullptr, &s_GrenadeSmallExp[6]}, + {SPR_GRENADE_EXP, 'G', GRENADE_EXP_RATE, nullptr, &s_GrenadeSmallExp[7]}, + {SPR_GRENADE_EXP, 'H', GRENADE_EXP_RATE, nullptr, &s_GrenadeSmallExp[8]}, + {SPR_GRENADE_EXP, 'I', GRENADE_EXP_RATE, nullptr, &s_GrenadeSmallExp[9]}, + {SPR_GRENADE_EXP, 'J', GRENADE_EXP_RATE, nullptr, &s_GrenadeSmallExp[10]}, + {SPR_GRENADE_EXP, 'K', GRENADE_EXP_RATE, nullptr, &s_GrenadeSmallExp[11]}, + {SPR_GRENADE_EXP, 'L', GRENADE_EXP_RATE, nullptr, &s_GrenadeSmallExp[12]}, + {SPR_GRENADE_EXP, 'M', GRENADE_EXP_RATE, nullptr, &s_GrenadeSmallExp[13]}, + {SPR_GRENADE_EXP, 'N', GRENADE_EXP_RATE, nullptr, &s_GrenadeSmallExp[14]}, + {SPR_GRENADE_EXP, 'N', GRENADE_EXP_RATE, nullptr, &s_GrenadeSmallExp[15]}, + {SPR_GRENADE_EXP, 'O', GRENADE_EXP_RATE, nullptr, &s_GrenadeSmallExp[16]}, + {SPR_GRENADE_EXP, 'P', GRENADE_EXP_RATE, nullptr, &s_GrenadeSmallExp[17]}, + {SPR_GRENADE_EXP, 'Q', GRENADE_EXP_RATE, nullptr, &s_GrenadeSmallExp[18]}, + {SPR_GRENADE_EXP, 'R', GRENADE_EXP_RATE, nullptr, &s_GrenadeSmallExp[19]}, + {SPR_GRENADE_EXP, 'S', GRENADE_EXP_RATE, nullptr, &s_GrenadeSmallExp[20]}, + {SPR_GRENADE_EXP, 'T', GRENADE_EXP_RATE, nullptr, &s_GrenadeSmallExp[21]}, + {SPR_GRENADE_EXP, 'U', GRENADE_EXP_RATE, nullptr, &s_GrenadeSmallExp[22]}, + {SPR_GRENADE_EXP, 'U', 100, &AF(DoSuicide), &s_GrenadeSmallExp[22]} }; STATE s_GrenadeExp[] = { - {GRENADE_EXP + 0, GRENADE_EXP_RATE, nullptr, &s_GrenadeExp[1]}, - {GRENADE_EXP + 1, GRENADE_EXP_RATE, nullptr, &s_GrenadeExp[2]}, - {GRENADE_EXP + 2, GRENADE_EXP_RATE, nullptr, &s_GrenadeExp[3]}, - {GRENADE_EXP + 3, GRENADE_EXP_RATE, nullptr, &s_GrenadeExp[4]}, - {GRENADE_EXP + 4, GRENADE_EXP_RATE, nullptr, &s_GrenadeExp[5]}, - {GRENADE_EXP + 5, GRENADE_EXP_RATE, nullptr, &s_GrenadeExp[6]}, - {GRENADE_EXP + 6, GRENADE_EXP_RATE, nullptr, &s_GrenadeExp[7]}, - {GRENADE_EXP + 6, SF_QUICK_CALL, &AF(SpawnGrenadeSmallExp), &s_GrenadeExp[8]}, - {GRENADE_EXP + 7, GRENADE_EXP_RATE, nullptr, &s_GrenadeExp[9]}, - {GRENADE_EXP + 8, GRENADE_EXP_RATE, nullptr, &s_GrenadeExp[10]}, - {GRENADE_EXP + 9, GRENADE_EXP_RATE, nullptr, &s_GrenadeExp[11]}, - {GRENADE_EXP + 10, GRENADE_EXP_RATE, nullptr, &s_GrenadeExp[12]}, - {GRENADE_EXP + 11, GRENADE_EXP_RATE, nullptr, &s_GrenadeExp[13]}, - {GRENADE_EXP + 12, SF_QUICK_CALL, &AF(SpawnGrenadeSmallExp), &s_GrenadeExp[14]}, - {GRENADE_EXP + 12, GRENADE_EXP_RATE, nullptr, &s_GrenadeExp[15]}, - {GRENADE_EXP + 13, GRENADE_EXP_RATE, nullptr, &s_GrenadeExp[16]}, - {GRENADE_EXP + 14, GRENADE_EXP_RATE, nullptr, &s_GrenadeExp[17]}, - {GRENADE_EXP + 15, GRENADE_EXP_RATE, nullptr, &s_GrenadeExp[18]}, - {GRENADE_EXP + 16, GRENADE_EXP_RATE, nullptr, &s_GrenadeExp[19]}, - {GRENADE_EXP + 17, SF_QUICK_CALL, &AF(SpawnGrenadeSmallExp), &s_GrenadeExp[20]}, - {GRENADE_EXP + 17, GRENADE_EXP_RATE, nullptr, &s_GrenadeExp[21]}, - {GRENADE_EXP + 18, GRENADE_EXP_RATE, nullptr, &s_GrenadeExp[22]}, - {GRENADE_EXP + 19, GRENADE_EXP_RATE, nullptr, &s_GrenadeExp[23]}, - {GRENADE_EXP + 20, GRENADE_EXP_RATE, nullptr, &s_GrenadeExp[24]}, - {GRENADE_EXP + 21, GRENADE_EXP_RATE, nullptr, &s_GrenadeExp[25]}, - {GRENADE_EXP + 21, 100, &AF(DoSuicide), &s_GrenadeExp[25]} + {SPR_GRENADE_EXP, 'A', GRENADE_EXP_RATE, nullptr, &s_GrenadeExp[1]}, + {SPR_GRENADE_EXP, 'B', GRENADE_EXP_RATE, nullptr, &s_GrenadeExp[2]}, + {SPR_GRENADE_EXP, 'C', GRENADE_EXP_RATE, nullptr, &s_GrenadeExp[3]}, + {SPR_GRENADE_EXP, 'D', GRENADE_EXP_RATE, nullptr, &s_GrenadeExp[4]}, + {SPR_GRENADE_EXP, 'E', GRENADE_EXP_RATE, nullptr, &s_GrenadeExp[5]}, + {SPR_GRENADE_EXP, 'F', GRENADE_EXP_RATE, nullptr, &s_GrenadeExp[6]}, + {SPR_GRENADE_EXP, 'G', GRENADE_EXP_RATE, nullptr, &s_GrenadeExp[7]}, + {SPR_GRENADE_EXP, 'G', SF_QUICK_CALL, &AF(SpawnGrenadeSmallExp), &s_GrenadeExp[8]}, + {SPR_GRENADE_EXP, 'H', GRENADE_EXP_RATE, nullptr, &s_GrenadeExp[9]}, + {SPR_GRENADE_EXP, 'I', GRENADE_EXP_RATE, nullptr, &s_GrenadeExp[10]}, + {SPR_GRENADE_EXP, 'J', GRENADE_EXP_RATE, nullptr, &s_GrenadeExp[11]}, + {SPR_GRENADE_EXP, 'K', GRENADE_EXP_RATE, nullptr, &s_GrenadeExp[12]}, + {SPR_GRENADE_EXP, 'L', GRENADE_EXP_RATE, nullptr, &s_GrenadeExp[13]}, + {SPR_GRENADE_EXP, 'M', SF_QUICK_CALL, &AF(SpawnGrenadeSmallExp), &s_GrenadeExp[14]}, + {SPR_GRENADE_EXP, 'M', GRENADE_EXP_RATE, nullptr, &s_GrenadeExp[15]}, + {SPR_GRENADE_EXP, 'N', GRENADE_EXP_RATE, nullptr, &s_GrenadeExp[16]}, + {SPR_GRENADE_EXP, 'O', GRENADE_EXP_RATE, nullptr, &s_GrenadeExp[17]}, + {SPR_GRENADE_EXP, 'P', GRENADE_EXP_RATE, nullptr, &s_GrenadeExp[18]}, + {SPR_GRENADE_EXP, 'Q', GRENADE_EXP_RATE, nullptr, &s_GrenadeExp[19]}, + {SPR_GRENADE_EXP, 'R', SF_QUICK_CALL, &AF(SpawnGrenadeSmallExp), &s_GrenadeExp[20]}, + {SPR_GRENADE_EXP, 'R', GRENADE_EXP_RATE, nullptr, &s_GrenadeExp[21]}, + {SPR_GRENADE_EXP, 'S', GRENADE_EXP_RATE, nullptr, &s_GrenadeExp[22]}, + {SPR_GRENADE_EXP, 'T', GRENADE_EXP_RATE, nullptr, &s_GrenadeExp[23]}, + {SPR_GRENADE_EXP, 'U', GRENADE_EXP_RATE, nullptr, &s_GrenadeExp[24]}, + {SPR_GRENADE_EXP, 'V', GRENADE_EXP_RATE, nullptr, &s_GrenadeExp[25]}, + {SPR_GRENADE_EXP, 'V', 100, &AF(DoSuicide), &s_GrenadeExp[25]} }; #endif #define MINE_EXP GRENADE_EXP+1 STATE s_MineExp[] = { - {GRENADE_EXP + 0, GRENADE_EXP_RATE, nullptr, &s_MineExp[1]}, - {GRENADE_EXP + 1, GRENADE_EXP_RATE, nullptr, &s_MineExp[2]}, - {GRENADE_EXP + 2, GRENADE_EXP_RATE, nullptr, &s_MineExp[3]}, - {GRENADE_EXP + 3, 0|SF_QUICK_CALL, &AF(DoMineExp), &s_MineExp[4]}, - {GRENADE_EXP + 3, GRENADE_EXP_RATE, nullptr, &s_MineExp[5]}, - {GRENADE_EXP + 4, GRENADE_EXP_RATE, nullptr, &s_MineExp[6]}, - {GRENADE_EXP + 5, GRENADE_EXP_RATE, nullptr, &s_MineExp[7]}, - {GRENADE_EXP + 6, GRENADE_EXP_RATE, nullptr, &s_MineExp[8]}, - {GRENADE_EXP + 7, GRENADE_EXP_RATE, nullptr, &s_MineExp[9]}, - {GRENADE_EXP + 8, GRENADE_EXP_RATE, nullptr, &s_MineExp[10]}, - {GRENADE_EXP + 9, GRENADE_EXP_RATE, nullptr, &s_MineExp[11]}, - {GRENADE_EXP + 10, GRENADE_EXP_RATE, nullptr, &s_MineExp[12]}, - {GRENADE_EXP + 11, GRENADE_EXP_RATE, nullptr, &s_MineExp[13]}, - {GRENADE_EXP + 12, GRENADE_EXP_RATE, nullptr, &s_MineExp[14]}, - {GRENADE_EXP + 13, GRENADE_EXP_RATE, nullptr, &s_MineExp[15]}, - {GRENADE_EXP + 14, GRENADE_EXP_RATE, nullptr, &s_MineExp[16]}, - {GRENADE_EXP + 15, GRENADE_EXP_RATE, nullptr, &s_MineExp[17]}, - {GRENADE_EXP + 16, GRENADE_EXP_RATE, nullptr, &s_MineExp[18]}, - {GRENADE_EXP + 17, GRENADE_EXP_RATE, nullptr, &s_MineExp[19]}, - {GRENADE_EXP + 17, 0|SF_QUICK_CALL, &AF(DoMineExpMine), &s_MineExp[20]}, - {GRENADE_EXP + 18, GRENADE_EXP_RATE, nullptr, &s_MineExp[21]}, - {GRENADE_EXP + 19, GRENADE_EXP_RATE, nullptr, &s_MineExp[22]}, - {GRENADE_EXP + 20, GRENADE_EXP_RATE, nullptr, &s_MineExp[23]}, - {GRENADE_EXP + 21, GRENADE_EXP_RATE, nullptr, &s_MineExp[24]}, - {GRENADE_EXP + 21, 100, &AF(DoSuicide), &s_MineExp[24]} + {SPR_GRENADE_EXP, 'A', GRENADE_EXP_RATE, nullptr, &s_MineExp[1]}, + {SPR_GRENADE_EXP, 'B', GRENADE_EXP_RATE, nullptr, &s_MineExp[2]}, + {SPR_GRENADE_EXP, 'C', GRENADE_EXP_RATE, nullptr, &s_MineExp[3]}, + {SPR_GRENADE_EXP, 'D', 0|SF_QUICK_CALL, &AF(DoMineExp), &s_MineExp[4]}, + {SPR_GRENADE_EXP, 'D', GRENADE_EXP_RATE, nullptr, &s_MineExp[5]}, + {SPR_GRENADE_EXP, 'E', GRENADE_EXP_RATE, nullptr, &s_MineExp[6]}, + {SPR_GRENADE_EXP, 'F', GRENADE_EXP_RATE, nullptr, &s_MineExp[7]}, + {SPR_GRENADE_EXP, 'G', GRENADE_EXP_RATE, nullptr, &s_MineExp[8]}, + {SPR_GRENADE_EXP, 'H', GRENADE_EXP_RATE, nullptr, &s_MineExp[9]}, + {SPR_GRENADE_EXP, 'I', GRENADE_EXP_RATE, nullptr, &s_MineExp[10]}, + {SPR_GRENADE_EXP, 'J', GRENADE_EXP_RATE, nullptr, &s_MineExp[11]}, + {SPR_GRENADE_EXP, 'K', GRENADE_EXP_RATE, nullptr, &s_MineExp[12]}, + {SPR_GRENADE_EXP, 'L', GRENADE_EXP_RATE, nullptr, &s_MineExp[13]}, + {SPR_GRENADE_EXP, 'M', GRENADE_EXP_RATE, nullptr, &s_MineExp[14]}, + {SPR_GRENADE_EXP, 'N', GRENADE_EXP_RATE, nullptr, &s_MineExp[15]}, + {SPR_GRENADE_EXP, 'O', GRENADE_EXP_RATE, nullptr, &s_MineExp[16]}, + {SPR_GRENADE_EXP, 'P', GRENADE_EXP_RATE, nullptr, &s_MineExp[17]}, + {SPR_GRENADE_EXP, 'Q', GRENADE_EXP_RATE, nullptr, &s_MineExp[18]}, + {SPR_GRENADE_EXP, 'R', GRENADE_EXP_RATE, nullptr, &s_MineExp[19]}, + {SPR_GRENADE_EXP, 'R', 0 | SF_QUICK_CALL, &AF(DoMineExpMine), &s_MineExp[20]}, + {SPR_GRENADE_EXP, 'S', GRENADE_EXP_RATE, nullptr, &s_MineExp[21]}, + {SPR_GRENADE_EXP, 'T', GRENADE_EXP_RATE, nullptr, &s_MineExp[22]}, + {SPR_GRENADE_EXP, 'U', GRENADE_EXP_RATE, nullptr, &s_MineExp[23]}, + {SPR_GRENADE_EXP, 'V', GRENADE_EXP_RATE, nullptr, &s_MineExp[24]}, + {SPR_GRENADE_EXP, 'V', 100, &AF(DoSuicide), &s_MineExp[24]} }; #define EXP_RATE_W 7 @@ -1478,56 +1139,56 @@ STATE s_MineExp[] = STATE s_BasicExp[] = { - {EXP + 0, EXP_RATE_W, nullptr, &s_BasicExp[1]}, - {EXP + 1, EXP_RATE_W, nullptr, &s_BasicExp[2]}, - {EXP + 2, EXP_RATE_W, nullptr, &s_BasicExp[3]}, - {EXP + 3, EXP_RATE_W, nullptr, &s_BasicExp[4]}, - {EXP + 4, EXP_RATE_W, nullptr, &s_BasicExp[5]}, - {EXP + 5, EXP_RATE_W, nullptr, &s_BasicExp[6]}, - {EXP + 6, EXP_RATE_W, nullptr, &s_BasicExp[7]}, - {EXP + 7, EXP_RATE_W, nullptr, &s_BasicExp[8]}, - {EXP + 8, EXP_RATE_W, nullptr, &s_BasicExp[9]}, - {EXP + 9, EXP_RATE_W, nullptr, &s_BasicExp[10]}, - {EXP + 10, EXP_RATE_W, nullptr, &s_BasicExp[11]}, - {EXP + 11, EXP_RATE_W, nullptr, &s_BasicExp[12]}, - {EXP + 12, EXP_RATE_W, nullptr, &s_BasicExp[13]}, - {EXP + 13, EXP_RATE_W, nullptr, &s_BasicExp[14]}, - {EXP + 14, EXP_RATE_W, nullptr, &s_BasicExp[15]}, - {EXP + 15, EXP_RATE_W, nullptr, &s_BasicExp[16]}, - {EXP + 16, EXP_RATE_W, nullptr, &s_BasicExp[17]}, - {EXP + 17, EXP_RATE_W, nullptr, &s_BasicExp[18]}, - {EXP + 18, EXP_RATE_W, nullptr, &s_BasicExp[19]}, - {EXP + 19, EXP_RATE_W, nullptr, &s_BasicExp[20]}, - {EXP + 20, 100, &AF(DoSuicide), &s_BasicExp[0]} + {SPR_EXP, 'A', EXP_RATE_W, nullptr, &s_BasicExp[1]}, + {SPR_EXP, 'B', EXP_RATE_W, nullptr, &s_BasicExp[2]}, + {SPR_EXP, 'C', EXP_RATE_W, nullptr, &s_BasicExp[3]}, + {SPR_EXP, 'D', EXP_RATE_W, nullptr, &s_BasicExp[4]}, + {SPR_EXP, 'E', EXP_RATE_W, nullptr, &s_BasicExp[5]}, + {SPR_EXP, 'F', EXP_RATE_W, nullptr, &s_BasicExp[6]}, + {SPR_EXP, 'G', EXP_RATE_W, nullptr, &s_BasicExp[7]}, + {SPR_EXP, 'H', EXP_RATE_W, nullptr, &s_BasicExp[8]}, + {SPR_EXP, 'I', EXP_RATE_W, nullptr, &s_BasicExp[9]}, + {SPR_EXP, 'J', EXP_RATE_W, nullptr, &s_BasicExp[10]}, + {SPR_EXP, 'K', EXP_RATE_W, nullptr, &s_BasicExp[11]}, + {SPR_EXP, 'L', EXP_RATE_W, nullptr, &s_BasicExp[12]}, + {SPR_EXP, 'M', EXP_RATE_W, nullptr, &s_BasicExp[13]}, + {SPR_EXP, 'N', EXP_RATE_W, nullptr, &s_BasicExp[14]}, + {SPR_EXP, 'O', EXP_RATE_W, nullptr, &s_BasicExp[15]}, + {SPR_EXP, 'P', EXP_RATE_W, nullptr, &s_BasicExp[16]}, + {SPR_EXP, 'Q', EXP_RATE_W, nullptr, &s_BasicExp[17]}, + {SPR_EXP, 'R', EXP_RATE_W, nullptr, &s_BasicExp[18]}, + {SPR_EXP, 'R', EXP_RATE_W, nullptr, &s_BasicExp[19]}, + {SPR_EXP, 'S', EXP_RATE_W, nullptr, &s_BasicExp[20]}, + {SPR_EXP, 'T', 100, &AF(DoSuicide), &s_BasicExp[0]} }; #define MICRO_EXP_RATE 3 STATE s_MicroExp[] = { - {EXP + 0, MICRO_EXP_RATE, nullptr, &s_MicroExp[1]}, - {EXP + 0, SF_QUICK_CALL, &AF(DoExpDamageTest), &s_MicroExp[2]}, - {EXP + 1, MICRO_EXP_RATE, nullptr, &s_MicroExp[3]}, - {EXP + 2, MICRO_EXP_RATE, nullptr, &s_MicroExp[4]}, - {EXP + 3, MICRO_EXP_RATE, nullptr, &s_MicroExp[5]}, - {EXP + 4, MICRO_EXP_RATE, nullptr, &s_MicroExp[6]}, - {EXP + 5, MICRO_EXP_RATE, nullptr, &s_MicroExp[7]}, - {EXP + 6, MICRO_EXP_RATE, nullptr, &s_MicroExp[8]}, - {EXP + 7, MICRO_EXP_RATE, nullptr, &s_MicroExp[9]}, - {EXP + 8, MICRO_EXP_RATE, nullptr, &s_MicroExp[10]}, - {EXP + 9, MICRO_EXP_RATE, nullptr, &s_MicroExp[11]}, - {EXP + 10, MICRO_EXP_RATE, nullptr, &s_MicroExp[12]}, - {EXP + 11, MICRO_EXP_RATE, nullptr, &s_MicroExp[13]}, - {EXP + 12, MICRO_EXP_RATE, nullptr, &s_MicroExp[14]}, - {EXP + 13, MICRO_EXP_RATE, nullptr, &s_MicroExp[15]}, - {EXP + 14, MICRO_EXP_RATE, nullptr, &s_MicroExp[16]}, - {EXP + 15, MICRO_EXP_RATE, nullptr, &s_MicroExp[17]}, - {EXP + 16, MICRO_EXP_RATE, nullptr, &s_MicroExp[18]}, - {EXP + 17, MICRO_EXP_RATE, nullptr, &s_MicroExp[19]}, - {EXP + 18, MICRO_EXP_RATE, nullptr, &s_MicroExp[20]}, - {EXP + 19, MICRO_EXP_RATE, nullptr, &s_MicroExp[21]}, - {EXP + 20, MICRO_EXP_RATE, nullptr, &s_MicroExp[22]}, - {EXP + 20, 100, &AF(DoSuicide), &s_MicroExp[22]} + {SPR_EXP, 'A', MICRO_EXP_RATE, nullptr, &s_MicroExp[1]}, + {SPR_EXP, 'A', SF_QUICK_CALL, &AF(DoExpDamageTest), &s_MicroExp[2]}, + {SPR_EXP, 'B', MICRO_EXP_RATE, nullptr, &s_MicroExp[3]}, + {SPR_EXP, 'C', MICRO_EXP_RATE, nullptr, &s_MicroExp[4]}, + {SPR_EXP, 'D', MICRO_EXP_RATE, nullptr, &s_MicroExp[5]}, + {SPR_EXP, 'E', MICRO_EXP_RATE, nullptr, &s_MicroExp[6]}, + {SPR_EXP, 'F', MICRO_EXP_RATE, nullptr, &s_MicroExp[7]}, + {SPR_EXP, 'G', MICRO_EXP_RATE, nullptr, &s_MicroExp[8]}, + {SPR_EXP, 'H', MICRO_EXP_RATE, nullptr, &s_MicroExp[9]}, + {SPR_EXP, 'I', MICRO_EXP_RATE, nullptr, &s_MicroExp[10]}, + {SPR_EXP, 'J', MICRO_EXP_RATE, nullptr, &s_MicroExp[11]}, + {SPR_EXP, 'K', MICRO_EXP_RATE, nullptr, &s_MicroExp[12]}, + {SPR_EXP, 'L', MICRO_EXP_RATE, nullptr, &s_MicroExp[13]}, + {SPR_EXP, 'M', MICRO_EXP_RATE, nullptr, &s_MicroExp[14]}, + {SPR_EXP, 'N', MICRO_EXP_RATE, nullptr, &s_MicroExp[15]}, + {SPR_EXP, 'O', MICRO_EXP_RATE, nullptr, &s_MicroExp[16]}, + {SPR_EXP, 'P', MICRO_EXP_RATE, nullptr, &s_MicroExp[17]}, + {SPR_EXP, 'Q', MICRO_EXP_RATE, nullptr, &s_MicroExp[18]}, + {SPR_EXP, 'R', MICRO_EXP_RATE, nullptr, &s_MicroExp[19]}, + {SPR_EXP, 'S', MICRO_EXP_RATE, nullptr, &s_MicroExp[20]}, + {SPR_EXP, 'T', MICRO_EXP_RATE, nullptr, &s_MicroExp[21]}, + {SPR_EXP, 'U', MICRO_EXP_RATE, nullptr, &s_MicroExp[22]}, + {SPR_EXP, 'U', 100, &AF(DoSuicide), &s_MicroExp[22]} }; @@ -1535,134 +1196,134 @@ STATE s_MicroExp[] = STATE s_BigGunFlame[] = { // first 3 frames - {EXP + 0, BIG_GUN_FLAME_RATE, nullptr, &s_BigGunFlame[1]}, - {EXP + 1, BIG_GUN_FLAME_RATE, nullptr, &s_BigGunFlame[2]}, - {EXP + 2, BIG_GUN_FLAME_RATE, nullptr, &s_BigGunFlame[3]}, + {SPR_EXP, 'A', BIG_GUN_FLAME_RATE, nullptr, &s_BigGunFlame[1]}, + {SPR_EXP, 'B', BIG_GUN_FLAME_RATE, nullptr, &s_BigGunFlame[2]}, + {SPR_EXP, 'C', BIG_GUN_FLAME_RATE, nullptr, &s_BigGunFlame[3]}, // last 4 frames frames - {EXP + 17, BIG_GUN_FLAME_RATE, nullptr, &s_BigGunFlame[4]}, - {EXP + 18, BIG_GUN_FLAME_RATE, nullptr, &s_BigGunFlame[5]}, - {EXP + 19, BIG_GUN_FLAME_RATE, nullptr, &s_BigGunFlame[6]}, - {EXP + 20, BIG_GUN_FLAME_RATE, nullptr, &s_BigGunFlame[7]}, - {EXP + 20, 100, &AF(DoSuicide), &s_BigGunFlame[0]} + {SPR_EXP, 'R', BIG_GUN_FLAME_RATE, nullptr, &s_BigGunFlame[4]}, + {SPR_EXP, 'S', BIG_GUN_FLAME_RATE, nullptr, &s_BigGunFlame[5]}, + {SPR_EXP, 'T', BIG_GUN_FLAME_RATE, nullptr, &s_BigGunFlame[6]}, + {SPR_EXP, 'U', BIG_GUN_FLAME_RATE, nullptr, &s_BigGunFlame[7]}, + {SPR_EXP, 'U', 100, &AF(DoSuicide), &s_BigGunFlame[0]} }; STATE s_BoltExp[] = { - {EXP + 0, EXP_RATE_W, nullptr, &s_BoltExp[1]}, - {EXP + 0, SF_QUICK_CALL, nullptr, &s_BoltExp[2]}, - {EXP + 0, SF_QUICK_CALL, &AF(SpawnShrapX), &s_BoltExp[3]}, - {EXP + 1, EXP_RATE_W, nullptr, &s_BoltExp[4]}, - {EXP + 2, EXP_RATE_W, nullptr, &s_BoltExp[5]}, - {EXP + 3, EXP_RATE_W, nullptr, &s_BoltExp[6]}, - {EXP + 4, EXP_RATE_W, nullptr, &s_BoltExp[7]}, - {EXP + 5, EXP_RATE_W, nullptr, &s_BoltExp[8]}, - {EXP + 6, EXP_RATE_W, nullptr, &s_BoltExp[9]}, - {EXP + 7, EXP_RATE_W, nullptr, &s_BoltExp[10]}, - {EXP + 7, SF_QUICK_CALL, &AF(SpawnShrapX), &s_BoltExp[11]}, - {EXP + 8, EXP_RATE_W, nullptr, &s_BoltExp[12]}, - {EXP + 9, EXP_RATE_W, nullptr, &s_BoltExp[13]}, - {EXP + 10, EXP_RATE_W, nullptr, &s_BoltExp[14]}, - {EXP + 11, EXP_RATE_W, nullptr, &s_BoltExp[15]}, - {EXP + 12, EXP_RATE_W, nullptr, &s_BoltExp[16]}, - {EXP + 13, EXP_RATE_W, nullptr, &s_BoltExp[17]}, - {EXP + 14, EXP_RATE_W, nullptr, &s_BoltExp[18]}, - {EXP + 15, EXP_RATE_W, nullptr, &s_BoltExp[19]}, - {EXP + 16, EXP_RATE_W, nullptr, &s_BoltExp[20]}, - {EXP + 17, EXP_RATE_W, nullptr, &s_BoltExp[21]}, - {EXP + 18, EXP_RATE_W, nullptr, &s_BoltExp[22]}, - {EXP + 19, EXP_RATE_W, nullptr, &s_BoltExp[23]}, - {EXP + 20, EXP_RATE_W, nullptr, &s_BoltExp[24]}, - {EXP + 20, 100, &AF(DoSuicide), &s_BoltExp[0]} + {SPR_EXP, 'A', EXP_RATE_W, nullptr, &s_BoltExp[1]}, + {SPR_EXP, 'A', SF_QUICK_CALL, nullptr, &s_BoltExp[2]}, + {SPR_EXP, 'A', SF_QUICK_CALL, &AF(SpawnShrapX), &s_BoltExp[3]}, + {SPR_EXP, 'B', EXP_RATE_W, nullptr, &s_BoltExp[4]}, + {SPR_EXP, 'C', EXP_RATE_W, nullptr, &s_BoltExp[5]}, + {SPR_EXP, 'D', EXP_RATE_W, nullptr, &s_BoltExp[6]}, + {SPR_EXP, 'E', EXP_RATE_W, nullptr, &s_BoltExp[7]}, + {SPR_EXP, 'F', EXP_RATE_W, nullptr, &s_BoltExp[8]}, + {SPR_EXP, 'G', EXP_RATE_W, nullptr, &s_BoltExp[9]}, + {SPR_EXP, 'H', EXP_RATE_W, nullptr, &s_BoltExp[10]}, + {SPR_EXP, 'H', SF_QUICK_CALL, &AF(SpawnShrapX), &s_BoltExp[11]}, + {SPR_EXP, 'I', EXP_RATE_W, nullptr, &s_BoltExp[12]}, + {SPR_EXP, 'J', EXP_RATE_W, nullptr, &s_BoltExp[13]}, + {SPR_EXP, 'K', EXP_RATE_W, nullptr, &s_BoltExp[14]}, + {SPR_EXP, 'L', EXP_RATE_W, nullptr, &s_BoltExp[15]}, + {SPR_EXP, 'M', EXP_RATE_W, nullptr, &s_BoltExp[16]}, + {SPR_EXP, 'N', EXP_RATE_W, nullptr, &s_BoltExp[17]}, + {SPR_EXP, 'O', EXP_RATE_W, nullptr, &s_BoltExp[18]}, + {SPR_EXP, 'P', EXP_RATE_W, nullptr, &s_BoltExp[19]}, + {SPR_EXP, 'Q', EXP_RATE_W, nullptr, &s_BoltExp[20]}, + {SPR_EXP, 'R', EXP_RATE_W, nullptr, &s_BoltExp[21]}, + {SPR_EXP, 'S', EXP_RATE_W, nullptr, &s_BoltExp[22]}, + {SPR_EXP, 'T', EXP_RATE_W, nullptr, &s_BoltExp[23]}, + {SPR_EXP, 'U', EXP_RATE_W, nullptr, &s_BoltExp[24]}, + {SPR_EXP, 'U', 100, &AF(DoSuicide), &s_BoltExp[0]} }; STATE s_TankShellExp[] = { - {EXP + 0, EXP_RATE_W, nullptr, &s_TankShellExp[1]}, - {EXP + 0, SF_QUICK_CALL, nullptr, &s_TankShellExp[2]}, - {EXP + 0, SF_QUICK_CALL, &AF(SpawnShrapX), &s_TankShellExp[3]}, - {EXP + 1, EXP_RATE_W, nullptr, &s_TankShellExp[4]}, - {EXP + 2, EXP_RATE_W, nullptr, &s_TankShellExp[5]}, - {EXP + 3, EXP_RATE_W, nullptr, &s_TankShellExp[6]}, - {EXP + 4, EXP_RATE_W, nullptr, &s_TankShellExp[7]}, - {EXP + 5, EXP_RATE_W, nullptr, &s_TankShellExp[8]}, - {EXP + 6, EXP_RATE_W, nullptr, &s_TankShellExp[9]}, - {EXP + 7, EXP_RATE_W, nullptr, &s_TankShellExp[10]}, - {EXP + 7, SF_QUICK_CALL, &AF(SpawnShrapX), &s_TankShellExp[11]}, - {EXP + 8, EXP_RATE_W, nullptr, &s_TankShellExp[12]}, - {EXP + 9, EXP_RATE_W, nullptr, &s_TankShellExp[13]}, - {EXP + 10, EXP_RATE_W, nullptr, &s_TankShellExp[14]}, - {EXP + 11, EXP_RATE_W, nullptr, &s_TankShellExp[15]}, - {EXP + 12, EXP_RATE_W, nullptr, &s_TankShellExp[16]}, - {EXP + 13, EXP_RATE_W, nullptr, &s_TankShellExp[17]}, - {EXP + 14, EXP_RATE_W, nullptr, &s_TankShellExp[18]}, - {EXP + 15, EXP_RATE_W, nullptr, &s_TankShellExp[19]}, - {EXP + 16, EXP_RATE_W, nullptr, &s_TankShellExp[20]}, - {EXP + 17, EXP_RATE_W, nullptr, &s_TankShellExp[21]}, - {EXP + 18, EXP_RATE_W, nullptr, &s_TankShellExp[22]}, - {EXP + 19, EXP_RATE_W, nullptr, &s_TankShellExp[23]}, - {EXP + 20, EXP_RATE_W, nullptr, &s_TankShellExp[24]}, - {EXP + 20, 100, &AF(DoSuicide), &s_TankShellExp[0]} + {SPR_EXP, 'A', EXP_RATE_W, nullptr, &s_TankShellExp[1]}, + {SPR_EXP, 'A', SF_QUICK_CALL, nullptr, &s_TankShellExp[2]}, + {SPR_EXP, 'A', SF_QUICK_CALL, &AF(SpawnShrapX), &s_TankShellExp[3]}, + {SPR_EXP, 'B', EXP_RATE_W, nullptr, &s_TankShellExp[4]}, + {SPR_EXP, 'C', EXP_RATE_W, nullptr, &s_TankShellExp[5]}, + {SPR_EXP, 'D', EXP_RATE_W, nullptr, &s_TankShellExp[6]}, + {SPR_EXP, 'E', EXP_RATE_W, nullptr, &s_TankShellExp[7]}, + {SPR_EXP, 'F', EXP_RATE_W, nullptr, &s_TankShellExp[8]}, + {SPR_EXP, 'G', EXP_RATE_W, nullptr, &s_TankShellExp[9]}, + {SPR_EXP, 'H', EXP_RATE_W, nullptr, &s_TankShellExp[10]}, + {SPR_EXP, 'H', SF_QUICK_CALL, &AF(SpawnShrapX), &s_TankShellExp[11]}, + {SPR_EXP, 'I', EXP_RATE_W, nullptr, &s_TankShellExp[12]}, + {SPR_EXP, 'J', EXP_RATE_W, nullptr, &s_TankShellExp[13]}, + {SPR_EXP, 'K', EXP_RATE_W, nullptr, &s_TankShellExp[14]}, + {SPR_EXP, 'L', EXP_RATE_W, nullptr, &s_TankShellExp[15]}, + {SPR_EXP, 'M', EXP_RATE_W, nullptr, &s_TankShellExp[16]}, + {SPR_EXP, 'N', EXP_RATE_W, nullptr, &s_TankShellExp[17]}, + {SPR_EXP, 'O', EXP_RATE_W, nullptr, &s_TankShellExp[18]}, + {SPR_EXP, 'P', EXP_RATE_W, nullptr, &s_TankShellExp[19]}, + {SPR_EXP, 'Q', EXP_RATE_W, nullptr, &s_TankShellExp[20]}, + {SPR_EXP, 'R', EXP_RATE_W, nullptr, &s_TankShellExp[21]}, + {SPR_EXP, 'S', EXP_RATE_W, nullptr, &s_TankShellExp[22]}, + {SPR_EXP, 'T', EXP_RATE_W, nullptr, &s_TankShellExp[23]}, + {SPR_EXP, 'U', EXP_RATE_W, nullptr, &s_TankShellExp[24]}, + {SPR_EXP, 'U', 100, &AF(DoSuicide), &s_TankShellExp[0]} }; #define TRACER_EXP_RATE 4 STATE s_TracerExp[] = { - {EXP + 0, TRACER_EXP_RATE, nullptr, &s_TracerExp[1]}, - {EXP + 0, SF_QUICK_CALL, nullptr, &s_TracerExp[2]}, - {EXP + 0, SF_QUICK_CALL, nullptr, &s_TracerExp[3]}, - {EXP + 1, TRACER_EXP_RATE, nullptr, &s_TracerExp[4]}, - {EXP + 2, TRACER_EXP_RATE, nullptr, &s_TracerExp[5]}, - {EXP + 3, TRACER_EXP_RATE, nullptr, &s_TracerExp[6]}, - {EXP + 4, TRACER_EXP_RATE, nullptr, &s_TracerExp[7]}, - {EXP + 5, TRACER_EXP_RATE, nullptr, &s_TracerExp[8]}, - {EXP + 6, TRACER_EXP_RATE, nullptr, &s_TracerExp[9]}, - {EXP + 7, TRACER_EXP_RATE, nullptr, &s_TracerExp[10]}, - {EXP + 7, SF_QUICK_CALL, nullptr, &s_TracerExp[11]}, - {EXP + 8, TRACER_EXP_RATE, nullptr, &s_TracerExp[12]}, - {EXP + 9, TRACER_EXP_RATE, nullptr, &s_TracerExp[13]}, - {EXP + 10, TRACER_EXP_RATE, nullptr, &s_TracerExp[14]}, - {EXP + 11, TRACER_EXP_RATE, nullptr, &s_TracerExp[15]}, - {EXP + 12, TRACER_EXP_RATE, nullptr, &s_TracerExp[16]}, - {EXP + 13, TRACER_EXP_RATE, nullptr, &s_TracerExp[17]}, - {EXP + 14, TRACER_EXP_RATE, nullptr, &s_TracerExp[18]}, - {EXP + 15, TRACER_EXP_RATE, nullptr, &s_TracerExp[19]}, - {EXP + 16, TRACER_EXP_RATE, nullptr, &s_TracerExp[20]}, - {EXP + 17, TRACER_EXP_RATE, nullptr, &s_TracerExp[21]}, - {EXP + 18, TRACER_EXP_RATE, nullptr, &s_TracerExp[22]}, - {EXP + 19, TRACER_EXP_RATE, nullptr, &s_TracerExp[23]}, - {EXP + 20, TRACER_EXP_RATE, nullptr, &s_TracerExp[24]}, - {EXP + 20, 100, &AF(DoSuicide), &s_TracerExp[0]} + {SPR_EXP, 'A', TRACER_EXP_RATE, nullptr, &s_TracerExp[1]}, + {SPR_EXP, 'A', SF_QUICK_CALL, nullptr, &s_TracerExp[2]}, + {SPR_EXP, 'A', SF_QUICK_CALL, nullptr, &s_TracerExp[3]}, + {SPR_EXP, 'B', TRACER_EXP_RATE, nullptr, &s_TracerExp[4]}, + {SPR_EXP, 'C', TRACER_EXP_RATE, nullptr, &s_TracerExp[5]}, + {SPR_EXP, 'D', TRACER_EXP_RATE, nullptr, &s_TracerExp[6]}, + {SPR_EXP, 'E', TRACER_EXP_RATE, nullptr, &s_TracerExp[7]}, + {SPR_EXP, 'F', TRACER_EXP_RATE, nullptr, &s_TracerExp[8]}, + {SPR_EXP, 'G', TRACER_EXP_RATE, nullptr, &s_TracerExp[9]}, + {SPR_EXP, 'H', TRACER_EXP_RATE, nullptr, &s_TracerExp[10]}, + {SPR_EXP, 'H', SF_QUICK_CALL, nullptr, &s_TracerExp[11]}, + {SPR_EXP, 'I', TRACER_EXP_RATE, nullptr, &s_TracerExp[12]}, + {SPR_EXP, 'J', TRACER_EXP_RATE, nullptr, &s_TracerExp[13]}, + {SPR_EXP, 'K', TRACER_EXP_RATE, nullptr, &s_TracerExp[14]}, + {SPR_EXP, 'L', TRACER_EXP_RATE, nullptr, &s_TracerExp[15]}, + {SPR_EXP, 'M', TRACER_EXP_RATE, nullptr, &s_TracerExp[16]}, + {SPR_EXP, 'N', TRACER_EXP_RATE, nullptr, &s_TracerExp[17]}, + {SPR_EXP, 'O', TRACER_EXP_RATE, nullptr, &s_TracerExp[18]}, + {SPR_EXP, 'P', TRACER_EXP_RATE, nullptr, &s_TracerExp[19]}, + {SPR_EXP, 'Q', TRACER_EXP_RATE, nullptr, &s_TracerExp[20]}, + {SPR_EXP, 'R', TRACER_EXP_RATE, nullptr, &s_TracerExp[21]}, + {SPR_EXP, 'S', TRACER_EXP_RATE, nullptr, &s_TracerExp[22]}, + {SPR_EXP, 'T', TRACER_EXP_RATE, nullptr, &s_TracerExp[23]}, + {SPR_EXP, 'U', TRACER_EXP_RATE, nullptr, &s_TracerExp[24]}, + {SPR_EXP, 'U', 100, &AF(DoSuicide), &s_TracerExp[0]} }; #define EXP_RATE_W 7 STATE s_SectorExp[] = { - {EXP + 0, EXP_RATE_W, &AF(DoSectorExp), &s_SectorExp[1]}, - {EXP + 0, SF_QUICK_CALL, &AF(SpawnShrapX), &s_SectorExp[2]}, - {EXP + 0, SF_QUICK_CALL, &AF(DoSectorExp), &s_SectorExp[3]}, - {EXP + 1, EXP_RATE_W, &AF(DoSectorExp), &s_SectorExp[4]}, - {EXP + 2, EXP_RATE_W, &AF(DoSectorExp), &s_SectorExp[5]}, - {EXP + 3, EXP_RATE_W, &AF(DoSectorExp), &s_SectorExp[6]}, - {EXP + 4, EXP_RATE_W, &AF(DoSectorExp), &s_SectorExp[7]}, - {EXP + 5, EXP_RATE_W, &AF(DoSectorExp), &s_SectorExp[8]}, - {EXP + 6, EXP_RATE_W, &AF(DoSectorExp), &s_SectorExp[9]}, - {EXP + 7, EXP_RATE_W, &AF(DoSectorExp), &s_SectorExp[10]}, - {EXP + 7, SF_QUICK_CALL, &AF(DoSectorExp), &s_SectorExp[11]}, - {EXP + 8, EXP_RATE_W, &AF(DoSectorExp), &s_SectorExp[12]}, - {EXP + 9, EXP_RATE_W, &AF(DoSectorExp), &s_SectorExp[13]}, - {EXP + 10, EXP_RATE_W, &AF(DoSectorExp), &s_SectorExp[14]}, - {EXP + 11, EXP_RATE_W, &AF(DoSectorExp), &s_SectorExp[15]}, - {EXP + 12, EXP_RATE_W, &AF(DoSectorExp), &s_SectorExp[16]}, - {EXP + 13, EXP_RATE_W, &AF(DoSectorExp), &s_SectorExp[17]}, - {EXP + 14, EXP_RATE_W, &AF(DoSectorExp), &s_SectorExp[18]}, - {EXP + 15, EXP_RATE_W, &AF(DoSectorExp), &s_SectorExp[19]}, - {EXP + 16, EXP_RATE_W, &AF(DoSectorExp), &s_SectorExp[20]}, - {EXP + 17, EXP_RATE_W, &AF(DoSectorExp), &s_SectorExp[21]}, - {EXP + 18, EXP_RATE_W, &AF(DoSectorExp), &s_SectorExp[22]}, - {EXP + 19, EXP_RATE_W, &AF(DoSectorExp), &s_SectorExp[23]}, - {EXP + 20, EXP_RATE_W, &AF(DoSectorExp), &s_SectorExp[24]}, - {EXP + 20, 100, &AF(DoSuicide), &s_SectorExp[0]} + {SPR_EXP, 'A', EXP_RATE_W, &AF(DoSectorExp), &s_SectorExp[1]}, + {SPR_EXP, 'A', SF_QUICK_CALL, &AF(SpawnShrapX), &s_SectorExp[2]}, + {SPR_EXP, 'A', SF_QUICK_CALL, &AF(DoSectorExp), &s_SectorExp[3]}, + {SPR_EXP, 'B', EXP_RATE_W, &AF(DoSectorExp), &s_SectorExp[4]}, + {SPR_EXP, 'C', EXP_RATE_W, &AF(DoSectorExp), &s_SectorExp[5]}, + {SPR_EXP, 'D', EXP_RATE_W, &AF(DoSectorExp), &s_SectorExp[6]}, + {SPR_EXP, 'E', EXP_RATE_W, &AF(DoSectorExp), &s_SectorExp[7]}, + {SPR_EXP, 'F', EXP_RATE_W, &AF(DoSectorExp), &s_SectorExp[8]}, + {SPR_EXP, 'G', EXP_RATE_W, &AF(DoSectorExp), &s_SectorExp[9]}, + {SPR_EXP, 'H', EXP_RATE_W, &AF(DoSectorExp), &s_SectorExp[10]}, + {SPR_EXP, 'H', SF_QUICK_CALL, &AF(DoSectorExp), &s_SectorExp[11]}, + {SPR_EXP, 'I', EXP_RATE_W, &AF(DoSectorExp), &s_SectorExp[12]}, + {SPR_EXP, 'J', EXP_RATE_W, &AF(DoSectorExp), &s_SectorExp[13]}, + {SPR_EXP, 'K', EXP_RATE_W, &AF(DoSectorExp), &s_SectorExp[14]}, + {SPR_EXP, 'L', EXP_RATE_W, &AF(DoSectorExp), &s_SectorExp[15]}, + {SPR_EXP, 'M', EXP_RATE_W, &AF(DoSectorExp), &s_SectorExp[16]}, + {SPR_EXP, 'N', EXP_RATE_W, &AF(DoSectorExp), &s_SectorExp[17]}, + {SPR_EXP, 'O', EXP_RATE_W, &AF(DoSectorExp), &s_SectorExp[18]}, + {SPR_EXP, 'P', EXP_RATE_W, &AF(DoSectorExp), &s_SectorExp[19]}, + {SPR_EXP, 'Q', EXP_RATE_W, &AF(DoSectorExp), &s_SectorExp[20]}, + {SPR_EXP, 'R', EXP_RATE_W, &AF(DoSectorExp), &s_SectorExp[21]}, + {SPR_EXP, 'S', EXP_RATE_W, &AF(DoSectorExp), &s_SectorExp[22]}, + {SPR_EXP, 'T', EXP_RATE_W, &AF(DoSectorExp), &s_SectorExp[23]}, + {SPR_EXP, 'U', EXP_RATE_W, &AF(DoSectorExp), &s_SectorExp[24]}, + {SPR_EXP, 'U', 100, &AF(DoSuicide), &s_SectorExp[0]} }; @@ -1670,12 +1331,12 @@ STATE s_SectorExp[] = #define FIREBALL_DISS_RATE 8 STATE s_FireballExp[] = { - {FIREBALL_DISS + 0, FIREBALL_DISS_RATE, nullptr, &s_FireballExp[1]}, - {FIREBALL_DISS + 1, FIREBALL_DISS_RATE, nullptr, &s_FireballExp[2]}, - {FIREBALL_DISS + 2, FIREBALL_DISS_RATE, nullptr, &s_FireballExp[3]}, - {FIREBALL_DISS + 3, FIREBALL_DISS_RATE, nullptr, &s_FireballExp[4]}, - {FIREBALL_DISS + 4, FIREBALL_DISS_RATE, nullptr, &s_FireballExp[5]}, - {FIREBALL_DISS + 4, 100, &AF(DoSuicide), &s_FireballExp[0]} + {SPR_FIREBALL_DISS, 'A', FIREBALL_DISS_RATE, nullptr, &s_FireballExp[1]}, + {SPR_FIREBALL_DISS, 'B', FIREBALL_DISS_RATE, nullptr, &s_FireballExp[2]}, + {SPR_FIREBALL_DISS, 'C', FIREBALL_DISS_RATE, nullptr, &s_FireballExp[3]}, + {SPR_FIREBALL_DISS, 'D', FIREBALL_DISS_RATE, nullptr, &s_FireballExp[4]}, + {SPR_FIREBALL_DISS, 'E', FIREBALL_DISS_RATE, nullptr, &s_FireballExp[5]}, + {SPR_FIREBALL_DISS, 'E', 100, &AF(DoSuicide), &s_FireballExp[0]} }; #define NAP_EXP (3072) @@ -1683,70 +1344,70 @@ STATE s_FireballExp[] = STATE s_NapExp[] = { - {NAP_EXP + 0, NAP_EXP_RATE, nullptr, &s_NapExp[1]}, - {NAP_EXP + 0, 0 | SF_QUICK_CALL, &AF(DoDamageTest), &s_NapExp[2]}, - {NAP_EXP + 1, NAP_EXP_RATE, nullptr, &s_NapExp[3]}, - {NAP_EXP + 2, NAP_EXP_RATE, nullptr, &s_NapExp[4]}, - {NAP_EXP + 3, NAP_EXP_RATE, nullptr, &s_NapExp[5]}, - {NAP_EXP + 4, NAP_EXP_RATE, nullptr, &s_NapExp[6]}, - {NAP_EXP + 5, NAP_EXP_RATE, nullptr, &s_NapExp[7]}, - {NAP_EXP + 6, NAP_EXP_RATE, nullptr, &s_NapExp[8]}, - {NAP_EXP + 7, NAP_EXP_RATE, nullptr, &s_NapExp[9]}, - {NAP_EXP + 8, NAP_EXP_RATE, nullptr, &s_NapExp[10]}, - {NAP_EXP + 9, NAP_EXP_RATE, nullptr, &s_NapExp[11]}, - {NAP_EXP + 10, NAP_EXP_RATE, nullptr, &s_NapExp[12]}, - {NAP_EXP + 11, NAP_EXP_RATE, nullptr, &s_NapExp[13]}, - {NAP_EXP + 12, NAP_EXP_RATE, nullptr, &s_NapExp[14]}, - {NAP_EXP + 13, NAP_EXP_RATE, nullptr, &s_NapExp[15]}, - {NAP_EXP + 14, NAP_EXP_RATE, nullptr, &s_NapExp[16]}, - {NAP_EXP + 15, NAP_EXP_RATE-2, nullptr, &s_NapExp[17]}, - {NAP_EXP + 16, NAP_EXP_RATE-2, nullptr, &s_NapExp[18]}, - {NAP_EXP + 17, NAP_EXP_RATE-2, nullptr, &s_NapExp[19]}, - {NAP_EXP + 18, NAP_EXP_RATE-2, nullptr, &s_NapExp[20]}, - {NAP_EXP + 19, NAP_EXP_RATE-2, nullptr, &s_NapExp[21]}, - {NAP_EXP + 20, NAP_EXP_RATE-2, nullptr, &s_NapExp[22]}, - {NAP_EXP + 21, NAP_EXP_RATE-2, nullptr, &s_NapExp[23]}, - {NAP_EXP + 21, NAP_EXP_RATE-2, &AF(DoSuicide), &s_NapExp[23]} + {SPR_NAP_EXP, 'A', NAP_EXP_RATE, nullptr, &s_NapExp[1]}, + {SPR_NAP_EXP, 'A', 0 | SF_QUICK_CALL, &AF(DoDamageTest), &s_NapExp[2]}, + {SPR_NAP_EXP, 'B', NAP_EXP_RATE, nullptr, &s_NapExp[3]}, + {SPR_NAP_EXP, 'C', NAP_EXP_RATE, nullptr, &s_NapExp[4]}, + {SPR_NAP_EXP, 'D', NAP_EXP_RATE, nullptr, &s_NapExp[5]}, + {SPR_NAP_EXP, 'E', NAP_EXP_RATE, nullptr, &s_NapExp[6]}, + {SPR_NAP_EXP, 'F', NAP_EXP_RATE, nullptr, &s_NapExp[7]}, + {SPR_NAP_EXP, 'G', NAP_EXP_RATE, nullptr, &s_NapExp[8]}, + {SPR_NAP_EXP, 'H', NAP_EXP_RATE, nullptr, &s_NapExp[9]}, + {SPR_NAP_EXP, 'I', NAP_EXP_RATE, nullptr, &s_NapExp[10]}, + {SPR_NAP_EXP, 'J', NAP_EXP_RATE, nullptr, &s_NapExp[11]}, + {SPR_NAP_EXP, 'K', NAP_EXP_RATE, nullptr, &s_NapExp[12]}, + {SPR_NAP_EXP, 'L', NAP_EXP_RATE, nullptr, &s_NapExp[13]}, + {SPR_NAP_EXP, 'M', NAP_EXP_RATE, nullptr, &s_NapExp[14]}, + {SPR_NAP_EXP, 'N', NAP_EXP_RATE, nullptr, &s_NapExp[15]}, + {SPR_NAP_EXP, 'O', NAP_EXP_RATE, nullptr, &s_NapExp[16]}, + {SPR_NAP_EXP, 'P', NAP_EXP_RATE - 2, nullptr, &s_NapExp[17]}, + {SPR_NAP_EXP, 'Q', NAP_EXP_RATE - 2, nullptr, &s_NapExp[18]}, + {SPR_NAP_EXP, 'R', NAP_EXP_RATE - 2, nullptr, &s_NapExp[19]}, + {SPR_NAP_EXP, 'S', NAP_EXP_RATE - 2, nullptr, &s_NapExp[20]}, + {SPR_NAP_EXP, 'T', NAP_EXP_RATE - 2, nullptr, &s_NapExp[21]}, + {SPR_NAP_EXP, 'U', NAP_EXP_RATE - 2, nullptr, &s_NapExp[22]}, + {SPR_NAP_EXP, 'V', NAP_EXP_RATE-2, nullptr, &s_NapExp[23]}, + {SPR_NAP_EXP, 'V', NAP_EXP_RATE - 2, &AF(DoSuicide), &s_NapExp[23]} }; #define FLAME_RATE 6 STATE s_FireballFlames[] = { - {FIREBALL_FLAMES + 0, FLAME_RATE, &AF(DoFireballFlames), &s_FireballFlames[1]}, - {FIREBALL_FLAMES + 1, FLAME_RATE, &AF(DoFireballFlames), &s_FireballFlames[2]}, - {FIREBALL_FLAMES + 2, FLAME_RATE, &AF(DoFireballFlames), &s_FireballFlames[3]}, - {FIREBALL_FLAMES + 3, FLAME_RATE, &AF(DoFireballFlames), &s_FireballFlames[4]}, - {FIREBALL_FLAMES + 4, FLAME_RATE, &AF(DoFireballFlames), &s_FireballFlames[5]}, - {FIREBALL_FLAMES + 5, FLAME_RATE, &AF(DoFireballFlames), &s_FireballFlames[6]}, - {FIREBALL_FLAMES + 6, FLAME_RATE, &AF(DoFireballFlames), &s_FireballFlames[7]}, - {FIREBALL_FLAMES + 7, FLAME_RATE, &AF(DoFireballFlames), &s_FireballFlames[8]}, - {FIREBALL_FLAMES + 8, FLAME_RATE, &AF(DoFireballFlames), &s_FireballFlames[9]}, - {FIREBALL_FLAMES + 9, FLAME_RATE, &AF(DoFireballFlames), &s_FireballFlames[10]}, - {FIREBALL_FLAMES +10, FLAME_RATE, &AF(DoFireballFlames), &s_FireballFlames[11]}, - {FIREBALL_FLAMES +11, FLAME_RATE, &AF(DoFireballFlames), &s_FireballFlames[12]}, - {FIREBALL_FLAMES +12, FLAME_RATE, &AF(DoFireballFlames), &s_FireballFlames[13]}, - {FIREBALL_FLAMES +13, FLAME_RATE, &AF(DoFireballFlames), &s_FireballFlames[0]}, + {SPR_FIREBALL_FLAMES, 'A', FLAME_RATE, &AF(DoFireballFlames), &s_FireballFlames[1]}, + {SPR_FIREBALL_FLAMES, 'B', FLAME_RATE, &AF(DoFireballFlames), &s_FireballFlames[2]}, + {SPR_FIREBALL_FLAMES, 'C', FLAME_RATE, &AF(DoFireballFlames), &s_FireballFlames[3]}, + {SPR_FIREBALL_FLAMES, 'D', FLAME_RATE, &AF(DoFireballFlames), &s_FireballFlames[4]}, + {SPR_FIREBALL_FLAMES, 'E', FLAME_RATE, &AF(DoFireballFlames), &s_FireballFlames[5]}, + {SPR_FIREBALL_FLAMES, 'F', FLAME_RATE, &AF(DoFireballFlames), &s_FireballFlames[6]}, + {SPR_FIREBALL_FLAMES, 'G', FLAME_RATE, &AF(DoFireballFlames), &s_FireballFlames[7]}, + {SPR_FIREBALL_FLAMES, 'H', FLAME_RATE, &AF(DoFireballFlames), &s_FireballFlames[8]}, + {SPR_FIREBALL_FLAMES, 'I', FLAME_RATE, &AF(DoFireballFlames), &s_FireballFlames[9]}, + {SPR_FIREBALL_FLAMES, 'J', FLAME_RATE, &AF(DoFireballFlames), &s_FireballFlames[10]}, + {SPR_FIREBALL_FLAMES, 'K', FLAME_RATE, &AF(DoFireballFlames), &s_FireballFlames[11]}, + {SPR_FIREBALL_FLAMES, 'L', FLAME_RATE, &AF(DoFireballFlames), &s_FireballFlames[12]}, + {SPR_FIREBALL_FLAMES, 'M', FLAME_RATE, &AF(DoFireballFlames), &s_FireballFlames[13]}, + {SPR_FIREBALL_FLAMES, 'N', FLAME_RATE, &AF(DoFireballFlames), &s_FireballFlames[0]}, }; #define FLAME_RATE 6 STATE s_BreakFlames[] = { - {FIREBALL_FLAMES + 0, FLAME_RATE, &AF(DoBreakFlames), &s_BreakFlames[1]}, - {FIREBALL_FLAMES + 1, FLAME_RATE, &AF(DoBreakFlames), &s_BreakFlames[2]}, - {FIREBALL_FLAMES + 2, FLAME_RATE, &AF(DoBreakFlames), &s_BreakFlames[3]}, - {FIREBALL_FLAMES + 3, FLAME_RATE, &AF(DoBreakFlames), &s_BreakFlames[4]}, - {FIREBALL_FLAMES + 4, FLAME_RATE, &AF(DoBreakFlames), &s_BreakFlames[5]}, - {FIREBALL_FLAMES + 5, FLAME_RATE, &AF(DoBreakFlames), &s_BreakFlames[6]}, - {FIREBALL_FLAMES + 6, FLAME_RATE, &AF(DoBreakFlames), &s_BreakFlames[7]}, - {FIREBALL_FLAMES + 7, FLAME_RATE, &AF(DoBreakFlames), &s_BreakFlames[8]}, - {FIREBALL_FLAMES + 8, FLAME_RATE, &AF(DoBreakFlames), &s_BreakFlames[9]}, - {FIREBALL_FLAMES + 9, FLAME_RATE, &AF(DoBreakFlames), &s_BreakFlames[10]}, - {FIREBALL_FLAMES +10, FLAME_RATE, &AF(DoBreakFlames), &s_BreakFlames[11]}, - {FIREBALL_FLAMES +11, FLAME_RATE, &AF(DoBreakFlames), &s_BreakFlames[12]}, - {FIREBALL_FLAMES +12, FLAME_RATE, &AF(DoBreakFlames), &s_BreakFlames[13]}, - {FIREBALL_FLAMES +13, FLAME_RATE, &AF(DoBreakFlames), &s_BreakFlames[0]}, + {SPR_FIREBALL_FLAMES, 'A', FLAME_RATE, &AF(DoBreakFlames), &s_BreakFlames[1]}, + {SPR_FIREBALL_FLAMES, 'B', FLAME_RATE, &AF(DoBreakFlames), &s_BreakFlames[2]}, + {SPR_FIREBALL_FLAMES, 'C', FLAME_RATE, &AF(DoBreakFlames), &s_BreakFlames[3]}, + {SPR_FIREBALL_FLAMES, 'D', FLAME_RATE, &AF(DoBreakFlames), &s_BreakFlames[4]}, + {SPR_FIREBALL_FLAMES, 'E', FLAME_RATE, &AF(DoBreakFlames), &s_BreakFlames[5]}, + {SPR_FIREBALL_FLAMES, 'F', FLAME_RATE, &AF(DoBreakFlames), &s_BreakFlames[6]}, + {SPR_FIREBALL_FLAMES, 'G', FLAME_RATE, &AF(DoBreakFlames), &s_BreakFlames[7]}, + {SPR_FIREBALL_FLAMES, 'H', FLAME_RATE, &AF(DoBreakFlames), &s_BreakFlames[8]}, + {SPR_FIREBALL_FLAMES, 'I', FLAME_RATE, &AF(DoBreakFlames), &s_BreakFlames[9]}, + {SPR_FIREBALL_FLAMES, 'J', FLAME_RATE, &AF(DoBreakFlames), &s_BreakFlames[10]}, + {SPR_FIREBALL_FLAMES, 'K', FLAME_RATE, &AF(DoBreakFlames), &s_BreakFlames[11]}, + {SPR_FIREBALL_FLAMES, 'L', FLAME_RATE, &AF(DoBreakFlames), &s_BreakFlames[12]}, + {SPR_FIREBALL_FLAMES, 'M', FLAME_RATE, &AF(DoBreakFlames), &s_BreakFlames[13]}, + {SPR_FIREBALL_FLAMES, 'N', FLAME_RATE, &AF(DoBreakFlames), &s_BreakFlames[0]}, }; ////////////////////// @@ -1760,35 +1421,35 @@ STATE s_BreakFlames[] = STATE s_Fireball[] = { - {FIREBALL + 0, 12, &AF(DoFireball), &s_Fireball[1]}, - {FIREBALL + 1, 12, &AF(DoFireball), &s_Fireball[2]}, - {FIREBALL + 2, 12, &AF(DoFireball), &s_Fireball[3]}, - {FIREBALL + 3, 12, &AF(DoFireball), &s_Fireball[0]} + {SPR_FIREBALL, 'A', 12, &AF(DoFireball), &s_Fireball[1]}, + {SPR_FIREBALL, 'B', 12, &AF(DoFireball), &s_Fireball[2]}, + {SPR_FIREBALL, 'C', 12, &AF(DoFireball), &s_Fireball[3]}, + {SPR_FIREBALL, 'D', 12, &AF(DoFireball), &s_Fireball[0]} }; STATE s_Ring[] = { - {FIREBALL + 0, 12, &AF(DoRing), &s_Ring[1]}, - {FIREBALL + 1, 12, &AF(DoRing), &s_Ring[2]}, - {FIREBALL + 2, 12, &AF(DoRing), &s_Ring[3]}, - {FIREBALL + 3, 12, &AF(DoRing), &s_Ring[0]} + {SPR_FIREBALL, 'A', 12, &AF(DoRing), &s_Ring[1]}, + {SPR_FIREBALL, 'B', 12, &AF(DoRing), &s_Ring[2]}, + {SPR_FIREBALL, 'C', 12, &AF(DoRing), &s_Ring[3]}, + {SPR_FIREBALL, 'D', 12, &AF(DoRing), &s_Ring[0]} }; STATE s_Ring2[] = { - {2031 + 0, 12, &AF(DoRing), &s_Ring2[1]}, - {2031 + 1, 12, &AF(DoRing), &s_Ring2[2]}, - {2031 + 2, 12, &AF(DoRing), &s_Ring2[3]}, - {2031 + 3, 12, &AF(DoRing), &s_Ring2[0]} + {SPR_SERP_METEOR, 'A', 12, &AF(DoRing), &s_Ring2[1]}, + {SPR_SERP_METEOR, 'B', 12, &AF(DoRing), &s_Ring2[2]}, + {SPR_SERP_METEOR, 'C', 12, &AF(DoRing), &s_Ring2[3]}, + {SPR_SERP_METEOR, 'D', 12, &AF(DoRing), &s_Ring2[0]} }; STATE s_Napalm[] = { - {FIREBALL + 0, 12, &AF(DoNapalm), &s_Napalm[1]}, - {FIREBALL + 1, 12, &AF(DoNapalm), &s_Napalm[2]}, - {FIREBALL + 2, 12, &AF(DoNapalm), &s_Napalm[3]}, - {FIREBALL + 3, 12, &AF(DoNapalm), &s_Napalm[0]} + {SPR_FIREBALL, 'A', 12, &AF(DoNapalm), &s_Napalm[1]}, + {SPR_FIREBALL, 'B', 12, &AF(DoNapalm), &s_Napalm[2]}, + {SPR_FIREBALL, 'C', 12, &AF(DoNapalm), &s_Napalm[3]}, + {SPR_FIREBALL, 'D', 12, &AF(DoNapalm), &s_Napalm[0]} }; @@ -1796,22 +1457,14 @@ STATE s_Napalm[] = #define BLOOD_WORM 2106 STATE s_BloodWorm[] = { - {BLOOD_WORM + 0, 12, &AF(DoBloodWorm), &s_BloodWorm[1]}, - {BLOOD_WORM + 1, 12, &AF(DoBloodWorm), &s_BloodWorm[2]}, - {BLOOD_WORM + 2, 12, &AF(DoBloodWorm), &s_BloodWorm[3]}, - {BLOOD_WORM + 3, 12, &AF(DoBloodWorm), &s_BloodWorm[4]}, - {BLOOD_WORM + 2, 12, &AF(DoBloodWorm), &s_BloodWorm[5]}, - {BLOOD_WORM + 1, 12, &AF(DoBloodWorm), &s_BloodWorm[0]} + {SPR_BLOOD_WORM, 'A', 12, &AF(DoBloodWorm), &s_BloodWorm[1]}, + {SPR_BLOOD_WORM, 'B', 12, &AF(DoBloodWorm), &s_BloodWorm[2]}, + {SPR_BLOOD_WORM, 'C', 12, &AF(DoBloodWorm), &s_BloodWorm[3]}, + {SPR_BLOOD_WORM, 'D', 12, &AF(DoBloodWorm), &s_BloodWorm[4]}, + {SPR_BLOOD_WORM, 'C', 12, &AF(DoBloodWorm), &s_BloodWorm[5]}, + {SPR_BLOOD_WORM, 'B', 12, &AF(DoBloodWorm), &s_BloodWorm[0]} }; #else -#define BLOOD_WORM FIREBALL+5 -STATE s_BloodWorm[] = -{ - {FIREBALL + 0, 12, &AF(DoBloodWorm), &s_BloodWorm[1]}, - {FIREBALL + 1, 12, &AF(DoBloodWorm), &s_BloodWorm[2]}, - {FIREBALL + 2, 12, &AF(DoBloodWorm), &s_BloodWorm[3]}, - {FIREBALL + 3, 12, &AF(DoBloodWorm), &s_BloodWorm[0]} -}; #endif #if 1 @@ -1820,19 +1473,19 @@ STATE s_BloodWorm[] = STATE s_PlasmaExp[] = { - {BLOOD_WORM + 0, PLASMA_EXP_RATE, nullptr, &s_PlasmaExp[1]}, - {BLOOD_WORM + 1, PLASMA_EXP_RATE, nullptr, &s_PlasmaExp[2]}, - {BLOOD_WORM + 2, PLASMA_EXP_RATE, nullptr, &s_PlasmaExp[3]}, - {BLOOD_WORM + 3, PLASMA_EXP_RATE, nullptr, &s_PlasmaExp[4]}, - {BLOOD_WORM + 2, PLASMA_EXP_RATE, nullptr, &s_PlasmaExp[5]}, - {BLOOD_WORM + 1, PLASMA_EXP_RATE, nullptr, &s_PlasmaExp[6]}, - {BLOOD_WORM + 0, PLASMA_EXP_RATE, nullptr, &s_PlasmaExp[7]}, - {BLOOD_WORM + 1, PLASMA_EXP_RATE, nullptr, &s_PlasmaExp[8]}, - {BLOOD_WORM + 2, PLASMA_EXP_RATE, nullptr, &s_PlasmaExp[9]}, - {BLOOD_WORM + 3, PLASMA_EXP_RATE, nullptr, &s_PlasmaExp[10]}, - {BLOOD_WORM + 2, PLASMA_EXP_RATE, nullptr, &s_PlasmaExp[11]}, - {BLOOD_WORM + 1, PLASMA_EXP_RATE, nullptr, &s_PlasmaExp[12]}, - {BLOOD_WORM + 0, PLASMA_EXP_RATE, &AF(DoSuicide), &s_PlasmaExp[12]}, + {SPR_BLOOD_WORM, 'A', PLASMA_EXP_RATE, nullptr, &s_PlasmaExp[1]}, + {SPR_BLOOD_WORM, 'B', PLASMA_EXP_RATE, nullptr, &s_PlasmaExp[2]}, + {SPR_BLOOD_WORM, 'C', PLASMA_EXP_RATE, nullptr, &s_PlasmaExp[3]}, + {SPR_BLOOD_WORM, 'D', PLASMA_EXP_RATE, nullptr, &s_PlasmaExp[4]}, + {SPR_BLOOD_WORM, 'C', PLASMA_EXP_RATE, nullptr, &s_PlasmaExp[5]}, + {SPR_BLOOD_WORM, 'B', PLASMA_EXP_RATE, nullptr, &s_PlasmaExp[6]}, + {SPR_BLOOD_WORM, 'A', PLASMA_EXP_RATE, nullptr, &s_PlasmaExp[7]}, + {SPR_BLOOD_WORM, 'B', PLASMA_EXP_RATE, nullptr, &s_PlasmaExp[8]}, + {SPR_BLOOD_WORM, 'C', PLASMA_EXP_RATE, nullptr, &s_PlasmaExp[9]}, + {SPR_BLOOD_WORM, 'D', PLASMA_EXP_RATE, nullptr, &s_PlasmaExp[10]}, + {SPR_BLOOD_WORM, 'C', PLASMA_EXP_RATE, nullptr, &s_PlasmaExp[11]}, + {SPR_BLOOD_WORM, 'B', PLASMA_EXP_RATE, nullptr, &s_PlasmaExp[12]}, + {SPR_BLOOD_WORM, 'A', PLASMA_EXP_RATE, &AF(DoSuicide), &s_PlasmaExp[12]}, }; #endif @@ -1840,18 +1493,18 @@ STATE s_PlasmaExp[] = STATE s_Mirv[] = { - {FIREBALL + 0, 12, &AF(DoMirv), &s_Mirv[1]}, - {FIREBALL + 1, 12, &AF(DoMirv), &s_Mirv[2]}, - {FIREBALL + 2, 12, &AF(DoMirv), &s_Mirv[3]}, - {FIREBALL + 3, 12, &AF(DoMirv), &s_Mirv[0]} + {SPR_FIREBALL, 'A', 12, &AF(DoMirv), &s_Mirv[1]}, + {SPR_FIREBALL, 'B', 12, &AF(DoMirv), &s_Mirv[2]}, + {SPR_FIREBALL, 'C', 12, &AF(DoMirv), &s_Mirv[3]}, + {SPR_FIREBALL, 'D', 12, &AF(DoMirv), &s_Mirv[0]} }; STATE s_MirvMissile[] = { - {FIREBALL + 0, 12, &AF(DoMirvMissile), &s_MirvMissile[1]}, - {FIREBALL + 1, 12, &AF(DoMirvMissile), &s_MirvMissile[2]}, - {FIREBALL + 2, 12, &AF(DoMirvMissile), &s_MirvMissile[3]}, - {FIREBALL + 3, 12, &AF(DoMirvMissile), &s_MirvMissile[0]} + {SPR_FIREBALL, 'A', 12, &AF(DoMirvMissile), &s_MirvMissile[1]}, + {SPR_FIREBALL, 'B', 12, &AF(DoMirvMissile), &s_MirvMissile[2]}, + {SPR_FIREBALL, 'C', 12, &AF(DoMirvMissile), &s_MirvMissile[3]}, + {SPR_FIREBALL, 'D', 12, &AF(DoMirvMissile), &s_MirvMissile[0]} }; //#define Vomit1 1740 @@ -1864,17 +1517,17 @@ STATE s_MirvMissile[] = STATE s_Vomit1[] = { - {Vomit1 + 0, Vomit_RATE, &AF(DoVomit), &s_Vomit1[0]} + {SPR_Vomit1, 'A', Vomit_RATE, &AF(DoVomit), &s_Vomit1[0]} }; STATE s_Vomit2[] = { - {Vomit2 + 0, Vomit_RATE, &AF(DoVomit), &s_Vomit2[0]} + {SPR_Vomit2, 'A', Vomit_RATE, &AF(DoVomit), &s_Vomit2[0]} }; STATE s_VomitSplash[] = { - {VomitSplash + 0, Vomit_RATE, &AF(DoVomitSplash), &s_VomitSplash[0]} + {SPR_VomitSplash, 'A', Vomit_RATE, &AF(DoVomitSplash), &s_VomitSplash[0]} }; #define GORE_Head 1670 @@ -1882,18 +1535,18 @@ STATE s_VomitSplash[] = STATE s_GoreHead[] = { - {GORE_Head + 0, GORE_Head_RATE, &AF(DoShrapJumpFall), &s_GoreHead[1]}, - {GORE_Head + 1, GORE_Head_RATE, &AF(DoShrapJumpFall), &s_GoreHead[2]}, - {GORE_Head + 2, GORE_Head_RATE, &AF(DoShrapJumpFall), &s_GoreHead[3]}, - {GORE_Head + 3, GORE_Head_RATE, &AF(DoShrapJumpFall), &s_GoreHead[4]}, - {GORE_Head + 4, GORE_Head_RATE, &AF(DoShrapJumpFall), &s_GoreHead[5]}, - {GORE_Head + 5, GORE_Head_RATE, &AF(DoShrapJumpFall), &s_GoreHead[6]}, - {GORE_Head + 6, GORE_Head_RATE, &AF(DoShrapJumpFall), &s_GoreHead[7]}, - {GORE_Head + 7, GORE_Head_RATE, &AF(DoShrapJumpFall), &s_GoreHead[8]}, - {GORE_Head + 8, GORE_Head_RATE, &AF(DoShrapJumpFall), &s_GoreHead[9]}, - {GORE_Head + 9, GORE_Head_RATE, &AF(DoShrapJumpFall), &s_GoreHead[10]}, - {GORE_Head + 10, GORE_Head_RATE, &AF(DoShrapJumpFall), &s_GoreHead[11]}, - {GORE_Head + 11, GORE_Head_RATE, &AF(DoShrapJumpFall), &s_GoreHead[0]}, + {SPR_GORE_Head, 'A', GORE_Head_RATE, &AF(DoShrapJumpFall), &s_GoreHead[1]}, + {SPR_GORE_Head, 'B', GORE_Head_RATE, &AF(DoShrapJumpFall), &s_GoreHead[2]}, + {SPR_GORE_Head, 'C', GORE_Head_RATE, &AF(DoShrapJumpFall), &s_GoreHead[3]}, + {SPR_GORE_Head, 'D', GORE_Head_RATE, &AF(DoShrapJumpFall), &s_GoreHead[4]}, + {SPR_GORE_Head, 'E', GORE_Head_RATE, &AF(DoShrapJumpFall), &s_GoreHead[5]}, + {SPR_GORE_Head, 'F', GORE_Head_RATE, &AF(DoShrapJumpFall), &s_GoreHead[6]}, + {SPR_GORE_Head, 'G', GORE_Head_RATE, &AF(DoShrapJumpFall), &s_GoreHead[7]}, + {SPR_GORE_Head, 'H', GORE_Head_RATE, &AF(DoShrapJumpFall), &s_GoreHead[8]}, + {SPR_GORE_Head, 'I', GORE_Head_RATE, &AF(DoShrapJumpFall), &s_GoreHead[9]}, + {SPR_GORE_Head, 'J', GORE_Head_RATE, &AF(DoShrapJumpFall), &s_GoreHead[10]}, + {SPR_GORE_Head, 'K', GORE_Head_RATE, &AF(DoShrapJumpFall), &s_GoreHead[11]}, + {SPR_GORE_Head, 'L', GORE_Head_RATE, &AF(DoShrapJumpFall), &s_GoreHead[0]}, }; #define GORE_Leg 1689 @@ -1901,9 +1554,9 @@ STATE s_GoreHead[] = STATE s_GoreLeg[] = { - {GORE_Leg + 0, GORE_Leg_RATE, &AF(DoShrapJumpFall), &s_GoreLeg[1]}, - {GORE_Leg + 1, GORE_Leg_RATE, &AF(DoShrapJumpFall), &s_GoreLeg[2]}, - {GORE_Leg + 2, GORE_Leg_RATE, &AF(DoShrapJumpFall), &s_GoreLeg[0]}, + {SPR_GORE_Leg, 'A', GORE_Leg_RATE, &AF(DoShrapJumpFall), &s_GoreLeg[1]}, + {SPR_GORE_Leg, 'B', GORE_Leg_RATE, &AF(DoShrapJumpFall), &s_GoreLeg[2]}, + {SPR_GORE_Leg, 'C', GORE_Leg_RATE, &AF(DoShrapJumpFall), &s_GoreLeg[0]}, }; #define GORE_Eye 1692 @@ -1911,10 +1564,10 @@ STATE s_GoreLeg[] = STATE s_GoreEye[] = { - {GORE_Eye + 0, GORE_Eye_RATE, &AF(DoShrapJumpFall), &s_GoreEye[1]}, - {GORE_Eye + 1, GORE_Eye_RATE, &AF(DoShrapJumpFall), &s_GoreEye[2]}, - {GORE_Eye + 2, GORE_Eye_RATE, &AF(DoShrapJumpFall), &s_GoreEye[3]}, - {GORE_Eye + 3, GORE_Eye_RATE, &AF(DoShrapJumpFall), &s_GoreEye[0]}, + {SPR_GORE_Eye, 'A', GORE_Eye_RATE, &AF(DoShrapJumpFall), &s_GoreEye[1]}, + {SPR_GORE_Eye, 'B', GORE_Eye_RATE, &AF(DoShrapJumpFall), &s_GoreEye[2]}, + {SPR_GORE_Eye, 'C', GORE_Eye_RATE, &AF(DoShrapJumpFall), &s_GoreEye[3]}, + {SPR_GORE_Eye, 'D', GORE_Eye_RATE, &AF(DoShrapJumpFall), &s_GoreEye[0]}, }; #define GORE_Torso 1696 @@ -1922,14 +1575,14 @@ STATE s_GoreEye[] = STATE s_GoreTorso[] = { - {GORE_Torso + 0, GORE_Torso_RATE, &AF(DoShrapJumpFall), &s_GoreTorso[1]}, - {GORE_Torso + 1, GORE_Torso_RATE, &AF(DoShrapJumpFall), &s_GoreTorso[2]}, - {GORE_Torso + 2, GORE_Torso_RATE, &AF(DoShrapJumpFall), &s_GoreTorso[3]}, - {GORE_Torso + 3, GORE_Torso_RATE, &AF(DoShrapJumpFall), &s_GoreTorso[4]}, - {GORE_Torso + 4, GORE_Torso_RATE, &AF(DoShrapJumpFall), &s_GoreTorso[5]}, - {GORE_Torso + 5, GORE_Torso_RATE, &AF(DoShrapJumpFall), &s_GoreTorso[6]}, - {GORE_Torso + 6, GORE_Torso_RATE, &AF(DoShrapJumpFall), &s_GoreTorso[7]}, - {GORE_Torso + 7, GORE_Torso_RATE, &AF(DoShrapJumpFall), &s_GoreTorso[0]}, + {SPR_GORE_Torso, 'A', GORE_Torso_RATE, &AF(DoShrapJumpFall), &s_GoreTorso[1]}, + {SPR_GORE_Torso, 'B', GORE_Torso_RATE, &AF(DoShrapJumpFall), &s_GoreTorso[2]}, + {SPR_GORE_Torso, 'C', GORE_Torso_RATE, &AF(DoShrapJumpFall), &s_GoreTorso[3]}, + {SPR_GORE_Torso, 'D', GORE_Torso_RATE, &AF(DoShrapJumpFall), &s_GoreTorso[4]}, + {SPR_GORE_Torso, 'E', GORE_Torso_RATE, &AF(DoShrapJumpFall), &s_GoreTorso[5]}, + {SPR_GORE_Torso, 'F', GORE_Torso_RATE, &AF(DoShrapJumpFall), &s_GoreTorso[6]}, + {SPR_GORE_Torso, 'G', GORE_Torso_RATE, &AF(DoShrapJumpFall), &s_GoreTorso[7]}, + {SPR_GORE_Torso, 'H', GORE_Torso_RATE, &AF(DoShrapJumpFall), &s_GoreTorso[0]}, }; @@ -1938,18 +1591,18 @@ STATE s_GoreTorso[] = STATE s_GoreArm[] = { - {GORE_Arm + 0, GORE_Arm_RATE, &AF(DoShrapJumpFall), &s_GoreArm[1]}, - {GORE_Arm + 1, GORE_Arm_RATE, &AF(DoShrapJumpFall), &s_GoreArm[2]}, - {GORE_Arm + 2, GORE_Arm_RATE, &AF(DoShrapJumpFall), &s_GoreArm[3]}, - {GORE_Arm + 3, GORE_Arm_RATE, &AF(DoShrapJumpFall), &s_GoreArm[4]}, - {GORE_Arm + 4, GORE_Arm_RATE, &AF(DoShrapJumpFall), &s_GoreArm[5]}, - {GORE_Arm + 5, GORE_Arm_RATE, &AF(DoShrapJumpFall), &s_GoreArm[6]}, - {GORE_Arm + 6, GORE_Arm_RATE, &AF(DoShrapJumpFall), &s_GoreArm[7]}, - {GORE_Arm + 7, GORE_Arm_RATE, &AF(DoShrapJumpFall), &s_GoreArm[8]}, - {GORE_Arm + 8, GORE_Arm_RATE, &AF(DoShrapJumpFall), &s_GoreArm[9]}, - {GORE_Arm + 9, GORE_Arm_RATE, &AF(DoShrapJumpFall), &s_GoreArm[10]}, - {GORE_Arm + 10, GORE_Arm_RATE, &AF(DoShrapJumpFall), &s_GoreArm[11]}, - {GORE_Arm + 11, GORE_Arm_RATE, &AF(DoShrapJumpFall), &s_GoreArm[0]}, + {SPR_GORE_Arm, 'A', GORE_Arm_RATE, &AF(DoShrapJumpFall), &s_GoreArm[1]}, + {SPR_GORE_Arm, 'B', GORE_Arm_RATE, &AF(DoShrapJumpFall), &s_GoreArm[2]}, + {SPR_GORE_Arm, 'C', GORE_Arm_RATE, &AF(DoShrapJumpFall), &s_GoreArm[3]}, + {SPR_GORE_Arm, 'D', GORE_Arm_RATE, &AF(DoShrapJumpFall), &s_GoreArm[4]}, + {SPR_GORE_Arm, 'E', GORE_Arm_RATE, &AF(DoShrapJumpFall), &s_GoreArm[5]}, + {SPR_GORE_Arm, 'F', GORE_Arm_RATE, &AF(DoShrapJumpFall), &s_GoreArm[6]}, + {SPR_GORE_Arm, 'G', GORE_Arm_RATE, &AF(DoShrapJumpFall), &s_GoreArm[7]}, + {SPR_GORE_Arm, 'H', GORE_Arm_RATE, &AF(DoShrapJumpFall), &s_GoreArm[8]}, + {SPR_GORE_Arm, 'I', GORE_Arm_RATE, &AF(DoShrapJumpFall), &s_GoreArm[9]}, + {SPR_GORE_Arm, 'J', GORE_Arm_RATE, &AF(DoShrapJumpFall), &s_GoreArm[10]}, + {SPR_GORE_Arm, 'K', GORE_Arm_RATE, &AF(DoShrapJumpFall), &s_GoreArm[11]}, + {SPR_GORE_Arm, 'L', GORE_Arm_RATE, &AF(DoShrapJumpFall), &s_GoreArm[0]}, }; #define GORE_Lung 903 @@ -1957,18 +1610,18 @@ STATE s_GoreArm[] = STATE s_GoreLung[] = { - {GORE_Lung + 0, GORE_Lung_RATE, &AF(DoShrapJumpFall), &s_GoreLung[1]}, - {GORE_Lung + 1, GORE_Lung_RATE, &AF(DoShrapJumpFall), &s_GoreLung[2]}, - {GORE_Lung + 2, GORE_Lung_RATE, &AF(DoShrapJumpFall), &s_GoreLung[3]}, - {GORE_Lung + 3, GORE_Lung_RATE, &AF(DoShrapJumpFall), &s_GoreLung[4]}, - {GORE_Lung + 4, GORE_Lung_RATE, &AF(DoShrapJumpFall), &s_GoreLung[5]}, - {GORE_Lung + 5, GORE_Lung_RATE, &AF(DoShrapJumpFall), &s_GoreLung[6]}, - {GORE_Lung + 6, GORE_Lung_RATE, &AF(DoShrapJumpFall), &s_GoreLung[7]}, - {GORE_Lung + 7, GORE_Lung_RATE, &AF(DoShrapJumpFall), &s_GoreLung[8]}, - {GORE_Lung + 8, GORE_Lung_RATE, &AF(DoShrapJumpFall), &s_GoreLung[9]}, - {GORE_Lung + 9, GORE_Lung_RATE, &AF(DoShrapJumpFall), &s_GoreLung[10]}, - {GORE_Lung + 10, GORE_Lung_RATE, &AF(DoShrapJumpFall), &s_GoreLung[11]}, - {GORE_Lung + 11, GORE_Lung_RATE, &AF(DoShrapJumpFall), &s_GoreLung[0]}, + {SPR_GORE_Lung, 'A', GORE_Lung_RATE, &AF(DoShrapJumpFall), &s_GoreLung[1]}, + {SPR_GORE_Lung, 'B', GORE_Lung_RATE, &AF(DoShrapJumpFall), &s_GoreLung[2]}, + {SPR_GORE_Lung, 'C', GORE_Lung_RATE, &AF(DoShrapJumpFall), &s_GoreLung[3]}, + {SPR_GORE_Lung, 'D', GORE_Lung_RATE, &AF(DoShrapJumpFall), &s_GoreLung[4]}, + {SPR_GORE_Lung, 'E', GORE_Lung_RATE, &AF(DoShrapJumpFall), &s_GoreLung[5]}, + {SPR_GORE_Lung, 'F', GORE_Lung_RATE, &AF(DoShrapJumpFall), &s_GoreLung[6]}, + {SPR_GORE_Lung, 'G', GORE_Lung_RATE, &AF(DoShrapJumpFall), &s_GoreLung[7]}, + {SPR_GORE_Lung, 'H', GORE_Lung_RATE, &AF(DoShrapJumpFall), &s_GoreLung[8]}, + {SPR_GORE_Lung, 'I', GORE_Lung_RATE, &AF(DoShrapJumpFall), &s_GoreLung[9]}, + {SPR_GORE_Lung, 'J', GORE_Lung_RATE, &AF(DoShrapJumpFall), &s_GoreLung[10]}, + {SPR_GORE_Lung, 'K', GORE_Lung_RATE, &AF(DoShrapJumpFall), &s_GoreLung[11]}, + {SPR_GORE_Lung, 'L', GORE_Lung_RATE, &AF(DoShrapJumpFall), &s_GoreLung[0]}, }; #define GORE_Liver 918 @@ -1976,18 +1629,18 @@ STATE s_GoreLung[] = STATE s_GoreLiver[] = { - {GORE_Liver + 0, GORE_Liver_RATE, &AF(DoShrapJumpFall), &s_GoreLiver[1]}, - {GORE_Liver + 1, GORE_Liver_RATE, &AF(DoShrapJumpFall), &s_GoreLiver[2]}, - {GORE_Liver + 2, GORE_Liver_RATE, &AF(DoShrapJumpFall), &s_GoreLiver[3]}, - {GORE_Liver + 3, GORE_Liver_RATE, &AF(DoShrapJumpFall), &s_GoreLiver[4]}, - {GORE_Liver + 4, GORE_Liver_RATE, &AF(DoShrapJumpFall), &s_GoreLiver[5]}, - {GORE_Liver + 5, GORE_Liver_RATE, &AF(DoShrapJumpFall), &s_GoreLiver[6]}, - {GORE_Liver + 6, GORE_Liver_RATE, &AF(DoShrapJumpFall), &s_GoreLiver[7]}, - {GORE_Liver + 7, GORE_Liver_RATE, &AF(DoShrapJumpFall), &s_GoreLiver[8]}, - {GORE_Liver + 8, GORE_Liver_RATE, &AF(DoShrapJumpFall), &s_GoreLiver[9]}, - {GORE_Liver + 9, GORE_Liver_RATE, &AF(DoShrapJumpFall), &s_GoreLiver[10]}, - {GORE_Liver + 10, GORE_Liver_RATE, &AF(DoShrapJumpFall), &s_GoreLiver[11]}, - {GORE_Liver + 11, GORE_Liver_RATE, &AF(DoShrapJumpFall), &s_GoreLiver[0]}, + {SPR_GORE_Liver, 'A', GORE_Liver_RATE, &AF(DoShrapJumpFall), &s_GoreLiver[1]}, + {SPR_GORE_Liver, 'B', GORE_Liver_RATE, &AF(DoShrapJumpFall), &s_GoreLiver[2]}, + {SPR_GORE_Liver, 'C', GORE_Liver_RATE, &AF(DoShrapJumpFall), &s_GoreLiver[3]}, + {SPR_GORE_Liver, 'D', GORE_Liver_RATE, &AF(DoShrapJumpFall), &s_GoreLiver[4]}, + {SPR_GORE_Liver, 'E', GORE_Liver_RATE, &AF(DoShrapJumpFall), &s_GoreLiver[5]}, + {SPR_GORE_Liver, 'F', GORE_Liver_RATE, &AF(DoShrapJumpFall), &s_GoreLiver[6]}, + {SPR_GORE_Liver, 'G', GORE_Liver_RATE, &AF(DoShrapJumpFall), &s_GoreLiver[7]}, + {SPR_GORE_Liver, 'H', GORE_Liver_RATE, &AF(DoShrapJumpFall), &s_GoreLiver[8]}, + {SPR_GORE_Liver, 'I', GORE_Liver_RATE, &AF(DoShrapJumpFall), &s_GoreLiver[9]}, + {SPR_GORE_Liver, 'J', GORE_Liver_RATE, &AF(DoShrapJumpFall), &s_GoreLiver[10]}, + {SPR_GORE_Liver, 'K', GORE_Liver_RATE, &AF(DoShrapJumpFall), &s_GoreLiver[11]}, + {SPR_GORE_Liver, 'L', GORE_Liver_RATE, &AF(DoShrapJumpFall), &s_GoreLiver[0]}, }; #define GORE_SkullCap 933 @@ -1995,18 +1648,18 @@ STATE s_GoreLiver[] = STATE s_GoreSkullCap[] = { - {GORE_SkullCap + 0, GORE_SkullCap_RATE, &AF(DoShrapJumpFall), &s_GoreSkullCap[1]}, - {GORE_SkullCap + 1, GORE_SkullCap_RATE, &AF(DoShrapJumpFall), &s_GoreSkullCap[2]}, - {GORE_SkullCap + 2, GORE_SkullCap_RATE, &AF(DoShrapJumpFall), &s_GoreSkullCap[3]}, - {GORE_SkullCap + 3, GORE_SkullCap_RATE, &AF(DoShrapJumpFall), &s_GoreSkullCap[4]}, - {GORE_SkullCap + 4, GORE_SkullCap_RATE, &AF(DoShrapJumpFall), &s_GoreSkullCap[5]}, - {GORE_SkullCap + 5, GORE_SkullCap_RATE, &AF(DoShrapJumpFall), &s_GoreSkullCap[6]}, - {GORE_SkullCap + 6, GORE_SkullCap_RATE, &AF(DoShrapJumpFall), &s_GoreSkullCap[7]}, - {GORE_SkullCap + 7, GORE_SkullCap_RATE, &AF(DoShrapJumpFall), &s_GoreSkullCap[8]}, - {GORE_SkullCap + 8, GORE_SkullCap_RATE, &AF(DoShrapJumpFall), &s_GoreSkullCap[9]}, - {GORE_SkullCap + 9, GORE_SkullCap_RATE, &AF(DoShrapJumpFall), &s_GoreSkullCap[10]}, - {GORE_SkullCap + 10, GORE_SkullCap_RATE, &AF(DoShrapJumpFall), &s_GoreSkullCap[11]}, - {GORE_SkullCap + 11, GORE_SkullCap_RATE, &AF(DoShrapJumpFall), &s_GoreSkullCap[0]}, + {SPR_GORE_SkullCap, 'A', GORE_SkullCap_RATE, &AF(DoShrapJumpFall), &s_GoreSkullCap[1]}, + {SPR_GORE_SkullCap, 'B', GORE_SkullCap_RATE, &AF(DoShrapJumpFall), &s_GoreSkullCap[2]}, + {SPR_GORE_SkullCap, 'C', GORE_SkullCap_RATE, &AF(DoShrapJumpFall), &s_GoreSkullCap[3]}, + {SPR_GORE_SkullCap, 'D', GORE_SkullCap_RATE, &AF(DoShrapJumpFall), &s_GoreSkullCap[4]}, + {SPR_GORE_SkullCap, 'E', GORE_SkullCap_RATE, &AF(DoShrapJumpFall), &s_GoreSkullCap[5]}, + {SPR_GORE_SkullCap, 'F', GORE_SkullCap_RATE, &AF(DoShrapJumpFall), &s_GoreSkullCap[6]}, + {SPR_GORE_SkullCap, 'G', GORE_SkullCap_RATE, &AF(DoShrapJumpFall), &s_GoreSkullCap[7]}, + {SPR_GORE_SkullCap, 'H', GORE_SkullCap_RATE, &AF(DoShrapJumpFall), &s_GoreSkullCap[8]}, + {SPR_GORE_SkullCap, 'I', GORE_SkullCap_RATE, &AF(DoShrapJumpFall), &s_GoreSkullCap[9]}, + {SPR_GORE_SkullCap, 'J', GORE_SkullCap_RATE, &AF(DoShrapJumpFall), &s_GoreSkullCap[10]}, + {SPR_GORE_SkullCap, 'K', GORE_SkullCap_RATE, &AF(DoShrapJumpFall), &s_GoreSkullCap[11]}, + {SPR_GORE_SkullCap, 'L', GORE_SkullCap_RATE, &AF(DoShrapJumpFall), &s_GoreSkullCap[0]}, }; @@ -2015,10 +1668,10 @@ STATE s_GoreSkullCap[] = STATE s_GoreChunkS[] = { - {GORE_ChunkS + 0, GORE_ChunkS_RATE, &AF(DoShrapJumpFall), &s_GoreChunkS[1]}, - {GORE_ChunkS + 1, GORE_ChunkS_RATE, &AF(DoShrapJumpFall), &s_GoreChunkS[2]}, - {GORE_ChunkS + 2, GORE_ChunkS_RATE, &AF(DoShrapJumpFall), &s_GoreChunkS[3]}, - {GORE_ChunkS + 3, GORE_ChunkS_RATE, &AF(DoShrapJumpFall), &s_GoreChunkS[0]}, + {SPR_GORE_ChunkS, 'A', GORE_ChunkS_RATE, &AF(DoShrapJumpFall), &s_GoreChunkS[1]}, + {SPR_GORE_ChunkS, 'B', GORE_ChunkS_RATE, &AF(DoShrapJumpFall), &s_GoreChunkS[2]}, + {SPR_GORE_ChunkS, 'C', GORE_ChunkS_RATE, &AF(DoShrapJumpFall), &s_GoreChunkS[3]}, + {SPR_GORE_ChunkS, 'D', GORE_ChunkS_RATE, &AF(DoShrapJumpFall), &s_GoreChunkS[0]}, }; #define GORE_Drip 1562 //2430 @@ -2026,18 +1679,18 @@ STATE s_GoreChunkS[] = STATE s_GoreDrip[] = { - {GORE_Drip + 0, GORE_Drip_RATE, &AF(DoShrapJumpFall), &s_GoreDrip[1]}, - {GORE_Drip + 1, GORE_Drip_RATE, &AF(DoShrapJumpFall), &s_GoreDrip[2]}, - {GORE_Drip + 2, GORE_Drip_RATE, &AF(DoShrapJumpFall), &s_GoreDrip[3]}, - {GORE_Drip + 3, GORE_Drip_RATE, &AF(DoShrapJumpFall), &s_GoreDrip[0]}, + {SPR_GORE_Drip, 'A', GORE_Drip_RATE, &AF(DoShrapJumpFall), &s_GoreDrip[1]}, + {SPR_GORE_Drip, 'B', GORE_Drip_RATE, &AF(DoShrapJumpFall), &s_GoreDrip[2]}, + {SPR_GORE_Drip, 'C', GORE_Drip_RATE, &AF(DoShrapJumpFall), &s_GoreDrip[3]}, + {SPR_GORE_Drip, 'D', GORE_Drip_RATE, &AF(DoShrapJumpFall), &s_GoreDrip[0]}, }; STATE s_FastGoreDrip[] = { - {GORE_Drip + 0, GORE_Drip_RATE, &AF(DoFastShrapJumpFall), &s_FastGoreDrip[1]}, - {GORE_Drip + 1, GORE_Drip_RATE, &AF(DoFastShrapJumpFall), &s_FastGoreDrip[2]}, - {GORE_Drip + 2, GORE_Drip_RATE, &AF(DoFastShrapJumpFall), &s_FastGoreDrip[3]}, - {GORE_Drip + 3, GORE_Drip_RATE, &AF(DoFastShrapJumpFall), &s_FastGoreDrip[0]}, + {SPR_GORE_Drip, 'A', GORE_Drip_RATE, &AF(DoFastShrapJumpFall), &s_FastGoreDrip[1]}, + {SPR_GORE_Drip, 'B', GORE_Drip_RATE, &AF(DoFastShrapJumpFall), &s_FastGoreDrip[2]}, + {SPR_GORE_Drip, 'C', GORE_Drip_RATE, &AF(DoFastShrapJumpFall), &s_FastGoreDrip[3]}, + {SPR_GORE_Drip, 'D', GORE_Drip_RATE, &AF(DoFastShrapJumpFall), &s_FastGoreDrip[0]}, }; /////////////////////////////////////////////// @@ -2051,90 +1704,90 @@ STATE s_FastGoreDrip[] = STATE s_GoreFlame[] = { - {GORE_Flame + 0, GORE_Flame_RATE, &AF(DoFastShrapJumpFall), &s_GoreFlame[1]}, - {GORE_Flame + 1, GORE_Flame_RATE, &AF(DoFastShrapJumpFall), &s_GoreFlame[2]}, - {GORE_Flame + 2, GORE_Flame_RATE, &AF(DoFastShrapJumpFall), &s_GoreFlame[3]}, - {GORE_Flame + 3, GORE_Flame_RATE, &AF(DoFastShrapJumpFall), &s_GoreFlame[4]}, - {GORE_Flame + 4, GORE_Flame_RATE, &AF(DoFastShrapJumpFall), &s_GoreFlame[5]}, - {GORE_Flame + 5, GORE_Flame_RATE, &AF(DoFastShrapJumpFall), &s_GoreFlame[6]}, - {GORE_Flame + 6, GORE_Flame_RATE, &AF(DoFastShrapJumpFall), &s_GoreFlame[7]}, - {GORE_Flame + 7, GORE_Flame_RATE, &AF(DoFastShrapJumpFall), &s_GoreFlame[0]}, + {SPR_GORE_Flame, 'A', GORE_Flame_RATE, &AF(DoFastShrapJumpFall), &s_GoreFlame[1]}, + {SPR_GORE_Flame, 'B', GORE_Flame_RATE, &AF(DoFastShrapJumpFall), &s_GoreFlame[2]}, + {SPR_GORE_Flame, 'C', GORE_Flame_RATE, &AF(DoFastShrapJumpFall), &s_GoreFlame[3]}, + {SPR_GORE_Flame, 'D', GORE_Flame_RATE, &AF(DoFastShrapJumpFall), &s_GoreFlame[4]}, + {SPR_GORE_Flame, 'E', GORE_Flame_RATE, &AF(DoFastShrapJumpFall), &s_GoreFlame[5]}, + {SPR_GORE_Flame, 'F', GORE_Flame_RATE, &AF(DoFastShrapJumpFall), &s_GoreFlame[6]}, + {SPR_GORE_Flame, 'G', GORE_Flame_RATE, &AF(DoFastShrapJumpFall), &s_GoreFlame[7]}, + {SPR_GORE_Flame, 'H', GORE_Flame_RATE, &AF(DoFastShrapJumpFall), &s_GoreFlame[0]}, }; STATE s_TracerShrap[] = { - {GORE_Flame + 0, GORE_Flame_RATE, &AF(DoTracerShrap), &s_TracerShrap[1]}, - {GORE_Flame + 1, GORE_Flame_RATE, &AF(DoTracerShrap), &s_TracerShrap[2]}, - {GORE_Flame + 2, GORE_Flame_RATE, &AF(DoTracerShrap), &s_TracerShrap[3]}, - {GORE_Flame + 3, GORE_Flame_RATE, &AF(DoTracerShrap), &s_TracerShrap[4]}, - {GORE_Flame + 4, GORE_Flame_RATE, &AF(DoTracerShrap), &s_TracerShrap[5]}, - {GORE_Flame + 5, GORE_Flame_RATE, &AF(DoTracerShrap), &s_TracerShrap[6]}, - {GORE_Flame + 6, GORE_Flame_RATE, &AF(DoTracerShrap), &s_TracerShrap[7]}, - {GORE_Flame + 7, GORE_Flame_RATE, &AF(DoTracerShrap), &s_TracerShrap[0]}, + {SPR_GORE_Flame, 'A', GORE_Flame_RATE, &AF(DoTracerShrap), &s_TracerShrap[1]}, + {SPR_GORE_Flame, 'B', GORE_Flame_RATE, &AF(DoTracerShrap), &s_TracerShrap[2]}, + {SPR_GORE_Flame, 'C', GORE_Flame_RATE, &AF(DoTracerShrap), &s_TracerShrap[3]}, + {SPR_GORE_Flame, 'D', GORE_Flame_RATE, &AF(DoTracerShrap), &s_TracerShrap[4]}, + {SPR_GORE_Flame, 'E', GORE_Flame_RATE, &AF(DoTracerShrap), &s_TracerShrap[5]}, + {SPR_GORE_Flame, 'F', GORE_Flame_RATE, &AF(DoTracerShrap), &s_TracerShrap[6]}, + {SPR_GORE_Flame, 'G', GORE_Flame_RATE, &AF(DoTracerShrap), &s_TracerShrap[7]}, + {SPR_GORE_Flame, 'H', GORE_Flame_RATE, &AF(DoTracerShrap), &s_TracerShrap[0]}, }; #define UZI_SHELL 2152 #define UZISHELL_RATE 8 STATE s_UziShellShrap[] = { - {UZI_SHELL + 0, UZISHELL_RATE, &AF(DoShrapJumpFall), &s_UziShellShrap[1]}, - {UZI_SHELL + 1, UZISHELL_RATE, &AF(DoShrapJumpFall), &s_UziShellShrap[2]}, - {UZI_SHELL + 2, UZISHELL_RATE, &AF(DoShrapJumpFall), &s_UziShellShrap[3]}, - {UZI_SHELL + 3, UZISHELL_RATE, &AF(DoShrapJumpFall), &s_UziShellShrap[4]}, - {UZI_SHELL + 4, UZISHELL_RATE, &AF(DoShrapJumpFall), &s_UziShellShrap[5]}, - {UZI_SHELL + 5, UZISHELL_RATE, &AF(DoShrapJumpFall), &s_UziShellShrap[0]}, + {SPR_UZI_SHELL, 'A', UZISHELL_RATE, &AF(DoShrapJumpFall), &s_UziShellShrap[1]}, + {SPR_UZI_SHELL, 'B', UZISHELL_RATE, &AF(DoShrapJumpFall), &s_UziShellShrap[2]}, + {SPR_UZI_SHELL, 'C', UZISHELL_RATE, &AF(DoShrapJumpFall), &s_UziShellShrap[3]}, + {SPR_UZI_SHELL, 'D', UZISHELL_RATE, &AF(DoShrapJumpFall), &s_UziShellShrap[4]}, + {SPR_UZI_SHELL, 'E', UZISHELL_RATE, &AF(DoShrapJumpFall), &s_UziShellShrap[5]}, + {SPR_UZI_SHELL, 'F', UZISHELL_RATE, &AF(DoShrapJumpFall), &s_UziShellShrap[0]}, }; STATE s_UziShellShrapStill1[] = { - {UZI_SHELL + 0, UZISHELL_RATE, nullptr, &s_UziShellShrapStill1[0]} + {SPR_UZI_SHELL, 'A', UZISHELL_RATE, nullptr, &s_UziShellShrapStill1[0]} }; STATE s_UziShellShrapStill2[] = { - {UZI_SHELL + 1, UZISHELL_RATE, nullptr, &s_UziShellShrapStill2[0]} + {SPR_UZI_SHELL, 'B', UZISHELL_RATE, nullptr, &s_UziShellShrapStill2[0]} }; STATE s_UziShellShrapStill3[] = { - {UZI_SHELL + 2, UZISHELL_RATE, nullptr, &s_UziShellShrapStill3[0]} + {SPR_UZI_SHELL, 'C', UZISHELL_RATE, nullptr, &s_UziShellShrapStill3[0]} }; STATE s_UziShellShrapStill4[] = { - {UZI_SHELL + 3, UZISHELL_RATE, nullptr, &s_UziShellShrapStill4[0]} + {SPR_UZI_SHELL, 'D', UZISHELL_RATE, nullptr, &s_UziShellShrapStill4[0]} }; STATE s_UziShellShrapStill5[] = { - {UZI_SHELL + 4, UZISHELL_RATE, nullptr, &s_UziShellShrapStill5[0]} + {SPR_UZI_SHELL, 'E', UZISHELL_RATE, nullptr, &s_UziShellShrapStill5[0]} }; STATE s_UziShellShrapStill6[] = { - {UZI_SHELL + 5, UZISHELL_RATE, nullptr, &s_UziShellShrapStill6[0]} + {SPR_UZI_SHELL, 'F', UZISHELL_RATE, nullptr, &s_UziShellShrapStill6[0]} }; #define SHOT_SHELL 2180 #define SHOTSHELL_RATE 8 STATE s_ShotgunShellShrap[] = { - {SHOT_SHELL + 0, SHOTSHELL_RATE, &AF(DoShrapJumpFall), &s_ShotgunShellShrap[1]}, - {SHOT_SHELL + 1, SHOTSHELL_RATE, &AF(DoShrapJumpFall), &s_ShotgunShellShrap[2]}, - {SHOT_SHELL + 2, SHOTSHELL_RATE, &AF(DoShrapJumpFall), &s_ShotgunShellShrap[3]}, - {SHOT_SHELL + 3, SHOTSHELL_RATE, &AF(DoShrapJumpFall), &s_ShotgunShellShrap[4]}, - {SHOT_SHELL + 4, SHOTSHELL_RATE, &AF(DoShrapJumpFall), &s_ShotgunShellShrap[5]}, - {SHOT_SHELL + 5, SHOTSHELL_RATE, &AF(DoShrapJumpFall), &s_ShotgunShellShrap[6]}, - {SHOT_SHELL + 6, SHOTSHELL_RATE, &AF(DoShrapJumpFall), &s_ShotgunShellShrap[7]}, - {SHOT_SHELL + 7, SHOTSHELL_RATE, &AF(DoShrapJumpFall), &s_ShotgunShellShrap[0]}, + {SPR_SHOT_SHELL, 'A', SHOTSHELL_RATE, &AF(DoShrapJumpFall), &s_ShotgunShellShrap[1]}, + {SPR_SHOT_SHELL, 'B', SHOTSHELL_RATE, &AF(DoShrapJumpFall), &s_ShotgunShellShrap[2]}, + {SPR_SHOT_SHELL, 'C', SHOTSHELL_RATE, &AF(DoShrapJumpFall), &s_ShotgunShellShrap[3]}, + {SPR_SHOT_SHELL, 'D', SHOTSHELL_RATE, &AF(DoShrapJumpFall), &s_ShotgunShellShrap[4]}, + {SPR_SHOT_SHELL, 'E', SHOTSHELL_RATE, &AF(DoShrapJumpFall), &s_ShotgunShellShrap[5]}, + {SPR_SHOT_SHELL, 'F', SHOTSHELL_RATE, &AF(DoShrapJumpFall), &s_ShotgunShellShrap[6]}, + {SPR_SHOT_SHELL, 'G', SHOTSHELL_RATE, &AF(DoShrapJumpFall), &s_ShotgunShellShrap[7]}, + {SPR_SHOT_SHELL, 'H', SHOTSHELL_RATE, &AF(DoShrapJumpFall), &s_ShotgunShellShrap[0]}, }; STATE s_ShotgunShellShrapStill1[] = { - {SHOT_SHELL + 1, SHOTSHELL_RATE, nullptr, &s_ShotgunShellShrapStill1[0]} + {SPR_SHOT_SHELL, 'B', SHOTSHELL_RATE, nullptr, &s_ShotgunShellShrapStill1[0]} }; STATE s_ShotgunShellShrapStill2[] = { - {SHOT_SHELL + 3, SHOTSHELL_RATE, nullptr, &s_ShotgunShellShrapStill2[0]} + {SPR_SHOT_SHELL, 'D', SHOTSHELL_RATE, nullptr, &s_ShotgunShellShrapStill2[0]} }; STATE s_ShotgunShellShrapStill3[] = { - {SHOT_SHELL + 7, SHOTSHELL_RATE, nullptr, &s_ShotgunShellShrapStill3[0]} + {SPR_SHOT_SHELL, 'H', SHOTSHELL_RATE, nullptr, &s_ShotgunShellShrapStill3[0]} }; #define GORE_FlameChunkA 839 @@ -2142,10 +1795,10 @@ STATE s_ShotgunShellShrapStill3[] = STATE s_GoreFlameChunkA[] = { - {GORE_FlameChunkA + 0, GORE_FlameChunkA_RATE, &AF(DoShrapJumpFall), &s_GoreFlameChunkA[1]}, - {GORE_FlameChunkA + 1, GORE_FlameChunkA_RATE, &AF(DoShrapJumpFall), &s_GoreFlameChunkA[2]}, - {GORE_FlameChunkA + 2, GORE_FlameChunkA_RATE, &AF(DoShrapJumpFall), &s_GoreFlameChunkA[3]}, - {GORE_FlameChunkA + 3, GORE_FlameChunkA_RATE, &AF(DoShrapJumpFall), &s_GoreFlameChunkA[0]}, + {SPR_GORE_FlameChunkA, 'A', GORE_FlameChunkA_RATE, &AF(DoShrapJumpFall), &s_GoreFlameChunkA[1]}, + {SPR_GORE_FlameChunkA, 'B', GORE_FlameChunkA_RATE, &AF(DoShrapJumpFall), &s_GoreFlameChunkA[2]}, + {SPR_GORE_FlameChunkA, 'C', GORE_FlameChunkA_RATE, &AF(DoShrapJumpFall), &s_GoreFlameChunkA[3]}, + {SPR_GORE_FlameChunkA, 'D', GORE_FlameChunkA_RATE, &AF(DoShrapJumpFall), &s_GoreFlameChunkA[0]}, }; #define GORE_FlameChunkB 843 @@ -2153,10 +1806,10 @@ STATE s_GoreFlameChunkA[] = STATE s_GoreFlameChunkB[] = { - {GORE_FlameChunkB + 0, GORE_FlameChunkB_RATE, &AF(DoShrapJumpFall), &s_GoreFlameChunkB[1]}, - {GORE_FlameChunkB + 1, GORE_FlameChunkB_RATE, &AF(DoShrapJumpFall), &s_GoreFlameChunkB[2]}, - {GORE_FlameChunkB + 2, GORE_FlameChunkB_RATE, &AF(DoShrapJumpFall), &s_GoreFlameChunkB[3]}, - {GORE_FlameChunkB + 3, GORE_FlameChunkB_RATE, &AF(DoShrapJumpFall), &s_GoreFlameChunkB[0]}, + {SPR_GORE_FlameChunkB, 'A', GORE_FlameChunkB_RATE, &AF(DoShrapJumpFall), &s_GoreFlameChunkB[1]}, + {SPR_GORE_FlameChunkB, 'B', GORE_FlameChunkB_RATE, &AF(DoShrapJumpFall), &s_GoreFlameChunkB[2]}, + {SPR_GORE_FlameChunkB, 'C', GORE_FlameChunkB_RATE, &AF(DoShrapJumpFall), &s_GoreFlameChunkB[3]}, + {SPR_GORE_FlameChunkB, 'D', GORE_FlameChunkB_RATE, &AF(DoShrapJumpFall), &s_GoreFlameChunkB[0]}, }; ///////////////////////////////////////////////////////////////////// @@ -2170,10 +1823,10 @@ STATE s_GoreFlameChunkB[] = STATE s_CoinShrap[] = { - {COIN_SHRAP + 0, CoinShrap_RATE, &AF(DoShrapJumpFall), &s_CoinShrap[1]}, - {COIN_SHRAP + 1, CoinShrap_RATE, &AF(DoShrapJumpFall), &s_CoinShrap[2]}, - {COIN_SHRAP + 2, CoinShrap_RATE, &AF(DoShrapJumpFall), &s_CoinShrap[3]}, - {COIN_SHRAP + 3, CoinShrap_RATE, &AF(DoShrapJumpFall), &s_CoinShrap[0]}, + {SPR_COIN_SHRAP, 'A', CoinShrap_RATE, &AF(DoShrapJumpFall), &s_CoinShrap[1]}, + {SPR_COIN_SHRAP, 'B', CoinShrap_RATE, &AF(DoShrapJumpFall), &s_CoinShrap[2]}, + {SPR_COIN_SHRAP, 'C', CoinShrap_RATE, &AF(DoShrapJumpFall), &s_CoinShrap[3]}, + {SPR_COIN_SHRAP, 'D', CoinShrap_RATE, &AF(DoShrapJumpFall), &s_CoinShrap[0]}, }; #define MARBEL 5096 @@ -2181,7 +1834,7 @@ STATE s_CoinShrap[] = STATE s_Marbel[] = { - {MARBEL, Marbel_RATE, &AF(DoShrapJumpFall), &s_Marbel[0]}, + {SPR_MARBEL, 'A', Marbel_RATE, &AF(DoShrapJumpFall), &s_Marbel[0]}, }; // @@ -2193,14 +1846,14 @@ STATE s_Marbel[] = STATE s_GlassShrapA[] = { - {GLASS_SHRAP_A + 0, GlassShrapA_RATE, &AF(DoShrapJumpFall), &s_GlassShrapA[1]}, - {GLASS_SHRAP_A + 1, GlassShrapA_RATE, &AF(DoShrapJumpFall), &s_GlassShrapA[2]}, - {GLASS_SHRAP_A + 2, GlassShrapA_RATE, &AF(DoShrapJumpFall), &s_GlassShrapA[3]}, - {GLASS_SHRAP_A + 3, GlassShrapA_RATE, &AF(DoShrapJumpFall), &s_GlassShrapA[4]}, - {GLASS_SHRAP_A + 4, GlassShrapA_RATE, &AF(DoShrapJumpFall), &s_GlassShrapA[5]}, - {GLASS_SHRAP_A + 5, GlassShrapA_RATE, &AF(DoShrapJumpFall), &s_GlassShrapA[6]}, - {GLASS_SHRAP_A + 6, GlassShrapA_RATE, &AF(DoShrapJumpFall), &s_GlassShrapA[7]}, - {GLASS_SHRAP_A + 7, GlassShrapA_RATE, &AF(DoShrapJumpFall), &s_GlassShrapA[0]}, + {SPR_GLASS_SHRAP_A, 'A', GlassShrapA_RATE, &AF(DoShrapJumpFall), &s_GlassShrapA[1]}, + {SPR_GLASS_SHRAP_A, 'B', GlassShrapA_RATE, &AF(DoShrapJumpFall), &s_GlassShrapA[2]}, + {SPR_GLASS_SHRAP_A, 'C', GlassShrapA_RATE, &AF(DoShrapJumpFall), &s_GlassShrapA[3]}, + {SPR_GLASS_SHRAP_A, 'D', GlassShrapA_RATE, &AF(DoShrapJumpFall), &s_GlassShrapA[4]}, + {SPR_GLASS_SHRAP_A, 'E', GlassShrapA_RATE, &AF(DoShrapJumpFall), &s_GlassShrapA[5]}, + {SPR_GLASS_SHRAP_A, 'F', GlassShrapA_RATE, &AF(DoShrapJumpFall), &s_GlassShrapA[6]}, + {SPR_GLASS_SHRAP_A, 'G', GlassShrapA_RATE, &AF(DoShrapJumpFall), &s_GlassShrapA[7]}, + {SPR_GLASS_SHRAP_A, 'H', GlassShrapA_RATE, &AF(DoShrapJumpFall), &s_GlassShrapA[0]}, }; #define GLASS_SHRAP_B 3872 @@ -2208,14 +1861,14 @@ STATE s_GlassShrapA[] = STATE s_GlassShrapB[] = { - {GLASS_SHRAP_B + 0, GlassShrapB_RATE, &AF(DoShrapJumpFall), &s_GlassShrapB[1]}, - {GLASS_SHRAP_B + 1, GlassShrapB_RATE, &AF(DoShrapJumpFall), &s_GlassShrapB[2]}, - {GLASS_SHRAP_B + 2, GlassShrapB_RATE, &AF(DoShrapJumpFall), &s_GlassShrapB[3]}, - {GLASS_SHRAP_B + 3, GlassShrapB_RATE, &AF(DoShrapJumpFall), &s_GlassShrapB[4]}, - {GLASS_SHRAP_B + 4, GlassShrapB_RATE, &AF(DoShrapJumpFall), &s_GlassShrapB[5]}, - {GLASS_SHRAP_B + 5, GlassShrapB_RATE, &AF(DoShrapJumpFall), &s_GlassShrapB[6]}, - {GLASS_SHRAP_B + 6, GlassShrapB_RATE, &AF(DoShrapJumpFall), &s_GlassShrapB[7]}, - {GLASS_SHRAP_B + 7, GlassShrapB_RATE, &AF(DoShrapJumpFall), &s_GlassShrapB[0]}, + {SPR_GLASS_SHRAP_B, 'A', GlassShrapB_RATE, &AF(DoShrapJumpFall), &s_GlassShrapB[1]}, + {SPR_GLASS_SHRAP_B, 'B', GlassShrapB_RATE, &AF(DoShrapJumpFall), &s_GlassShrapB[2]}, + {SPR_GLASS_SHRAP_B, 'C', GlassShrapB_RATE, &AF(DoShrapJumpFall), &s_GlassShrapB[3]}, + {SPR_GLASS_SHRAP_B, 'D', GlassShrapB_RATE, &AF(DoShrapJumpFall), &s_GlassShrapB[4]}, + {SPR_GLASS_SHRAP_B, 'E', GlassShrapB_RATE, &AF(DoShrapJumpFall), &s_GlassShrapB[5]}, + {SPR_GLASS_SHRAP_B, 'F', GlassShrapB_RATE, &AF(DoShrapJumpFall), &s_GlassShrapB[6]}, + {SPR_GLASS_SHRAP_B, 'G', GlassShrapB_RATE, &AF(DoShrapJumpFall), &s_GlassShrapB[7]}, + {SPR_GLASS_SHRAP_B, 'H', GlassShrapB_RATE, &AF(DoShrapJumpFall), &s_GlassShrapB[0]}, }; #define GLASS_SHRAP_C 3880 @@ -2223,14 +1876,14 @@ STATE s_GlassShrapB[] = STATE s_GlassShrapC[] = { - {GLASS_SHRAP_C + 0, GlassShrapC_RATE, &AF(DoShrapJumpFall), &s_GlassShrapC[1]}, - {GLASS_SHRAP_C + 1, GlassShrapC_RATE, &AF(DoShrapJumpFall), &s_GlassShrapC[2]}, - {GLASS_SHRAP_C + 2, GlassShrapC_RATE, &AF(DoShrapJumpFall), &s_GlassShrapC[3]}, - {GLASS_SHRAP_C + 3, GlassShrapC_RATE, &AF(DoShrapJumpFall), &s_GlassShrapC[4]}, - {GLASS_SHRAP_C + 4, GlassShrapC_RATE, &AF(DoShrapJumpFall), &s_GlassShrapC[5]}, - {GLASS_SHRAP_C + 5, GlassShrapC_RATE, &AF(DoShrapJumpFall), &s_GlassShrapC[6]}, - {GLASS_SHRAP_C + 6, GlassShrapC_RATE, &AF(DoShrapJumpFall), &s_GlassShrapC[7]}, - {GLASS_SHRAP_C + 7, GlassShrapC_RATE, &AF(DoShrapJumpFall), &s_GlassShrapC[0]}, + {SPR_GLASS_SHRAP_C, 'A', GlassShrapC_RATE, &AF(DoShrapJumpFall), &s_GlassShrapC[1]}, + {SPR_GLASS_SHRAP_C, 'B', GlassShrapC_RATE, &AF(DoShrapJumpFall), &s_GlassShrapC[2]}, + {SPR_GLASS_SHRAP_C, 'C', GlassShrapC_RATE, &AF(DoShrapJumpFall), &s_GlassShrapC[3]}, + {SPR_GLASS_SHRAP_C, 'D', GlassShrapC_RATE, &AF(DoShrapJumpFall), &s_GlassShrapC[4]}, + {SPR_GLASS_SHRAP_C, 'E', GlassShrapC_RATE, &AF(DoShrapJumpFall), &s_GlassShrapC[5]}, + {SPR_GLASS_SHRAP_C, 'F', GlassShrapC_RATE, &AF(DoShrapJumpFall), &s_GlassShrapC[6]}, + {SPR_GLASS_SHRAP_C, 'G', GlassShrapC_RATE, &AF(DoShrapJumpFall), &s_GlassShrapC[7]}, + {SPR_GLASS_SHRAP_C, 'H', GlassShrapC_RATE, &AF(DoShrapJumpFall), &s_GlassShrapC[0]}, }; // @@ -2242,14 +1895,14 @@ STATE s_GlassShrapC[] = STATE s_WoodShrapA[] = { - {WOOD_SHRAP_A + 0, WoodShrapA_RATE, &AF(DoShrapJumpFall), &s_WoodShrapA[1]}, - {WOOD_SHRAP_A + 1, WoodShrapA_RATE, &AF(DoShrapJumpFall), &s_WoodShrapA[2]}, - {WOOD_SHRAP_A + 2, WoodShrapA_RATE, &AF(DoShrapJumpFall), &s_WoodShrapA[3]}, - {WOOD_SHRAP_A + 3, WoodShrapA_RATE, &AF(DoShrapJumpFall), &s_WoodShrapA[4]}, - {WOOD_SHRAP_A + 4, WoodShrapA_RATE, &AF(DoShrapJumpFall), &s_WoodShrapA[5]}, - {WOOD_SHRAP_A + 5, WoodShrapA_RATE, &AF(DoShrapJumpFall), &s_WoodShrapA[6]}, - {WOOD_SHRAP_A + 6, WoodShrapA_RATE, &AF(DoShrapJumpFall), &s_WoodShrapA[7]}, - {WOOD_SHRAP_A + 7, WoodShrapA_RATE, &AF(DoShrapJumpFall), &s_WoodShrapA[0]}, + {SPR_WOOD_SHRAP_A, 'A', WoodShrapA_RATE, &AF(DoShrapJumpFall), &s_WoodShrapA[1]}, + {SPR_WOOD_SHRAP_A, 'B', WoodShrapA_RATE, &AF(DoShrapJumpFall), &s_WoodShrapA[2]}, + {SPR_WOOD_SHRAP_A, 'C', WoodShrapA_RATE, &AF(DoShrapJumpFall), &s_WoodShrapA[3]}, + {SPR_WOOD_SHRAP_A, 'D', WoodShrapA_RATE, &AF(DoShrapJumpFall), &s_WoodShrapA[4]}, + {SPR_WOOD_SHRAP_A, 'E', WoodShrapA_RATE, &AF(DoShrapJumpFall), &s_WoodShrapA[5]}, + {SPR_WOOD_SHRAP_A, 'F', WoodShrapA_RATE, &AF(DoShrapJumpFall), &s_WoodShrapA[6]}, + {SPR_WOOD_SHRAP_A, 'G', WoodShrapA_RATE, &AF(DoShrapJumpFall), &s_WoodShrapA[7]}, + {SPR_WOOD_SHRAP_A, 'H', WoodShrapA_RATE, &AF(DoShrapJumpFall), &s_WoodShrapA[0]}, }; #define WOOD_SHRAP_B 3932 @@ -2257,14 +1910,14 @@ STATE s_WoodShrapA[] = STATE s_WoodShrapB[] = { - {WOOD_SHRAP_B + 0, WoodShrapB_RATE, &AF(DoShrapJumpFall), &s_WoodShrapB[1]}, - {WOOD_SHRAP_B + 1, WoodShrapB_RATE, &AF(DoShrapJumpFall), &s_WoodShrapB[2]}, - {WOOD_SHRAP_B + 2, WoodShrapB_RATE, &AF(DoShrapJumpFall), &s_WoodShrapB[3]}, - {WOOD_SHRAP_B + 3, WoodShrapB_RATE, &AF(DoShrapJumpFall), &s_WoodShrapB[4]}, - {WOOD_SHRAP_B + 4, WoodShrapB_RATE, &AF(DoShrapJumpFall), &s_WoodShrapB[5]}, - {WOOD_SHRAP_B + 5, WoodShrapB_RATE, &AF(DoShrapJumpFall), &s_WoodShrapB[6]}, - {WOOD_SHRAP_B + 6, WoodShrapB_RATE, &AF(DoShrapJumpFall), &s_WoodShrapB[7]}, - {WOOD_SHRAP_B + 7, WoodShrapB_RATE, &AF(DoShrapJumpFall), &s_WoodShrapB[0]}, + {SPR_WOOD_SHRAP_B, 'A', WoodShrapB_RATE, &AF(DoShrapJumpFall), &s_WoodShrapB[1]}, + {SPR_WOOD_SHRAP_B, 'B', WoodShrapB_RATE, &AF(DoShrapJumpFall), &s_WoodShrapB[2]}, + {SPR_WOOD_SHRAP_B, 'C', WoodShrapB_RATE, &AF(DoShrapJumpFall), &s_WoodShrapB[3]}, + {SPR_WOOD_SHRAP_B, 'D', WoodShrapB_RATE, &AF(DoShrapJumpFall), &s_WoodShrapB[4]}, + {SPR_WOOD_SHRAP_B, 'E', WoodShrapB_RATE, &AF(DoShrapJumpFall), &s_WoodShrapB[5]}, + {SPR_WOOD_SHRAP_B, 'F', WoodShrapB_RATE, &AF(DoShrapJumpFall), &s_WoodShrapB[6]}, + {SPR_WOOD_SHRAP_B, 'G', WoodShrapB_RATE, &AF(DoShrapJumpFall), &s_WoodShrapB[7]}, + {SPR_WOOD_SHRAP_B, 'H', WoodShrapB_RATE, &AF(DoShrapJumpFall), &s_WoodShrapB[0]}, }; #define WOOD_SHRAP_C 3941 @@ -2272,14 +1925,14 @@ STATE s_WoodShrapB[] = STATE s_WoodShrapC[] = { - {WOOD_SHRAP_C + 0, WoodShrapC_RATE, &AF(DoShrapJumpFall), &s_WoodShrapC[1]}, - {WOOD_SHRAP_C + 1, WoodShrapC_RATE, &AF(DoShrapJumpFall), &s_WoodShrapC[2]}, - {WOOD_SHRAP_C + 2, WoodShrapC_RATE, &AF(DoShrapJumpFall), &s_WoodShrapC[3]}, - {WOOD_SHRAP_C + 3, WoodShrapC_RATE, &AF(DoShrapJumpFall), &s_WoodShrapC[4]}, - {WOOD_SHRAP_C + 4, WoodShrapC_RATE, &AF(DoShrapJumpFall), &s_WoodShrapC[5]}, - {WOOD_SHRAP_C + 5, WoodShrapC_RATE, &AF(DoShrapJumpFall), &s_WoodShrapC[6]}, - {WOOD_SHRAP_C + 6, WoodShrapC_RATE, &AF(DoShrapJumpFall), &s_WoodShrapC[7]}, - {WOOD_SHRAP_C + 7, WoodShrapC_RATE, &AF(DoShrapJumpFall), &s_WoodShrapC[0]}, + {SPR_WOOD_SHRAP_C, 'A', WoodShrapC_RATE, &AF(DoShrapJumpFall), &s_WoodShrapC[1]}, + {SPR_WOOD_SHRAP_C, 'B', WoodShrapC_RATE, &AF(DoShrapJumpFall), &s_WoodShrapC[2]}, + {SPR_WOOD_SHRAP_C, 'C', WoodShrapC_RATE, &AF(DoShrapJumpFall), &s_WoodShrapC[3]}, + {SPR_WOOD_SHRAP_C, 'D', WoodShrapC_RATE, &AF(DoShrapJumpFall), &s_WoodShrapC[4]}, + {SPR_WOOD_SHRAP_C, 'E', WoodShrapC_RATE, &AF(DoShrapJumpFall), &s_WoodShrapC[5]}, + {SPR_WOOD_SHRAP_C, 'F', WoodShrapC_RATE, &AF(DoShrapJumpFall), &s_WoodShrapC[6]}, + {SPR_WOOD_SHRAP_C, 'G', WoodShrapC_RATE, &AF(DoShrapJumpFall), &s_WoodShrapC[7]}, + {SPR_WOOD_SHRAP_C, 'H', WoodShrapC_RATE, &AF(DoShrapJumpFall), &s_WoodShrapC[0]}, }; // @@ -2291,14 +1944,14 @@ STATE s_WoodShrapC[] = STATE s_StoneShrapA[] = { - {STONE_SHRAP_A + 0, StoneShrapA_RATE, &AF(DoShrapJumpFall), &s_StoneShrapA[1]}, - {STONE_SHRAP_A + 1, StoneShrapA_RATE, &AF(DoShrapJumpFall), &s_StoneShrapA[2]}, - {STONE_SHRAP_A + 2, StoneShrapA_RATE, &AF(DoShrapJumpFall), &s_StoneShrapA[3]}, - {STONE_SHRAP_A + 3, StoneShrapA_RATE, &AF(DoShrapJumpFall), &s_StoneShrapA[4]}, - {STONE_SHRAP_A + 4, StoneShrapA_RATE, &AF(DoShrapJumpFall), &s_StoneShrapA[5]}, - {STONE_SHRAP_A + 5, StoneShrapA_RATE, &AF(DoShrapJumpFall), &s_StoneShrapA[6]}, - {STONE_SHRAP_A + 6, StoneShrapA_RATE, &AF(DoShrapJumpFall), &s_StoneShrapA[7]}, - {STONE_SHRAP_A + 7, StoneShrapA_RATE, &AF(DoShrapJumpFall), &s_StoneShrapA[0]}, + {SPR_STONE_SHRAP_A, 'A', StoneShrapA_RATE, &AF(DoShrapJumpFall), &s_StoneShrapA[1]}, + {SPR_STONE_SHRAP_A, 'B', StoneShrapA_RATE, &AF(DoShrapJumpFall), &s_StoneShrapA[2]}, + {SPR_STONE_SHRAP_A, 'C', StoneShrapA_RATE, &AF(DoShrapJumpFall), &s_StoneShrapA[3]}, + {SPR_STONE_SHRAP_A, 'D', StoneShrapA_RATE, &AF(DoShrapJumpFall), &s_StoneShrapA[4]}, + {SPR_STONE_SHRAP_A, 'E', StoneShrapA_RATE, &AF(DoShrapJumpFall), &s_StoneShrapA[5]}, + {SPR_STONE_SHRAP_A, 'F', StoneShrapA_RATE, &AF(DoShrapJumpFall), &s_StoneShrapA[6]}, + {SPR_STONE_SHRAP_A, 'G', StoneShrapA_RATE, &AF(DoShrapJumpFall), &s_StoneShrapA[7]}, + {SPR_STONE_SHRAP_A, 'H', StoneShrapA_RATE, &AF(DoShrapJumpFall), &s_StoneShrapA[0]}, }; #define STONE_SHRAP_B 3848 @@ -2306,14 +1959,14 @@ STATE s_StoneShrapA[] = STATE s_StoneShrapB[] = { - {STONE_SHRAP_B + 0, StoneShrapB_RATE, &AF(DoShrapJumpFall), &s_StoneShrapB[1]}, - {STONE_SHRAP_B + 1, StoneShrapB_RATE, &AF(DoShrapJumpFall), &s_StoneShrapB[2]}, - {STONE_SHRAP_B + 2, StoneShrapB_RATE, &AF(DoShrapJumpFall), &s_StoneShrapB[3]}, - {STONE_SHRAP_B + 3, StoneShrapB_RATE, &AF(DoShrapJumpFall), &s_StoneShrapB[4]}, - {STONE_SHRAP_B + 4, StoneShrapB_RATE, &AF(DoShrapJumpFall), &s_StoneShrapB[5]}, - {STONE_SHRAP_B + 5, StoneShrapB_RATE, &AF(DoShrapJumpFall), &s_StoneShrapB[6]}, - {STONE_SHRAP_B + 6, StoneShrapB_RATE, &AF(DoShrapJumpFall), &s_StoneShrapB[7]}, - {STONE_SHRAP_B + 7, StoneShrapB_RATE, &AF(DoShrapJumpFall), &s_StoneShrapB[0]}, + {SPR_STONE_SHRAP_B, 'A', StoneShrapB_RATE, &AF(DoShrapJumpFall), &s_StoneShrapB[1]}, + {SPR_STONE_SHRAP_B, 'B', StoneShrapB_RATE, &AF(DoShrapJumpFall), &s_StoneShrapB[2]}, + {SPR_STONE_SHRAP_B, 'C', StoneShrapB_RATE, &AF(DoShrapJumpFall), &s_StoneShrapB[3]}, + {SPR_STONE_SHRAP_B, 'D', StoneShrapB_RATE, &AF(DoShrapJumpFall), &s_StoneShrapB[4]}, + {SPR_STONE_SHRAP_B, 'E', StoneShrapB_RATE, &AF(DoShrapJumpFall), &s_StoneShrapB[5]}, + {SPR_STONE_SHRAP_B, 'F', StoneShrapB_RATE, &AF(DoShrapJumpFall), &s_StoneShrapB[6]}, + {SPR_STONE_SHRAP_B, 'G', StoneShrapB_RATE, &AF(DoShrapJumpFall), &s_StoneShrapB[7]}, + {SPR_STONE_SHRAP_B, 'H', StoneShrapB_RATE, &AF(DoShrapJumpFall), &s_StoneShrapB[0]}, }; #define STONE_SHRAP_C 3856 @@ -2321,14 +1974,14 @@ STATE s_StoneShrapB[] = STATE s_StoneShrapC[] = { - {STONE_SHRAP_C + 0, StoneShrapC_RATE, &AF(DoShrapJumpFall), &s_StoneShrapC[1]}, - {STONE_SHRAP_C + 1, StoneShrapC_RATE, &AF(DoShrapJumpFall), &s_StoneShrapC[2]}, - {STONE_SHRAP_C + 2, StoneShrapC_RATE, &AF(DoShrapJumpFall), &s_StoneShrapC[3]}, - {STONE_SHRAP_C + 3, StoneShrapC_RATE, &AF(DoShrapJumpFall), &s_StoneShrapC[4]}, - {STONE_SHRAP_C + 4, StoneShrapC_RATE, &AF(DoShrapJumpFall), &s_StoneShrapC[5]}, - {STONE_SHRAP_C + 5, StoneShrapC_RATE, &AF(DoShrapJumpFall), &s_StoneShrapC[6]}, - {STONE_SHRAP_C + 6, StoneShrapC_RATE, &AF(DoShrapJumpFall), &s_StoneShrapC[7]}, - {STONE_SHRAP_C + 7, StoneShrapC_RATE, &AF(DoShrapJumpFall), &s_StoneShrapC[0]}, + {SPR_STONE_SHRAP_C, 'A', StoneShrapC_RATE, &AF(DoShrapJumpFall), &s_StoneShrapC[1]}, + {SPR_STONE_SHRAP_C, 'B', StoneShrapC_RATE, &AF(DoShrapJumpFall), &s_StoneShrapC[2]}, + {SPR_STONE_SHRAP_C, 'C', StoneShrapC_RATE, &AF(DoShrapJumpFall), &s_StoneShrapC[3]}, + {SPR_STONE_SHRAP_C, 'D', StoneShrapC_RATE, &AF(DoShrapJumpFall), &s_StoneShrapC[4]}, + {SPR_STONE_SHRAP_C, 'E', StoneShrapC_RATE, &AF(DoShrapJumpFall), &s_StoneShrapC[5]}, + {SPR_STONE_SHRAP_C, 'F', StoneShrapC_RATE, &AF(DoShrapJumpFall), &s_StoneShrapC[6]}, + {SPR_STONE_SHRAP_C, 'G', StoneShrapC_RATE, &AF(DoShrapJumpFall), &s_StoneShrapC[7]}, + {SPR_STONE_SHRAP_C, 'H', StoneShrapC_RATE, &AF(DoShrapJumpFall), &s_StoneShrapC[0]}, }; // @@ -2340,14 +1993,14 @@ STATE s_StoneShrapC[] = STATE s_MetalShrapA[] = { - {METAL_SHRAP_A + 0, MetalShrapA_RATE, &AF(DoShrapJumpFall), &s_MetalShrapA[1]}, - {METAL_SHRAP_A + 1, MetalShrapA_RATE, &AF(DoShrapJumpFall), &s_MetalShrapA[2]}, - {METAL_SHRAP_A + 2, MetalShrapA_RATE, &AF(DoShrapJumpFall), &s_MetalShrapA[3]}, - {METAL_SHRAP_A + 3, MetalShrapA_RATE, &AF(DoShrapJumpFall), &s_MetalShrapA[4]}, - {METAL_SHRAP_A + 4, MetalShrapA_RATE, &AF(DoShrapJumpFall), &s_MetalShrapA[5]}, - {METAL_SHRAP_A + 5, MetalShrapA_RATE, &AF(DoShrapJumpFall), &s_MetalShrapA[6]}, - {METAL_SHRAP_A + 6, MetalShrapA_RATE, &AF(DoShrapJumpFall), &s_MetalShrapA[7]}, - {METAL_SHRAP_A + 7, MetalShrapA_RATE, &AF(DoShrapJumpFall), &s_MetalShrapA[0]}, + {SPR_METAL_SHRAP_A, 'A', MetalShrapA_RATE, &AF(DoShrapJumpFall), &s_MetalShrapA[1]}, + {SPR_METAL_SHRAP_A, 'B', MetalShrapA_RATE, &AF(DoShrapJumpFall), &s_MetalShrapA[2]}, + {SPR_METAL_SHRAP_A, 'C', MetalShrapA_RATE, &AF(DoShrapJumpFall), &s_MetalShrapA[3]}, + {SPR_METAL_SHRAP_A, 'D', MetalShrapA_RATE, &AF(DoShrapJumpFall), &s_MetalShrapA[4]}, + {SPR_METAL_SHRAP_A, 'E', MetalShrapA_RATE, &AF(DoShrapJumpFall), &s_MetalShrapA[5]}, + {SPR_METAL_SHRAP_A, 'F', MetalShrapA_RATE, &AF(DoShrapJumpFall), &s_MetalShrapA[6]}, + {SPR_METAL_SHRAP_A, 'G', MetalShrapA_RATE, &AF(DoShrapJumpFall), &s_MetalShrapA[7]}, + {SPR_METAL_SHRAP_A, 'H', MetalShrapA_RATE, &AF(DoShrapJumpFall), &s_MetalShrapA[0]}, }; #define METAL_SHRAP_B 3896 @@ -2355,14 +2008,14 @@ STATE s_MetalShrapA[] = STATE s_MetalShrapB[] = { - {METAL_SHRAP_B + 0, MetalShrapB_RATE, &AF(DoShrapJumpFall), &s_MetalShrapB[1]}, - {METAL_SHRAP_B + 1, MetalShrapB_RATE, &AF(DoShrapJumpFall), &s_MetalShrapB[2]}, - {METAL_SHRAP_B + 2, MetalShrapB_RATE, &AF(DoShrapJumpFall), &s_MetalShrapB[3]}, - {METAL_SHRAP_B + 3, MetalShrapB_RATE, &AF(DoShrapJumpFall), &s_MetalShrapB[4]}, - {METAL_SHRAP_B + 4, MetalShrapB_RATE, &AF(DoShrapJumpFall), &s_MetalShrapB[5]}, - {METAL_SHRAP_B + 5, MetalShrapB_RATE, &AF(DoShrapJumpFall), &s_MetalShrapB[6]}, - {METAL_SHRAP_B + 6, MetalShrapB_RATE, &AF(DoShrapJumpFall), &s_MetalShrapB[7]}, - {METAL_SHRAP_B + 7, MetalShrapB_RATE, &AF(DoShrapJumpFall), &s_MetalShrapB[0]}, + {SPR_METAL_SHRAP_B, 'A', MetalShrapB_RATE, &AF(DoShrapJumpFall), &s_MetalShrapB[1]}, + {SPR_METAL_SHRAP_B, 'B', MetalShrapB_RATE, &AF(DoShrapJumpFall), &s_MetalShrapB[2]}, + {SPR_METAL_SHRAP_B, 'C', MetalShrapB_RATE, &AF(DoShrapJumpFall), &s_MetalShrapB[3]}, + {SPR_METAL_SHRAP_B, 'D', MetalShrapB_RATE, &AF(DoShrapJumpFall), &s_MetalShrapB[4]}, + {SPR_METAL_SHRAP_B, 'E', MetalShrapB_RATE, &AF(DoShrapJumpFall), &s_MetalShrapB[5]}, + {SPR_METAL_SHRAP_B, 'F', MetalShrapB_RATE, &AF(DoShrapJumpFall), &s_MetalShrapB[6]}, + {SPR_METAL_SHRAP_B, 'G', MetalShrapB_RATE, &AF(DoShrapJumpFall), &s_MetalShrapB[7]}, + {SPR_METAL_SHRAP_B, 'H', MetalShrapB_RATE, &AF(DoShrapJumpFall), &s_MetalShrapB[0]}, }; #define METAL_SHRAP_C 3904 @@ -2370,14 +2023,14 @@ STATE s_MetalShrapB[] = STATE s_MetalShrapC[] = { - {METAL_SHRAP_C + 0, MetalShrapC_RATE, &AF(DoShrapJumpFall), &s_MetalShrapC[1]}, - {METAL_SHRAP_C + 1, MetalShrapC_RATE, &AF(DoShrapJumpFall), &s_MetalShrapC[2]}, - {METAL_SHRAP_C + 2, MetalShrapC_RATE, &AF(DoShrapJumpFall), &s_MetalShrapC[3]}, - {METAL_SHRAP_C + 3, MetalShrapC_RATE, &AF(DoShrapJumpFall), &s_MetalShrapC[4]}, - {METAL_SHRAP_C + 4, MetalShrapC_RATE, &AF(DoShrapJumpFall), &s_MetalShrapC[5]}, - {METAL_SHRAP_C + 5, MetalShrapC_RATE, &AF(DoShrapJumpFall), &s_MetalShrapC[6]}, - {METAL_SHRAP_C + 6, MetalShrapC_RATE, &AF(DoShrapJumpFall), &s_MetalShrapC[7]}, - {METAL_SHRAP_C + 7, MetalShrapC_RATE, &AF(DoShrapJumpFall), &s_MetalShrapC[0]}, + {SPR_METAL_SHRAP_C, 'A', MetalShrapC_RATE, &AF(DoShrapJumpFall), &s_MetalShrapC[1]}, + {SPR_METAL_SHRAP_C, 'B', MetalShrapC_RATE, &AF(DoShrapJumpFall), &s_MetalShrapC[2]}, + {SPR_METAL_SHRAP_C, 'C', MetalShrapC_RATE, &AF(DoShrapJumpFall), &s_MetalShrapC[3]}, + {SPR_METAL_SHRAP_C, 'D', MetalShrapC_RATE, &AF(DoShrapJumpFall), &s_MetalShrapC[4]}, + {SPR_METAL_SHRAP_C, 'E', MetalShrapC_RATE, &AF(DoShrapJumpFall), &s_MetalShrapC[5]}, + {SPR_METAL_SHRAP_C, 'F', MetalShrapC_RATE, &AF(DoShrapJumpFall), &s_MetalShrapC[6]}, + {SPR_METAL_SHRAP_C, 'G', MetalShrapC_RATE, &AF(DoShrapJumpFall), &s_MetalShrapC[7]}, + {SPR_METAL_SHRAP_C, 'H', MetalShrapC_RATE, &AF(DoShrapJumpFall), &s_MetalShrapC[0]}, }; // @@ -2389,10 +2042,10 @@ STATE s_MetalShrapC[] = STATE s_PaperShrapA[] = { - {PAPER_SHRAP_A + 0, PaperShrapA_RATE, &AF(DoShrapJumpFall), &s_PaperShrapA[1]}, - {PAPER_SHRAP_A + 1, PaperShrapA_RATE, &AF(DoShrapJumpFall), &s_PaperShrapA[2]}, - {PAPER_SHRAP_A + 2, PaperShrapA_RATE, &AF(DoShrapJumpFall), &s_PaperShrapA[3]}, - {PAPER_SHRAP_A + 3, PaperShrapA_RATE, &AF(DoShrapJumpFall), &s_PaperShrapA[0]}, + {SPR_PAPER_SHRAP_A, 'A', PaperShrapA_RATE, &AF(DoShrapJumpFall), &s_PaperShrapA[1]}, + {SPR_PAPER_SHRAP_A, 'B', PaperShrapA_RATE, &AF(DoShrapJumpFall), &s_PaperShrapA[2]}, + {SPR_PAPER_SHRAP_A, 'C', PaperShrapA_RATE, &AF(DoShrapJumpFall), &s_PaperShrapA[3]}, + {SPR_PAPER_SHRAP_A, 'D', PaperShrapA_RATE, &AF(DoShrapJumpFall), &s_PaperShrapA[0]}, }; #define PAPER_SHRAP_B 3932 @@ -2400,10 +2053,10 @@ STATE s_PaperShrapA[] = STATE s_PaperShrapB[] = { - {PAPER_SHRAP_B + 0, PaperShrapB_RATE, &AF(DoShrapJumpFall), &s_PaperShrapB[1]}, - {PAPER_SHRAP_B + 1, PaperShrapB_RATE, &AF(DoShrapJumpFall), &s_PaperShrapB[2]}, - {PAPER_SHRAP_B + 2, PaperShrapB_RATE, &AF(DoShrapJumpFall), &s_PaperShrapB[3]}, - {PAPER_SHRAP_B + 3, PaperShrapB_RATE, &AF(DoShrapJumpFall), &s_PaperShrapB[0]}, + {SPR_PAPER_SHRAP_B, 'A', PaperShrapB_RATE, &AF(DoShrapJumpFall), &s_PaperShrapB[1]}, + {SPR_PAPER_SHRAP_B, 'B', PaperShrapB_RATE, &AF(DoShrapJumpFall), &s_PaperShrapB[2]}, + {SPR_PAPER_SHRAP_B, 'C', PaperShrapB_RATE, &AF(DoShrapJumpFall), &s_PaperShrapB[3]}, + {SPR_PAPER_SHRAP_B, 'D', PaperShrapB_RATE, &AF(DoShrapJumpFall), &s_PaperShrapB[0]}, }; #define PAPER_SHRAP_C 3941 @@ -2411,10 +2064,10 @@ STATE s_PaperShrapB[] = STATE s_PaperShrapC[] = { - {PAPER_SHRAP_C + 0, PaperShrapC_RATE, &AF(DoShrapJumpFall), &s_PaperShrapC[1]}, - {PAPER_SHRAP_C + 1, PaperShrapC_RATE, &AF(DoShrapJumpFall), &s_PaperShrapC[2]}, - {PAPER_SHRAP_C + 2, PaperShrapC_RATE, &AF(DoShrapJumpFall), &s_PaperShrapC[3]}, - {PAPER_SHRAP_C + 3, PaperShrapC_RATE, &AF(DoShrapJumpFall), &s_PaperShrapC[0]}, + {SPR_PAPER_SHRAP_C, 'A', PaperShrapC_RATE, &AF(DoShrapJumpFall), &s_PaperShrapC[1]}, + {SPR_PAPER_SHRAP_C, 'B', PaperShrapC_RATE, &AF(DoShrapJumpFall), &s_PaperShrapC[2]}, + {SPR_PAPER_SHRAP_C, 'C', PaperShrapC_RATE, &AF(DoShrapJumpFall), &s_PaperShrapC[3]}, + {SPR_PAPER_SHRAP_C, 'D', PaperShrapC_RATE, &AF(DoShrapJumpFall), &s_PaperShrapC[0]}, }; bool MissileHitMatch(DSWActor* weapActor, int WeaponNum, DSWActor* hitActor) @@ -11627,7 +11280,7 @@ int InitSerpRing(DSWActor* actor) const int SERP_RING_DIST = 175; extern STATE s_SkullExplode[]; - extern STATE s_SkullRing[5][1]; + extern STATE s_SkullRing[1][1]; extern STATE* sg_SkullRing[]; max_missiles = 12; @@ -12363,7 +12016,7 @@ int InitSumoNapalm(DSWActor* actor) int InitSumoSkull(DSWActor* actor) { extern STATE s_SkullExplode[]; - extern STATE s_SkullWait[5][1]; + extern STATE s_SkullWait[1][1]; extern STATE* sg_SkullWait[]; extern ATTRIBUTE SkullAttrib; @@ -17613,8 +17266,8 @@ enum { FLOORBLOOD_RATE = 30 }; STATE s_FloorBlood1[] = { - {FLOORBLOOD1, SF_QUICK_CALL, &AF(DoFloorBlood), &s_FloorBlood1[1]}, - {FLOORBLOOD1, FLOORBLOOD_RATE, nullptr, &s_FloorBlood1[0]}, + {SPR_FLOORBLOOD1, 'A', SF_QUICK_CALL, &AF(DoFloorBlood), &s_FloorBlood1[1]}, + {SPR_FLOORBLOOD1, 'A', FLOORBLOOD_RATE, nullptr, &s_FloorBlood1[0]}, }; //--------------------------------------------------------------------------- @@ -17692,15 +17345,15 @@ enum }; STATE s_FootPrint1[] = { - {FOOTPRINT1, FOOTPRINT_RATE, nullptr, &s_FootPrint1[0]}, + {SPR_FOOTPRINT1, 'A', FOOTPRINT_RATE, nullptr, &s_FootPrint1[0]}, }; STATE s_FootPrint2[] = { - {FOOTPRINT2, FOOTPRINT_RATE, nullptr, &s_FootPrint2[0]}, + {SPR_FOOTPRINT2, 'A', FOOTPRINT_RATE, nullptr, &s_FootPrint2[0]}, }; STATE s_FootPrint3[] = { - {FOOTPRINT3, FOOTPRINT_RATE, nullptr, &s_FootPrint3[0]}, + {SPR_FOOTPRINT3, 'A', FOOTPRINT_RATE, nullptr, &s_FootPrint3[0]}, }; //--------------------------------------------------------------------------- @@ -17819,23 +17472,23 @@ enum }; STATE s_WallBlood1[] = { - {WALLBLOOD1, SF_QUICK_CALL, &AF(DoWallBlood), &s_WallBlood1[1]}, - {WALLBLOOD1, WALLBLOOD_RATE, nullptr, &s_WallBlood1[0]}, + {SPR_WALLBLOOD1, 'A', SF_QUICK_CALL, &AF(DoWallBlood), &s_WallBlood1[1]}, + {SPR_WALLBLOOD1, 'A', WALLBLOOD_RATE, nullptr, &s_WallBlood1[0]}, }; STATE s_WallBlood2[] = { - {WALLBLOOD2, SF_QUICK_CALL, &AF(DoWallBlood), &s_WallBlood2[1]}, - {WALLBLOOD2, WALLBLOOD_RATE, nullptr, &s_WallBlood2[0]}, + {SPR_WALLBLOOD2, 'A', SF_QUICK_CALL, &AF(DoWallBlood), &s_WallBlood2[1]}, + {SPR_WALLBLOOD2, 'A', WALLBLOOD_RATE, nullptr, &s_WallBlood2[0]}, }; STATE s_WallBlood3[] = { - {WALLBLOOD3, SF_QUICK_CALL, &AF(DoWallBlood), &s_WallBlood3[1]}, - {WALLBLOOD3, WALLBLOOD_RATE, nullptr, &s_WallBlood3[0]}, + {SPR_WALLBLOOD3, 'A', SF_QUICK_CALL, &AF(DoWallBlood), &s_WallBlood3[1]}, + {SPR_WALLBLOOD3, 'A', WALLBLOOD_RATE, nullptr, &s_WallBlood3[0]}, }; STATE s_WallBlood4[] = { - {WALLBLOOD4, SF_QUICK_CALL, &AF(DoWallBlood), &s_WallBlood4[1]}, - {WALLBLOOD4, WALLBLOOD_RATE, nullptr, &s_WallBlood4[0]}, + {SPR_WALLBLOOD4, 'A', SF_QUICK_CALL, &AF(DoWallBlood), &s_WallBlood4[1]}, + {SPR_WALLBLOOD4, 'A', WALLBLOOD_RATE, nullptr, &s_WallBlood4[0]}, }; diff --git a/source/games/sw/src/weapon.h b/source/games/sw/src/weapon.h index 4ee4593a88..92bfe58be1 100644 --- a/source/games/sw/src/weapon.h +++ b/source/games/sw/src/weapon.h @@ -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(PLAYER* pp); int InitChemBomb(DSWActor*); diff --git a/source/games/sw/src/zilla.cpp b/source/games/sw/src/zilla.cpp index b650b3b874..24d414e0ec 100644 --- a/source/games/sw/src/zilla.cpp +++ b/source/games/sw/src/zilla.cpp @@ -116,15 +116,15 @@ 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]} + {ZILLA_RUN, 'A', ZILLA_RATE, &AF(DoZillaMove), &s_ZillaRun[0][1]}, + {ZILLA_RUN, 'B', SF_QUICK_CALL, &AF(DoZillaStomp), &s_ZillaRun[0][2]}, + {ZILLA_RUN, 'B', ZILLA_RATE, &AF(DoZillaMove), &s_ZillaRun[0][3]}, + {ZILLA_RUN, 'C', ZILLA_RATE, &AF(DoZillaMove), &s_ZillaRun[0][4]}, + {ZILLA_RUN, 'D', SF_QUICK_CALL, &AF(DoZillaStomp), &s_ZillaRun[0][5]}, + {ZILLA_RUN, 'D', ZILLA_RATE, &AF(DoZillaMove), &s_ZillaRun[0][0]} }, { {ZILLA_RUN_R1 + 0, ZILLA_RATE, &AF(DoZillaMove), &s_ZillaRun[1][1]}, @@ -176,10 +176,10 @@ 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]} + {ZILLA_RUN, 'A', ZILLA_RATE, &AF(DoZillaMove), &s_ZillaStand[0][0]} }, { {ZILLA_RUN_R1 + 0, ZILLA_RATE, &AF(DoZillaMove), &s_ZillaStand[1][0]} @@ -212,11 +212,11 @@ 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]} + {ZILLA_PAIN, 'A', ZILLA_PAIN_RATE, &AF(NullZilla), &s_ZillaPain[0][1]}, + {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]}, @@ -253,23 +253,23 @@ STATE* sg_ZillaPain[] = #define ZILLA_RAIL_RATE 12 -STATE s_ZillaRail[5][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]} +STATE s_ZillaRail[1][14] = +{ + { + {ZILLA_RAIL, 'A', ZILLA_RAIL_RATE, &AF(NullZilla), &s_ZillaRail[0][1]}, + {ZILLA_RAIL, 'B', ZILLA_RAIL_RATE, &AF(NullZilla), &s_ZillaRail[0][2]}, + {ZILLA_RAIL, 'C', ZILLA_RAIL_RATE, &AF(NullZilla), &s_ZillaRail[0][3]}, + {ZILLA_RAIL, 'D', SF_QUICK_CALL, &AF(InitZillaRail), &s_ZillaRail[0][4]}, + {ZILLA_RAIL, 'A', ZILLA_RAIL_RATE, &AF(NullZilla), &s_ZillaRail[0][5]}, + {ZILLA_RAIL, 'B', ZILLA_RAIL_RATE, &AF(NullZilla), &s_ZillaRail[0][6]}, + {ZILLA_RAIL, 'C', ZILLA_RAIL_RATE, &AF(NullZilla), &s_ZillaRail[0][7]}, + {ZILLA_RAIL, 'D', SF_QUICK_CALL, &AF(InitZillaRail), &s_ZillaRail[0][8]}, + {ZILLA_RAIL, 'A', ZILLA_RAIL_RATE, &AF(NullZilla), &s_ZillaRail[0][9]}, + {ZILLA_RAIL, 'B', ZILLA_RAIL_RATE, &AF(NullZilla), &s_ZillaRail[0][10]}, + {ZILLA_RAIL, 'C', ZILLA_RAIL_RATE, &AF(NullZilla), &s_ZillaRail[0][11]}, + {ZILLA_RAIL, 'D', SF_QUICK_CALL, &AF(InitZillaRail), &s_ZillaRail[0][12]}, + {ZILLA_RAIL, 'D', ZILLA_RAIL_RATE, &AF(NullZilla), &s_ZillaRail[0][13]}, + {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]}, @@ -354,16 +354,16 @@ 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]} + {ZILLA_ROCKET, 'A', ZILLA_ROCKET_RATE, &AF(NullZilla), &s_ZillaRocket[0][1]}, + {ZILLA_ROCKET, 'B', ZILLA_ROCKET_RATE, &AF(NullZilla), &s_ZillaRocket[0][2]}, + {ZILLA_ROCKET, 'C', ZILLA_ROCKET_RATE*4, &AF(NullZilla), &s_ZillaRocket[0][3]}, + {ZILLA_ROCKET, 'C', SF_QUICK_CALL, &AF(InitZillaRocket), &s_ZillaRocket[0][4]}, + {ZILLA_ROCKET, 'C', ZILLA_ROCKET_RATE*4, &AF(NullZilla), &s_ZillaRocket[0][5]}, + {ZILLA_ROCKET, 'D', SF_QUICK_CALL, &AF(InitActorDecide), &s_ZillaRocket[0][6]}, + {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]}, @@ -420,26 +420,26 @@ STATE* sg_ZillaRocket[] = #define ZILLA_UZI_RATE 8 -STATE s_ZillaUzi[5][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]}, +STATE s_ZillaUzi[1][17] = +{ + { + {ZILLA_SHOOT, 'A', ZILLA_UZI_RATE, &AF(NullZilla), &s_ZillaUzi[0][1]}, + {ZILLA_SHOOT, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZillaUzi[0][2]}, + {ZILLA_SHOOT, 'A', ZILLA_UZI_RATE, &AF(NullZilla), &s_ZillaUzi[0][3]}, + {ZILLA_SHOOT, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZillaUzi[0][4]}, + {ZILLA_SHOOT, 'A', ZILLA_UZI_RATE, &AF(NullZilla), &s_ZillaUzi[0][5]}, + {ZILLA_SHOOT, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZillaUzi[0][6]}, + {ZILLA_SHOOT, 'A', ZILLA_UZI_RATE, &AF(NullZilla), &s_ZillaUzi[0][7]}, + {ZILLA_SHOOT, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZillaUzi[0][8]}, + {ZILLA_SHOOT, 'A', ZILLA_UZI_RATE, &AF(NullZilla), &s_ZillaUzi[0][9]}, + {ZILLA_SHOOT, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZillaUzi[0][10]}, + {ZILLA_SHOOT, 'A', ZILLA_UZI_RATE, &AF(NullZilla), &s_ZillaUzi[0][11]}, + {ZILLA_SHOOT, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZillaUzi[0][12]}, + {ZILLA_SHOOT, 'A', ZILLA_UZI_RATE, &AF(NullZilla), &s_ZillaUzi[0][13]}, + {ZILLA_SHOOT, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZillaUzi[0][14]}, + {ZILLA_SHOOT, 'A', ZILLA_UZI_RATE, &AF(NullZilla), &s_ZillaUzi[0][15]}, + {ZILLA_SHOOT, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZillaUzi[0][16]}, + {ZILLA_SHOOT, 'A', 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_ZillaUzi[0][16]}, }, { {ZILLA_SHOOT_R1 + 0, ZILLA_UZI_RATE, &AF(NullZilla), &s_ZillaUzi[1][1]}, @@ -540,14 +540,14 @@ 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_DIE, 'A', ZILLA_DIE_RATE*15, &AF(DoZillaDeathMelt), &s_ZillaDie[1]}, + {ZILLA_DIE, 'B', ZILLA_DIE_RATE, &AF(NullZilla), &s_ZillaDie[2]}, + {ZILLA_DIE, 'C', ZILLA_DIE_RATE, &AF(NullZilla), &s_ZillaDie[3]}, + {ZILLA_DIE, 'D', ZILLA_DIE_RATE, &AF(NullZilla), &s_ZillaDie[4]}, + {ZILLA_DIE, 'E', ZILLA_DIE_RATE, &AF(NullZilla), &s_ZillaDie[5]}, + {ZILLA_DIE, 'F', ZILLA_DIE_RATE, &AF(NullZilla), &s_ZillaDie[6]}, + {ZILLA_DIE, 'G', ZILLA_DIE_RATE, &AF(NullZilla), &s_ZillaDie[7]}, + {ZILLA_DIE, 'H', ZILLA_DIE_RATE*3, &AF(NullZilla), &s_ZillaDie[8]}, {ZILLA_DEAD, ZILLA_DIE_RATE, &AF(DoActorDebris), &s_ZillaDie[8]} }; diff --git a/source/games/sw/src/zombie.cpp b/source/games/sw/src/zombie.cpp index 0750f36bf8..40eb8a13ff 100644 --- a/source/games/sw/src/zombie.cpp +++ b/source/games/sw/src/zombie.cpp @@ -117,13 +117,13 @@ 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, 'A', ZOMBIE_RATE | SF_TIC_ADJUST, &AF(DoZombieMove), &s_ZombieRun[0][1]}, + {PLAYER_NINJA_RUN, 'B', ZOMBIE_RATE | SF_TIC_ADJUST, &AF(DoZombieMove), &s_ZombieRun[0][2]}, + {PLAYER_NINJA_RUN, 'C', ZOMBIE_RATE | SF_TIC_ADJUST, &AF(DoZombieMove), &s_ZombieRun[0][3]}, + {PLAYER_NINJA_RUN, 'D', 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]}, @@ -168,10 +168,10 @@ 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, 'A', ZOMBIE_STAND_RATE, &AF(NullZombie), &s_ZombieStand[0][0]}, }, { {PLAYER_NINJA_STAND_R1 + 0, ZOMBIE_STAND_RATE, &AF(NullZombie), &s_ZombieStand[1][0]}, @@ -204,11 +204,11 @@ 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, 'A', ZOMBIE_PAIN_RATE, &AF(DoZombiePain), &s_ZombiePain[0][1]}, + {PLAYER_NINJA_STAND, 'B', ZOMBIE_PAIN_RATE, &AF(DoZombiePain), &s_ZombiePain[0][1]}, }, { {PLAYER_NINJA_STAND_R1 + 0, ZOMBIE_PAIN_RATE, &AF(DoZombiePain), &s_ZombiePain[1][1]}, @@ -245,15 +245,15 @@ 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, 'A', ZOMBIE_NUKE_RATE * 2, &AF(NullZombie), &s_ZombieNuke[0][1]}, + {PLAYER_NINJA_SHOOT, 'A', ZOMBIE_NUKE_RATE, &AF(NullZombie), &s_ZombieNuke[0][2]}, + {PLAYER_NINJA_SHOOT, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyNuke), &s_ZombieNuke[0][3]}, + {PLAYER_NINJA_SHOOT, 'A', ZOMBIE_NUKE_RATE * 2, &AF(NullZombie), &s_ZombieNuke[0][4]}, + {PLAYER_NINJA_SHOOT, 'A', 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_ZombieNuke[0][5]}, + {PLAYER_NINJA_SHOOT, 'A', ZOMBIE_NUKE_RATE, &AF(DoZombieMove), &s_ZombieNuke[0][5]}, }, { {PLAYER_NINJA_SHOOT_R1 + 0, ZOMBIE_NUKE_RATE * 2, &AF(NullZombie), &s_ZombieNuke[1][1]}, @@ -307,14 +307,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, 'A', ZOMBIE_ROCKET_RATE * 2, &AF(NullZombie), &s_ZombieRocket[0][1]}, + {PLAYER_NINJA_STAND, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyRocket), &s_ZombieRocket[0][2]}, + {PLAYER_NINJA_STAND, 'A', ZOMBIE_ROCKET_RATE, &AF(NullZombie), &s_ZombieRocket[0][3]}, + {PLAYER_NINJA_STAND, 'A', 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_ZombieRocket[0][4]}, + {PLAYER_NINJA_STAND, 'A', ZOMBIE_ROCKET_RATE, &AF(DoZombieMove), &s_ZombieRocket[0][4]}, }, { {PLAYER_NINJA_STAND_R1 + 0, ZOMBIE_ROCKET_RATE * 2, &AF(NullZombie), &s_ZombieRocket[1][1]}, @@ -364,14 +364,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, 'A', ZOMBIE_RAIL_RATE * 2, &AF(NullZombie), &s_ZombieRail[0][1]}, + {PLAYER_NINJA_STAND, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyRail), &s_ZombieRail[0][2]}, + {PLAYER_NINJA_STAND, 'A', ZOMBIE_RAIL_RATE, &AF(NullZombie), &s_ZombieRail[0][3]}, + {PLAYER_NINJA_STAND, 'A', 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_ZombieRail[0][4]}, + {PLAYER_NINJA_STAND, 'A', ZOMBIE_RAIL_RATE, &AF(DoZombieMove), &s_ZombieRail[0][4]}, }, { {PLAYER_NINJA_STAND_R1 + 0, ZOMBIE_RAIL_RATE * 2, &AF(NullZombie), &s_ZombieRail[1][1]}, @@ -421,14 +421,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, 'A', ZOMBIE_ROCKET_RATE * 2, &AF(NullZombie), &s_ZombieGrenade[0][1]}, + {PLAYER_NINJA_STAND, 'A', 0 | SF_QUICK_CALL, &AF(InitSpriteGrenade), &s_ZombieGrenade[0][2]}, + {PLAYER_NINJA_STAND, 'A', ZOMBIE_ROCKET_RATE, &AF(NullZombie), &s_ZombieGrenade[0][3]}, + {PLAYER_NINJA_STAND, 'A', 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_ZombieGrenade[0][4]}, + {PLAYER_NINJA_STAND, 'A', ZOMBIE_ROCKET_RATE, &AF(DoZombieMove), &s_ZombieGrenade[0][4]}, }, { {PLAYER_NINJA_STAND_R1 + 0, ZOMBIE_ROCKET_RATE * 2, &AF(NullZombie), &s_ZombieGrenade[1][1]}, @@ -479,14 +479,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, 'A', ZOMBIE_FLASHBOMB_RATE * 2, &AF(NullZombie), &s_ZombieFlashBomb[0][1]}, + {PLAYER_NINJA_STAND, 'A', 0 | SF_QUICK_CALL, &AF(InitFlashBomb), &s_ZombieFlashBomb[0][2]}, + {PLAYER_NINJA_STAND, 'A', ZOMBIE_FLASHBOMB_RATE, &AF(NullZombie), &s_ZombieFlashBomb[0][3]}, + {PLAYER_NINJA_STAND, 'A', 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_ZombieFlashBomb[0][4]}, + {PLAYER_NINJA_STAND, 'A', ZOMBIE_FLASHBOMB_RATE, &AF(DoZombieMove), &s_ZombieFlashBomb[0][4]}, }, { {PLAYER_NINJA_STAND_R1 + 0, ZOMBIE_FLASHBOMB_RATE * 2, &AF(NullZombie), &s_ZombieFlashBomb[1][1]}, @@ -536,26 +536,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, 'A', ZOMBIE_UZI_RATE, &AF(NullZombie), &s_ZombieUzi[0][1]}, + {PLAYER_NINJA_SHOOT, 'A', 0 | SF_QUICK_CALL, &AF(CheckFire), &s_ZombieUzi[0][2]}, + {PLAYER_NINJA_SHOOT, 'A', ZOMBIE_UZI_RATE, &AF(NullZombie), &s_ZombieUzi[0][3]}, + {PLAYER_NINJA_SHOOT, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZombieUzi[0][4]}, + {PLAYER_NINJA_SHOOT, 'A', ZOMBIE_UZI_RATE, &AF(NullZombie), &s_ZombieUzi[0][5]}, + {PLAYER_NINJA_SHOOT, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZombieUzi[0][6]}, + {PLAYER_NINJA_SHOOT, 'A', ZOMBIE_UZI_RATE, &AF(NullZombie), &s_ZombieUzi[0][7]}, + {PLAYER_NINJA_SHOOT, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZombieUzi[0][8]}, + {PLAYER_NINJA_SHOOT, 'A', ZOMBIE_UZI_RATE, &AF(NullZombie), &s_ZombieUzi[0][9]}, + {PLAYER_NINJA_SHOOT, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZombieUzi[0][10]}, + {PLAYER_NINJA_SHOOT, 'A', ZOMBIE_UZI_RATE, &AF(NullZombie), &s_ZombieUzi[0][11]}, + {PLAYER_NINJA_SHOOT, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZombieUzi[0][12]}, + {PLAYER_NINJA_SHOOT, 'A', ZOMBIE_UZI_RATE, &AF(NullZombie), &s_ZombieUzi[0][13]}, + {PLAYER_NINJA_SHOOT, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZombieUzi[0][14]}, + {PLAYER_NINJA_SHOOT, 'A', ZOMBIE_UZI_RATE, &AF(NullZombie), &s_ZombieUzi[0][15]}, + {PLAYER_NINJA_SHOOT, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZombieUzi[0][16]}, + {PLAYER_NINJA_SHOOT, 'A', 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_ZombieUzi[0][16]}, }, { {PLAYER_NINJA_SHOOT_R1 + 0, ZOMBIE_UZI_RATE, &AF(NullZombie), &s_ZombieUzi[1][1]}, @@ -653,10 +653,10 @@ 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]}, + {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]}, diff --git a/wadsrc/static/filter/shadowwarrior/texnames.txt b/wadsrc/static/filter/shadowwarrior/texnames.txt new file mode 100644 index 0000000000..109b76ca98 --- /dev/null +++ b/wadsrc/static/filter/shadowwarrior/texnames.txt @@ -0,0 +1,330 @@ +4550 = "BUNNY_RUN", 5, 5, 1 // # of animation frames, # of rotations per frame (either 1, 5, 8), 1: order is frames first, rotation second. Generated name will be "BUNNY_RUN@A1" and up (A = frame, 1 = rotation) - The first frame will also get the base name. +4575 = "BUNNY_SWIPE", 5, 5, 1 +4580 = "BUNNY_DIE", 3 +4584 = "BUNNY_DEAD" + +4277 = "COOLG_RUN", 4, 5, 1 +1451 = "COOLG_CLUB", 2, 5, 1 +4297 = "COOLG_FIRE", 3, 3, 1, "COOLG_RUN" // this borrows the missing rotations from the COOLG_RUN sequence +4306 = "COOLG_PAIN" + +4307 = "COOLG_DIE", 6 +4312 = "COOLG_DEAD" +4268 = COOLG_BIRTH", 8 + +1420 = "COOLIE_CHARGE", 4, 5, 1 +1400 = "COOLIE_RUN", 4, 5, 1 +1420 = "COOLIE_PAIN" +1440 = "COOLIE_DEAD_NOHEAD" +4267 = "COOLIE_DEAD_HEAD" +4260 = "COOLIE_DIE" +4268 = "COOLIE_DEAD" + +3780 = "EEL_RUN", 3, 5, 1 +3760 = "EEL_FIRE", 3, 4, 1, "EEL_RUN" +3795 = "EEL_DIE" +3795 = "EEL_DEAD" + +5162 = "GIRLNINJA_RUN", 4, 5, 1 +5162 = "GIRLNINJA_STAND", 1, 5, 4 +5211 = "GIRLNINJA_CRAWL", 1, 5, 1 +5246 = "GIRLNINJA_THROW", 3, 3, 1, "@4" = "@3", "@5" = "@3" // rotation 3 stands in for the missing ones. +5192 = "GIRLNINJA_PAIN" +5226 = "GIRLNINJA_JUMP", 4, 5, 1 +5211 = "GIRLNINJA_KNEEL", 1, 5, 1 +5182 = "GIRLNINJA_FIRE", 2, 5, 1 +5206 = "GIRLNINJA_STAB", 1, 5, 1 +5197 = "GIRLNINJA_DIE, 9 +5205 = "GIRLNINJA_DEAD" +4227 = "GIRLNINJA_SLICED", 10 +4236 = "GIRLNINJA_DEAD_SLICED" + +1469 = "GORO_RUN", 4, 5, 1 +1489 = "GORO_CHOP", 3, 5, 1 +1489 = "GORO_STAND", 1, 5, 3 +1513 = "GORO_SPELL", 2, 3, 1, "GORO_RUN" +1504 = "GORO_DIE", 9 +1512 = "GORO_DEAD" + +800 = "HORNET_RUN", 2, 5, 1 +810 = "HORNET_DIE" +811 = "HORNET_DEAD" + +// hmmmm... +2355 = "LAVA_RUN", 1, 5, 1 +2355 = "LAVA_THROW" +2355 = "LAVA_FLAME" +2355 = "LAVA_DIE" +2355 = "LAVA_DEAD" + + + + +1562 = "GOREDrip", 4 +3100 = "EXP", 21 +3258 = "RADIATION_CLOUD", 20 +3280 = "MUSHROOM_CLOUD", 20 +3038 = "CHEMBOMB", 1, 5, 1 +2217 = "CALTROPSR", 3 +2520 = "FLAG", 3 + +1397 = "PHOSPHORUS", 2 +1685 = "CHUNK1", 6 +1566 = "DRIP", 3 + + +2540 = TRASHCAN, 7 +618 = PACHINKOLIGHT, 6 +4768 = PACHINKO1, 23 +4792 = PACHINKO2, 23 +4816 = PACHINKO3, 23 +4840 = PACHINKO4, 23 + +5023 = TOILETGIRL, 2 +5025 = TOILETGIRL_FIRE, 2 +5032 = WASHGIRL, 2 +5034 = WASHGIRL_FIRE, 2 +4594 = CARGIRL, 2 +4596 = CARGIRL_FIRE, 2 +4590 = MECHANICGIRL, 2 +4592 = MECHANICGIRL_DRILL, 2 + +4600 = SAILORGIRL, 2 +4602 = SAILORGIRL_FIRE + +4604 = PRUNEGIRL, 2 + + +4096 = NINJA_RUN, 4, 5, 1 +4096 = NINJA_STAND, 1, 5, 4 +4162 = NINJA_CRAWL,4, 5, 1 +4122 = NINJA_SWIM, 4, 5, 1 +4211 = NINJA_HARI_KARI, 8 +4182 = NINJA_CLIMB, 4, 5, 1 +4202 = NINJA_THROW, 3, 3, 1, "@4" = "@3", "@5" = "@3" +4219 = NINJA_PAIN, 2 +4142 = NINJA_JUMP, 4, 5, 1 +4116 = NINJA_FLY, 2, 5, 1 +4116 = NINJA_FIRE, 2, 5, 1 +4219 = NINJA_DIE, 8 +4227 = NINJA_SLICED, 10 +4211 = NINJA_SLICED_HACK, 8 +4237 = NINJA_GRAB_THROAT, 3 + + +1094 = PLAYER_NINJA_RUN, 4, 5, 1 +1069 = PLAYER_NINJA_SHOOT, 1, 5, 1 +1094 = PLAYER_NINJA_STAND, 1, 5, 4 +1074 = PLAYER_NINJA_JUMP, 4, 5, 1 +1024 = PLAYER_NINJA_CLIMB, 4, 5, 1 +1044 = PLAYER_NINJA_CRAWL, 4, 5, 1 +1114 = PLAYER_NINJA_SWIM, 4, 5, 1 +1161 = PLAYER_NINJA_SWORD, 3, 5, 1 +1176 = PLAYER_NINJA_PUNCH, 2, 5, 1 +1186 = PLAYER_NINJA_KICK, 2, 5, 1 +1152 = PLAYER_NINJA_DIE, 9 +1142 = NINJA_Head, 1, 5, 1 +1147 = NINJA_HeadHurl, 1, 5, 1 +1134 = NINJA_HeadFly, 8 +1200 = PLAYER_NINJA_FLY + +1580 = RIPPER_RUN, 4, 5, 1 +1620 = RIPPER_JUMP, 2, 5, 1 +1621 = RIPPER_FALL, 1, 5, 2 +1620 = RIPPER_STAND, 1, 5, 2 +1600 = RIPPER_SWIPE, 4, 5, 1; +1635 = RIPPER_HEART +1640 = RIPPER_DIE, 4 +1643 = RIPPER_DEAD + +// these are unordered so we have to define them manually. +1645 = "RIPPER_HANG@A1" +1645 = "RIPPER_HANG@A2" +1639 = "RIPPER_HANG@A3" +1637 = "RIPPER_HANG@A4" +1635 = "RIPPER_HANG@A5" + +4320 = RIPPER2_RUN, 4, 5, 1 +4340 = RIPPER2_RUNFAST, 4, 5, 1 +4374 = RIPPER2_JUMP, 4, 5, 1 +4376 = RIPPER2_FALL, 1, 5, 4 +4377 = RIPPER2_STAND, 1, 5, 4 +4369 = RIPPER2_HANG, 1, 5, 1 +4394 = RIPPER2_SWIPE, 4, 5, 1 +4360 = RIPPER2_MEKONG, 3, 5, 1 +4422 = RIPPER2_HEART, 2, 5, 1 +4414 = RIPPER2_DIE, 8 +4421 = RIPPER2_DEAD + +1300 = SERP_RUN, 3, 5, 1 +972 = SERP_SLASH, 5, 5, 1 +997 = SERP_SPELL, 4, 5, 1 +960 = SERP_DIE, 10 +969 = SERP_DEAD + +1367 = SKEL_RUN, 6, 5, 1 +1326 = SKEL_SLASH, 3, 5, 1 +1341 = SKEL_SPELL, 4, 5, 1 +1327 = SKEL_PAIN, 1, 5, 3 +1361 = SKEL_TELEPORT, 6 +1320 = SKEL_DIE, 6 + +820 = SKULL, 1, 5, 1 +825 = SKULL_EXPLODE, 14 +817 = BETTY + +740 = RAT_DEBRIS +423 = CRAB_DEBRIS +426 = STARFISH_DEBRIS + +2440 = Red_COIN, 8 +2450 = Yellow_COIN, 8 +2460 = Green_COIN, 8 + +630 = FIRE_FLY0 + +3035 = ICON_FIREBALL_LG_AMMO, 3 +1824 = ICON_HEART, 2 +1820 = ICON_HEART_LG_AMMO, 2 +1880 = ICON_SPELL, 16 +1822 = ICON_ELECTRO, 2 +1782 = ICON_FLY, 8 +2520 = ICON_FLAG, 3 + +1210 = SUMO_RUN, 4, 5, 1 +1265 = SUMO_PAIN +1230 = SUMO_STOMP, 3, 5, 1 +1245 = SUMO_CLAP, 4, 5, 1 +1280 = SUMO_FART, 4 +1270 = SUMO_DIE, 8 +1277 = SUMO_DEAD + +2323 = NOTRESTORED +1 = SUICIDES +1160 = DEADLOWANG + +447 = BREAK_LIGHT_ANIM, 6 +453 = BREAK_BARREL, 10 +463 = BREAK_PEDISTAL, 5 +468 = BREAK_BOTTLE1, 7 +475 = BREAK_BOTTLE2, 7 +1748 = PUFF +3201 = LASER_PUFF +3969 = RAIL_PUFF, 16, 3, 1, NINJA_THROW, 3, 3, 1, "@4" = "@2", "@5" = "@1" + +3201 = TRACER, 6 +2058 = EMP, 3 +2146 = UZI_SMOKE, 4 +717 = UZI_BULLET +2140 = UZI_SPARK, 6 +716 = BUBBLE +772 = SPLASH, 5 + +2230 = "CROSSBOLT@A1" +2232 = "CROSSBOLT@A2" +2233 = "CROSSBOLT@A3" +2234 = "CROSSBOLT@A4" +2231 = "CROSSBOLT@A5" + +2102 = STAR, 4 +2066 = STAR_DOWN, 4 +2196 = LAVA_BOULDER, 10 + +2110 = GRENADE, 1, 5, 1 +2223 = MINE, 2 + +// This one's messy... +2098 = "METEOR@A1" +2099 = "METEOR@B1" +2100 = "METEOR@C1" +2101 = "METEOR@D1" + +2090 = "METEOR@A2" +2091 = "METEOR@B2" +2192 = "METEOR@C2" +2193 = "METEOR@D2" + +2094 = "METEOR@A3" +2095 = "METEOR@B3" +2196 = "METEOR@C3" +2197 = "METEOR@D3" + +2090 = "METEOR@A4" +2091 = "METEOR@B4" +2192 = "METEOR@C4" +2193 = "METEOR@D4" + +2098 = "METEOR@A5" +2099 = "METEOR@B5" +2100 = "METEOR@C5" +2101 = "METEOR@D5" + +2115 = METEOR_EXP, 6 +2031 = SERP_METEOR, 4 // correct? + +2030 = SPEAR, 1, 5, 1 +2206 = ROCKET, 1, 5, 1 +4552 = BUNNYROCKET, 1, 5, 1 +2206 = MICRO, 1, 5, 1 +2018 = BOLT_THINMAN, 1, 5, 1 +2102 = BOLT_FATMAN, 4 +2102 = BOLT_SHRAPNEL, 4 +2410 = COOLG_FIRE_DONE, 5 +1720 = COOLG_DRIP +1710 = GORE_FLOOR_SPLASH, 6 +2410 = GORE_SPLASH, 6 +1562 = PLASMA, 3 +1562 = PLASMA_Drip, 8 +3240 = TELEPORT_EFFECT, 18 +2025 = ELECTRO, 4 +3121 = GRENADE_EXP, 22 +3196 = FIREBALL_DISS, 5 +3072 = NAP_EXP, 22 +3212 = FIREBALL_FLAMES, 14 +2035 = FIREBALL, 4 +2106 = BLOOD_WORM, 4 + +1719 = Vomit1 +1721 = Vomit2 +1711 = VomitSplash +1670 = GORE_Head, 12 +1689 = GORE_Leg, 3 +1692 = GORE_Eye, 4 +1696 = GORE_Torso, 8 +1550 = GORE_Arm, 12 +903 = GORE_Lung, 12 +918 = GORE_Liver, 12 +933 = GORE_SkullCap, 12 +2430 = GORE_ChunkS, 4 +1562 = GORE_Drip, 4 +847 = GORE_Flame, 8 +2152 = UZI_SHELL, 6 +2180 = SHOT_SHELL, 8 +839 = GORE_FlameChunkA, 4 +843 = GORE_FlameChunkB, 4 +2530 = COIN_SHRAP, 4 +5096 = MARBEL +3864 = GLASS_SHRAP_A, 8 +3872 = GLASS_SHRAP_B, 8 +3880 = GLASS_SHRAP_C, 8 +3924 = WOOD_SHRAP_A, 8 +3932 = WOOD_SHRAP_B, 8 +3941 = WOOD_SHRAP_C, 8 +3840 = STONE_SHRAP_A, 8 +3848 = STONE_SHRAP_B, 8 +3856 = STONE_SHRAP_C, 8 +3888 = METAL_SHRAP_A, 8 +3896 = METAL_SHRAP_B, 8 +3904 = METAL_SHRAP_C, 8 +3924 = PAPER_SHRAP_A, 4 +3932 = PAPER_SHRAP_B, 4 +3941 = PAPER_SHRAP_C, 4 + +389 = FLOORBLOOD1 +2490 = FOOTPRINT1 +2491 = FOOTPRINT2 +2492 = FOOTPRINT3 +2500 = WALLBLOOD1 +2501 = WALLBLOOD2 +2502 = WALLBLOOD3 +2503 = WALLBLOOD4