diff --git a/source/common/objects/dobject.h b/source/common/objects/dobject.h index ce591b6d6..a7d857dc6 100644 --- a/source/common/objects/dobject.h +++ b/source/common/objects/dobject.h @@ -179,8 +179,6 @@ public: \ #include "dobjgc.h" -class AActor; - class DObject { public: diff --git a/source/common/scripting/frontend/zcc_compile.h b/source/common/scripting/frontend/zcc_compile.h index 82c6342ff..19e9f8ff0 100644 --- a/source/common/scripting/frontend/zcc_compile.h +++ b/source/common/scripting/frontend/zcc_compile.h @@ -6,7 +6,6 @@ struct Baggage; struct FPropertyInfo; -class AActor; class FxExpression; typedef TDeletingArray FArgumentList; diff --git a/source/core/actorlist.cpp b/source/core/actorlist.cpp index 6a2e35652..5cf1fc10d 100644 --- a/source/core/actorlist.cpp +++ b/source/core/actorlist.cpp @@ -547,3 +547,14 @@ double DCoreActor::GetOffsetAndHeight(double& height) return zofs - tex->GetDisplayTopOffset() * yscale; } +int DCoreActor::callFunction(VMFunction* func) +{ + int ret = 0; + if (func) + { + VMValue param[] = { this }; + VMReturn r(&ret); + VMCall(func, param, 1, &r, 1); + } + return ret; +} diff --git a/source/core/coreactor.h b/source/core/coreactor.h index e2c610dd7..acf9ea7fd 100644 --- a/source/core/coreactor.h +++ b/source/core/coreactor.h @@ -220,6 +220,9 @@ public: clipdist = other->clipdist; } + int callFunction(VMFunction* func); + + }; // holds pointers to the game-side actors. diff --git a/source/core/serializer_raze.h b/source/core/serializer_raze.h index 1cc4ba049..058c4e9da 100644 --- a/source/core/serializer_raze.h +++ b/source/core/serializer_raze.h @@ -16,6 +16,8 @@ public: template<> FSerializer &Serialize(FSerializer &arc, const char *key, PClassActor *&clst, PClassActor **def); FSerializer &Serialize(FSerializer &arc, const char *key, FState *&state, FState **def, bool *retcode); +FSerializer& Serialize(FSerializer& arc, const char* key, FState**& state, FState*** def, bool* retcode); + template<> inline FSerializer &Serialize(FSerializer &arc, const char *key, FState *&state, FState **def) { return Serialize(arc, key, state, def, nullptr); diff --git a/source/core/states.cpp b/source/core/states.cpp index 0d3625cfe..1f5a9e819 100644 --- a/source/core/states.cpp +++ b/source/core/states.cpp @@ -168,6 +168,13 @@ DEFINE_ACTION_FUNCTION(FState, GetSpriteTexture) } */ +bool FState::CallAction(DCoreActor* self) +{ + if (AnimatorPtr && *AnimatorPtr) self->callFunction(*AnimatorPtr); + else if (ActionFunc) self->callFunction(ActionFunc); + return true; +} + //========================================================================== // @@ -567,7 +574,7 @@ FStateLabels *FStateDefinitions::CreateStateLabelList(TArray & sta // //=========================================================================== -void FStateDefinitions::InstallStates(PClassActor *info, AActor *defaults) +void FStateDefinitions::InstallStates(PClassActor *info, DCoreActor *defaults) { if (defaults == nullptr) { diff --git a/source/core/states.h b/source/core/states.h index 086a2e041..2c3be28ba 100644 --- a/source/core/states.h +++ b/source/core/states.h @@ -95,19 +95,34 @@ struct FStateParamInfo }; - +class VMNativeFunction; +class DCoreActor; struct FState { + int sprite; + int Frame; + int Tics; +#if 0 + + uint8_t StateFlags; + uint8_t DefineFlags; FState *NextState; VMFunction *ActionFunc; // called when an attached animation triggers an event. (i.e. Blood's SEQs. Should be made game independent.) VMFunction *EnterFunc; // called when entering the state. VMFunction *TickFunc; // called when ticking the state. VMFunction *MoveFunc; // called when moving the actor - int16_t sprite; - int16_t Tics; - uint8_t Frame; + VMNativeFunction** AnimatorPtr; // temporary kludge so we can define state arrays statically. +#else + // this order is suboptimal but needed for SW's still existing in-code definitions. + VMNativeFunction** AnimatorPtr; // temporary kludge so we can define state arrays statically. + FState* NextState; uint8_t StateFlags; uint8_t DefineFlags; + VMFunction* ActionFunc; // called when an attached animation triggers an event. (i.e. Blood's SEQs. Should be made game independent.) + VMFunction* EnterFunc; // called when entering the state. + VMFunction* TickFunc; // called when ticking the state. + VMFunction* MoveFunc; // called when moving the actor +#endif public: inline int GetFullbright() const { @@ -123,7 +138,7 @@ public: } void SetAction(VMFunction *func) { ActionFunc = func; } void ClearAction() { ActionFunc = NULL; } - //bool CallAction(AActor *self, AActor *stateowner, FStateParamInfo *stateinfo, FState **stateret); + bool CallAction(DCoreActor *self); static PClassActor *StaticFindStateOwner (const FState *state); static PClassActor *StaticFindStateOwner (const FState *state, PClassActor *info); @@ -242,7 +257,7 @@ public: void SetStateLabel(const char *statename, FState *state, uint8_t defflags = SDF_STATE); void AddStateLabel(const char *statename); int GetStateLabelIndex (FName statename); - void InstallStates(PClassActor *info, AActor *defaults); + void InstallStates(PClassActor *info, DCoreActor *defaults); int FinishStates(PClassActor *actor); void MakeStateDefines(const PClassActor *cls); diff --git a/source/games/sw/src/actor.cpp b/source/games/sw/src/actor.cpp index 169df32a4..6274fe1ba 100644 --- a/source/games/sw/src/actor.cpp +++ b/source/games/sw/src/actor.cpp @@ -45,14 +45,14 @@ BEGIN_SW_NS extern int jump_grav; -extern STATE s_DebrisNinja[]; -extern STATE s_DebrisRat[]; -extern STATE s_DebrisCrab[]; -extern STATE s_DebrisStarFish[]; -extern STATE s_NinjaDieSliced[]; -extern STATE s_NinjaDieSlicedHack[]; +extern FState s_DebrisNinja[]; +extern FState s_DebrisRat[]; +extern FState s_DebrisCrab[]; +extern FState s_DebrisStarFish[]; +extern FState s_NinjaDieSliced[]; +extern FState s_NinjaDieSlicedHack[]; -extern STATE* sg_NinjaGrabThroat[]; +extern FState s_NinjaGrabThroat[]; @@ -484,7 +484,7 @@ int DoFireFly(DSWActor* actor) int DoGenerateSewerDebris(DSWActor* actor) { - static STATE* Debris[] = + static FState* Debris[] = { s_DebrisNinja, s_DebrisRat, @@ -964,7 +964,7 @@ Personality* DSWActor::getPersonality() return nullptr; // not implemented yet. } -static STATE** getLegacyState(ACTOR_ACTION_SET* a, FName label, int subl) +static FState* getLegacyState(ACTOR_ACTION_SET* a, FName label, int subl) { if (label == NAME_Run) { @@ -1078,20 +1078,7 @@ void DSWActor::callAction() void DSWActor::callStateAction() { - if (user.__legacyState.State && user.__legacyState.State->Animator) - callFunction(*user.__legacyState.State->Animator); -} - -int DSWActor::callFunction(VMFunction* func) -{ - int ret = 0; - if (func) - { - VMValue param[] = { this }; - VMReturn r(&ret); - VMCall(func, param, 1, &r, 1); - } - return ret; + user.__legacyState.State->CallAction(this); } END_SW_NS diff --git a/source/games/sw/src/bunny.cpp b/source/games/sw/src/bunny.cpp index 35c743dfe..21b9d0349 100644 --- a/source/games/sw/src/bunny.cpp +++ b/source/games/sw/src/bunny.cpp @@ -156,24 +156,17 @@ ATTRIBUTE WhiteBunnyAttrib = #define BUNNY_RUN_RATE 10 -STATE s_BunnyRun[][6] = +FState s_BunnyRun[] = { - { - {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]}, - }, + {SPR_BUNNY_RUN, 'A', BUNNY_RUN_RATE | SF_TIC_ADJUST, &AF(DoBunnyMove), &s_BunnyRun[1]}, + {SPR_BUNNY_RUN, 'B', BUNNY_RUN_RATE | SF_TIC_ADJUST, &AF(DoBunnyMove), &s_BunnyRun[2]}, + {SPR_BUNNY_RUN, 'C', BUNNY_RUN_RATE | SF_TIC_ADJUST, &AF(DoBunnyMove), &s_BunnyRun[3]}, + {SPR_BUNNY_RUN, 'D', BUNNY_RUN_RATE | SF_TIC_ADJUST, &AF(DoBunnyMove), &s_BunnyRun[4]}, + {SPR_BUNNY_RUN, 'E', SF_QUICK_CALL, &AF(DoBunnyGrowUp), &s_BunnyRun[5]}, + {SPR_BUNNY_RUN, 'F', BUNNY_RUN_RATE | SF_TIC_ADJUST, &AF(DoBunnyMove), &s_BunnyRun[0]}, }; -STATE* sg_BunnyRun[] = -{ - &s_BunnyRun[0][0], -}; - ////////////////////// // // BUNNY STAND @@ -182,21 +175,14 @@ STATE* sg_BunnyRun[] = #define BUNNY_STAND_RATE 12 -STATE s_BunnyStand[][3] = +FState s_BunnyStand[] = { - { - {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]}, - }, + {SPR_BUNNY_RUN, 'A', BUNNY_STAND_RATE, &AF(DoBunnyEat), &s_BunnyStand[1]}, + {SPR_BUNNY_RUN, 'E', SF_QUICK_CALL, &AF(DoBunnyGrowUp), &s_BunnyStand[2]}, + {SPR_BUNNY_RUN, 'E', BUNNY_STAND_RATE, &AF(DoBunnyEat), &s_BunnyStand[0]}, }; -STATE* sg_BunnyStand[] = -{ - s_BunnyStand[0], -}; - ////////////////////// // // BUNNY GET LAYED @@ -205,20 +191,13 @@ STATE* sg_BunnyStand[] = #define BUNNY_SCREW_RATE 16 -STATE s_BunnyScrew[][2] = +FState s_BunnyScrew[] = { - { - {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]}, - }, + {SPR_BUNNY_RUN, 'A', BUNNY_SCREW_RATE, &AF(DoBunnyScrew), &s_BunnyScrew[1]}, + {SPR_BUNNY_RUN, 'C', BUNNY_SCREW_RATE, &AF(DoBunnyScrew), &s_BunnyScrew[0]}, }; -STATE* sg_BunnyScrew[] = -{ - s_BunnyScrew[0], -}; - ////////////////////// // // BUNNY SWIPE @@ -227,24 +206,16 @@ STATE* sg_BunnyScrew[] = #define BUNNY_SWIPE_RATE 8 -STATE s_BunnySwipe[][8] = +FState s_BunnySwipe[] = { - { - {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]}, - }, -}; - - -STATE* sg_BunnySwipe[] = -{ - &s_BunnySwipe[0][0], + {SPR_BUNNY_SWIPE, 'A', BUNNY_SWIPE_RATE, &AF(NullBunny), &s_BunnySwipe[1]}, + {SPR_BUNNY_SWIPE, 'B', BUNNY_SWIPE_RATE, &AF(NullBunny), &s_BunnySwipe[2]}, + {SPR_BUNNY_SWIPE, 'B', 0 | SF_QUICK_CALL, &AF(InitBunnySlash), &s_BunnySwipe[3]}, + {SPR_BUNNY_SWIPE, 'C', BUNNY_SWIPE_RATE, &AF(NullBunny), &s_BunnySwipe[4]}, + {SPR_BUNNY_SWIPE, 'D', BUNNY_SWIPE_RATE, &AF(NullBunny), &s_BunnySwipe[5]}, + {SPR_BUNNY_SWIPE, 'D', 0 | SF_QUICK_CALL, &AF(InitBunnySlash), &s_BunnySwipe[6]}, + {SPR_BUNNY_SWIPE, 'D', 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_BunnySwipe[7]}, + {SPR_BUNNY_SWIPE, 'D', BUNNY_SWIPE_RATE, &AF(DoBunnyMove), &s_BunnySwipe[7]}, }; @@ -256,19 +227,12 @@ STATE* sg_BunnySwipe[] = #define BUNNY_HEART_RATE 14 -STATE s_BunnyHeart[][4] = +FState s_BunnyHeart[] = { - { - {SPR_BUNNY_SWIPE, 'A', BUNNY_HEART_RATE, &AF(DoBunnyStandKill), &s_BunnyHeart[0][0]}, - }, + {SPR_BUNNY_SWIPE, 'A', BUNNY_HEART_RATE, &AF(DoBunnyStandKill), &s_BunnyHeart[0]}, }; -STATE* sg_BunnyHeart[] = -{ - &s_BunnyHeart[0][0], -}; - ////////////////////// // // BUNNY PAIN @@ -277,16 +241,9 @@ STATE* sg_BunnyHeart[] = #define BUNNY_PAIN_RATE 38 -STATE s_BunnyPain[][1] = +FState s_BunnyPain[] = { - { - {SPR_BUNNY_SWIPE, 'A', BUNNY_PAIN_RATE, &AF(DoBunnyPain), &s_BunnyPain[0][0]}, - }, -}; - -STATE* sg_BunnyPain[] = -{ - &s_BunnyPain[0][0], + {SPR_BUNNY_SWIPE, 'A', BUNNY_PAIN_RATE, &AF(DoBunnyPain), &s_BunnyPain[0]}, }; ////////////////////// @@ -297,18 +254,10 @@ STATE* sg_BunnyPain[] = #define BUNNY_JUMP_RATE 25 -STATE s_BunnyJump[][6] = +FState s_BunnyJump[] = { - { - {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]}, - }, -}; - - -STATE* sg_BunnyJump[] = -{ - &s_BunnyJump[0][0], + {SPR_BUNNY_RUN, 'B', BUNNY_JUMP_RATE, &AF(DoBunnyMoveJump), &s_BunnyJump[1]}, + {SPR_BUNNY_RUN, 'C', BUNNY_JUMP_RATE, &AF(DoBunnyMoveJump), &s_BunnyJump[1]}, }; @@ -320,17 +269,9 @@ STATE* sg_BunnyJump[] = #define BUNNY_FALL_RATE 25 -STATE s_BunnyFall[][6] = +FState s_BunnyFall[] = { - { - {SPR_BUNNY_RUN, 'D', BUNNY_FALL_RATE, &AF(DoBunnyMoveJump), &s_BunnyFall[0][0]}, - }, -}; - - -STATE* sg_BunnyFall[] = -{ - &s_BunnyFall[0][0], + {SPR_BUNNY_RUN, 'D', BUNNY_FALL_RATE, &AF(DoBunnyMoveJump), &s_BunnyFall[0]}, }; @@ -343,19 +284,11 @@ STATE* sg_BunnyFall[] = #define BUNNY_JUMP_ATTACK_RATE 35 int DoBunnyBeginJumpAttack(DSWActor* actor); -STATE s_BunnyJumpAttack[][6] = +FState s_BunnyJumpAttack[] = { - { - {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]}, - }, -}; - - -STATE* sg_BunnyJumpAttack[] = -{ - &s_BunnyJumpAttack[0][0], + {SPR_BUNNY_RUN, 'B', BUNNY_JUMP_ATTACK_RATE, &AF(NullBunny), &s_BunnyJumpAttack[1]}, + {SPR_BUNNY_RUN, 'B', 0 | SF_QUICK_CALL, &AF(DoBunnyBeginJumpAttack), &s_BunnyJumpAttack[2]}, + {SPR_BUNNY_RUN, 'C', BUNNY_JUMP_ATTACK_RATE, &AF(DoBunnyMoveJump), &s_BunnyJumpAttack[2]}, }; @@ -367,7 +300,7 @@ STATE* sg_BunnyJumpAttack[] = #define BUNNY_DIE_RATE 16 -STATE s_BunnyDie[] = +FState s_BunnyDie[] = { {SPR_BUNNY_DIE, 'A', BUNNY_DIE_RATE, &AF(NullBunny), &s_BunnyDie[1]}, {SPR_BUNNY_DIE, 'A', SF_QUICK_CALL, &AF(BunnySpew), &s_BunnyDie[2]}, @@ -379,7 +312,7 @@ STATE s_BunnyDie[] = #define BUNNY_DEAD_RATE 8 -STATE s_BunnyDead[] = +FState s_BunnyDead[] = { {SPR_BUNNY_DIE, 'A', BUNNY_DEAD_RATE, nullptr, &s_BunnyDie[1]}, {SPR_BUNNY_DIE, 'A', SF_QUICK_CALL, &AF(BunnySpew), &s_BunnyDie[2]}, @@ -389,114 +322,95 @@ STATE s_BunnyDead[] = {SPR_BUNNY_DEAD, 'A', BUNNY_DEAD_RATE, &AF(DoActorDebris), &s_BunnyDead[5]}, }; -STATE* sg_BunnyDie[] = -{ - s_BunnyDie -}; - -STATE* sg_BunnyDead[] = -{ - s_BunnyDead -}; - -STATE s_BunnyDeathJump[] = +FState s_BunnyDeathJump[] = { {SPR_BUNNY_DIE, 'A', BUNNY_DIE_RATE, &AF(DoActorDeathMove), &s_BunnyDeathJump[0]} }; -STATE s_BunnyDeathFall[] = +FState s_BunnyDeathFall[] = { {SPR_BUNNY_DIE, 'B', BUNNY_DIE_RATE, &AF(DoActorDeathMove), &s_BunnyDeathFall[0]} }; -STATE* sg_BunnyDeathJump[] = -{ - s_BunnyDeathJump -}; - -STATE* sg_BunnyDeathFall[] = -{ - s_BunnyDeathFall -}; /* -STATE* *Stand[MAX_WEAPONS]; -STATE* *Run; -STATE* *Jump; -STATE* *Fall; -STATE* *Crawl; -STATE* *Swim; -STATE* *Fly; -STATE* *Rise; -STATE* *Sit; -STATE* *Look; -STATE* *Climb; -STATE* *Pain; -STATE* *Death1; -STATE* *Death2; -STATE* *Dead; -STATE* *DeathJump; -STATE* *DeathFall; -STATE* *CloseAttack[2]; -STATE* *Attack[6]; -STATE* *Special[2]; +FState* *Stand[MAX_WEAPONS]; +FState* *Run; +FState* *Jump; +FState* *Fall; +FState* *Crawl; +FState* *Swim; +FState* *Fly; +FState* *Rise; +FState* *Sit; +FState* *Look; +FState* *Climb; +FState* *Pain; +FState* *Death1; +FState* *Death2; +FState* *Dead; +FState* *DeathJump; +FState* *DeathFall; +FState* *CloseAttack[2]; +FState* *Attack[6]; +FState* *Special[2]; */ ACTOR_ACTION_SET BunnyActionSet = { - sg_BunnyStand, - sg_BunnyRun, - sg_BunnyJump, - sg_BunnyFall, - nullptr, // sg_BunnyCrawl, - nullptr, // sg_BunnySwim, - nullptr, // sg_BunnyFly, - nullptr, // sg_BunnyRise, - nullptr, // sg_BunnySit, - nullptr, // sg_BunnyLook, + s_BunnyStand, + s_BunnyRun, + s_BunnyJump, + s_BunnyFall, + nullptr, // s_BunnyCrawl, + nullptr, // s_BunnySwim, + nullptr, // s_BunnyFly, + nullptr, // s_BunnyRise, + nullptr, // s_BunnySit, + nullptr, // s_BunnyLook, nullptr, // climb - sg_BunnyPain, - sg_BunnyDie, + s_BunnyPain, + s_BunnyDie, nullptr, - sg_BunnyDead, - sg_BunnyDeathJump, - sg_BunnyDeathFall, + s_BunnyDead, + s_BunnyDeathJump, + s_BunnyDeathFall, {nullptr}, {1024}, {nullptr}, {1024}, - {sg_BunnyHeart, sg_BunnyRun}, + {s_BunnyHeart, s_BunnyRun}, nullptr, nullptr }; ACTOR_ACTION_SET BunnyWhiteActionSet = { - sg_BunnyStand, - sg_BunnyRun, - sg_BunnyJump, - sg_BunnyFall, - nullptr, // sg_BunnyCrawl, - nullptr, // sg_BunnySwim, - nullptr, // sg_BunnyFly, - nullptr, // sg_BunnyRise, - nullptr, // sg_BunnySit, - nullptr, // sg_BunnyLook, + s_BunnyStand, + s_BunnyRun, + s_BunnyJump, + s_BunnyFall, + nullptr, // s_BunnyCrawl, + nullptr, // s_BunnySwim, + nullptr, // s_BunnyFly, + nullptr, // s_BunnyRise, + nullptr, // s_BunnySit, + nullptr, // s_BunnyLook, nullptr, // climb - sg_BunnyPain, // pain - sg_BunnyDie, + s_BunnyPain, // pain + s_BunnyDie, nullptr, - sg_BunnyDead, - sg_BunnyDeathJump, - sg_BunnyDeathFall, - {sg_BunnySwipe}, + s_BunnyDead, + s_BunnyDeathJump, + s_BunnyDeathFall, + {s_BunnySwipe}, {1024}, -// {sg_BunnyJumpAttack, sg_BunnySwipe}, +// {s_BunnyJumpAttack, s_BunnySwipe}, // {800, 1024}, - {sg_BunnySwipe}, + {s_BunnySwipe}, {1024}, - {sg_BunnyHeart, sg_BunnySwipe}, + {s_BunnyHeart, s_BunnySwipe}, nullptr, nullptr }; @@ -511,15 +425,15 @@ int SetupBunny(DSWActor* actor) { if (!(actor->spr.cstat & CSTAT_SPRITE_RESTORE)) { - SpawnUser(actor, BUNNY_RUN_R0, s_BunnyRun[0]); + SpawnUser(actor, BUNNY_RUN_R0, &s_BunnyRun[0]); actor->user.Health = 10; } Bunny_Count++; - ChangeState(actor, s_BunnyRun[0]); + ChangeState(actor, &s_BunnyRun[0]); actor->user.__legacyState.StateEnd = s_BunnyDie; - actor->user.__legacyState.Rot = sg_BunnyRun; + actor->user.__legacyState.Rot = s_BunnyRun; actor->user.ShellNum = 0; // Not Pregnant right now actor->user.FlagOwner = 0; @@ -826,8 +740,8 @@ int DoBunnyQuickJump(DSWActor* actor) HelpMissileLateral(actor, 2000); actor->spr.Angles.Yaw = hitActor->spr.Angles.Yaw; - NewStateGroup(actor, sg_BunnyScrew); - NewStateGroup(hitActor, sg_BunnyScrew); + NewStateGroup(actor, s_BunnyScrew); + NewStateGroup(hitActor, s_BunnyScrew); actor->user.WaitTics = hitActor->user.WaitTics = SEC(10); // Mate for this long return true; } @@ -885,7 +799,7 @@ int DoBunnyRipHeart(DSWActor* actor) { DSWActor* target = actor->user.targetActor; - NewStateGroup(actor, sg_BunnyHeart); + NewStateGroup(actor, s_BunnyHeart); actor->user.WaitTics = 6 * 120; // player face bunny @@ -902,7 +816,7 @@ int DoBunnyStandKill(DSWActor* actor) PlaySound(DIGI_BUNNYATTACK, actor, v3df_none); if ((actor->user.WaitTics -= ACTORMOVETICS) <= 0) - NewStateGroup(actor, sg_BunnyRun); + NewStateGroup(actor, s_BunnyRun); return 0; } @@ -1085,7 +999,7 @@ int DoBunnyMove(DSWActor* actor) { if (tileflags(actor->sector()->floortexture) & TFLAG_BUNNYFRIENDLY) { - NewStateGroup(actor, sg_BunnyStand); + NewStateGroup(actor, s_BunnyStand); } else { @@ -1145,11 +1059,11 @@ int DoBunnyEat(DSWActor* actor) if (tileflags(actor->sector()->floortexture) & TFLAG_BUNNYFRIENDLY) { if (RandomRange(1000) > 970) - NewStateGroup(actor, sg_BunnyRun); + NewStateGroup(actor, s_BunnyRun); } else { - NewStateGroup(actor,sg_BunnyRun); + NewStateGroup(actor,s_BunnyRun); } return 0; } @@ -1187,7 +1101,7 @@ int DoBunnyScrew(DSWActor* actor) actor->user.WaitTics -= ACTORMOVETICS; if ((actor->user.FlagOwner || actor->user.spal == PALETTE_PLAYER0) && actor->user.WaitTics > 0) // Keep Girl still - NewStateGroup(actor,sg_BunnyScrew); + NewStateGroup(actor,s_BunnyScrew); if (actor->user.spal == PALETTE_PLAYER0 && actor->user.WaitTics <= 0) // Female has baby { @@ -1199,7 +1113,7 @@ int DoBunnyScrew(DSWActor* actor) { actor->spr.cstat &= ~(CSTAT_SPRITE_INVISIBLE); // Turn em' back on actor->user.FlagOwner = 0; - NewStateGroup(actor,sg_BunnyRun); + NewStateGroup(actor,s_BunnyRun); } return 0; @@ -1262,32 +1176,18 @@ static saveable_data saveable_bunny_data[] = SAVE_DATA(BunnyAttrib), SAVE_DATA(s_BunnyRun), - SAVE_DATA(sg_BunnyRun), SAVE_DATA(s_BunnyStand), - SAVE_DATA(sg_BunnyStand), SAVE_DATA(s_BunnyScrew), - SAVE_DATA(sg_BunnyScrew), SAVE_DATA(s_BunnySwipe), - SAVE_DATA(sg_BunnySwipe), SAVE_DATA(s_BunnyHeart), - SAVE_DATA(sg_BunnyHeart), SAVE_DATA(s_BunnyPain), - SAVE_DATA(sg_BunnyPain), SAVE_DATA(s_BunnyJump), - SAVE_DATA(sg_BunnyJump), SAVE_DATA(s_BunnyFall), - SAVE_DATA(sg_BunnyFall), SAVE_DATA(s_BunnyJumpAttack), - SAVE_DATA(sg_BunnyJumpAttack), SAVE_DATA(s_BunnyDie), - SAVE_DATA(sg_BunnyDie), SAVE_DATA(s_BunnyDead), - SAVE_DATA(sg_BunnyDead), SAVE_DATA(s_BunnyDeathJump), - SAVE_DATA(sg_BunnyDeathJump), SAVE_DATA(s_BunnyDeathFall), - SAVE_DATA(sg_BunnyDeathFall), - SAVE_DATA(BunnyActionSet), SAVE_DATA(BunnyWhiteActionSet), }; diff --git a/source/games/sw/src/coolg.cpp b/source/games/sw/src/coolg.cpp index 226441445..7e05238f3 100644 --- a/source/games/sw/src/coolg.cpp +++ b/source/games/sw/src/coolg.cpp @@ -120,19 +120,12 @@ ATTRIBUTE CoolgAttrib = #define COOLG_RUN_RATE 40 -STATE s_CoolgRun[][4] = +FState s_CoolgRun[] = { - { - {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]}, - }, -}; - -STATE* sg_CoolgRun[] = -{ - &s_CoolgRun[0][0], + {SPR_COOLG_RUN, 'A', COOLG_RUN_RATE, &AF(DoCoolgMove), &s_CoolgRun[1]}, + {SPR_COOLG_RUN, 'B', COOLG_RUN_RATE, &AF(DoCoolgMove), &s_CoolgRun[2]}, + {SPR_COOLG_RUN, 'C', COOLG_RUN_RATE, &AF(DoCoolgMove), &s_CoolgRun[3]}, + {SPR_COOLG_RUN, 'D', COOLG_RUN_RATE, &AF(DoCoolgMove), &s_CoolgRun[0]}, }; ////////////////////// @@ -142,16 +135,9 @@ STATE* sg_CoolgRun[] = ////////////////////// -STATE s_CoolgStand[][1] = +FState s_CoolgStand[] = { - { - {SPR_COOLG_RUN, 'A', COOLG_RUN_RATE, &AF(DoCoolgMove), &s_CoolgStand[0][0]}, - }, -}; - -STATE* sg_CoolgStand[] = -{ - &s_CoolgStand[0][0], + {SPR_COOLG_RUN, 'A', COOLG_RUN_RATE, &AF(DoCoolgMove), &s_CoolgStand[0]}, }; ////////////////////// @@ -162,21 +148,14 @@ STATE* sg_CoolgStand[] = #define COOLG_RATE 16 -STATE s_CoolgClub[][6] = +FState s_CoolgClub[] = { - { - {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]} - }, -}; - -STATE* sg_CoolgClub[] = -{ - &s_CoolgClub[0][0], + {SPR_COOLG_CLUB, 'A', COOLG_RATE, &AF(NullCoolg), &s_CoolgClub[1]}, + {SPR_COOLG_RUN, 'A', COOLG_RATE, &AF(NullCoolg), &s_CoolgClub[2]}, + {SPR_COOLG_CLUB, 'B', 0|SF_QUICK_CALL, &AF(InitCoolgBash), &s_CoolgClub[3]}, + {SPR_COOLG_CLUB, 'B', COOLG_RATE, &AF(NullCoolg), &s_CoolgClub[4]}, + {SPR_COOLG_CLUB, 'B', 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_CoolgClub[5]}, + {SPR_COOLG_CLUB, 'B', COOLG_RATE, &AF(DoCoolgMove), &s_CoolgClub[5]} }; ////////////////////// @@ -187,22 +166,15 @@ STATE* sg_CoolgClub[] = #define COOLG_FIRE_RATE 12 -STATE s_CoolgAttack[][7] = +FState s_CoolgAttack[] = { - { - {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]} - }, -}; - -STATE* sg_CoolgAttack[] = -{ - &s_CoolgAttack[0][0], + {SPR_COOLG_FIRE, 'A', COOLG_FIRE_RATE*2, &AF(NullCoolg), &s_CoolgAttack[1]}, + {SPR_COOLG_FIRE, 'B', COOLG_FIRE_RATE*2, &AF(NullCoolg), &s_CoolgAttack[2]}, + {SPR_COOLG_FIRE, 'C', COOLG_FIRE_RATE*2, &AF(NullCoolg), &s_CoolgAttack[3]}, + {SPR_COOLG_FIRE, 'C', 0|SF_QUICK_CALL, &AF(InitCoolgFire), &s_CoolgAttack[4]}, + {SPR_COOLG_FIRE, 'C', COOLG_FIRE_RATE, &AF(NullCoolg), &s_CoolgAttack[5]}, + {SPR_COOLG_FIRE, 'C', 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_CoolgAttack[6]}, + {SPR_COOLG_RUN, 'C', COOLG_FIRE_RATE, &AF(DoCoolgMove), &s_CoolgAttack[6]} }; ////////////////////// @@ -213,20 +185,12 @@ STATE* sg_CoolgAttack[] = #define COOLG_PAIN_RATE 15 -STATE s_CoolgPain[][2] = +FState s_CoolgPain[] = { - { - {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]}, - }, + {SPR_COOLG_PAIN, 'A', COOLG_PAIN_RATE, &AF(DoCoolgPain), &s_CoolgPain[1]}, + {SPR_COOLG_PAIN, 'A', COOLG_PAIN_RATE, &AF(DoCoolgPain), &s_CoolgPain[1]}, }; -STATE* sg_CoolgPain[] = -{ - s_CoolgPain[0], -}; - - ////////////////////// // // COOLG DIE @@ -235,7 +199,7 @@ STATE* sg_CoolgPain[] = #define COOLG_DIE_RATE 20 -STATE s_CoolgDie[] = +FState s_CoolgDie[] = { {SPR_COOLG_DIE, 'A', COOLG_DIE_RATE, &AF(DoCoolgDeath), &s_CoolgDie[1]}, {SPR_COOLG_DIE, 'B', COOLG_DIE_RATE, &AF(DoCoolgDeath), &s_CoolgDie[2]}, @@ -245,22 +209,12 @@ STATE s_CoolgDie[] = {SPR_COOLG_DIE, 'F', COOLG_DIE_RATE, &AF(DoCoolgDeath), &s_CoolgDie[5]}, }; -STATE* sg_CoolgDie[] = -{ - s_CoolgDie -}; - -STATE s_CoolgDead[] = +FState s_CoolgDead[] = { {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[] = -{ - s_CoolgDead -}; - ////////////////////// // // COOLG BIRTH @@ -269,7 +223,7 @@ STATE* sg_CoolgDead[] = #define COOLG_BIRTH_RATE 20 -STATE s_CoolgBirth[] = +FState s_CoolgBirth[] = { {SPR_COOLG_BIRTH, 'A', COOLG_BIRTH_RATE, nullptr, &s_CoolgBirth[1]}, {SPR_COOLG_BIRTH, 'B', COOLG_BIRTH_RATE, nullptr, &s_CoolgBirth[2]}, @@ -284,39 +238,34 @@ STATE s_CoolgBirth[] = {SPR_COOLG_BIRTH, 'I', 0 | SF_QUICK_CALL, &AF(DoCoolgBirth), &s_CoolgBirth[10]} }; -STATE* sg_CoolgBirth[] = -{ - s_CoolgBirth -}; - /* -STATE* *Stand[MAX_WEAPONS]; -STATE* *Run; -STATE* *Jump; -STATE* *Fall; -STATE* *Crawl; -STATE* *Swim; -STATE* *Fly; -STATE* *Rise; -STATE* *Sit; -STATE* *Look; -STATE* *Climb; -STATE* *Pain; -STATE* *Death1; -STATE* *Death2; -STATE* *Dead; -STATE* *DeathJump; -STATE* *DeathFall; -STATE* *CloseAttack[2]; -STATE* *Attack[6]; -STATE* *Special[2]; +FState* *Stand[MAX_WEAPONS]; +FState* *Run; +FState* *Jump; +FState* *Fall; +FState* *Crawl; +FState* *Swim; +FState* *Fly; +FState* *Rise; +FState* *Sit; +FState* *Look; +FState* *Climb; +FState* *Pain; +FState* *Death1; +FState* *Death2; +FState* *Dead; +FState* *DeathJump; +FState* *DeathFall; +FState* *CloseAttack[2]; +FState* *Attack[6]; +FState* *Special[2]; */ ACTOR_ACTION_SET CoolgActionSet = { - sg_CoolgStand, - sg_CoolgRun, + s_CoolgStand, + s_CoolgRun, nullptr, nullptr, nullptr, @@ -326,16 +275,16 @@ ACTOR_ACTION_SET CoolgActionSet = nullptr, nullptr, nullptr, //climb - sg_CoolgPain, //pain - sg_CoolgDie, + s_CoolgPain, //pain + s_CoolgDie, nullptr, - sg_CoolgDead, + s_CoolgDead, nullptr, nullptr, -// {sg_CoolgClub}, - {sg_CoolgAttack}, +// {s_CoolgClub}, + {s_CoolgAttack}, {1024}, - {sg_CoolgAttack}, + {s_CoolgAttack}, {1024}, {nullptr,nullptr}, nullptr, @@ -380,7 +329,7 @@ int SetupCoolg(DSWActor* actor) actor->user.__legacyState.Attrib = &CoolgAttrib; DoActorSetSpeed(actor, NORM_SPEED); actor->user.__legacyState.StateEnd = s_CoolgDie; - actor->user.__legacyState.Rot = sg_CoolgRun; + actor->user.__legacyState.Rot = s_CoolgRun; EnemyDefaults(actor, &CoolgActionSet, &CoolgPersonality); @@ -411,7 +360,7 @@ int NewCoolg(DSWActor* actor) ChangeState(actorNew, &s_CoolgBirth[0]); actorNew->user.__legacyState.StateEnd = s_CoolgDie; - actorNew->user.__legacyState.Rot = sg_CoolgRun; + actorNew->user.__legacyState.Rot = s_CoolgRun; actorNew->spr.pal = actorNew->user.spal = actor->user.spal; actorNew->user.__legacyState.ActorActionSet = &CoolgActionSet; @@ -442,7 +391,7 @@ int DoCoolgBirth(DSWActor* actor) ChangeState(actor, s_CoolgRun[0]); actor->user.__legacyState.StateEnd = s_CoolgDie; - actor->user.__legacyState.Rot = sg_CoolgRun; + actor->user.__legacyState.Rot = s_CoolgRun; EnemyDefaults(actor, &CoolgActionSet, &CoolgPersonality); // special case @@ -795,21 +744,13 @@ static saveable_data saveable_coolg_data[] = SAVE_DATA(CoolgAttrib), SAVE_DATA(s_CoolgRun), - SAVE_DATA(sg_CoolgRun), SAVE_DATA(s_CoolgStand), - SAVE_DATA(sg_CoolgStand), SAVE_DATA(s_CoolgClub), - SAVE_DATA(sg_CoolgClub), SAVE_DATA(s_CoolgAttack), - SAVE_DATA(sg_CoolgAttack), SAVE_DATA(s_CoolgPain), - SAVE_DATA(sg_CoolgPain), SAVE_DATA(s_CoolgDie), - SAVE_DATA(sg_CoolgDie), SAVE_DATA(s_CoolgDead), - SAVE_DATA(sg_CoolgDead), SAVE_DATA(s_CoolgBirth), - SAVE_DATA(sg_CoolgBirth), SAVE_DATA(CoolgActionSet), }; diff --git a/source/games/sw/src/coolie.cpp b/source/games/sw/src/coolie.cpp index 69636b363..8212ebfa8 100644 --- a/source/games/sw/src/coolie.cpp +++ b/source/games/sw/src/coolie.cpp @@ -116,19 +116,12 @@ ATTRIBUTE CoolieAttrib = #define COOLIE_RATE 12 -STATE s_CoolieRun[][4] = +FState s_CoolieRun[] = { - { - {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]} - }, -}; - -STATE* sg_CoolieRun[] = -{ - &s_CoolieRun[0][0], + {SPR_COOLIE_RUN, 'A', COOLIE_RATE, &AF(DoCoolieMove), &s_CoolieRun[1]}, + {SPR_COOLIE_RUN, 'B', COOLIE_RATE, &AF(DoCoolieMove), &s_CoolieRun[2]}, + {SPR_COOLIE_RUN, 'C', COOLIE_RATE, &AF(DoCoolieMove), &s_CoolieRun[3]}, + {SPR_COOLIE_RUN, 'D', COOLIE_RATE, &AF(DoCoolieMove), &s_CoolieRun[0]} }; ////////////////////// @@ -139,19 +132,12 @@ STATE* sg_CoolieRun[] = #define COOLIE_RATE 12 -STATE s_CoolieCharge[][4] = +FState s_CoolieCharge[] = { - { - {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]} - }, -}; - -STATE* sg_CoolieCharge[] = -{ - &s_CoolieCharge[0][0], + {SPR_COOLIE_CHARGE, 'A', COOLIE_RATE, &AF(DoCoolieMove), &s_CoolieCharge[1]}, + {SPR_COOLIE_CHARGE, 'B', COOLIE_RATE, &AF(DoCoolieMove), &s_CoolieCharge[2]}, + {SPR_COOLIE_CHARGE, 'C', COOLIE_RATE, &AF(DoCoolieMove), &s_CoolieCharge[3]}, + {SPR_COOLIE_CHARGE, 'D', COOLIE_RATE, &AF(DoCoolieMove), &s_CoolieCharge[0]} }; ////////////////////// @@ -160,16 +146,9 @@ STATE* sg_CoolieCharge[] = // ////////////////////// -STATE s_CoolieStand[][6] = +FState s_CoolieStand[] = { - { - {SPR_COOLIE_RUN, 'A', COOLIE_RATE, &AF(DoCoolieMove), &s_CoolieStand[0][0]} - }, -}; - -STATE* sg_CoolieStand[] = -{ - &s_CoolieStand[0][0], + {SPR_COOLIE_RUN, 'A', COOLIE_RATE, &AF(DoCoolieMove), &s_CoolieStand[0]} }; ////////////////////// @@ -180,16 +159,9 @@ STATE* sg_CoolieStand[] = #define COOLIE_PAIN_RATE 60 -STATE s_CooliePain[][1] = +FState s_CooliePain[] = { - { - {SPR_COOLIE_PAIN, 'A', COOLIE_PAIN_RATE, &AF(CooliePain), &s_CooliePain[0][0]}, - }, -}; - -STATE* sg_CooliePain[] = -{ - &s_CooliePain[0][0], + {SPR_COOLIE_PAIN, 'A', COOLIE_PAIN_RATE, &AF(CooliePain), &s_CooliePain[0]}, }; ////////////////////// @@ -200,7 +172,7 @@ STATE* sg_CooliePain[] = #define COOLIE_DIE_RATE 30 -STATE s_CoolieDie[] = +FState s_CoolieDie[] = { {SPR_COOLIE_DIE, 'A', COOLIE_DIE_RATE, &AF(NullCoolie), &s_CoolieDie[1]}, @@ -220,25 +192,15 @@ STATE s_CoolieDie[] = {SPR_COOLIE_DEAD_NOHEAD, 'A', COOLIE_DIE_RATE, &AF(DoActorDebris), &s_CoolieDie[12]} }; -STATE* sg_CoolieDie[] = -{ - s_CoolieDie -}; - -STATE s_CoolieDead[] = +FState s_CoolieDead[] = { {SPR_COOLIE_DEAD, 'A', COOLIE_DIE_RATE, &AF(DoActorDebris), &s_CoolieDead[0]}, }; -STATE* sg_CoolieDead[] = -{ - s_CoolieDead -}; - ACTOR_ACTION_SET CoolieActionSet = { - sg_CoolieStand, - sg_CoolieRun, + s_CoolieStand, + s_CoolieRun, nullptr, nullptr, nullptr, @@ -248,15 +210,15 @@ ACTOR_ACTION_SET CoolieActionSet = nullptr, nullptr, nullptr, //climb - sg_CooliePain, //pain - sg_CoolieDie, + s_CooliePain, //pain + s_CoolieDie, nullptr, - sg_CoolieDead, + s_CoolieDead, nullptr, nullptr, - {sg_CoolieCharge}, + {s_CoolieCharge}, {1024}, - {sg_CoolieCharge}, + {s_CoolieCharge}, {1024}, {nullptr}, nullptr, @@ -391,7 +353,7 @@ int SetupCoolie(DSWActor* actor) actor->user.__legacyState.Attrib = &CoolieAttrib; DoActorSetSpeed(actor, NORM_SPEED); actor->user.__legacyState.StateEnd = s_CoolieDie; - actor->user.__legacyState.Rot = sg_CoolieRun; + actor->user.__legacyState.Rot = s_CoolieRun; EnemyDefaults(actor, &CoolieActionSet, &CooliePersonality); @@ -519,7 +481,7 @@ int InitCoolieCharge(DSWActor* actor) InitActorMoveCloser(actor); - NewStateGroup(actor, sg_CoolieCharge); + NewStateGroup(actor, s_CoolieCharge); return 0; } @@ -557,17 +519,11 @@ static saveable_data saveable_coolie_data[] = SAVE_DATA(CoolieAttrib), SAVE_DATA(s_CoolieRun), - SAVE_DATA(sg_CoolieRun), SAVE_DATA(s_CoolieCharge), - SAVE_DATA(sg_CoolieCharge), SAVE_DATA(s_CoolieStand), - SAVE_DATA(sg_CoolieStand), SAVE_DATA(s_CooliePain), - SAVE_DATA(sg_CooliePain), SAVE_DATA(s_CoolieDie), - SAVE_DATA(sg_CoolieDie), SAVE_DATA(s_CoolieDead), - SAVE_DATA(sg_CoolieDead), SAVE_DATA(CoolieActionSet), }; diff --git a/source/games/sw/src/draw.cpp b/source/games/sw/src/draw.cpp index 2b3b521ea..420480c2a 100644 --- a/source/games/sw/src/draw.cpp +++ b/source/games/sw/src/draw.cpp @@ -110,7 +110,7 @@ int SetActorRotation(tspriteArray& tsprites, int tSpriteNum, const DVector2& vie if (!ownerActor->hasU() || ownerActor->user.__legacyState.State == nullptr) return 0; - unsigned sprite = ownerActor->user.__legacyState.State->Sprite; + unsigned sprite = ownerActor->user.__legacyState.State->sprite; unsigned frame = ownerActor->user.__legacyState.State->Frame - 'A'; if (SpriteDefs.Size() <= sprite) return 0; @@ -472,8 +472,8 @@ void WarpCopySprite(tspriteArray& tsprites) void DoStarView(tspritetype* tsp, DSWActor* tActor, double viewz) { - extern STATE s_Star[], s_StarDown[]; - extern STATE s_StarStuck[], s_StarDownStuck[]; + extern FState s_Star[], s_StarDown[]; + extern FState s_StarStuck[], s_StarDownStuck[]; double zdiff = viewz - tsp->pos.Z; if (abs(zdiff) > 24) diff --git a/source/games/sw/src/eel.cpp b/source/games/sw/src/eel.cpp index cab2b6087..f719092b4 100644 --- a/source/games/sw/src/eel.cpp +++ b/source/games/sw/src/eel.cpp @@ -116,19 +116,12 @@ ATTRIBUTE EelAttrib = #define EEL_RUN_RATE 20 -STATE s_EelRun[][4] = +FState s_EelRun[] = { - { - {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]}, - }, -}; - -STATE* sg_EelRun[] = -{ - &s_EelRun[0][0], + {SPR_EEL_RUN, 'A', EEL_RUN_RATE, &AF(DoEelMove), &s_EelRun[1]}, + {SPR_EEL_RUN, 'B', EEL_RUN_RATE, &AF(DoEelMove), &s_EelRun[2]}, + {SPR_EEL_RUN, 'C', EEL_RUN_RATE, &AF(DoEelMove), &s_EelRun[3]}, + {SPR_EEL_RUN, 'B', EEL_RUN_RATE, &AF(DoEelMove), &s_EelRun[0]}, }; ////////////////////// @@ -138,16 +131,9 @@ STATE* sg_EelRun[] = ////////////////////// -STATE s_EelStand[][1] = +FState s_EelStand[] = { - { - {SPR_EEL_RUN, 'A', EEL_RUN_RATE, &AF(DoEelMove), &s_EelStand[0][0]}, - }, -}; - -STATE* sg_EelStand[] = -{ - &s_EelStand[0][0], + {SPR_EEL_RUN, 'A', EEL_RUN_RATE, &AF(DoEelMove), &s_EelStand[0]}, }; ////////////////////// @@ -158,25 +144,17 @@ STATE* sg_EelStand[] = #define EEL_FIRE_RATE 12 -STATE s_EelAttack[][7] = +FState s_EelAttack[] = { - { - {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]} - }, + {SPR_EEL_FIRE, 'A', EEL_FIRE_RATE*2, &AF(NullEel), &s_EelAttack[1]}, + {SPR_EEL_FIRE, 'B', EEL_FIRE_RATE*2, &AF(NullEel), &s_EelAttack[2]}, + {SPR_EEL_FIRE, 'C', EEL_FIRE_RATE*2, &AF(NullEel), &s_EelAttack[3]}, + {SPR_EEL_FIRE, 'C', 0|SF_QUICK_CALL, &AF(InitEelFire), &s_EelAttack[4]}, + {SPR_EEL_FIRE, 'C', EEL_FIRE_RATE, &AF(NullEel), &s_EelAttack[5]}, + {SPR_EEL_FIRE, 'D', 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_EelAttack[6]}, + {SPR_EEL_RUN, 'D', EEL_FIRE_RATE, &AF(DoEelMove), &s_EelAttack[6]} }; -STATE* sg_EelAttack[] = -{ - &s_EelAttack[0][0], -}; - - ////////////////////// // // EEL DIE @@ -185,7 +163,7 @@ STATE* sg_EelAttack[] = #define EEL_DIE_RATE 20 -STATE s_EelDie[] = +FState s_EelDie[] = { {SPR_EEL_DIE, 'A', EEL_DIE_RATE, &AF(DoEelDeath), &s_EelDie[1]}, {SPR_EEL_DIE, 'A', EEL_DIE_RATE, &AF(DoEelDeath), &s_EelDie[2]}, @@ -195,68 +173,58 @@ STATE s_EelDie[] = {SPR_EEL_DIE, 'A', EEL_DIE_RATE, &AF(DoEelDeath), &s_EelDie[5]}, }; -STATE* sg_EelDie[] = -{ - s_EelDie -}; - -STATE s_EelDead[] = +FState s_EelDead[] = { {SPR_EEL_DEAD, 'A', EEL_DIE_RATE, &AF(DoActorDebris), &s_EelDead[0]}, }; -STATE* sg_EelDead[] = -{ - s_EelDead -}; - /* -STATE* *Stand[MAX_WEAPONS]; -STATE* *Run; -STATE* *Jump; -STATE* *Fall; -STATE* *Crawl; -STATE* *Swim; -STATE* *Fly; -STATE* *Rise; -STATE* *Sit; -STATE* *Look; -STATE* *Climb; -STATE* *Pain; -STATE* *Death1; -STATE* *Death2; -STATE* *Dead; -STATE* *DeathJump; -STATE* *DeathFall; -STATE* *CloseAttack[2]; -STATE* *Attack[6]; -STATE* *Special[2]; +FState* *Stand[MAX_WEAPONS]; +FState* *Run; +FState* *Jump; +FState* *Fall; +FState* *Crawl; +FState* *Swim; +FState* *Fly; +FState* *Rise; +FState* *Sit; +FState* *Look; +FState* *Climb; +FState* *Pain; +FState* *Death1; +FState* *Death2; +FState* *Dead; +FState* *DeathJump; +FState* *DeathFall; +FState* *CloseAttack[2]; +FState* *Attack[6]; +FState* *Special[2]; */ ACTOR_ACTION_SET EelActionSet = { - sg_EelStand, - sg_EelRun, + s_EelStand, + s_EelRun, nullptr, nullptr, nullptr, - sg_EelRun, + s_EelRun, nullptr, nullptr, - sg_EelStand, + s_EelStand, nullptr, nullptr, //climb - sg_EelStand, //pain - sg_EelDie, + s_EelStand, //pain + s_EelDie, nullptr, - sg_EelDead, + s_EelDead, nullptr, nullptr, - {sg_EelAttack}, + {s_EelAttack}, {1024}, - {sg_EelAttack}, + {s_EelAttack}, {1024}, {nullptr,nullptr}, nullptr, @@ -303,7 +271,7 @@ int SetupEel(DSWActor* actor) actor->user.__legacyState.Attrib = &EelAttrib; DoActorSetSpeed(actor, NORM_SPEED); actor->user.__legacyState.StateEnd = s_EelDie; - actor->user.__legacyState.Rot = sg_EelRun; + actor->user.__legacyState.Rot = s_EelRun; EnemyDefaults(actor, &EelActionSet, &EelPersonality); @@ -530,15 +498,10 @@ static saveable_data saveable_eel_data[] = SAVE_DATA(EelAttrib), SAVE_DATA(s_EelRun), - SAVE_DATA(sg_EelRun), SAVE_DATA(s_EelStand), - SAVE_DATA(sg_EelStand), SAVE_DATA(s_EelAttack), - SAVE_DATA(sg_EelAttack), SAVE_DATA(s_EelDie), - SAVE_DATA(sg_EelDie), SAVE_DATA(s_EelDead), - SAVE_DATA(sg_EelDead), SAVE_DATA(EelActionSet) }; diff --git a/source/games/sw/src/game.h b/source/games/sw/src/game.h index 63efea6f0..68f64bf11 100644 --- a/source/games/sw/src/game.h +++ b/source/games/sw/src/game.h @@ -325,7 +325,6 @@ enum dam // Forward declarations -struct STATE; struct PANEL_STATE; class DSWPlayer; struct PERSONALITY; @@ -360,16 +359,6 @@ enum spriteindex_t #undef x -struct STATE -{ - spriteindex_t Sprite; - char Frame; - int Tics; - VMNativeFunction** Animator; // go through the scripting interface - - STATE* NextState; -}; - // // State Flags // @@ -626,33 +615,33 @@ enum struct ACTOR_ACTION_SET { - STATE* *Stand; - STATE* *Run; - STATE* *Jump; - STATE* *Fall; - STATE* *Crawl; - STATE* *Swim; - STATE* *Fly; - STATE* *Rise; - STATE* *Sit; - STATE* *Look; - STATE* *Climb; - STATE* *Pain; - STATE* *Death1; - STATE* *Death2; - STATE* *Dead; - STATE* *DeathJump; - STATE* *DeathFall; + FState* Stand; + FState* Run; + FState* Jump; + FState* Fall; + FState* Crawl; + FState* Swim; + FState* Fly; + FState* Rise; + FState* Sit; + FState* Look; + FState* Climb; + FState* Pain; + FState* Death1; + FState* Death2; + FState* Dead; + FState* DeathJump; + FState* DeathFall; - STATE* *CloseAttack[MAX_ACTOR_CLOSE_ATTACK]; + FState* CloseAttack[MAX_ACTOR_CLOSE_ATTACK]; int16_t CloseAttackPercent[MAX_ACTOR_CLOSE_ATTACK]; - STATE* *Attack[MAX_ACTOR_ATTACK]; + FState* Attack[MAX_ACTOR_ATTACK]; int16_t AttackPercent[MAX_ACTOR_ATTACK]; - STATE* *Special[2]; - STATE* *Duck; - STATE* *Dive; + FState* Special[2]; + FState* Duck; + FState* Dive; }; struct ROTATOR @@ -710,11 +699,11 @@ struct USER struct LegacyState { - STATE* State; - STATE** Rot; - STATE* StateStart; - STATE* StateEnd; - STATE** StateFallOverride; // a bit kludgy - override std fall state + FState* State; + FState* Rot; + FState* StateStart; + FState* StateEnd; + FState* StateFallOverride; // a bit kludgy - override std fall state ACTOR_ACTION_SET* ActorActionSet; int16_t RotNum; ATTRIBUTE* Attrib; @@ -1401,9 +1390,13 @@ extern SECTOR_OBJECT SectorObject[MAX_SECTOR_OBJECTS]; // /////////////////////////////////////////////////////////////////////////////////////////// -int NewStateGroup(DSWActor* actor, STATE* SpriteGroup[]); +int NewStateGroup(DSWActor* actor, FState* SpriteGroup); DVector3 SectorMidPoint(sectortype* sectp); -void SpawnUser(DSWActor* actor, short id, STATE* state); +void SpawnUser(DSWActor* actor, short id, FState* state); +inline void SpawnUser(DSWActor* actor, short id, FState& state) +{ + SpawnUser(actor, id, &state); +} short ActorFindTrack(DSWActor* actor, int8_t player_dir, int track_type, int *track_point_num, int *track_dir); diff --git a/source/games/sw/src/girlninj.cpp b/source/games/sw/src/girlninj.cpp index beb501097..a17e756dc 100644 --- a/source/games/sw/src/girlninj.cpp +++ b/source/games/sw/src/girlninj.cpp @@ -120,21 +120,12 @@ ATTRIBUTE GirlNinjaAttrib = #define GIRLNINJA_RATE 18 -STATE s_GirlNinjaRun[1][4] = +FState s_GirlNinjaRun[] = { - - { - {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]}, - }, -}; - - -STATE* sg_GirlNinjaRun[] = -{ - s_GirlNinjaRun[0], + {SPR_GIRLNINJA_RUN, 'A', GIRLNINJA_RATE | SF_TIC_ADJUST, &AF(DoGirlNinjaMove), &s_GirlNinjaRun[1]}, + {SPR_GIRLNINJA_RUN, 'B', GIRLNINJA_RATE | SF_TIC_ADJUST, &AF(DoGirlNinjaMove), &s_GirlNinjaRun[2]}, + {SPR_GIRLNINJA_RUN, 'C', GIRLNINJA_RATE | SF_TIC_ADJUST, &AF(DoGirlNinjaMove), &s_GirlNinjaRun[3]}, + {SPR_GIRLNINJA_RUN, 'D', GIRLNINJA_RATE | SF_TIC_ADJUST, &AF(DoGirlNinjaMove), &s_GirlNinjaRun[0]}, }; ////////////////////// @@ -145,19 +136,12 @@ STATE* sg_GirlNinjaRun[] = #define GIRLNINJA_STAND_RATE 10 -STATE s_GirlNinjaStand[1][1] = +FState s_GirlNinjaStand[] = { - { - {SPR_GIRLNINJA_STAND, 'A', GIRLNINJA_STAND_RATE, &AF(DoGirlNinjaMove), &s_GirlNinjaStand[0][0]}, - }, + {SPR_GIRLNINJA_STAND, 'A', GIRLNINJA_STAND_RATE, &AF(DoGirlNinjaMove), &s_GirlNinjaStand[0]}, }; -STATE* sg_GirlNinjaStand[] = -{ - s_GirlNinjaStand[0], -}; - ////////////////////// // // GIRLNINJA RISE @@ -166,23 +150,16 @@ STATE* sg_GirlNinjaStand[] = #define GIRLNINJA_RISE_RATE 10 -STATE s_GirlNinjaRise[1][3] = +FState s_GirlNinjaRise[] = { - { - {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 + {SPR_GIRLNINJA_KNEEL, 'A', GIRLNINJA_RISE_RATE, &AF(NullGirlNinja), &s_GirlNinjaRise[1]}, + {SPR_GIRLNINJA_STAND, 'A', GIRLNINJA_STAND_RATE, &AF(NullGirlNinja), &s_GirlNinjaRise[2]}, + {SPR_NULL, 0, 0, nullptr, &s_GirlNinjaRun[0]}, // JBF: s_GirlNinjaRun really is supposed to be the // pointer to the state group. See StateControl() where // it says "if (!actor->user.__legacyState.State->Pic)". - }, }; -STATE* sg_GirlNinjaRise[] = -{ - s_GirlNinjaRise[0], -}; - ////////////////////// // // GIRLNINJA DUCK @@ -192,18 +169,10 @@ STATE* sg_GirlNinjaRise[] = #define GIRLNINJA_DUCK_RATE 10 #define GIRLNINJA_CRAWL_RATE 14 -STATE s_GirlNinjaDuck[1][2] = +FState s_GirlNinjaDuck[] = { - { - {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]}, - }, -}; - - -STATE* sg_GirlNinjaDuck[] = -{ - s_GirlNinjaDuck[0], + {SPR_GIRLNINJA_KNEEL, 'A', GIRLNINJA_DUCK_RATE, &AF(NullGirlNinja), &s_GirlNinjaDuck[1]}, + {SPR_GIRLNINJA_CRAWL, 'A', GIRLNINJA_CRAWL_RATE, &AF(DoGirlNinjaMove), &s_GirlNinjaDuck[1]}, }; @@ -213,17 +182,9 @@ STATE* sg_GirlNinjaDuck[] = // ////////////////////// -STATE s_GirlNinjaSit[1][1] = +FState s_GirlNinjaSit[] = { - { - {SPR_GIRLNINJA_KNEEL, 'A', GIRLNINJA_RISE_RATE, &AF(DoGirlNinjaMove), &s_GirlNinjaSit[0][0]}, - }, -}; - - -STATE* sg_GirlNinjaSit[] = -{ - s_GirlNinjaSit[0], + {SPR_GIRLNINJA_KNEEL, 'A', GIRLNINJA_RISE_RATE, &AF(DoGirlNinjaMove), &s_GirlNinjaSit[0]}, }; @@ -235,18 +196,10 @@ STATE* sg_GirlNinjaSit[] = #define GIRLNINJA_JUMP_RATE 24 -STATE s_GirlNinjaJump[1][2] = +FState s_GirlNinjaJump[] = { - { - {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]}, - }, -}; - - -STATE* sg_GirlNinjaJump[] = -{ - s_GirlNinjaJump[0], + {SPR_GIRLNINJA_JUMP, 'A', GIRLNINJA_JUMP_RATE, &AF(DoGirlNinjaMove), &s_GirlNinjaJump[1]}, + {SPR_GIRLNINJA_JUMP, 'B', GIRLNINJA_JUMP_RATE, &AF(DoGirlNinjaMove), &s_GirlNinjaJump[1]}, }; @@ -258,20 +211,13 @@ STATE* sg_GirlNinjaJump[] = #define GIRLNINJA_FALL_RATE 16 -STATE s_GirlNinjaFall[1][2] = +FState s_GirlNinjaFall[] = { - { - {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]}, - }, + {SPR_GIRLNINJA_JUMP, 'B', GIRLNINJA_FALL_RATE, &AF(DoGirlNinjaMove), &s_GirlNinjaFall[1]}, + {SPR_GIRLNINJA_JUMP, 'C', GIRLNINJA_FALL_RATE, &AF(DoGirlNinjaMove), &s_GirlNinjaFall[1]}, }; -STATE* sg_GirlNinjaFall[] = -{ - s_GirlNinjaFall[0], -}; - ////////////////////// // // GIRLNINJA PAIN @@ -280,16 +226,9 @@ STATE* sg_GirlNinjaFall[] = #define GIRLNINJA_PAIN_RATE 15 -STATE s_GirlNinjaPain[1][1] = +FState s_GirlNinjaPain[] = { - { - {SPR_GIRLNINJA_PAIN, 'A', GIRLNINJA_PAIN_RATE, &AF(DoGirlNinjaPain), &s_GirlNinjaPain[0][0]}, - }, -}; - -STATE* sg_GirlNinjaPain[] = -{ - s_GirlNinjaPain[0], + {SPR_GIRLNINJA_PAIN, 'A', GIRLNINJA_PAIN_RATE, &AF(DoGirlNinjaPain), &s_GirlNinjaPain[0]}, }; ////////////////////// @@ -300,24 +239,16 @@ STATE* sg_GirlNinjaPain[] = #define GIRLNINJA_STICKY_RATE 32 -STATE s_GirlNinjaSticky[1][6] = +FState s_GirlNinjaSticky[] = { - { - {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]}, - }, + {SPR_GIRLNINJA_THROW, 'A', GIRLNINJA_STICKY_RATE * 2, &AF(NullGirlNinja), &s_GirlNinjaSticky[1]}, + {SPR_GIRLNINJA_THROW, 'A', GIRLNINJA_STICKY_RATE, &AF(NullGirlNinja), &s_GirlNinjaSticky[2]}, + {SPR_GIRLNINJA_THROW, 'B', 0 | SF_QUICK_CALL, &AF(InitEnemyMine), &s_GirlNinjaSticky[3]}, + {SPR_GIRLNINJA_THROW, 'B', GIRLNINJA_STICKY_RATE * 2, &AF(NullGirlNinja), &s_GirlNinjaSticky[4]}, + {SPR_GIRLNINJA_THROW, 'C', 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_GirlNinjaSticky[5]}, + {SPR_GIRLNINJA_THROW, 'C', GIRLNINJA_STICKY_RATE, &AF(DoGirlNinjaMove), &s_GirlNinjaSticky[5]}, }; -STATE* sg_GirlNinjaSticky[] = -{ - s_GirlNinjaSticky[0], -}; - - ////////////////////// // // GIRLNINJA CROSSBOW @@ -326,25 +257,16 @@ STATE* sg_GirlNinjaSticky[] = #define GIRLNINJA_CROSSBOW_RATE 14 -STATE s_GirlNinjaCrossbow[1][5] = +FState s_GirlNinjaCrossbow[] = { - { - {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]}, - }, + {SPR_GIRLNINJA_FIRE, 'A', GIRLNINJA_CROSSBOW_RATE * 2, &AF(NullGirlNinja), &s_GirlNinjaCrossbow[1]}, + {SPR_GIRLNINJA_FIRE, 'B', 0 | SF_QUICK_CALL, &AF(InitEnemyCrossbow), &s_GirlNinjaCrossbow[2]}, + {SPR_GIRLNINJA_FIRE, 'B', GIRLNINJA_CROSSBOW_RATE, &AF(NullGirlNinja), &s_GirlNinjaCrossbow[3]}, + {SPR_GIRLNINJA_FIRE, 'B', 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_GirlNinjaCrossbow[4]}, + {SPR_GIRLNINJA_FIRE, 'B', GIRLNINJA_CROSSBOW_RATE, &AF(DoGirlNinjaMove), &s_GirlNinjaCrossbow[4]}, }; -STATE* sg_GirlNinjaCrossbow[] = -{ - s_GirlNinjaCrossbow[0], -}; - - - ////////////////////// // // GIRLNINJA DIE @@ -353,7 +275,7 @@ STATE* sg_GirlNinjaCrossbow[] = #define GIRLNINJA_DIE_RATE 30 -STATE s_GirlNinjaDie[] = +FState s_GirlNinjaDie[] = { {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]}, @@ -368,7 +290,7 @@ STATE s_GirlNinjaDie[] = {SPR_GIRLNINJA_DIE, 'I', GIRLNINJA_DIE_RATE, &AF(DoActorDebris), &s_GirlNinjaDie[10]}, }; -STATE s_GirlNinjaDead[] = +FState s_GirlNinjaDead[] = { {SPR_GIRLNINJA_DIE, 'G', GIRLNINJA_DIE_RATE, &AF(DoActorDebris), &s_GirlNinjaDead[1]}, {SPR_GIRLNINJA_DIE, 'H', SF_QUICK_CALL, &AF(DoGirlNinjaSpecial), &s_GirlNinjaDead[2]}, @@ -378,62 +300,42 @@ STATE s_GirlNinjaDead[] = }; -STATE s_GirlNinjaDeathJump[] = +FState s_GirlNinjaDeathJump[] = { {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[] = +FState s_GirlNinjaDeathFall[] = { {SPR_GIRLNINJA_DIE, 'D', GIRLNINJA_DIE_RATE, &AF(DoActorDeathMove), &s_GirlNinjaDeathFall[1]}, {SPR_GIRLNINJA_DIE, 'E', GIRLNINJA_DIE_RATE, &AF(DoActorDeathMove), &s_GirlNinjaDeathFall[1]}, }; /* -STATE* *Stand[MAX_WEAPONS]; -STATE* *Run; -STATE* *Jump; -STATE* *Fall; -STATE* *Crawl; -STATE* *Swim; -STATE* *Fly; -STATE* *Rise; -STATE* *Sit; -STATE* *Look; -STATE* *Climb; -STATE* *Pain; -STATE* *Death1; -STATE* *Death2; -STATE* *Dead; -STATE* *DeathJump; -STATE* *DeathFall; -STATE* *CloseAttack[2]; -STATE* *Attack[6]; -STATE* *Special[2]; +FState* *Stand[MAX_WEAPONS]; +FState* *Run; +FState* *Jump; +FState* *Fall; +FState* *Crawl; +FState* *Swim; +FState* *Fly; +FState* *Rise; +FState* *Sit; +FState* *Look; +FState* *Climb; +FState* *Pain; +FState* *Death1; +FState* *Death2; +FState* *Dead; +FState* *DeathJump; +FState* *DeathFall; +FState* *CloseAttack[2]; +FState* *Attack[6]; +FState* *Special[2]; */ -STATE* sg_GirlNinjaDie[] = -{ - s_GirlNinjaDie -}; - -STATE* sg_GirlNinjaDead[] = -{ - s_GirlNinjaDead -}; - -STATE* sg_GirlNinjaDeathJump[] = -{ - s_GirlNinjaDeathJump -}; - -STATE* sg_GirlNinjaDeathFall[] = -{ - s_GirlNinjaDeathFall -}; - /* !AIC - Collection of states that connect action to states @@ -442,29 +344,29 @@ STATE* sg_GirlNinjaDeathFall[] = ACTOR_ACTION_SET GirlNinjaActionSet = { - sg_GirlNinjaStand, - sg_GirlNinjaRun, - sg_GirlNinjaJump, - sg_GirlNinjaFall, + s_GirlNinjaStand, + s_GirlNinjaRun, + s_GirlNinjaJump, + s_GirlNinjaFall, nullptr, nullptr, nullptr, - sg_GirlNinjaRise, - sg_GirlNinjaSit, + s_GirlNinjaRise, + s_GirlNinjaSit, nullptr, nullptr, - sg_GirlNinjaPain, - sg_GirlNinjaDie, + s_GirlNinjaPain, + s_GirlNinjaDie, nullptr, - sg_GirlNinjaDead, - sg_GirlNinjaDeathJump, - sg_GirlNinjaDeathFall, - {sg_GirlNinjaCrossbow, sg_GirlNinjaSticky}, + s_GirlNinjaDead, + s_GirlNinjaDeathJump, + s_GirlNinjaDeathFall, + {s_GirlNinjaCrossbow, s_GirlNinjaSticky}, {800, 1024}, - {sg_GirlNinjaCrossbow, sg_GirlNinjaSticky}, + {s_GirlNinjaCrossbow, s_GirlNinjaSticky}, {800, 1024}, {nullptr}, - sg_GirlNinjaDuck, + s_GirlNinjaDuck, nullptr }; @@ -483,7 +385,7 @@ int SetupGirlNinja(DSWActor* actor) } actor->user.__legacyState.StateEnd = s_GirlNinjaDie; - actor->user.__legacyState.Rot = sg_GirlNinjaRun; + actor->user.__legacyState.Rot = s_GirlNinjaRun; actor->spr.scale = DVector2(0.796875, 0.671875); actor->user.__legacyState.Attrib = &GirlNinjaAttrib; @@ -640,33 +542,19 @@ static saveable_data saveable_girlninj_data[] = SAVE_DATA(GirlNinjaAttrib), SAVE_DATA(s_GirlNinjaRun), - SAVE_DATA(sg_GirlNinjaRun), SAVE_DATA(s_GirlNinjaStand), - SAVE_DATA(sg_GirlNinjaStand), SAVE_DATA(s_GirlNinjaRise), - SAVE_DATA(sg_GirlNinjaRise), SAVE_DATA(s_GirlNinjaDuck), - SAVE_DATA(sg_GirlNinjaDuck), SAVE_DATA(s_GirlNinjaSit), - SAVE_DATA(sg_GirlNinjaSit), SAVE_DATA(s_GirlNinjaJump), - SAVE_DATA(sg_GirlNinjaJump), SAVE_DATA(s_GirlNinjaFall), - SAVE_DATA(sg_GirlNinjaFall), SAVE_DATA(s_GirlNinjaPain), - SAVE_DATA(sg_GirlNinjaPain), SAVE_DATA(s_GirlNinjaSticky), - SAVE_DATA(sg_GirlNinjaSticky), SAVE_DATA(s_GirlNinjaCrossbow), - SAVE_DATA(sg_GirlNinjaCrossbow), SAVE_DATA(s_GirlNinjaDie), SAVE_DATA(s_GirlNinjaDead), SAVE_DATA(s_GirlNinjaDeathJump), SAVE_DATA(s_GirlNinjaDeathFall), - SAVE_DATA(sg_GirlNinjaDie), - SAVE_DATA(sg_GirlNinjaDead), - SAVE_DATA(sg_GirlNinjaDeathJump), - SAVE_DATA(sg_GirlNinjaDeathFall), SAVE_DATA(GirlNinjaActionSet), }; diff --git a/source/games/sw/src/goro.cpp b/source/games/sw/src/goro.cpp index 75fbd8765..acd674784 100644 --- a/source/games/sw/src/goro.cpp +++ b/source/games/sw/src/goro.cpp @@ -112,22 +112,15 @@ ATTRIBUTE GoroAttrib = #define GORO_RUN_RATE 18 -STATE s_GoroRun[1][4] = +FState s_GoroRun[] = { - { - {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]}, - }, + {SPR_GORO_RUN, 'A', GORO_RUN_RATE|SF_TIC_ADJUST, &AF(DoGoroMove), &s_GoroRun[1]}, + {SPR_GORO_RUN, 'B', GORO_RUN_RATE|SF_TIC_ADJUST, &AF(DoGoroMove), &s_GoroRun[2]}, + {SPR_GORO_RUN, 'C', GORO_RUN_RATE|SF_TIC_ADJUST, &AF(DoGoroMove), &s_GoroRun[3]}, + {SPR_GORO_RUN, 'D', GORO_RUN_RATE|SF_TIC_ADJUST, &AF(DoGoroMove), &s_GoroRun[0]}, }; -STATE* sg_GoroRun[] = -{ - &s_GoroRun[0][0], -}; - ////////////////////// // // GORO CHOP @@ -136,29 +129,18 @@ STATE* sg_GoroRun[] = #define GORO_CHOP_RATE 14 -STATE s_GoroChop[1][7] = +FState s_GoroChop[] = { - { - {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]}, - }, + {SPR_GORO_CHOP, 'A', GORO_CHOP_RATE, &AF(NullGoro), &s_GoroChop[1]}, + {SPR_GORO_CHOP, 'B', GORO_CHOP_RATE, &AF(NullGoro), &s_GoroChop[2]}, + {SPR_GORO_CHOP, 'C', GORO_CHOP_RATE, &AF(NullGoro), &s_GoroChop[3]}, + {SPR_GORO_CHOP, 'C', 0|SF_QUICK_CALL, &AF(InitGoroChop), &s_GoroChop[4]}, + {SPR_GORO_CHOP, 'C', GORO_CHOP_RATE, &AF(NullGoro), &s_GoroChop[5]}, + {SPR_GORO_CHOP, 'C', 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_GoroChop[6]}, + {SPR_GORO_CHOP, 'C', GORO_CHOP_RATE, &AF(DoGoroMove), &s_GoroChop[6]}, }; -STATE* sg_GoroChop[] = -{ - &s_GoroChop[0][0], - &s_GoroChop[1][0], - &s_GoroChop[2][0], - &s_GoroChop[3][0], - &s_GoroChop[4][0] -}; - ////////////////////// // @@ -169,28 +151,21 @@ STATE* sg_GoroChop[] = #define GORO_SPELL_RATE 6 #define GORO_SPELL_PAUSE 30 -STATE s_GoroSpell[1][10] = +FState s_GoroSpell[] = { - { - {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]}, - }, + {SPR_GORO_SPELL, 'A', GORO_SPELL_PAUSE, &AF(NullGoro), &s_GoroSpell[1]}, + {SPR_GORO_SPELL, 'B', GORO_SPELL_PAUSE, &AF(NullGoro), &s_GoroSpell[2]}, + {SPR_GORO_SPELL, 'B', GORO_SPELL_RATE, &AF(InitEnemyFireball), &s_GoroSpell[3]}, + {SPR_GORO_SPELL, 'B', GORO_SPELL_RATE, &AF(NullGoro), &s_GoroSpell[4]}, + {SPR_GORO_SPELL, 'B', GORO_SPELL_RATE, &AF(InitEnemyFireball), &s_GoroSpell[5]}, + {SPR_GORO_SPELL, 'B', GORO_SPELL_RATE, &AF(NullGoro), &s_GoroSpell[6]}, + {SPR_GORO_SPELL, 'B', GORO_SPELL_RATE, &AF(InitEnemyFireball), &s_GoroSpell[7]}, + {SPR_GORO_SPELL, 'B', GORO_SPELL_PAUSE, &AF(NullGoro), &s_GoroSpell[8]}, + {SPR_GORO_SPELL, 'B', 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_GoroSpell[9]}, + {SPR_GORO_SPELL, 'B', GORO_SPELL_RATE, &AF(DoGoroMove), &s_GoroSpell[9]}, }; -STATE* sg_GoroSpell[] = -{ - &s_GoroSpell[0][0], -}; - ////////////////////// // // GORO STAND @@ -199,19 +174,12 @@ STATE* sg_GoroSpell[] = #define GORO_STAND_RATE 12 -STATE s_GoroStand[1][1] = +FState s_GoroStand[] = { - { - {SPR_GORO_STAND, 'A', GORO_STAND_RATE, &AF(DoGoroMove), &s_GoroStand[0][0]}, - }, + {SPR_GORO_STAND, 'A', GORO_STAND_RATE, &AF(DoGoroMove), &s_GoroStand[0]}, }; -STATE* sg_GoroStand[] = -{ - s_GoroStand[0], -}; - ////////////////////// // // GORO PAIN @@ -220,19 +188,12 @@ STATE* sg_GoroStand[] = #define GORO_PAIN_RATE 12 -STATE s_GoroPain[1][1] = +FState s_GoroPain[] = { - { - {SPR_GORO_STAND, 'A', GORO_PAIN_RATE, &AF(DoGoroPain), &s_GoroPain[0][0]}, - }, + {SPR_GORO_STAND, 'A', GORO_PAIN_RATE, &AF(DoGoroPain), &s_GoroPain[0]}, }; -STATE* sg_GoroPain[] = -{ - s_GoroPain[0], -}; - ////////////////////// // // GORO DIE @@ -241,7 +202,7 @@ STATE* sg_GoroPain[] = #define GORO_DIE_RATE 16 -STATE s_GoroDie[] = +FState s_GoroDie[] = { {SPR_GORO_DIE, 'A', GORO_DIE_RATE, &AF(NullGoro), &s_GoroDie[1]}, {SPR_GORO_DIE, 'B', GORO_DIE_RATE, &AF(NullGoro), &s_GoroDie[2]}, @@ -256,66 +217,56 @@ STATE s_GoroDie[] = {SPR_GORO_DEAD, 'A', GORO_DIE_RATE, &AF(DoActorDebris), &s_GoroDie[10]}, }; -STATE s_GoroDead[] = +FState s_GoroDead[] = { {SPR_GORO_DEAD, 'A', GORO_DIE_RATE, &AF(DoActorDebris), &s_GoroDead[0]}, }; -STATE* sg_GoroDie[] = -{ - s_GoroDie -}; - -STATE* sg_GoroDead[] = -{ - s_GoroDead -}; - /* -STATE* *Stand[MAX_WEAPONS]; -STATE* *Run; -STATE* *Jump; -STATE* *Fall; -STATE* *Crawl; -STATE* *Swim; -STATE* *Fly; -STATE* *Rise; -STATE* *Sit; -STATE* *Look; -STATE* *Climb; -STATE* *Pain; -STATE* *Death1; -STATE* *Death2; -STATE* *Dead; -STATE* *DeathJump; -STATE* *DeathFall; -STATE* *CloseAttack[2]; -STATE* *Attack[6]; -STATE* *Special[2]; +FState* *Stand[MAX_WEAPONS]; +FState* *Run; +FState* *Jump; +FState* *Fall; +FState* *Crawl; +FState* *Swim; +FState* *Fly; +FState* *Rise; +FState* *Sit; +FState* *Look; +FState* *Climb; +FState* *Pain; +FState* *Death1; +FState* *Death2; +FState* *Dead; +FState* *DeathJump; +FState* *DeathFall; +FState* *CloseAttack[2]; +FState* *Attack[6]; +FState* *Special[2]; */ ACTOR_ACTION_SET GoroActionSet = { - sg_GoroStand, - sg_GoroRun, - nullptr, //sg_GoroJump, - nullptr, //sg_GoroFall, - nullptr, //sg_GoroCrawl, - nullptr, //sg_GoroSwim, - nullptr, //sg_GoroFly, - nullptr, //sg_GoroRise, - nullptr, //sg_GoroSit, - nullptr, //sg_GoroLook, + s_GoroStand, + s_GoroRun, + nullptr, //s_GoroJump, + nullptr, //s_GoroFall, + nullptr, //s_GoroCrawl, + nullptr, //s_GoroSwim, + nullptr, //s_GoroFly, + nullptr, //s_GoroRise, + nullptr, //s_GoroSit, + nullptr, //s_GoroLook, nullptr, //climb - sg_GoroPain, - sg_GoroDie, - nullptr, //sg_GoroHariKari, - sg_GoroDead, - nullptr, //sg_GoroDeathJump, - nullptr, //sg_GoroDeathFall, - {sg_GoroChop}, + s_GoroPain, + s_GoroDie, + nullptr, //s_GoroHariKari, + s_GoroDead, + nullptr, //s_GoroDeathJump, + nullptr, //s_GoroDeathFall, + {s_GoroChop}, {1024}, - {sg_GoroSpell}, + {s_GoroSpell}, {1024}, {nullptr,nullptr}, nullptr, @@ -340,7 +291,7 @@ int SetupGoro(DSWActor* actor) actor->user.__legacyState.Attrib = &GoroAttrib; DoActorSetSpeed(actor, NORM_SPEED); actor->user.__legacyState.StateEnd = s_GoroDie; - actor->user.__legacyState.Rot = sg_GoroRun; + actor->user.__legacyState.Rot = s_GoroRun; EnemyDefaults(actor, &GoroActionSet, &GoroPersonality); @@ -428,19 +379,12 @@ static saveable_data saveable_goro_data[] = SAVE_DATA(GoroAttrib), SAVE_DATA(s_GoroRun), - SAVE_DATA(sg_GoroRun), SAVE_DATA(s_GoroChop), - SAVE_DATA(sg_GoroChop), SAVE_DATA(s_GoroSpell), - SAVE_DATA(sg_GoroSpell), SAVE_DATA(s_GoroStand), - SAVE_DATA(sg_GoroStand), SAVE_DATA(s_GoroPain), - SAVE_DATA(sg_GoroPain), SAVE_DATA(s_GoroDie), SAVE_DATA(s_GoroDead), - SAVE_DATA(sg_GoroDie), - SAVE_DATA(sg_GoroDead), SAVE_DATA(GoroActionSet), }; diff --git a/source/games/sw/src/hornet.cpp b/source/games/sw/src/hornet.cpp index d619850b8..1f34e8afb 100644 --- a/source/games/sw/src/hornet.cpp +++ b/source/games/sw/src/hornet.cpp @@ -119,17 +119,10 @@ ATTRIBUTE HornetAttrib = #define HORNET_RUN_RATE 7 -STATE s_HornetRun[1][2] = +FState s_HornetRun[] = { - { - {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]}, - }, -}; - -STATE* sg_HornetRun[] = -{ - &s_HornetRun[0][0], + {SPR_HORNET_RUN, 'A', HORNET_RUN_RATE, &AF(DoHornetMove), &s_HornetRun[1]}, + {SPR_HORNET_RUN, 'B', HORNET_RUN_RATE, &AF(DoHornetMove), &s_HornetRun[0]}, }; ////////////////////// @@ -140,17 +133,10 @@ STATE* sg_HornetRun[] = #define HORNET_STAND_RATE (HORNET_RUN_RATE + 5) -STATE s_HornetStand[1][2] = +FState s_HornetStand[] = { - { - {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]} - }, -}; - -STATE* sg_HornetStand[] = -{ - &s_HornetStand[0][0], + {SPR_HORNET_RUN, 'A', HORNET_STAND_RATE, &AF(DoHornetMove), &s_HornetStand[1]}, + {SPR_HORNET_RUN, 'B', HORNET_STAND_RATE, &AF(DoHornetMove), &s_HornetStand[0]} }; ////////////////////// @@ -160,53 +146,43 @@ STATE* sg_HornetStand[] = ////////////////////// #define HORNET_DIE_RATE 20 -STATE s_HornetDie[] = +FState s_HornetDie[] = { {SPR_HORNET_DIE, 'A', HORNET_DIE_RATE, &AF(DoHornetDeath), &s_HornetDie[0]}, }; -STATE* sg_HornetDie[] = -{ - s_HornetDie -}; - -STATE s_HornetDead[] = +FState s_HornetDead[] = { {SPR_HORNET_DEAD, 'A', HORNET_DIE_RATE, &AF(DoActorDebris), &s_HornetDead[0]}, }; -STATE* sg_HornetDead[] = -{ - s_HornetDead -}; - /* -STATE* *Stand[MAX_WEAPONS]; -STATE* *Run; -STATE* *Jump; -STATE* *Fall; -STATE* *Crawl; -STATE* *Swim; -STATE* *Fly; -STATE* *Rise; -STATE* *Sit; -STATE* *Look; -STATE* *Climb; -STATE* *Pain; -STATE* *Death1; -STATE* *Death2; -STATE* *Dead; -STATE* *DeathJump; -STATE* *DeathFall; -STATE* *CloseAttack[2]; -STATE* *Attack[6]; -STATE* *Special[2]; +FState* *Stand[MAX_WEAPONS]; +FState* *Run; +FState* *Jump; +FState* *Fall; +FState* *Crawl; +FState* *Swim; +FState* *Fly; +FState* *Rise; +FState* *Sit; +FState* *Look; +FState* *Climb; +FState* *Pain; +FState* *Death1; +FState* *Death2; +FState* *Dead; +FState* *DeathJump; +FState* *DeathFall; +FState* *CloseAttack[2]; +FState* *Attack[6]; +FState* *Special[2]; */ ACTOR_ACTION_SET HornetActionSet = { - sg_HornetStand, - sg_HornetRun, + s_HornetStand, + s_HornetRun, nullptr, nullptr, nullptr, @@ -217,9 +193,9 @@ ACTOR_ACTION_SET HornetActionSet = nullptr, nullptr, //climb nullptr, //pain - sg_HornetDie, + s_HornetDie, nullptr, - sg_HornetDead, + s_HornetDead, nullptr, nullptr, {nullptr}, @@ -252,7 +228,7 @@ int SetupHornet(DSWActor* actor) actor->user.__legacyState.Attrib = &HornetAttrib; DoActorSetSpeed(actor, NORM_SPEED); actor->user.__legacyState.StateEnd = s_HornetDie; - actor->user.__legacyState.Rot = sg_HornetRun; + actor->user.__legacyState.Rot = s_HornetRun; EnemyDefaults(actor, &HornetActionSet, &HornetPersonality); @@ -594,13 +570,9 @@ static saveable_data saveable_hornet_data[] = SAVE_DATA(HornetAttrib), SAVE_DATA(s_HornetRun), - SAVE_DATA(sg_HornetRun), SAVE_DATA(s_HornetStand), - SAVE_DATA(sg_HornetStand), SAVE_DATA(s_HornetDie), - SAVE_DATA(sg_HornetDie), SAVE_DATA(s_HornetDead), - SAVE_DATA(sg_HornetDead), SAVE_DATA(HornetActionSet), }; diff --git a/source/games/sw/src/jweapon.cpp b/source/games/sw/src/jweapon.cpp index 98ce826b2..d3c9a364b 100644 --- a/source/games/sw/src/jweapon.cpp +++ b/source/games/sw/src/jweapon.cpp @@ -45,10 +45,10 @@ BEGIN_SW_NS void SpawnFlashBombOnActor(DSWActor* actor); -extern STATE s_Puff[]; -extern STATE s_FireballFlames[]; -extern STATE s_GoreFloorSplash[]; -extern STATE s_GoreSplash[]; +extern FState s_Puff[]; +extern FState s_FireballFlames[]; +extern FState s_GoreFloorSplash[]; +extern FState s_GoreSplash[]; extern bool GlobalSkipZrange; #define CHEMTICS SEC(40) @@ -56,7 +56,7 @@ extern bool GlobalSkipZrange; #define GOREDrip 1562 //2430 #define BLOODSPRAY_RATE 20 -STATE s_BloodSpray[] = +FState s_BloodSpray[] = { {SPR_GOREDrip, 'A', BLOODSPRAY_RATE, &AF(BloodSprayFall), &s_BloodSpray[1]}, {SPR_GOREDrip, 'B', BLOODSPRAY_RATE, &AF(BloodSprayFall), &s_BloodSpray[2]}, @@ -67,7 +67,7 @@ STATE s_BloodSpray[] = #define EXP_RATE 2 -STATE s_PhosphorExp[] = +FState s_PhosphorExp[] = { {SPR_EXP, 'A', EXP_RATE, nullptr, &s_PhosphorExp[1]}, {SPR_EXP, 'B', EXP_RATE, nullptr, &s_PhosphorExp[2]}, @@ -94,7 +94,7 @@ STATE s_PhosphorExp[] = #define MUSHROOM_RATE 25 -STATE s_NukeMushroom[] = +FState s_NukeMushroom[] = { {SPR_MUSHROOM_CLOUD, 'A', MUSHROOM_RATE, nullptr, &s_NukeMushroom[1]}, {SPR_MUSHROOM_CLOUD, 'B', MUSHROOM_RATE, nullptr, &s_NukeMushroom[2]}, @@ -120,7 +120,7 @@ STATE s_NukeMushroom[] = #define RADIATION_RATE 16 -STATE s_RadiationCloud[] = +FState s_RadiationCloud[] = { {SPR_RADIATION_CLOUD, 'A', RADIATION_RATE, &AF(DoRadiationCloud), &s_RadiationCloud[1]}, {SPR_RADIATION_CLOUD, 'B', RADIATION_RATE, &AF(DoRadiationCloud), &s_RadiationCloud[2]}, @@ -147,7 +147,7 @@ STATE s_RadiationCloud[] = #define CHEMBOMB_RATE 8 -STATE s_ChemBomb[1] = +FState s_ChemBomb[1] = { {SPR_CHEMBOMB, 'A', CHEMBOMB_RATE, &AF(DoChemBomb), &s_ChemBomb[1]}, }; @@ -155,14 +155,14 @@ STATE s_ChemBomb[1] = #define CALTROPS_RATE 8 -STATE s_Caltrops[] = +FState s_Caltrops[] = { {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[] = +FState s_CaltropsStick[] = { {SPR_CALTROPSR, 'C', CALTROPS_RATE, &AF(DoCaltropsStick), &s_CaltropsStick[0]}, }; @@ -175,21 +175,21 @@ STATE s_CaltropsStick[] = #define FLAG_RATE 16 -STATE s_CarryFlag[] = +FState s_CarryFlag[] = { {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[] = +FState s_CarryFlagNoDet[] = { {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[] = +FState s_Flag[] = { {SPR_FLAG, 'A', FLAG_RATE, &AF(DoFlag), &s_Flag[1]}, {SPR_FLAG, 'B', FLAG_RATE, &AF(DoFlag), &s_Flag[2]}, @@ -198,13 +198,13 @@ STATE s_Flag[] = #define PHOSPHORUS_RATE 8 -STATE s_Phosphorus[] = +FState s_Phosphorus[] = { {SPR_PHOSPHORUS, 'A', PHOSPHORUS_RATE, &AF(DoPhosphorus), &s_Phosphorus[1]}, {SPR_PHOSPHORUS, 'B', PHOSPHORUS_RATE, &AF(DoPhosphorus), &s_Phosphorus[0]}, }; -STATE s_BloodSprayChunk[] = +FState s_BloodSprayChunk[] = { {SPR_CHUNK1, 'A', 8, &AF(DoBloodSpray), &s_BloodSprayChunk[1]}, {SPR_CHUNK1, 'B', 8, &AF(DoBloodSpray), &s_BloodSprayChunk[2]}, @@ -214,7 +214,7 @@ STATE s_BloodSprayChunk[] = {SPR_CHUNK1, 'F', 8, &AF(DoBloodSpray), &s_BloodSprayChunk[0]}, }; -STATE s_BloodSprayDrip[] = +FState s_BloodSprayDrip[] = { {SPR_DRIP, 'A', PHOSPHORUS_RATE, &AF(DoWallBloodDrip), &s_BloodSprayDrip[1]}, {SPR_DRIP, 'B', PHOSPHORUS_RATE, &AF(DoWallBloodDrip), &s_BloodSprayDrip[2]}, @@ -2139,9 +2139,9 @@ int SpawnShell(DSWActor* actor, int ShellNum) { short id = 0; double velocity = 0; - STATE* p=nullptr; - extern STATE s_UziShellShrap[]; - extern STATE s_ShotgunShellShrap[]; + FState* p=nullptr; + extern FState s_UziShellShrap[]; + extern FState s_ShotgunShellShrap[]; switch (ShellNum) { diff --git a/source/games/sw/src/lava.cpp b/source/games/sw/src/lava.cpp index 34893156c..6f174b4ea 100644 --- a/source/games/sw/src/lava.cpp +++ b/source/games/sw/src/lava.cpp @@ -127,17 +127,9 @@ ATTRIBUTE LavaPissedAttrib = ////////////////////// #define LAVA_STAND_RATE 12 -STATE s_LavaStand[1][1] = +FState s_LavaStand[] = { - { - {SPR_LAVA_RUN, 'A', LAVA_STAND_RATE, &AF(DoLavaMove), &s_LavaStand[0][0]}, - }, -}; - - -STATE* sg_LavaStand[] = -{ - s_LavaStand[0], + {SPR_LAVA_RUN, 'A', LAVA_STAND_RATE, &AF(DoLavaMove), &s_LavaStand[0]}, }; @@ -150,22 +142,15 @@ STATE* sg_LavaStand[] = #define LAVA_RUN_RATE 24 -STATE s_LavaRun[1][4] = +FState s_LavaRun[] = { - { - {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]}, - }, + {SPR_LAVA_RUN, 'A', LAVA_RUN_RATE, &AF(DoLavaMove), &s_LavaRun[1]}, + {SPR_LAVA_RUN, 'A', LAVA_RUN_RATE, &AF(DoLavaMove), &s_LavaRun[2]}, + {SPR_LAVA_RUN, 'A', LAVA_RUN_RATE, &AF(DoLavaMove), &s_LavaRun[3]}, + {SPR_LAVA_RUN, 'A', LAVA_RUN_RATE, &AF(DoLavaMove), &s_LavaRun[0]}, }; -STATE* sg_LavaRun[] = -{ - &s_LavaRun[0][0], -}; - ////////////////////// // // LAVA THROW @@ -174,32 +159,21 @@ STATE* sg_LavaRun[] = #define LAVA_THROW_RATE 9 -STATE s_LavaThrow[1][10] = +FState s_LavaThrow[] = { - { - {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]}, - }, + {SPR_LAVA_THROW, 'A', LAVA_THROW_RATE, &AF(NullLava), &s_LavaThrow[1]}, + {SPR_LAVA_THROW, 'A', LAVA_THROW_RATE, &AF(NullLava), &s_LavaThrow[2]}, + {SPR_LAVA_THROW, 'A', LAVA_THROW_RATE*2, &AF(NullLava), &s_LavaThrow[3]}, + {SPR_LAVA_THROW, 'A', LAVA_THROW_RATE, &AF(NullLava), &s_LavaThrow[4]}, + {SPR_LAVA_THROW, 'A', LAVA_THROW_RATE, &AF(NullLava), &s_LavaThrow[5]}, + {SPR_LAVA_THROW, 'A', SF_QUICK_CALL, &AF(InitLavaThrow), &s_LavaThrow[6]}, + {SPR_LAVA_THROW, 'A', LAVA_THROW_RATE, &AF(NullLava), &s_LavaThrow[7]}, + {SPR_LAVA_THROW, 'A', LAVA_THROW_RATE, &AF(NullLava), &s_LavaThrow[8]}, + {SPR_LAVA_THROW, 'A', 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_LavaThrow[9]}, + {SPR_LAVA_THROW, 'A', LAVA_THROW_RATE, &AF(DoLavaMove), &s_LavaThrow[9]}, }; -STATE* sg_LavaThrow[] = -{ - &s_LavaThrow[0][0], - &s_LavaThrow[1][0], - &s_LavaThrow[2][0], - &s_LavaThrow[3][0], - &s_LavaThrow[4][0] -}; - ////////////////////// // @@ -209,26 +183,19 @@ STATE* sg_LavaThrow[] = #define LAVA_FLAME_RATE 18 -STATE s_LavaFlame[1][8] = +FState s_LavaFlame[] = { - { - {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]}, - }, + {SPR_LAVA_FLAME, 'A', LAVA_FLAME_RATE*2, &AF(NullLava), &s_LavaFlame[1]}, + {SPR_LAVA_FLAME, 'A', LAVA_FLAME_RATE, &AF(NullLava), &s_LavaFlame[2]}, + {SPR_LAVA_FLAME, 'A', LAVA_FLAME_RATE*2, &AF(NullLava), &s_LavaFlame[3]}, + {SPR_LAVA_FLAME, 'A', SF_QUICK_CALL, &AF(InitLavaFlame), &s_LavaFlame[4]}, + {SPR_LAVA_FLAME, 'A', LAVA_FLAME_RATE, &AF(NullLava), &s_LavaFlame[5]}, + {SPR_LAVA_FLAME, 'A', LAVA_FLAME_RATE, &AF(NullLava), &s_LavaFlame[6]}, + {SPR_LAVA_FLAME, 'A', SF_QUICK_CALL, &AF(InitActorDecide), &s_LavaFlame[7]}, + {SPR_LAVA_FLAME, 'A', LAVA_FLAME_RATE, &AF(DoLavaMove), &s_LavaFlame[7]}, }; -STATE* sg_LavaFlame[] = -{ - &s_LavaFlame[0][0], -}; - ////////////////////// // // LAVA DIE @@ -237,73 +204,63 @@ STATE* sg_LavaFlame[] = #define LAVA_DIE_RATE 20 -STATE s_LavaDie[] = +FState s_LavaDie[] = { {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[] = +FState s_LavaDead[] = { {SPR_LAVA_DEAD, 'A', LAVA_DIE_RATE, &AF(DoActorDebris), &s_LavaDead[0]}, }; -STATE* sg_LavaDie[] = -{ - s_LavaDie -}; - -STATE* sg_LavaDead[] = -{ - s_LavaDead -}; - /* -STATE* *Stand[MAX_WEAPONS]; -STATE* *Run; -STATE* *Jump; -STATE* *Fall; -STATE* *Crawl; -STATE* *Swim; -STATE* *Fly; -STATE* *Rise; -STATE* *Sit; -STATE* *Look; -STATE* *Climb; -STATE* *Pain; -STATE* *Death1; -STATE* *Death2; -STATE* *Dead; -STATE* *DeathJump; -STATE* *DeathFall; -STATE* *CloseAttack[2]; -STATE* *Attack[6]; -STATE* *Special[2]; +FState* *Stand[MAX_WEAPONS]; +FState* *Run; +FState* *Jump; +FState* *Fall; +FState* *Crawl; +FState* *Swim; +FState* *Fly; +FState* *Rise; +FState* *Sit; +FState* *Look; +FState* *Climb; +FState* *Pain; +FState* *Death1; +FState* *Death2; +FState* *Dead; +FState* *DeathJump; +FState* *DeathFall; +FState* *CloseAttack[2]; +FState* *Attack[6]; +FState* *Special[2]; */ ACTOR_ACTION_SET LavaActionSet = { - sg_LavaStand, - sg_LavaRun, - nullptr, //sg_LavaJump, - nullptr, //sg_LavaFall, - nullptr, //sg_LavaCrawl, - nullptr, //sg_LavaSwim, - nullptr, //sg_LavaFly, - nullptr, //sg_LavaRise, - nullptr, //sg_LavaSit, - nullptr, //sg_LavaLook, + s_LavaStand, + s_LavaRun, + nullptr, //s_LavaJump, + nullptr, //s_LavaFall, + nullptr, //s_LavaCrawl, + nullptr, //s_LavaSwim, + nullptr, //s_LavaFly, + nullptr, //s_LavaRise, + nullptr, //s_LavaSit, + nullptr, //s_LavaLook, nullptr, //climb nullptr, //pain - sg_LavaDie, - nullptr, //sg_LavaHariKari, - sg_LavaDead, - nullptr, //sg_LavaDeathJump, - nullptr, //sg_LavaDeathFall, - {sg_LavaFlame}, + s_LavaDie, + nullptr, //s_LavaHariKari, + s_LavaDead, + nullptr, //s_LavaDeathJump, + nullptr, //s_LavaDeathFall, + {s_LavaFlame}, {1024}, - {sg_LavaFlame, sg_LavaThrow, sg_LavaThrow, sg_LavaThrow}, + {s_LavaFlame, s_LavaThrow, s_LavaThrow, s_LavaThrow}, {256, 512, 768, 1024}, {nullptr}, nullptr, @@ -328,7 +285,7 @@ int SetupLava(DSWActor* actor) actor->user.__legacyState.Attrib = &LavaAttrib; DoActorSetSpeed(actor, NORM_SPEED); actor->user.__legacyState.StateEnd = s_LavaDie; - actor->user.__legacyState.Rot = sg_LavaRun; + actor->user.__legacyState.Rot = s_LavaRun; EnemyDefaults(actor, &LavaActionSet, &LavaPersonality); actor->spr.scale = DVector2(1.71875, 1.71875); @@ -403,17 +360,11 @@ static saveable_data saveable_lava_data[] = SAVE_DATA(LavaPissedAttrib), SAVE_DATA(s_LavaStand), - SAVE_DATA(sg_LavaStand), SAVE_DATA(s_LavaRun), - SAVE_DATA(sg_LavaRun), SAVE_DATA(s_LavaThrow), - SAVE_DATA(sg_LavaThrow), SAVE_DATA(s_LavaFlame), - SAVE_DATA(sg_LavaFlame), SAVE_DATA(s_LavaDie), SAVE_DATA(s_LavaDead), - SAVE_DATA(sg_LavaDie), - SAVE_DATA(sg_LavaDead), SAVE_DATA(LavaActionSet), }; diff --git a/source/games/sw/src/miscactr.cpp b/source/games/sw/src/miscactr.cpp index 1f1fd4fab..3f92284e3 100644 --- a/source/games/sw/src/miscactr.cpp +++ b/source/games/sw/src/miscactr.cpp @@ -55,7 +55,7 @@ ATTRIBUTE ToiletGirlAttrib = ////////////////////// #define TOILETGIRL_RATE 60 -STATE s_ToiletGirlStand[2] = +FState s_ToiletGirlStand[2] = { {SPR_TOILETGIRL, 'A', TOILETGIRL_RATE, &AF(DoToiletGirl), &s_ToiletGirlStand[1]}, {SPR_TOILETGIRL, 'B', TOILETGIRL_RATE, &AF(DoToiletGirl), &s_ToiletGirlStand[0]} @@ -68,7 +68,7 @@ STATE s_ToiletGirlStand[2] = ////////////////////// #define TOILETGIRL_PAIN_RATE 32 -STATE s_ToiletGirlPain[2] = +FState s_ToiletGirlPain[2] = { {SPR_TOILETGIRL, 'A', TOILETGIRL_PAIN_RATE, &AF(ToiletGirlPain), &s_ToiletGirlPain[1]}, {SPR_TOILETGIRL, 'A', 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_ToiletGirlPain[0]} @@ -83,7 +83,7 @@ STATE s_ToiletGirlPain[2] = #define TOILETGIRL_UZI_RATE 8 #define TOILETGIRL_FIRE_R0 TOILETGIRL, 'C' -STATE s_ToiletGirlUzi[16] = +FState s_ToiletGirlUzi[16] = { {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]}, @@ -302,14 +302,14 @@ ATTRIBUTE WashGirlAttrib = ////////////////////// #define WASHGIRL_RATE 60 -STATE s_WashGirlStand[2] = +FState s_WashGirlStand[2] = { {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] = +FState s_WashGirlStandScrub[2] = { {SPR_WASHGIRL, 'A', WASHGIRL_RATE2, &AF(DoWashGirl), &s_WashGirlStandScrub[1]}, {SPR_WASHGIRL, 'B', WASHGIRL_RATE2, &AF(DoWashGirl), &s_WashGirlStandScrub[0]} @@ -323,7 +323,7 @@ STATE s_WashGirlStandScrub[2] = #define WASHGIRL_PAIN_RATE 30 -STATE s_WashGirlPain[2] = +FState s_WashGirlPain[2] = { {SPR_WASHGIRL, 'A', WASHGIRL_PAIN_RATE, &AF(WashGirlPain), &s_WashGirlPain[1]}, {SPR_WASHGIRL, 'A', 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_WashGirlPain[0]} @@ -338,7 +338,7 @@ STATE s_WashGirlPain[2] = #define WASHGIRL_UZI_RATE 8 -STATE s_WashGirlUzi[16] = +FState s_WashGirlUzi[16] = { {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]}, @@ -565,7 +565,7 @@ ATTRIBUTE TrashCanAttrib = #define TRASHCAN_RATE 120 #define TRASHCAN_R0 TRASHCAN -STATE s_TrashCanStand[1] = +FState s_TrashCanStand[1] = { {SPR_TRASHCAN, 'A', TRASHCAN_RATE, &AF(DoTrashCan), &s_TrashCanStand[0]} }; @@ -578,7 +578,7 @@ STATE s_TrashCanStand[1] = #define TRASHCAN_PAIN_RATE 8 -STATE s_TrashCanPain[7] = +FState s_TrashCanPain[7] = { {SPR_TRASHCAN, 'A', TRASHCAN_PAIN_RATE, &AF(TrashCanPain), &s_TrashCanPain[1]}, {SPR_TRASHCAN, 'B', TRASHCAN_PAIN_RATE, &AF(TrashCanPain), &s_TrashCanPain[2]}, @@ -683,12 +683,12 @@ ATTRIBUTE PachinkoLightAttrib = #define PACHINKOLIGHT_RATE 120 -STATE s_PachinkoLightStand[] = +FState s_PachinkoLightStand[] = { {SPR_PACHINKOLIGHT, 'F', PACHINKOLIGHT_RATE, nullptr, &s_PachinkoLightStand[0]} }; -STATE s_PachinkoLightOperate[] = +FState s_PachinkoLightOperate[] = { {SPR_PACHINKOLIGHT, 'F', 12, &AF(PachinkoLightOperate), &s_PachinkoLightOperate[1]}, {SPR_PACHINKOLIGHT, 'E', 12, &AF(PachinkoLightOperate), &s_PachinkoLightOperate[2]}, @@ -775,12 +775,12 @@ ATTRIBUTE Pachinko1Attrib = #define PACHINKO1_RATE 120 #define PACHINKO1_R0 PACHINKO1 -STATE s_Pachinko1Stand[] = +FState s_Pachinko1Stand[] = { {SPR_PACHINKO1, 'A', PACHINKO1_RATE, nullptr, &s_Pachinko1Stand[0]} }; -STATE s_Pachinko1Operate[] = +FState s_Pachinko1Operate[] = { {SPR_PACHINKO1, 'A', 12, &AF(Pachinko1Operate), &s_Pachinko1Operate[1]}, {SPR_PACHINKO1, 'B', 12, &AF(Pachinko1Operate), &s_Pachinko1Operate[2]}, @@ -952,12 +952,12 @@ ATTRIBUTE Pachinko2Attrib = #define PACHINKO2_RATE 120 #define PACHINKO2_R0 PACHINKO2 -STATE s_Pachinko2Stand[] = +FState s_Pachinko2Stand[] = { {SPR_PACHINKO2, 'A', PACHINKO2_RATE, nullptr, &s_Pachinko2Stand[0]} }; -STATE s_Pachinko2Operate[] = +FState s_Pachinko2Operate[] = { {SPR_PACHINKO2, 'A', 12, &AF(Pachinko1Operate), &s_Pachinko2Operate[1]}, {SPR_PACHINKO2, 'B', 12, &AF(Pachinko1Operate), &s_Pachinko2Operate[2]}, @@ -1041,12 +1041,12 @@ ATTRIBUTE Pachinko3Attrib = #define PACHINKO3_RATE 120 #define PACHINKO3_R0 PACHINKO3 -STATE s_Pachinko3Stand[] = +FState s_Pachinko3Stand[] = { {SPR_PACHINKO3, 'A', PACHINKO3_RATE, nullptr, &s_Pachinko3Stand[0]} }; -STATE s_Pachinko3Operate[] = +FState s_Pachinko3Operate[] = { {SPR_PACHINKO3, 'A', 12, &AF(Pachinko1Operate), &s_Pachinko3Operate[1]}, {SPR_PACHINKO3, 'B', 12, &AF(Pachinko1Operate), &s_Pachinko3Operate[2]}, @@ -1130,12 +1130,12 @@ ATTRIBUTE Pachinko4Attrib = #define PACHINKO4_RATE 120 #define PACHINKO4_R0 PACHINKO4 -STATE s_Pachinko4Stand[] = +FState s_Pachinko4Stand[] = { {SPR_PACHINKO4, 'A', PACHINKO4_RATE, nullptr, &s_Pachinko4Stand[0]} }; -STATE s_Pachinko4Operate[] = +FState s_Pachinko4Operate[] = { {SPR_PACHINKO4, 'A', 12, &AF(Pachinko1Operate), &s_Pachinko4Operate[1]}, {SPR_PACHINKO4, 'B', 12, &AF(Pachinko1Operate), &s_Pachinko4Operate[2]}, @@ -1225,7 +1225,7 @@ ATTRIBUTE CarGirlAttrib = ////////////////////// #define CARGIRL_RATE 60 -STATE s_CarGirlStand[2] = +FState s_CarGirlStand[2] = { {SPR_CARGIRL, 'A', CARGIRL_RATE, &AF(DoCarGirl), &s_CarGirlStand[1]}, {SPR_CARGIRL, 'B', CARGIRL_RATE, &AF(DoCarGirl), &s_CarGirlStand[0]} @@ -1240,7 +1240,7 @@ STATE s_CarGirlStand[2] = #define CARGIRL_PAIN_RATE 32 #define CARGIRL_PAIN_R0 CARGIRL_R0 -STATE s_CarGirlPain[2] = +FState s_CarGirlPain[2] = { {SPR_CARGIRL, 'A', CARGIRL_PAIN_RATE, &AF(CarGirlPain), &s_CarGirlPain[1]}, {SPR_CARGIRL, 'A', 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_CarGirlPain[0]} @@ -1254,7 +1254,7 @@ STATE s_CarGirlPain[2] = #define CARGIRL_UZI_RATE 8 -STATE s_CarGirlUzi[16] = +FState s_CarGirlUzi[16] = { {SPR_CARGIRL_FIRE, 'A', 240, &AF(CarGirlUzi), &s_CarGirlUzi[1]}, {SPR_CARGIRL_FIRE, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_CarGirlUzi[2]}, @@ -1472,7 +1472,7 @@ ATTRIBUTE MechanicGirlAttrib = ////////////////////// #define MECHANICGIRL_RATE 60 -STATE s_MechanicGirlStand[2] = +FState s_MechanicGirlStand[2] = { {SPR_MECHANICGIRL, 'A', MECHANICGIRL_RATE, &AF(DoMechanicGirl), &s_MechanicGirlStand[1]}, {SPR_MECHANICGIRL, 'B', MECHANICGIRL_RATE, &AF(DoMechanicGirl), &s_MechanicGirlStand[0]} @@ -1486,7 +1486,7 @@ STATE s_MechanicGirlStand[2] = #define MECHANICGIRL_PAIN_RATE 32 -STATE s_MechanicGirlPain[2] = +FState s_MechanicGirlPain[2] = { {SPR_MECHANICGIRL, 'A', MECHANICGIRL_PAIN_RATE, &AF(MechanicGirlPain), &s_MechanicGirlPain[1]}, {SPR_MECHANICGIRL, 'A', 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_MechanicGirlPain[0]} @@ -1500,7 +1500,7 @@ STATE s_MechanicGirlPain[2] = #define MECHANICGIRL_DRILL_RATE 32 -STATE s_MechanicGirlDrill[2] = +FState s_MechanicGirlDrill[2] = { {SPR_MECHANICGIRL_DRILL, 'A', MECHANICGIRL_DRILL_RATE, &AF(MechanicGirlDrill), &s_MechanicGirlDrill[1]}, {SPR_MECHANICGIRL_DRILL, 'B', MECHANICGIRL_DRILL_RATE, &AF(MechanicGirlDrill), &s_MechanicGirlDrill[0]}, @@ -1704,7 +1704,7 @@ ATTRIBUTE SailorGirlAttrib = ////////////////////// #define SAILORGIRL_RATE 60 -STATE s_SailorGirlStand[2] = +FState s_SailorGirlStand[2] = { {SPR_SAILORGIRL, 'A', SAILORGIRL_RATE, &AF(DoSailorGirl), &s_SailorGirlStand[1]}, {SPR_SAILORGIRL, 'B', SAILORGIRL_RATE, &AF(DoSailorGirl), &s_SailorGirlStand[0]} @@ -1718,7 +1718,7 @@ STATE s_SailorGirlStand[2] = #define SAILORGIRL_PAIN_RATE 32 -STATE s_SailorGirlPain[2] = +FState s_SailorGirlPain[2] = { {SPR_SAILORGIRL, 'A', SAILORGIRL_PAIN_RATE, &AF(SailorGirlPain), &s_SailorGirlPain[1]}, {SPR_SAILORGIRL, 'A', 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_SailorGirlPain[0]} @@ -1732,7 +1732,7 @@ STATE s_SailorGirlPain[2] = #define SAILORGIRL_UZI_RATE 128 -STATE s_SailorGirlThrow[] = +FState s_SailorGirlThrow[] = { {SPR_SAILORGIRL_FIRE, 'A', SAILORGIRL_UZI_RATE, &AF(SailorGirlThrow), &s_SailorGirlThrow[0]}, }; @@ -1948,7 +1948,7 @@ ATTRIBUTE PruneGirlAttrib = ////////////////////// #define PRUNEGIRL_RATE 60 -STATE s_PruneGirlStand[2] = +FState s_PruneGirlStand[2] = { {SPR_PRUNEGIRL, 'A', PRUNEGIRL_RATE, &AF(DoPruneGirl), &s_PruneGirlStand[1]}, {SPR_PRUNEGIRL, 'B', PRUNEGIRL_RATE, &AF(DoPruneGirl), &s_PruneGirlStand[0]} @@ -1962,7 +1962,7 @@ STATE s_PruneGirlStand[2] = #define PRUNEGIRL_PAIN_RATE 32 -STATE s_PruneGirlPain[2] = +FState s_PruneGirlPain[2] = { {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/ninja.cpp b/source/games/sw/src/ninja.cpp index dd99e0ae9..6a658ca2e 100644 --- a/source/games/sw/src/ninja.cpp +++ b/source/games/sw/src/ninja.cpp @@ -185,23 +185,16 @@ ATTRIBUTE InvisibleNinjaAttrib = #define NINJA_RATE 18 -STATE s_NinjaRun[1][4] = +FState s_NinjaRun[] = { - { - {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]}, - }, + {SPR_NINJA_RUN, 'A', NINJA_RATE | SF_TIC_ADJUST, &AF(DoNinjaMove), &s_NinjaRun[1]}, + {SPR_NINJA_RUN, 'B', NINJA_RATE | SF_TIC_ADJUST, &AF(DoNinjaMove), &s_NinjaRun[2]}, + {SPR_NINJA_RUN, 'C', NINJA_RATE | SF_TIC_ADJUST, &AF(DoNinjaMove), &s_NinjaRun[3]}, + {SPR_NINJA_RUN, 'D', NINJA_RATE | SF_TIC_ADJUST, &AF(DoNinjaMove), &s_NinjaRun[0]}, }; -STATE* sg_NinjaRun[] = -{ - s_NinjaRun[0], -}; - ////////////////////// // // NINJA STAND @@ -210,19 +203,12 @@ STATE* sg_NinjaRun[] = #define NINJA_STAND_RATE 10 -STATE s_NinjaStand[1][1] = +FState s_NinjaStand[] = { - { - {SPR_NINJA_STAND, 'A', NINJA_STAND_RATE, &AF(DoNinjaMove), &s_NinjaStand[0][0]}, - }, + {SPR_NINJA_STAND, 'A', NINJA_STAND_RATE, &AF(DoNinjaMove), &s_NinjaStand[0]}, }; -STATE* sg_NinjaStand[] = -{ - s_NinjaStand[0], -}; - ////////////////////// // // NINJA RISE @@ -231,21 +217,14 @@ STATE* sg_NinjaStand[] = #define NINJA_RISE_RATE 10 -STATE s_NinjaRise[1][3] = +FState s_NinjaRise[] = { - { - {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}, - }, + {SPR_NINJA_CRAWL, 'A', NINJA_RISE_RATE, &AF(NullNinja), &s_NinjaRise[1]}, + {SPR_NINJA_STAND, 'A', NINJA_STAND_RATE, &AF(NullNinja), &s_NinjaRise[2]}, + {SPR_NULL, 0, 0, nullptr, &s_NinjaRun[0]}, }; -STATE* sg_NinjaRise[] = -{ - s_NinjaRise[0], -}; - ////////////////////// // @@ -255,22 +234,15 @@ STATE* sg_NinjaRise[] = #define NINJA_CRAWL_RATE 14 -STATE s_NinjaCrawl[1][4] = +FState s_NinjaCrawl[] = { - { - {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]}, - }, + {SPR_NINJA_CRAWL, 'A', NINJA_CRAWL_RATE, &AF(DoNinjaMove), &s_NinjaCrawl[1]}, + {SPR_NINJA_CRAWL, 'B', NINJA_CRAWL_RATE, &AF(DoNinjaMove), &s_NinjaCrawl[2]}, + {SPR_NINJA_CRAWL, 'C', NINJA_CRAWL_RATE, &AF(DoNinjaMove), &s_NinjaCrawl[3]}, + {SPR_NINJA_CRAWL, 'B', NINJA_CRAWL_RATE, &AF(DoNinjaMove), &s_NinjaCrawl[0]}, }; -STATE* sg_NinjaCrawl[] = -{ - s_NinjaCrawl[0], -}; - ////////////////////// // // NINJA KNEEL_CRAWL @@ -279,21 +251,13 @@ STATE* sg_NinjaCrawl[] = #define NINJA_KNEEL_CRAWL_RATE 20 -STATE s_NinjaKneelCrawl[1][5] = +FState s_NinjaKneelCrawl[] = { - { - {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]}, - }, -}; - - -STATE* sg_NinjaKneelCrawl[] = -{ - s_NinjaKneelCrawl[0], + {SPR_NINJA_CRAWL, 'A', NINJA_KNEEL_CRAWL_RATE, &AF(NullNinja), &s_NinjaKneelCrawl[1]}, + {SPR_NINJA_CRAWL, 'A', NINJA_CRAWL_RATE, &AF(DoNinjaMove), &s_NinjaKneelCrawl[2]}, + {SPR_NINJA_CRAWL, 'B', NINJA_CRAWL_RATE, &AF(DoNinjaMove), &s_NinjaKneelCrawl[3]}, + {SPR_NINJA_CRAWL, 'C', NINJA_CRAWL_RATE, &AF(DoNinjaMove), &s_NinjaKneelCrawl[4]}, + {SPR_NINJA_CRAWL, 'B', NINJA_CRAWL_RATE, &AF(DoNinjaMove), &s_NinjaKneelCrawl[1]}, }; @@ -305,18 +269,10 @@ STATE* sg_NinjaKneelCrawl[] = #define NINJA_DUCK_RATE 10 -STATE s_NinjaDuck[1][2] = +FState s_NinjaDuck[] = { - { - {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]}, - }, -}; - - -STATE* sg_NinjaDuck[] = -{ - s_NinjaDuck[0], + {SPR_NINJA_CRAWL, 'A', NINJA_DUCK_RATE, &AF(NullNinja), &s_NinjaDuck[1]}, + {SPR_NINJA_CRAWL, 'A', NINJA_CRAWL_RATE, &AF(DoNinjaMove), &s_NinjaDuck[1]}, }; @@ -326,36 +282,21 @@ STATE* sg_NinjaDuck[] = // ////////////////////// -STATE s_NinjaSit[1][1] = +FState s_NinjaSit[] = { - { - {SPR_NINJA_CRAWL, 'A', NINJA_RISE_RATE, &AF(DoNinjaMove), &s_NinjaSit[0][0]}, - }, + {SPR_NINJA_CRAWL, 'A', NINJA_RISE_RATE, &AF(DoNinjaMove), &s_NinjaSit[0]}, }; -STATE* sg_NinjaSit[] = -{ - s_NinjaSit[0], -}; - ////////////////////// // // NINJA CEILING // ////////////////////// -STATE s_NinjaCeiling[1][1] = +FState s_NinjaCeiling[] = { - { - {SPR_NINJA_CRAWL, 'A', NINJA_RISE_RATE, &AF(DoNinjaCeiling), &s_NinjaCeiling[0][0]}, - }, -}; - - -STATE* sg_NinjaCeiling[] = -{ - s_NinjaCeiling[0], + {SPR_NINJA_CRAWL, 'A', NINJA_RISE_RATE, &AF(DoNinjaCeiling), &s_NinjaCeiling[0]}, }; @@ -367,18 +308,10 @@ STATE* sg_NinjaCeiling[] = #define NINJA_JUMP_RATE 24 -STATE s_NinjaJump[1][2] = +FState s_NinjaJump[] = { - { - {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]}, - }, -}; - - -STATE* sg_NinjaJump[] = -{ - s_NinjaJump[0], + {SPR_NINJA_JUMP, 'A', NINJA_JUMP_RATE, &AF(DoNinjaMove), &s_NinjaJump[1]}, + {SPR_NINJA_JUMP, 'B', NINJA_JUMP_RATE, &AF(DoNinjaMove), &s_NinjaJump[1]}, }; @@ -390,20 +323,13 @@ STATE* sg_NinjaJump[] = #define NINJA_FALL_RATE 16 -STATE s_NinjaFall[1][2] = +FState s_NinjaFall[] = { - { - {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]}, - }, + {SPR_NINJA_JUMP, 'B', NINJA_FALL_RATE, &AF(DoNinjaMove), &s_NinjaFall[1]}, + {SPR_NINJA_JUMP, 'C', NINJA_FALL_RATE, &AF(DoNinjaMove), &s_NinjaFall[1]}, }; -STATE* sg_NinjaFall[] = -{ - s_NinjaFall[0], -}; - ////////////////////// // // NINJA SWIM @@ -412,21 +338,14 @@ STATE* sg_NinjaFall[] = #define NINJA_SWIM_RATE 18 -STATE s_NinjaSwim[1][3] = +FState s_NinjaSwim[] = { - { - {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]}, - }, + {SPR_NINJA_SWIM, 'B', NINJA_SWIM_RATE, &AF(DoNinjaMove), &s_NinjaSwim[1]}, + {SPR_NINJA_SWIM, 'C', NINJA_SWIM_RATE, &AF(DoNinjaMove), &s_NinjaSwim[2]}, + {SPR_NINJA_SWIM, 'D', NINJA_SWIM_RATE, &AF(DoNinjaMove), &s_NinjaSwim[0]}, }; -STATE* sg_NinjaSwim[] = -{ - s_NinjaSwim[0], -}; - ////////////////////// // // NINJA DIVE @@ -436,19 +355,12 @@ STATE* sg_NinjaSwim[] = #define NINJA_DIVE_RATE 23 -STATE s_NinjaDive[1][4] = +FState s_NinjaDive[] = { - { - {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], + {SPR_NINJA_SWIM, 'A', NINJA_DIVE_RATE, &AF(DoNinjaMove), &s_NinjaDive[1]}, + {SPR_NINJA_SWIM, 'B', NINJA_DIVE_RATE, &AF(DoNinjaMove), &s_NinjaDive[2]}, + {SPR_NINJA_SWIM, 'C', NINJA_DIVE_RATE, &AF(DoNinjaMove), &s_NinjaDive[3]}, + {SPR_NINJA_SWIM, 'D', NINJA_DIVE_RATE, &AF(DoNinjaMove), &s_NinjaDive[0]}, }; ////////////////////// @@ -459,22 +371,14 @@ STATE* sg_NinjaDive[] = #define NINJA_CLIMB_RATE 20 -STATE s_NinjaClimb[1][4] = +FState s_NinjaClimb[] = { - { - {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]}, - }, + {SPR_NINJA_CLIMB, 'A', NINJA_CLIMB_RATE, &AF(DoNinjaMove), &s_NinjaClimb[1]}, + {SPR_NINJA_CLIMB, 'B', NINJA_CLIMB_RATE, &AF(DoNinjaMove), &s_NinjaClimb[2]}, + {SPR_NINJA_CLIMB, 'C', NINJA_CLIMB_RATE, &AF(DoNinjaMove), &s_NinjaClimb[3]}, + {SPR_NINJA_CLIMB, 'D', NINJA_CLIMB_RATE, &AF(DoNinjaMove), &s_NinjaClimb[0]}, }; -STATE* sg_NinjaClimb[] = -{ - s_NinjaClimb[0], -}; - - ////////////////////// // // NINJA FLY @@ -483,16 +387,9 @@ STATE* sg_NinjaClimb[] = #define NINJA_FLY_RATE 12 -STATE s_NinjaFly[1][1] = +FState s_NinjaFly[] = { - { - {SPR_NINJA_FLY, 'A', NINJA_FLY_RATE, &AF(DoNinjaMove), &s_NinjaFly[0][0]}, - }, -}; - -STATE* sg_NinjaFly[] = -{ - s_NinjaFly[0], + {SPR_NINJA_FLY, 'A', NINJA_FLY_RATE, &AF(DoNinjaMove), &s_NinjaFly[0]}, }; ////////////////////// @@ -503,17 +400,10 @@ STATE* sg_NinjaFly[] = #define NINJA_PAIN_RATE 15 -STATE s_NinjaPain[1][2] = +FState s_NinjaPain[] = { - { - {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], + {SPR_NINJA_PAIN, 'A', NINJA_PAIN_RATE, &AF(DoNinjaPain), &s_NinjaPain[1]}, + {SPR_NINJA_PAIN, 'B', NINJA_PAIN_RATE, &AF(DoNinjaPain), &s_NinjaPain[1]}, }; ////////////////////// @@ -524,21 +414,14 @@ STATE* sg_NinjaPain[] = #define NINJA_STAR_RATE 18 -STATE s_NinjaStar[1][6] = +FState s_NinjaStar[] = { - { - {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], + {SPR_NINJA_THROW, 'A', NINJA_STAR_RATE * 2, &AF(NullNinja), &s_NinjaStar[1]}, + {SPR_NINJA_THROW, 'A', NINJA_STAR_RATE, &AF(NullNinja), &s_NinjaStar[2]}, + {SPR_NINJA_THROW, 'B', 0 | SF_QUICK_CALL, &AF(InitEnemyStar), &s_NinjaStar[3]}, + {SPR_NINJA_THROW, 'B', NINJA_STAR_RATE * 2, &AF(NullNinja), &s_NinjaStar[4]}, + {SPR_NINJA_THROW, 'C', 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_NinjaStar[5]}, + {SPR_NINJA_THROW, 'C', NINJA_STAR_RATE, &AF(DoNinjaMove), &s_NinjaStar[5]}, }; ////////////////////// @@ -549,24 +432,17 @@ STATE* sg_NinjaStar[] = #define NINJA_MIRV_RATE 18 -STATE s_NinjaMirv[1][6] = +FState s_NinjaMirv[] = { - { - {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]}, - }, + {SPR_NINJA_THROW, 'A', NINJA_MIRV_RATE * 2, &AF(NullNinja), &s_NinjaMirv[1]}, + {SPR_NINJA_THROW, 'B', NINJA_MIRV_RATE, &AF(NullNinja), &s_NinjaMirv[2]}, + {SPR_NINJA_THROW, 'C', 0 | SF_QUICK_CALL, &AF(InitEnemyMirv), &s_NinjaMirv[3]}, + {SPR_NINJA_THROW, 'C', NINJA_MIRV_RATE * 2, &AF(NullNinja), &s_NinjaMirv[4]}, + {SPR_NINJA_THROW, 'C', 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_NinjaMirv[5]}, + {SPR_NINJA_THROW, 'C', NINJA_MIRV_RATE, &AF(DoNinjaMove), &s_NinjaMirv[5]}, }; -STATE* sg_NinjaMirv[] = -{ - s_NinjaMirv[0], -}; - ////////////////////// // // NINJA NAPALM @@ -575,22 +451,14 @@ STATE* sg_NinjaMirv[] = #define NINJA_NAPALM_RATE 18 -STATE s_NinjaNapalm[1][6] = +FState s_NinjaNapalm[] = { - { - {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]}, - }, -}; - - -STATE* sg_NinjaNapalm[] = -{ - s_NinjaNapalm[0], + {SPR_NINJA_THROW, 'A', NINJA_NAPALM_RATE * 2, &AF(NullNinja), &s_NinjaNapalm[1]}, + {SPR_NINJA_THROW, 'B', NINJA_NAPALM_RATE, &AF(NullNinja), &s_NinjaNapalm[2]}, + {SPR_NINJA_THROW, 'C', 0 | SF_QUICK_CALL, &AF(InitEnemyNapalm), &s_NinjaNapalm[3]}, + {SPR_NINJA_THROW, 'C', NINJA_NAPALM_RATE * 2, &AF(NullNinja), &s_NinjaNapalm[4]}, + {SPR_NINJA_THROW, 'C', 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_NinjaNapalm[5]}, + {SPR_NINJA_THROW, 'C', NINJA_NAPALM_RATE, &AF(DoNinjaMove), &s_NinjaNapalm[5]}, }; @@ -602,23 +470,16 @@ STATE* sg_NinjaNapalm[] = #define NINJA_ROCKET_RATE 14 -STATE s_NinjaRocket[1][5] = +FState s_NinjaRocket[] = { - { - {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]}, - }, + {SPR_NINJA_STAND, 'A', NINJA_ROCKET_RATE * 2, &AF(NullNinja), &s_NinjaRocket[1]}, + {SPR_NINJA_STAND, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyRocket), &s_NinjaRocket[2]}, + {SPR_NINJA_STAND, 'A', NINJA_ROCKET_RATE, &AF(NullNinja), &s_NinjaRocket[3]}, + {SPR_NINJA_STAND, 'A', 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_NinjaRocket[4]}, + {SPR_NINJA_STAND, 'A', NINJA_ROCKET_RATE, &AF(DoNinjaMove), &s_NinjaRocket[4]}, }; -STATE* sg_NinjaRocket[] = -{ - s_NinjaRocket[0], -}; - ////////////////////// // // NINJA ROCKET @@ -627,21 +488,13 @@ STATE* sg_NinjaRocket[] = #define NINJA_ROCKET_RATE 14 -STATE s_NinjaGrenade[1][5] = +FState s_NinjaGrenade[] = { - { - {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]}, - }, -}; - - -STATE* sg_NinjaGrenade[] = -{ - s_NinjaGrenade[0], + {SPR_NINJA_STAND, 'A', NINJA_ROCKET_RATE * 2, &AF(NullNinja), &s_NinjaGrenade[1]}, + {SPR_NINJA_STAND, 'A', 0 | SF_QUICK_CALL, &AF(InitSpriteGrenade), &s_NinjaGrenade[2]}, + {SPR_NINJA_STAND, 'A', NINJA_ROCKET_RATE, &AF(NullNinja), &s_NinjaGrenade[3]}, + {SPR_NINJA_STAND, 'A', 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_NinjaGrenade[4]}, + {SPR_NINJA_STAND, 'A', NINJA_ROCKET_RATE, &AF(DoNinjaMove), &s_NinjaGrenade[4]}, }; @@ -653,23 +506,16 @@ STATE* sg_NinjaGrenade[] = #define NINJA_FLASHBOMB_RATE 14 -STATE s_NinjaFlashBomb[1][5] = +FState s_NinjaFlashBomb[] = { - { - {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]}, - }, + {SPR_NINJA_STAND, 'A', NINJA_FLASHBOMB_RATE * 2, &AF(NullNinja), &s_NinjaFlashBomb[1]}, + {SPR_NINJA_STAND, 'A', 0 | SF_QUICK_CALL, &AF(InitFlashBomb), &s_NinjaFlashBomb[2]}, + {SPR_NINJA_STAND, 'A', NINJA_FLASHBOMB_RATE, &AF(NullNinja), &s_NinjaFlashBomb[3]}, + {SPR_NINJA_STAND, 'A', 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_NinjaFlashBomb[4]}, + {SPR_NINJA_STAND, 'A', NINJA_FLASHBOMB_RATE, &AF(DoNinjaMove), &s_NinjaFlashBomb[4]}, }; -STATE* sg_NinjaFlashBomb[] = -{ - s_NinjaFlashBomb[0], -}; - ////////////////////// // // NINJA UZI @@ -678,33 +524,25 @@ STATE* sg_NinjaFlashBomb[] = #define NINJA_UZI_RATE 8 -STATE s_NinjaUzi[1][17] = +FState s_NinjaUzi[] = { - { - {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]}, - }, -}; - - -STATE* sg_NinjaUzi[] = -{ - s_NinjaUzi[0], + {SPR_NINJA_FIRE, 'A', NINJA_UZI_RATE, &AF(NullNinja), &s_NinjaUzi[1]}, + {SPR_NINJA_FIRE, 'A', 0 | SF_QUICK_CALL, &AF(CheckFire), &s_NinjaUzi[2]}, + {SPR_NINJA_FIRE, 'B', NINJA_UZI_RATE, &AF(NullNinja), &s_NinjaUzi[3]}, + {SPR_NINJA_FIRE, 'B', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_NinjaUzi[4]}, + {SPR_NINJA_FIRE, 'A', NINJA_UZI_RATE, &AF(NullNinja), &s_NinjaUzi[5]}, + {SPR_NINJA_FIRE, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_NinjaUzi[6]}, + {SPR_NINJA_FIRE, 'B', NINJA_UZI_RATE, &AF(NullNinja), &s_NinjaUzi[7]}, + {SPR_NINJA_FIRE, 'B', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_NinjaUzi[8]}, + {SPR_NINJA_FIRE, 'A', NINJA_UZI_RATE, &AF(NullNinja), &s_NinjaUzi[9]}, + {SPR_NINJA_FIRE, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_NinjaUzi[10]}, + {SPR_NINJA_FIRE, 'B', NINJA_UZI_RATE, &AF(NullNinja), &s_NinjaUzi[11]}, + {SPR_NINJA_FIRE, 'B', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_NinjaUzi[12]}, + {SPR_NINJA_FIRE, 'A', NINJA_UZI_RATE, &AF(NullNinja), &s_NinjaUzi[13]}, + {SPR_NINJA_FIRE, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_NinjaUzi[14]}, + {SPR_NINJA_FIRE, 'B', NINJA_UZI_RATE, &AF(NullNinja), &s_NinjaUzi[15]}, + {SPR_NINJA_FIRE, 'B', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_NinjaUzi[16]}, + {SPR_NINJA_FIRE, 'A', 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_NinjaUzi[16]}, }; @@ -717,7 +555,7 @@ STATE* sg_NinjaUzi[] = #define NINJA_HARI_KARI_WAIT_RATE 200 #define NINJA_HARI_KARI_FALL_RATE 16 -STATE s_NinjaHariKari[] = +FState s_NinjaHariKari[] = { {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]}, @@ -732,12 +570,6 @@ STATE s_NinjaHariKari[] = {SPR_NINJA_HARI_KARI, 'H', NINJA_HARI_KARI_FALL_RATE, nullptr, &s_NinjaHariKari[10]}, }; -STATE* sg_NinjaHariKari[] = -{ - s_NinjaHariKari, -}; - - ////////////////////// // // NINJA GRAB THROAT @@ -746,7 +578,7 @@ STATE* sg_NinjaHariKari[] = #define NINJA_GRAB_THROAT_RATE 32 -STATE s_NinjaGrabThroat[] = +FState s_NinjaGrabThroat[] = { {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]}, @@ -756,12 +588,6 @@ STATE s_NinjaGrabThroat[] = {SPR_NINJA_GRAB_THROAT, 'B', NINJA_GRAB_THROAT_RATE, &AF(NullNinja), &s_NinjaGrabThroat[0]}, }; -STATE* sg_NinjaGrabThroat[] = -{ - s_NinjaGrabThroat, -}; - - ////////////////////// // // NINJA DIE @@ -770,7 +596,7 @@ STATE* sg_NinjaGrabThroat[] = #define NINJA_DIE_RATE 14 -STATE s_NinjaDie[] = +FState s_NinjaDie[] = { {SPR_NINJA_DIE, 'A', NINJA_DIE_RATE, &AF(NullNinja), &s_NinjaDie[1]}, {SPR_NINJA_DIE, 'B', NINJA_DIE_RATE, &AF(NullNinja), &s_NinjaDie[2]}, @@ -788,7 +614,7 @@ STATE s_NinjaDie[] = #define NINJA_DIESLICED_RATE 20 -STATE s_NinjaDieSliced[] = +FState s_NinjaDieSliced[] = { {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]}, @@ -804,7 +630,7 @@ STATE s_NinjaDieSliced[] = {SPR_NINJA_SLICED, 'J', NINJA_DIESLICED_RATE, &AF(DoActorDebris), &s_NinjaDieSliced[11]}, }; -STATE s_NinjaDieSlicedHack[] = +FState s_NinjaDieSlicedHack[] = { {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]}, @@ -820,7 +646,7 @@ STATE s_NinjaDieSlicedHack[] = {SPR_NINJA_SLICED_HACK, 'H', NINJA_DIESLICED_RATE-6, &AF(DoActorDebris), &s_NinjaDieSlicedHack[11]}, }; -STATE s_NinjaDead[] = +FState s_NinjaDead[] = { {SPR_NINJA_DIE, 'F', NINJA_DIE_RATE, &AF(DoActorDebris), &s_NinjaDead[1]}, {SPR_NINJA_DIE, 'G', SF_QUICK_CALL, &AF(DoNinjaSpecial), &s_NinjaDead[2]}, @@ -830,72 +656,42 @@ STATE s_NinjaDead[] = }; -STATE s_NinjaDeathJump[] = +FState s_NinjaDeathJump[] = { {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[] = +FState s_NinjaDeathFall[] = { {SPR_NINJA_DIE, 'D', NINJA_DIE_RATE, &AF(DoActorDeathMove), &s_NinjaDeathFall[1]}, {SPR_NINJA_DIE, 'E', NINJA_DIE_RATE, &AF(DoActorDeathMove), &s_NinjaDeathFall[1]}, }; /* -STATE* *Stand[MAX_WEAPONS]; -STATE* *Run; -STATE* *Jump; -STATE* *Fall; -STATE* *Crawl; -STATE* *Swim; -STATE* *Fly; -STATE* *Rise; -STATE* *Sit; -STATE* *Look; -STATE* *Climb; -STATE* *Pain; -STATE* *Death1; -STATE* *Death2; -STATE* *Dead; -STATE* *DeathJump; -STATE* *DeathFall; -STATE* *CloseAttack[2]; -STATE* *Attack[6]; -STATE* *Special[2]; +FState* *Stand[MAX_WEAPONS]; +FState* *Run; +FState* *Jump; +FState* *Fall; +FState* *Crawl; +FState* *Swim; +FState* *Fly; +FState* *Rise; +FState* *Sit; +FState* *Look; +FState* *Climb; +FState* *Pain; +FState* *Death1; +FState* *Death2; +FState* *Dead; +FState* *DeathJump; +FState* *DeathFall; +FState* *CloseAttack[2]; +FState* *Attack[6]; +FState* *Special[2]; */ -STATE* sg_NinjaDie[] = -{ - s_NinjaDie -}; - -STATE* sg_NinjaDieSliced[] = -{ - s_NinjaDieSliced -}; - -STATE* sg_NinjaDieSlicedHack[] = -{ - s_NinjaDieSlicedHack -}; - -STATE* sg_NinjaDead[] = -{ - s_NinjaDead -}; - -STATE* sg_NinjaDeathJump[] = -{ - s_NinjaDeathJump -}; - -STATE* sg_NinjaDeathFall[] = -{ - s_NinjaDeathFall -}; - /* !AIC - Collection of states that connect action to states @@ -904,210 +700,173 @@ STATE* sg_NinjaDeathFall[] = ACTOR_ACTION_SET NinjaSniperActionSet = { - sg_NinjaDuck, - sg_NinjaCrawl, - sg_NinjaJump, - sg_NinjaFall, - sg_NinjaKneelCrawl, - sg_NinjaSwim, - sg_NinjaFly, - sg_NinjaUzi, - sg_NinjaDuck, + s_NinjaDuck, + s_NinjaCrawl, + s_NinjaJump, + s_NinjaFall, + s_NinjaKneelCrawl, + s_NinjaSwim, + s_NinjaFly, + s_NinjaUzi, + s_NinjaDuck, nullptr, - sg_NinjaClimb, - sg_NinjaPain, - sg_NinjaDie, - sg_NinjaHariKari, - sg_NinjaDead, - sg_NinjaDeathJump, - sg_NinjaDeathFall, - {sg_NinjaUzi}, + s_NinjaClimb, + s_NinjaPain, + s_NinjaDie, + s_NinjaHariKari, + s_NinjaDead, + s_NinjaDeathJump, + s_NinjaDeathFall, + {s_NinjaUzi}, {1024}, - {sg_NinjaUzi}, + {s_NinjaUzi}, {1024}, {nullptr}, - sg_NinjaDuck, - sg_NinjaDive + s_NinjaDuck, + s_NinjaDive }; ACTOR_ACTION_SET NinjaActionSet = { - sg_NinjaStand, - sg_NinjaRun, - sg_NinjaJump, - sg_NinjaFall, - sg_NinjaKneelCrawl, - sg_NinjaSwim, - sg_NinjaFly, - sg_NinjaRise, - sg_NinjaSit, + s_NinjaStand, + s_NinjaRun, + s_NinjaJump, + s_NinjaFall, + s_NinjaKneelCrawl, + s_NinjaSwim, + s_NinjaFly, + s_NinjaRise, + s_NinjaSit, nullptr, - sg_NinjaClimb, - sg_NinjaPain, - sg_NinjaDie, - sg_NinjaHariKari, - sg_NinjaDead, - sg_NinjaDeathJump, - sg_NinjaDeathFall, - {sg_NinjaUzi, sg_NinjaStar}, + s_NinjaClimb, + s_NinjaPain, + s_NinjaDie, + s_NinjaHariKari, + s_NinjaDead, + s_NinjaDeathJump, + s_NinjaDeathFall, + {s_NinjaUzi, s_NinjaStar}, {1000, 1024}, - {sg_NinjaUzi, sg_NinjaStar}, + {s_NinjaUzi, s_NinjaStar}, {800, 1024}, {nullptr}, - sg_NinjaDuck, - sg_NinjaDive + s_NinjaDuck, + s_NinjaDive }; ACTOR_ACTION_SET NinjaRedActionSet = { - sg_NinjaStand, - sg_NinjaRun, - sg_NinjaJump, - sg_NinjaFall, - sg_NinjaKneelCrawl, - sg_NinjaSwim, - sg_NinjaFly, - sg_NinjaRise, - sg_NinjaSit, + s_NinjaStand, + s_NinjaRun, + s_NinjaJump, + s_NinjaFall, + s_NinjaKneelCrawl, + s_NinjaSwim, + s_NinjaFly, + s_NinjaRise, + s_NinjaSit, nullptr, - sg_NinjaClimb, - sg_NinjaPain, - sg_NinjaDie, - sg_NinjaHariKari, - sg_NinjaDead, - sg_NinjaDeathJump, - sg_NinjaDeathFall, - {sg_NinjaUzi, sg_NinjaUzi}, + s_NinjaClimb, + s_NinjaPain, + s_NinjaDie, + s_NinjaHariKari, + s_NinjaDead, + s_NinjaDeathJump, + s_NinjaDeathFall, + {s_NinjaUzi, s_NinjaUzi}, {812, 1024}, - {sg_NinjaUzi, sg_NinjaRocket}, + {s_NinjaUzi, s_NinjaRocket}, {812, 1024}, {nullptr}, - sg_NinjaDuck, - sg_NinjaDive + s_NinjaDuck, + s_NinjaDive }; ACTOR_ACTION_SET NinjaSeekerActionSet = { - sg_NinjaStand, - sg_NinjaRun, - sg_NinjaJump, - sg_NinjaFall, - sg_NinjaKneelCrawl, - sg_NinjaSwim, - sg_NinjaFly, - sg_NinjaRise, - sg_NinjaSit, + s_NinjaStand, + s_NinjaRun, + s_NinjaJump, + s_NinjaFall, + s_NinjaKneelCrawl, + s_NinjaSwim, + s_NinjaFly, + s_NinjaRise, + s_NinjaSit, nullptr, - sg_NinjaClimb, - sg_NinjaPain, - sg_NinjaDie, - sg_NinjaHariKari, - sg_NinjaDead, - sg_NinjaDeathJump, - sg_NinjaDeathFall, - {sg_NinjaUzi, sg_NinjaStar}, + s_NinjaClimb, + s_NinjaPain, + s_NinjaDie, + s_NinjaHariKari, + s_NinjaDead, + s_NinjaDeathJump, + s_NinjaDeathFall, + {s_NinjaUzi, s_NinjaStar}, {812, 1024}, - {sg_NinjaUzi, sg_NinjaRocket}, + {s_NinjaUzi, s_NinjaRocket}, {812, 1024}, {nullptr}, - sg_NinjaDuck, - sg_NinjaDive + s_NinjaDuck, + s_NinjaDive }; ACTOR_ACTION_SET NinjaGrenadeActionSet = { - sg_NinjaStand, - sg_NinjaRun, - sg_NinjaJump, - sg_NinjaFall, - sg_NinjaKneelCrawl, - sg_NinjaSwim, - sg_NinjaFly, - sg_NinjaRise, - sg_NinjaSit, + s_NinjaStand, + s_NinjaRun, + s_NinjaJump, + s_NinjaFall, + s_NinjaKneelCrawl, + s_NinjaSwim, + s_NinjaFly, + s_NinjaRise, + s_NinjaSit, nullptr, - sg_NinjaClimb, - sg_NinjaPain, - sg_NinjaDie, - sg_NinjaHariKari, - sg_NinjaDead, - sg_NinjaDeathJump, - sg_NinjaDeathFall, - {sg_NinjaUzi, sg_NinjaUzi}, + s_NinjaClimb, + s_NinjaPain, + s_NinjaDie, + s_NinjaHariKari, + s_NinjaDead, + s_NinjaDeathJump, + s_NinjaDeathFall, + {s_NinjaUzi, s_NinjaUzi}, {812, 1024}, - {sg_NinjaUzi, sg_NinjaGrenade}, + {s_NinjaUzi, s_NinjaGrenade}, {812, 1024}, {nullptr}, - sg_NinjaDuck, - sg_NinjaDive + s_NinjaDuck, + s_NinjaDive }; ACTOR_ACTION_SET NinjaGreenActionSet = { - sg_NinjaStand, - sg_NinjaRun, - sg_NinjaJump, - sg_NinjaFall, - sg_NinjaKneelCrawl, - sg_NinjaSwim, - sg_NinjaFly, - sg_NinjaRise, - sg_NinjaSit, + s_NinjaStand, + s_NinjaRun, + s_NinjaJump, + s_NinjaFall, + s_NinjaKneelCrawl, + s_NinjaSwim, + s_NinjaFly, + s_NinjaRise, + s_NinjaSit, nullptr, - sg_NinjaClimb, - sg_NinjaPain, - sg_NinjaDie, - sg_NinjaHariKari, - sg_NinjaDead, - sg_NinjaDeathJump, - sg_NinjaDeathFall, - {sg_NinjaUzi, sg_NinjaFlashBomb}, + s_NinjaClimb, + s_NinjaPain, + s_NinjaDie, + s_NinjaHariKari, + s_NinjaDead, + s_NinjaDeathJump, + s_NinjaDeathFall, + {s_NinjaUzi, s_NinjaFlashBomb}, {912, 1024}, - {sg_NinjaFlashBomb, sg_NinjaUzi, sg_NinjaMirv, sg_NinjaNapalm}, + {s_NinjaFlashBomb, s_NinjaUzi, s_NinjaMirv, s_NinjaNapalm}, {150, 500, 712, 1024}, {nullptr}, - sg_NinjaDuck, - sg_NinjaDive + s_NinjaDuck, + s_NinjaDive }; -extern STATE* sg_PlayerNinjaRun[]; -extern STATE* sg_PlayerNinjaStand[]; -extern STATE* sg_PlayerNinjaJump[]; -extern STATE* sg_PlayerNinjaFall[]; -extern STATE* sg_PlayerNinjaClimb[]; -extern STATE* sg_PlayerNinjaCrawl[]; -extern STATE* sg_PlayerNinjaSwim[]; -ACTOR_ACTION_SET PlayerNinjaActionSet = -{ - sg_PlayerNinjaStand, - sg_PlayerNinjaRun, - sg_PlayerNinjaJump, - sg_PlayerNinjaFall, - //sg_NinjaJump, - //sg_NinjaFall, - sg_PlayerNinjaCrawl, - sg_PlayerNinjaSwim, - sg_NinjaFly, - sg_NinjaRise, - sg_NinjaSit, - nullptr, - sg_PlayerNinjaClimb, - sg_NinjaPain, - sg_NinjaDie, - sg_NinjaHariKari, - sg_NinjaDead, - sg_NinjaDeathJump, - sg_NinjaDeathFall, - {sg_NinjaStar, sg_NinjaUzi}, - {1000, 1024}, - {sg_NinjaStar, sg_NinjaUzi}, - {800, 1024}, - {nullptr}, - sg_NinjaDuck, - sg_PlayerNinjaSwim -}; - /* @@ -1136,7 +895,7 @@ int SetupNinja(DSWActor* actor) } actor->user.__legacyState.StateEnd = s_NinjaDie; - actor->user.__legacyState.Rot = sg_NinjaRun; + actor->user.__legacyState.Rot = s_NinjaRun; actor->spr.scale = DVector2(0.71875, 0.71875); if (actor->spr.pal == PALETTE_PLAYER5) @@ -1322,9 +1081,9 @@ int DoNinjaMove(DSWActor* actor) if (actor->user.Flags2 & (SPR2_DYING)) { if (sw_ninjahack) - NewStateGroup(actor, sg_NinjaHariKari); + NewStateGroup(actor, s_NinjaHariKari); else - NewStateGroup(actor, sg_NinjaGrabThroat); + NewStateGroup(actor, s_NinjaGrabThroat); return 0; } @@ -1418,9 +1177,9 @@ int DoNinjaPain(DSWActor* actor) if (actor->user.Flags2 & (SPR2_DYING)) { if (sw_ninjahack) - NewStateGroup(actor, sg_NinjaHariKari); + NewStateGroup(actor, s_NinjaHariKari); else - NewStateGroup(actor, sg_NinjaGrabThroat); + NewStateGroup(actor, s_NinjaGrabThroat); return 0; } @@ -1719,7 +1478,7 @@ void InitPlayerSprite(DSWPlayer* pp, const DVector3& spawnpos, const DAngle star // Grouping items that need to be reset after a LoadLevel ChangeState(actor, s_NinjaRun[0]); - actor->user.__legacyState.Rot = sg_NinjaRun; + actor->user.__legacyState.Rot = s_NinjaRun; actor->user.__legacyState.ActorActionSet = &PlayerNinjaActionSet; actor->user.Radius = 400; @@ -1786,7 +1545,7 @@ void SpawnPlayerUnderSprite(DSWPlayer* pp) actor->spr.cstat |= (CSTAT_SPRITE_BLOCK | CSTAT_SPRITE_BLOCK_HITSCAN); actor->spr.extra |= (SPRX_PLAYER_OR_ENEMY); - actor->user.__legacyState.Rot = sg_NinjaRun; + actor->user.__legacyState.Rot = s_NinjaRun; actor->user.__legacyState.State = plActor->user.__legacyState.State; NewStateGroup(pp->PlayerUnderActor, plActor->user.__legacyState.Rot); @@ -1820,65 +1579,35 @@ static saveable_data saveable_ninja_data[] = SAVE_DATA(InvisibleNinjaAttrib), SAVE_DATA(s_NinjaRun), - SAVE_DATA(sg_NinjaRun), SAVE_DATA(s_NinjaStand), - SAVE_DATA(sg_NinjaStand), SAVE_DATA(s_NinjaRise), - SAVE_DATA(sg_NinjaRise), SAVE_DATA(s_NinjaCrawl), - SAVE_DATA(sg_NinjaCrawl), SAVE_DATA(s_NinjaKneelCrawl), - SAVE_DATA(sg_NinjaKneelCrawl), SAVE_DATA(s_NinjaDuck), - SAVE_DATA(sg_NinjaDuck), SAVE_DATA(s_NinjaSit), - SAVE_DATA(sg_NinjaSit), SAVE_DATA(s_NinjaCeiling), - SAVE_DATA(sg_NinjaCeiling), SAVE_DATA(s_NinjaJump), - SAVE_DATA(sg_NinjaJump), SAVE_DATA(s_NinjaFall), - SAVE_DATA(sg_NinjaFall), SAVE_DATA(s_NinjaSwim), - SAVE_DATA(sg_NinjaSwim), SAVE_DATA(s_NinjaDive), - SAVE_DATA(sg_NinjaDive), SAVE_DATA(s_NinjaClimb), - SAVE_DATA(sg_NinjaClimb), SAVE_DATA(s_NinjaFly), - SAVE_DATA(sg_NinjaFly), SAVE_DATA(s_NinjaPain), - SAVE_DATA(sg_NinjaPain), SAVE_DATA(s_NinjaStar), - SAVE_DATA(sg_NinjaStar), SAVE_DATA(s_NinjaMirv), - SAVE_DATA(sg_NinjaMirv), SAVE_DATA(s_NinjaNapalm), - SAVE_DATA(sg_NinjaNapalm), SAVE_DATA(s_NinjaRocket), - SAVE_DATA(sg_NinjaRocket), SAVE_DATA(s_NinjaGrenade), - SAVE_DATA(sg_NinjaGrenade), SAVE_DATA(s_NinjaFlashBomb), - SAVE_DATA(sg_NinjaFlashBomb), SAVE_DATA(s_NinjaUzi), - SAVE_DATA(sg_NinjaUzi), SAVE_DATA(s_NinjaHariKari), - SAVE_DATA(sg_NinjaHariKari), SAVE_DATA(s_NinjaGrabThroat), - SAVE_DATA(sg_NinjaGrabThroat), SAVE_DATA(s_NinjaDie), SAVE_DATA(s_NinjaDieSliced), SAVE_DATA(s_NinjaDieSlicedHack), SAVE_DATA(s_NinjaDead), SAVE_DATA(s_NinjaDeathJump), SAVE_DATA(s_NinjaDeathFall), - SAVE_DATA(sg_NinjaDie), - SAVE_DATA(sg_NinjaDieSliced), - SAVE_DATA(sg_NinjaDieSlicedHack), - SAVE_DATA(sg_NinjaDead), - SAVE_DATA(sg_NinjaDeathJump), - SAVE_DATA(sg_NinjaDeathFall), SAVE_DATA(NinjaSniperActionSet), SAVE_DATA(NinjaActionSet), diff --git a/source/games/sw/src/player.cpp b/source/games/sw/src/player.cpp index db21870ae..fa286733f 100644 --- a/source/games/sw/src/player.cpp +++ b/source/games/sw/src/player.cpp @@ -208,24 +208,17 @@ void DSWPlayer::OnDestroy() #define PLAYER_NINJA_RATE 14 -STATE s_PlayerNinjaRun[1][6] = +FState s_PlayerNinjaRun[] = { - - { - {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]}, - }, + {SPR_PLAYER_NINJA_RUN, 'A', PLAYER_NINJA_RATE | SF_TIC_ADJUST, nullptr, &s_PlayerNinjaRun[1]}, + {SPR_PLAYER_NINJA_RUN, 'B', PLAYER_NINJA_RATE | SF_TIC_ADJUST, nullptr, &s_PlayerNinjaRun[2]}, + {SPR_PLAYER_NINJA_RUN, 'B', 0 | SF_QUICK_CALL, &AF(DoFootPrints), &s_PlayerNinjaRun[3]}, + {SPR_PLAYER_NINJA_RUN, 'C', PLAYER_NINJA_RATE | SF_TIC_ADJUST, nullptr, &s_PlayerNinjaRun[4]}, + {SPR_PLAYER_NINJA_RUN, 'D', PLAYER_NINJA_RATE | SF_TIC_ADJUST, nullptr, &s_PlayerNinjaRun[5]}, + {SPR_PLAYER_NINJA_RUN, 'D', 0 | SF_QUICK_CALL, &AF(DoFootPrints), &s_PlayerNinjaRun[0]}, }; -STATE* sg_PlayerNinjaRun[] = -{ - s_PlayerNinjaRun[0], -}; #endif ////////////////////// @@ -236,41 +229,27 @@ STATE* sg_PlayerNinjaRun[] = #define PLAYER_NINJA_STAND_RATE 10 -STATE s_PlayerNinjaStand[1][1] = +FState s_PlayerNinjaStand[] = { - { - {SPR_PLAYER_NINJA_STAND, 'A', PLAYER_NINJA_STAND_RATE, nullptr, &s_PlayerNinjaStand[0][0]}, - }, + {SPR_PLAYER_NINJA_STAND, 'A', PLAYER_NINJA_STAND_RATE, nullptr, &s_PlayerNinjaStand[0]}, }; -STATE* sg_PlayerNinjaStand[] = -{ - s_PlayerNinjaStand[0], -}; - #define PLAYER_NINJA_STAR_RATE 12 -extern STATE* sg_NinjaRun[]; +extern FState s_NinjaRun[]; int DoPlayerSpriteReset(DSWActor* actor); #if 1 -STATE s_PlayerNinjaThrow[1][4] = +FState s_PlayerNinjaThrow[] = { - { - {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]}, - }, + {SPR_PLAYER_NINJA_SHOOT, 'A', PLAYER_NINJA_STAR_RATE, nullptr, &s_PlayerNinjaThrow[1]}, + {SPR_PLAYER_NINJA_SHOOT, 'A', PLAYER_NINJA_STAR_RATE, nullptr, &s_PlayerNinjaThrow[2]}, + {SPR_PLAYER_NINJA_SHOOT, 'A', PLAYER_NINJA_STAR_RATE, nullptr, &s_PlayerNinjaThrow[3]}, + {SPR_PLAYER_NINJA_SHOOT, 'A', PLAYER_NINJA_STAR_RATE | SF_PLAYER_FUNC, &AF(DoPlayerSpriteReset), &s_PlayerNinjaThrow[3]}, }; #endif -STATE* sg_PlayerNinjaThrow[] = -{ - s_PlayerNinjaThrow[0], -}; - ////////////////////// // // PLAYER_NINJA JUMP @@ -279,20 +258,12 @@ STATE* sg_PlayerNinjaThrow[] = #define PLAYER_NINJA_JUMP_RATE 24 -STATE s_PlayerNinjaJump[1][4] = +FState s_PlayerNinjaJump[] = { - { - {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]}, - }, -}; - - -STATE* sg_PlayerNinjaJump[] = -{ - s_PlayerNinjaJump[0], + {SPR_PLAYER_NINJA_JUMP, 'A', PLAYER_NINJA_JUMP_RATE, nullptr, &s_PlayerNinjaJump[1]}, + {SPR_PLAYER_NINJA_JUMP, 'B', PLAYER_NINJA_JUMP_RATE, nullptr, &s_PlayerNinjaJump[2]}, + {SPR_PLAYER_NINJA_JUMP, 'C', PLAYER_NINJA_JUMP_RATE, nullptr, &s_PlayerNinjaJump[3]}, + {SPR_PLAYER_NINJA_JUMP, 'D', PLAYER_NINJA_JUMP_RATE, nullptr, &s_PlayerNinjaJump[3]}, }; @@ -304,20 +275,13 @@ STATE* sg_PlayerNinjaJump[] = #define PLAYER_NINJA_FALL_RATE 16 -STATE s_PlayerNinjaFall[1][2] = +FState s_PlayerNinjaFall[] = { - { - {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]}, - }, + {SPR_PLAYER_NINJA_JUMP, 'B', PLAYER_NINJA_FALL_RATE, nullptr, &s_PlayerNinjaFall[1]}, + {SPR_PLAYER_NINJA_JUMP, 'C', PLAYER_NINJA_FALL_RATE, nullptr, &s_PlayerNinjaFall[1]}, }; -STATE* sg_PlayerNinjaFall[] = -{ - s_PlayerNinjaFall[0], -}; - ////////////////////// // // PLAYER_NINJA CLIMB @@ -326,19 +290,12 @@ STATE* sg_PlayerNinjaFall[] = #define PLAYER_NINJA_CLIMB_RATE 20 -STATE s_PlayerNinjaClimb[1][4] = +FState s_PlayerNinjaClimb[] = { - { - {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], + {SPR_PLAYER_NINJA_CLIMB, 'A', PLAYER_NINJA_CLIMB_RATE, nullptr, &s_PlayerNinjaClimb[1]}, + {SPR_PLAYER_NINJA_CLIMB, 'B', PLAYER_NINJA_CLIMB_RATE, nullptr, &s_PlayerNinjaClimb[2]}, + {SPR_PLAYER_NINJA_CLIMB, 'C', PLAYER_NINJA_CLIMB_RATE, nullptr, &s_PlayerNinjaClimb[3]}, + {SPR_PLAYER_NINJA_CLIMB, 'D', PLAYER_NINJA_CLIMB_RATE, nullptr, &s_PlayerNinjaClimb[0]}, }; ////////////////////// @@ -349,24 +306,17 @@ STATE* sg_PlayerNinjaClimb[] = #define PLAYER_NINJA_CRAWL_RATE 14 -STATE s_PlayerNinjaCrawl[1][6] = +FState s_PlayerNinjaCrawl[] = { - { - {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]}, - }, + {SPR_PLAYER_NINJA_CRAWL, 'A', PLAYER_NINJA_CRAWL_RATE, nullptr, &s_PlayerNinjaCrawl[1]}, + {SPR_PLAYER_NINJA_CRAWL, 'B', PLAYER_NINJA_CRAWL_RATE, nullptr, &s_PlayerNinjaCrawl[2]}, + {SPR_PLAYER_NINJA_CRAWL, 'B', 0 | SF_QUICK_CALL, &AF(DoFootPrints), &s_PlayerNinjaCrawl[3]}, + {SPR_PLAYER_NINJA_CRAWL, 'C', PLAYER_NINJA_CRAWL_RATE, nullptr, &s_PlayerNinjaCrawl[4]}, + {SPR_PLAYER_NINJA_CRAWL, 'B', PLAYER_NINJA_CRAWL_RATE, nullptr, &s_PlayerNinjaCrawl[5]}, + {SPR_PLAYER_NINJA_CRAWL, 'B', 0 | SF_QUICK_CALL, &AF(DoFootPrints), &s_PlayerNinjaCrawl[0]}, }; -STATE* sg_PlayerNinjaCrawl[] = -{ - s_PlayerNinjaCrawl[0], -}; - ////////////////////// // // PLAYER NINJA SWIM @@ -375,20 +325,12 @@ STATE* sg_PlayerNinjaCrawl[] = #define PLAYER_NINJA_SWIM_RATE 22 // Was 18 -STATE s_PlayerNinjaSwim[1][4] = +FState s_PlayerNinjaSwim[] = { - { - {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]}, - }, -}; - - -STATE* sg_PlayerNinjaSwim[] = -{ - s_PlayerNinjaSwim[0], + {SPR_PLAYER_NINJA_SWIM, 'A', PLAYER_NINJA_SWIM_RATE, nullptr, &s_PlayerNinjaSwim[1]}, + {SPR_PLAYER_NINJA_SWIM, 'B', PLAYER_NINJA_SWIM_RATE, nullptr, &s_PlayerNinjaSwim[2]}, + {SPR_PLAYER_NINJA_SWIM, 'C', PLAYER_NINJA_SWIM_RATE, nullptr, &s_PlayerNinjaSwim[3]}, + {SPR_PLAYER_NINJA_SWIM, 'D', PLAYER_NINJA_SWIM_RATE, nullptr, &s_PlayerNinjaSwim[0]}, }; @@ -396,71 +338,42 @@ STATE* sg_PlayerNinjaSwim[] = #define NINJA_Head_RATE 16 #define NINJA_HeadFly_RATE 16 -STATE s_PlayerHeadFly[1][8] = +FState s_PlayerHeadFly[] = { - { - {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]} - }, + {SPR_NINJA_HeadFly, 'A', NINJA_HeadFly_RATE, nullptr, &s_PlayerHeadFly[1]}, + {SPR_NINJA_HeadFly, 'B', NINJA_HeadFly_RATE, nullptr, &s_PlayerHeadFly[2]}, + {SPR_NINJA_HeadFly, 'C', NINJA_HeadFly_RATE, nullptr, &s_PlayerHeadFly[3]}, + {SPR_NINJA_HeadFly, 'D', NINJA_HeadFly_RATE, nullptr, &s_PlayerHeadFly[4]}, + {SPR_NINJA_HeadFly, 'E', NINJA_HeadFly_RATE, nullptr, &s_PlayerHeadFly[5]}, + {SPR_NINJA_HeadFly, 'F', NINJA_HeadFly_RATE, nullptr, &s_PlayerHeadFly[6]}, + {SPR_NINJA_HeadFly, 'G', NINJA_HeadFly_RATE, nullptr, &s_PlayerHeadFly[7]}, + {SPR_NINJA_HeadFly, 'H', NINJA_HeadFly_RATE, nullptr, &s_PlayerHeadFly[0]} }; -STATE* sg_PlayerHeadFly[] = +FState s_PlayerHead[] = { - s_PlayerHeadFly[0], + {SPR_NINJA_Head, 'A', NINJA_Head_RATE, nullptr, &s_PlayerHead[0]}, }; -STATE s_PlayerHead[1][1] = +FState s_PlayerHeadHurl[] = { - { - {SPR_NINJA_Head, 'A', NINJA_Head_RATE, nullptr, &s_PlayerHead[0][0]}, - }, -}; - -STATE* sg_PlayerHead[] = -{ - s_PlayerHead[0], -}; - - -STATE s_PlayerHeadHurl[1][1] = -{ - { - {SPR_NINJA_HeadHurl, 'A', NINJA_HeadHurl_RATE, nullptr, &s_PlayerHeadHurl[0][0]}, - }, -}; - -STATE* sg_PlayerHeadHurl[] = -{ - s_PlayerHeadHurl[0], + {SPR_NINJA_HeadHurl, 'A', NINJA_HeadHurl_RATE, nullptr, &s_PlayerHeadHurl[0]}, }; #define PLAYER_NINJA_DIE_RATE 22 -STATE s_PlayerDeath[1][10] = +FState s_PlayerDeath[] = { - { - {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], + {SPR_PLAYER_NINJA_DIE, 'A', PLAYER_NINJA_DIE_RATE, nullptr, &s_PlayerDeath[1]}, + {SPR_PLAYER_NINJA_DIE, 'B', PLAYER_NINJA_DIE_RATE, nullptr, &s_PlayerDeath[2]}, + {SPR_PLAYER_NINJA_DIE, 'C', PLAYER_NINJA_DIE_RATE, nullptr, &s_PlayerDeath[3]}, + {SPR_PLAYER_NINJA_DIE, 'D', PLAYER_NINJA_DIE_RATE, nullptr, &s_PlayerDeath[4]}, + {SPR_PLAYER_NINJA_DIE, 'E', PLAYER_NINJA_DIE_RATE, nullptr, &s_PlayerDeath[5]}, + {SPR_PLAYER_NINJA_DIE, 'F', PLAYER_NINJA_DIE_RATE, nullptr, &s_PlayerDeath[6]}, + {SPR_PLAYER_NINJA_DIE, 'G', PLAYER_NINJA_DIE_RATE, nullptr, &s_PlayerDeath[7]}, + {SPR_PLAYER_NINJA_DIE, 'H', PLAYER_NINJA_DIE_RATE, nullptr, &s_PlayerDeath[8]}, + {SPR_PLAYER_NINJA_DIE, 'I', 0 | SF_QUICK_CALL, &AF(QueueFloorBlood), &s_PlayerDeath[9]}, + {SPR_PLAYER_NINJA_DIE, 'I', PLAYER_NINJA_DIE_RATE, nullptr, &s_PlayerDeath[9]}, }; ////////////////////// @@ -471,22 +384,15 @@ STATE* sg_PlayerDeath[] = #define PLAYER_NINJA_SWORD_RATE 12 -STATE s_PlayerNinjaSword[1][4] = +FState s_PlayerNinjaSword[] = { - { - {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]}, - }, + {SPR_PLAYER_NINJA_SWORD, 'A', PLAYER_NINJA_SWORD_RATE, nullptr, &s_PlayerNinjaSword[1]}, + {SPR_PLAYER_NINJA_SWORD, 'B', PLAYER_NINJA_SWORD_RATE, nullptr, &s_PlayerNinjaSword[2]}, + {SPR_PLAYER_NINJA_SWORD, 'C', PLAYER_NINJA_SWORD_RATE, nullptr, &s_PlayerNinjaSword[3]}, + {SPR_PLAYER_NINJA_SWORD, 'C', PLAYER_NINJA_SWORD_RATE | SF_PLAYER_FUNC, &AF(DoPlayerSpriteReset), &s_PlayerNinjaSword[0]}, }; -STATE* sg_PlayerNinjaSword[] = -{ - s_PlayerNinjaSword[0], -}; - ////////////////////// // // PLAYER NINJA PUNCH @@ -495,21 +401,46 @@ STATE* sg_PlayerNinjaSword[] = #define PLAYER_NINJA_PUNCH_RATE 15 -STATE s_PlayerNinjaPunch[1][4] = +FState s_PlayerNinjaPunch[] = { - { - {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]}, - }, + {SPR_PLAYER_NINJA_PUNCH, 'A', PLAYER_NINJA_PUNCH_RATE, nullptr, &s_PlayerNinjaPunch[1]}, + {SPR_PLAYER_NINJA_PUNCH, 'B', PLAYER_NINJA_PUNCH_RATE, nullptr, &s_PlayerNinjaPunch[2]}, + {SPR_PLAYER_NINJA_PUNCH, 'B', PLAYER_NINJA_PUNCH_RATE | SF_PLAYER_FUNC, &AF(DoPlayerSpriteReset), &s_PlayerNinjaPunch[2]}, }; -STATE* sg_PlayerNinjaPunch[] = +ACTOR_ACTION_SET PlayerNinjaActionSet = { - s_PlayerNinjaPunch[0], + s_PlayerNinjaStand, + s_PlayerNinjaRun, + s_PlayerNinjaJump, + s_PlayerNinjaFall, + //s_NinjaJump, + //s_NinjaFall, + s_PlayerNinjaCrawl, + s_PlayerNinjaSwim, + s_NinjaFly, + s_NinjaRise, + s_NinjaSit, + nullptr, + s_PlayerNinjaClimb, + s_NinjaPain, + s_NinjaDie, + s_NinjaHariKari, + s_NinjaDead, + s_NinjaDeathJump, + s_NinjaDeathFall, + {s_NinjaStar, s_NinjaUzi}, + {1000, 1024}, + {s_NinjaStar, s_NinjaUzi}, + {800, 1024}, + {nullptr}, + s_NinjaDuck, + s_PlayerNinjaSwim }; + + ////////////////////// // // PLAYER NINJA FLY @@ -519,19 +450,12 @@ STATE* sg_PlayerNinjaPunch[] = #define PLAYER_NINJA_FLY_RATE 15 -STATE s_PlayerNinjaFly[1][4] = +FState s_PlayerNinjaFly[] = { - { - {SPR_PLAYER_NINJA_FLY, 'A', PLAYER_NINJA_FLY_RATE, nullptr, &s_PlayerNinjaFly[0][0]}, - }, + {SPR_PLAYER_NINJA_FLY, 'A', PLAYER_NINJA_FLY_RATE, nullptr, &s_PlayerNinjaFly[0]}, }; -STATE* sg_PlayerNinjaFly[] = -{ - s_PlayerNinjaFly[0], -}; - //--------------------------------------------------------------------------- // // @@ -542,10 +466,10 @@ void DoPlayerSpriteThrow(DSWPlayer* pp) { if (!(pp->Flags & (PF_DIVING|PF_FLYING|PF_CRAWLING))) { - if (pp->CurWpn == pp->Wpn[WPN_SWORD] && pp->GetActor()->user.__legacyState.Rot != sg_PlayerNinjaSword) - NewStateGroup(pp->GetActor(), sg_PlayerNinjaSword); + if (pp->CurWpn == pp->Wpn[WPN_SWORD] && pp->GetActor()->user.__legacyState.Rot != s_PlayerNinjaSword) + NewStateGroup(pp->GetActor(), s_PlayerNinjaSword); else - NewStateGroup(pp->GetActor(), sg_PlayerNinjaPunch); + NewStateGroup(pp->GetActor(), s_PlayerNinjaPunch); } } @@ -821,7 +745,7 @@ void DoPlayerTeleportToOffset(DSWPlayer* pp) void DoSpawnTeleporterEffect(DSWActor* actor) { - extern STATE s_TeleportEffect[]; + extern FState s_TeleportEffect[]; DVector2 vect = actor->spr.Angles.Yaw.ToVector() * 32; auto effectActor = SpawnActor(STAT_MISSILE, 0, s_TeleportEffect, actor->sector(), @@ -845,7 +769,7 @@ void DoSpawnTeleporterEffect(DSWActor* actor) void DoSpawnTeleporterEffectPlace(DSWActor* actor) { - extern STATE s_TeleportEffect[]; + extern FState s_TeleportEffect[]; auto effectActor = SpawnActor(STAT_MISSILE, 0, s_TeleportEffect, actor->sector(), ActorVectOfTop(actor).plusZ(16), actor->spr.Angles.Yaw); @@ -2628,7 +2552,7 @@ void DoPlayerBeginClimb(DSWPlayer* pp) pp->Flags |= (PF_CLIMBING|PF_WEAPON_DOWN); actor->spr.cstat |= (CSTAT_SPRITE_YCENTER); - NewStateGroup(pp->GetActor(), sg_PlayerNinjaClimb); + NewStateGroup(pp->GetActor(), s_PlayerNinjaClimb); } //--------------------------------------------------------------------------- @@ -2719,7 +2643,7 @@ void DoPlayerClimb(DSWPlayer* pp) { // put player at the hiz pp->posZset(pp->hiz); - NewStateGroup(pp->GetActor(), sg_PlayerNinjaClimb); + NewStateGroup(pp->GetActor(), s_PlayerNinjaClimb); } // if player gets to close the ceiling while climbing @@ -2727,7 +2651,7 @@ void DoPlayerClimb(DSWPlayer* pp) { // put player at the ceiling pp->posZset(pp->LadderSector->ceilingz + 4); - NewStateGroup(pp->GetActor(), sg_PlayerNinjaClimb); + NewStateGroup(pp->GetActor(), s_PlayerNinjaClimb); } // if floor is ABOVE you && your head goes above it, do a jump up to @@ -2766,7 +2690,7 @@ void DoPlayerClimb(DSWPlayer* pp) } else { - NewStateGroup(pp->GetActor(), sg_PlayerNinjaClimb); + NewStateGroup(pp->GetActor(), s_PlayerNinjaClimb); } // setsprite to players location @@ -3017,7 +2941,7 @@ void DoPlayerBeginFly(DSWPlayer* pp) pp->pbob_amt = 0; pp->bob_ndx = 1024; - NewStateGroup(pp->GetActor(), sg_PlayerNinjaFly); + NewStateGroup(pp->GetActor(), s_PlayerNinjaFly); } //--------------------------------------------------------------------------- @@ -5166,7 +5090,7 @@ void DoPlayerBeginDie(DSWPlayer* pp) pp->Flags |= (PF_JUMPING); plActor->user.ID = NINJA_DEAD; pp->jump_speed = -200; - NewStateGroup(pp->GetActor(), sg_PlayerDeath); + NewStateGroup(pp->GetActor(), s_PlayerDeath); DoFindGround(pp->GetActor()); DoBeginJump(pp->GetActor()); plActor->user.jump_speed = -300; @@ -5180,7 +5104,7 @@ void DoPlayerBeginDie(DSWPlayer* pp) pp->Flags |= (PF_JUMPING); plActor->user.ID = NINJA_DEAD; pp->jump_speed = -300; - NewStateGroup(pp->GetActor(), sg_PlayerDeath); + NewStateGroup(pp->GetActor(), s_PlayerDeath); //pp->ceiling_dist = Z(0); //pp->floor_dist = Z(0); @@ -5200,7 +5124,7 @@ void DoPlayerBeginDie(DSWPlayer* pp) plActor->user.slide_vel = 0; SpawnShrap(pp->GetActor(), nullptr); plActor->spr.cstat |= (CSTAT_SPRITE_YCENTER); - NewStateGroup(pp->GetActor(), sg_PlayerHeadFly); + NewStateGroup(pp->GetActor(), s_PlayerHeadFly); plActor->user.ID = NINJA_Head_R0; plActor->spr.scale = DVector2(0.75, 0.75); // Blood fountains @@ -5214,7 +5138,7 @@ void DoPlayerBeginDie(DSWPlayer* pp) pp->jump_speed = -650; SpawnShrap(pp->GetActor(), nullptr); plActor->spr.cstat |= (CSTAT_SPRITE_YCENTER); - NewStateGroup(pp->GetActor(), sg_PlayerHeadFly); + NewStateGroup(pp->GetActor(), s_PlayerHeadFly); plActor->user.ID = NINJA_Head_R0; plActor->spr.scale = DVector2(0.75, 0.75); // Blood fountains @@ -5231,7 +5155,7 @@ void DoPlayerBeginDie(DSWPlayer* pp) plActor->user.slide_vel = 50; SpawnShrap(pp->GetActor(), nullptr); plActor->spr.cstat |= (CSTAT_SPRITE_YCENTER); - NewStateGroup(pp->GetActor(), sg_PlayerHeadFly); + NewStateGroup(pp->GetActor(), s_PlayerHeadFly); plActor->user.ID = NINJA_Head_R0; plActor->spr.scale = DVector2(0.75, 0.75); // Blood fountains @@ -5304,7 +5228,7 @@ void DoPlayerDeathHurl(DSWPlayer* pp) pp->Flags |= (PF_HEAD_CONTROL); - NewStateGroup(pp->GetActor(), sg_PlayerHeadHurl); + NewStateGroup(pp->GetActor(), s_PlayerHeadHurl); if (MoveSkip4 == 0) { SpawnShrap(pp->GetActor(), nullptr); @@ -5317,7 +5241,7 @@ void DoPlayerDeathHurl(DSWPlayer* pp) } if (!(pp->Flags & (PF_JUMPING|PF_FALLING))) - NewStateGroup(pp->GetActor(), sg_PlayerHead); + NewStateGroup(pp->GetActor(), s_PlayerHead); } @@ -5474,7 +5398,7 @@ void DoPlayerDeathCheckKick(DSWPlayer* pp) plActor->user.slide_vel = itActor->vel.X * 2; plActor->user.Flags &= ~(SPR_BOUNCE); pp->jump_speed = -500; - NewStateGroup(pp->GetActor(), sg_PlayerHeadFly); + NewStateGroup(pp->GetActor(), s_PlayerHeadFly); pp->Flags |= (PF_JUMPING); SpawnShrap(pp->GetActor(), nullptr); } @@ -5490,7 +5414,7 @@ void DoPlayerDeathCheckKick(DSWPlayer* pp) plActor->user.slide_vel = 62.5; plActor->user.Flags &= ~(SPR_BOUNCE); pp->jump_speed = -100; - NewStateGroup(pp->GetActor(), sg_PlayerHeadFly); + NewStateGroup(pp->GetActor(), s_PlayerHeadFly); pp->Flags |= (PF_JUMPING); SpawnShrap(pp->GetActor(), nullptr); } @@ -5654,7 +5578,7 @@ void DoPlayerDeathBounce(DSWPlayer* pp) if (pp->lo_sectp && (pp->lo_sectp->extra & SECTFX_SINK)) { plActor->spr.cstat &= ~(CSTAT_SPRITE_BLOCK|CSTAT_SPRITE_BLOCK_HITSCAN); - NewStateGroup(pp->GetActor(), sg_PlayerHead); + NewStateGroup(pp->GetActor(), s_PlayerHead); plActor->user.slide_vel = 0; plActor->user.Flags |= (SPR_BOUNCE); @@ -5708,7 +5632,7 @@ void DoPlayerDeathCrumble(DSWPlayer* pp) } plActor->spr.cstat &= ~(CSTAT_SPRITE_BLOCK|CSTAT_SPRITE_BLOCK_HITSCAN); - NewStateGroup(pp->GetActor(), sg_PlayerHead); + NewStateGroup(pp->GetActor(), s_PlayerHead); } else { @@ -5765,7 +5689,7 @@ void DoPlayerDeathExplode(DSWPlayer* pp) } plActor->spr.cstat &= ~(CSTAT_SPRITE_BLOCK|CSTAT_SPRITE_BLOCK_HITSCAN); - NewStateGroup(pp->GetActor(), sg_PlayerHead); + NewStateGroup(pp->GetActor(), s_PlayerHead); } else { @@ -5929,7 +5853,7 @@ void DoPlayerRun(DSWPlayer* pp) // Move about DoPlayerMove(pp); - if (plActor->user.__legacyState.Rot != sg_PlayerNinjaSword && plActor->user.__legacyState.Rot != sg_PlayerNinjaPunch) + if (plActor->user.__legacyState.Rot != s_PlayerNinjaSword && plActor->user.__legacyState.Rot != s_PlayerNinjaPunch) { if (pp->Flags & (PF_PLAYER_MOVED)) { @@ -6013,9 +5937,9 @@ void PlayerStateControl(DSWActor* actor) actor->user.__legacyState.State = actor->user.__legacyState.State->NextState; } - if (actor->user.__legacyState.State->Sprite == SPR_NULL) + if (actor->user.__legacyState.State->sprite == SPR_NULL) { - NewStateGroup(actor, (STATE* *) actor->user.__legacyState.State->NextState); + NewStateGroup(actor, actor->user.__legacyState.State->NextState); } } @@ -6726,35 +6650,20 @@ static saveable_code saveable_player_code[] = static saveable_data saveable_player_data[] = { SAVE_DATA(s_PlayerNinjaRun), - SAVE_DATA(sg_PlayerNinjaRun), SAVE_DATA(s_PlayerNinjaStand), - SAVE_DATA(sg_PlayerNinjaStand), SAVE_DATA(s_PlayerNinjaThrow), - SAVE_DATA(sg_PlayerNinjaThrow), SAVE_DATA(s_PlayerNinjaJump), - SAVE_DATA(sg_PlayerNinjaJump), SAVE_DATA(s_PlayerNinjaFall), - SAVE_DATA(sg_PlayerNinjaFall), SAVE_DATA(s_PlayerNinjaClimb), - SAVE_DATA(sg_PlayerNinjaClimb), SAVE_DATA(s_PlayerNinjaCrawl), - SAVE_DATA(sg_PlayerNinjaCrawl), SAVE_DATA(s_PlayerNinjaSwim), - SAVE_DATA(sg_PlayerNinjaSwim), SAVE_DATA(s_PlayerHeadFly), - SAVE_DATA(sg_PlayerHeadFly), SAVE_DATA(s_PlayerHead), - SAVE_DATA(sg_PlayerHead), SAVE_DATA(s_PlayerHeadHurl), - SAVE_DATA(sg_PlayerHeadHurl), SAVE_DATA(s_PlayerDeath), - SAVE_DATA(sg_PlayerDeath), SAVE_DATA(s_PlayerNinjaSword), - SAVE_DATA(sg_PlayerNinjaSword), SAVE_DATA(s_PlayerNinjaPunch), - SAVE_DATA(sg_PlayerNinjaPunch), SAVE_DATA(s_PlayerNinjaFly), - SAVE_DATA(sg_PlayerNinjaFly), }; saveable_module saveable_player = diff --git a/source/games/sw/src/ripper.cpp b/source/games/sw/src/ripper.cpp index 453750ca2..3052d97a2 100644 --- a/source/games/sw/src/ripper.cpp +++ b/source/games/sw/src/ripper.cpp @@ -117,20 +117,12 @@ ATTRIBUTE RipperAttrib = #define RIPPER_RUN_RATE 16 -STATE s_RipperRun[1][4] = +FState s_RipperRun[] = { - { - {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]}, - }, -}; - - -STATE* sg_RipperRun[] = -{ - &s_RipperRun[0][0], + {SPR_RIPPER_RUN, 'A', RIPPER_RUN_RATE | SF_TIC_ADJUST, &AF(DoRipperMove), &s_RipperRun[1]}, + {SPR_RIPPER_RUN, 'B', RIPPER_RUN_RATE | SF_TIC_ADJUST, &AF(DoRipperMove), &s_RipperRun[2]}, + {SPR_RIPPER_RUN, 'C', RIPPER_RUN_RATE | SF_TIC_ADJUST, &AF(DoRipperMove), &s_RipperRun[3]}, + {SPR_RIPPER_RUN, 'D', RIPPER_RUN_RATE | SF_TIC_ADJUST, &AF(DoRipperMove), &s_RipperRun[0]}, }; ////////////////////// @@ -141,19 +133,12 @@ STATE* sg_RipperRun[] = #define RIPPER_STAND_RATE 12 -STATE s_RipperStand[1][1] = +FState s_RipperStand[] = { - { - {SPR_RIPPER_STAND, 'A', RIPPER_STAND_RATE, &AF(DoRipperMove), &s_RipperStand[0][0]}, - }, + {SPR_RIPPER_STAND, 'A', RIPPER_STAND_RATE, &AF(DoRipperMove), &s_RipperStand[0]}, }; -STATE* sg_RipperStand[] = -{ - s_RipperStand[0], -}; - ////////////////////// // // RIPPER SWIPE @@ -162,24 +147,16 @@ STATE* sg_RipperStand[] = #define RIPPER_SWIPE_RATE 8 -STATE s_RipperSwipe[1][8] = +FState s_RipperSwipe[] = { - { - {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]}, - }, -}; - - -STATE* sg_RipperSwipe[] = -{ - &s_RipperSwipe[0][0], + {SPR_RIPPER_SWIPE, 'A', RIPPER_SWIPE_RATE, &AF(NullRipper), &s_RipperSwipe[1]}, + {SPR_RIPPER_SWIPE, 'B', RIPPER_SWIPE_RATE, &AF(NullRipper), &s_RipperSwipe[2]}, + {SPR_RIPPER_SWIPE, 'B', 0 | SF_QUICK_CALL, &AF(InitRipperSlash), &s_RipperSwipe[3]}, + {SPR_RIPPER_SWIPE, 'C', RIPPER_SWIPE_RATE, &AF(NullRipper), &s_RipperSwipe[4]}, + {SPR_RIPPER_SWIPE, 'D', RIPPER_SWIPE_RATE, &AF(NullRipper), &s_RipperSwipe[5]}, + {SPR_RIPPER_SWIPE, 'D', 0 | SF_QUICK_CALL, &AF(InitRipperSlash), &s_RipperSwipe[6]}, + {SPR_RIPPER_SWIPE, 'D', 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_RipperSwipe[7]}, + {SPR_RIPPER_SWIPE, 'D', RIPPER_SWIPE_RATE, &AF(DoRipperMove), &s_RipperSwipe[7]}, }; @@ -191,23 +168,15 @@ STATE* sg_RipperSwipe[] = #define RIPPER_SPEW_RATE 8 -STATE s_RipperSpew[1][7] = +FState s_RipperSpew[] = { - { - {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]}, - }, -}; - - -STATE* sg_RipperSpew[] = -{ - &s_RipperSpew[0][0], + {SPR_RIPPER_SWIPE, 'A', RIPPER_SPEW_RATE, &AF(NullRipper), &s_RipperSpew[1]}, + {SPR_RIPPER_SWIPE, 'B', RIPPER_SPEW_RATE, &AF(NullRipper), &s_RipperSpew[2]}, + {SPR_RIPPER_SWIPE, 'B', 0 | SF_QUICK_CALL, &AF(InitCoolgFire), &s_RipperSpew[3]}, + {SPR_RIPPER_SWIPE, 'C', RIPPER_SPEW_RATE, &AF(NullRipper), &s_RipperSpew[4]}, + {SPR_RIPPER_SWIPE, 'D', RIPPER_SPEW_RATE, &AF(NullRipper), &s_RipperSpew[5]}, + {SPR_RIPPER_SWIPE, 'D', 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_RipperSpew[6]}, + {SPR_RIPPER_SWIPE, 'D', RIPPER_SPEW_RATE, &AF(DoRipperMove), &s_RipperSpew[6]}, }; @@ -219,16 +188,9 @@ STATE* sg_RipperSpew[] = #define RIPPER_HEART_RATE 14 -STATE s_RipperHeart[1][4] = +FState s_RipperHeart[] = { - { - {SPR_RIPPER_HEART, 'A', RIPPER_HEART_RATE, &AF(DoRipperStandHeart), &s_RipperHeart[0][0]}, - }, -}; - -STATE* sg_RipperHeart[] = -{ - &s_RipperHeart[0][0], + {SPR_RIPPER_HEART, 'A', RIPPER_HEART_RATE, &AF(DoRipperStandHeart), &s_RipperHeart[0]}, }; ////////////////////// @@ -239,17 +201,9 @@ STATE* sg_RipperHeart[] = #define RIPPER_HANG_RATE 14 -STATE s_RipperHang[1][4] = +FState s_RipperHang[] = { - { - {SPR_RIPPER_HANG, 'A', RIPPER_HANG_RATE, &AF(DoRipperHang), &s_RipperHang[0][0]}, - }, -}; - - -STATE* sg_RipperHang[] = -{ - &s_RipperHang[0][0], + {SPR_RIPPER_HANG, 'A', RIPPER_HANG_RATE, &AF(DoRipperHang), &s_RipperHang[0]}, }; @@ -261,16 +215,9 @@ STATE* sg_RipperHang[] = #define RIPPER_PAIN_RATE 38 -STATE s_RipperPain[1][1] = +FState s_RipperPain[] = { - { - {SPR_RIPPER_JUMP, 'A', RIPPER_PAIN_RATE, &AF(DoRipperPain), &s_RipperPain[0][0]}, - }, -}; - -STATE* sg_RipperPain[] = -{ - &s_RipperPain[0][0], + {SPR_RIPPER_JUMP, 'A', RIPPER_PAIN_RATE, &AF(DoRipperPain), &s_RipperPain[0]}, }; ////////////////////// @@ -281,18 +228,10 @@ STATE* sg_RipperPain[] = #define RIPPER_JUMP_RATE 25 -STATE s_RipperJump[1][6] = +FState s_RipperJump[] = { - { - {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]}, - }, -}; - - -STATE* sg_RipperJump[] = -{ - &s_RipperJump[0][0], + {SPR_RIPPER_JUMP, 'A', RIPPER_JUMP_RATE, &AF(NullRipper), &s_RipperJump[1]}, + {SPR_RIPPER_JUMP, 'B', RIPPER_JUMP_RATE, &AF(DoRipperMoveJump), &s_RipperJump[1]}, }; @@ -304,17 +243,9 @@ STATE* sg_RipperJump[] = #define RIPPER_FALL_RATE 25 -STATE s_RipperFall[1][6] = +FState s_RipperFall[] = { - { - {SPR_RIPPER_FALL, 'A', RIPPER_FALL_RATE, &AF(DoRipperMoveJump), &s_RipperFall[0][0]}, - }, -}; - - -STATE* sg_RipperFall[] = -{ - &s_RipperFall[0][0], + {SPR_RIPPER_FALL, 'A', RIPPER_FALL_RATE, &AF(DoRipperMoveJump), &s_RipperFall[0]}, }; @@ -327,19 +258,11 @@ STATE* sg_RipperFall[] = #define RIPPER_JUMP_ATTACK_RATE 35 int DoRipperBeginJumpAttack(DSWActor* actor); -STATE s_RipperJumpAttack[1][6] = +FState s_RipperJumpAttack[] = { - { - {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]}, - }, -}; - - -STATE* sg_RipperJumpAttack[] = -{ - &s_RipperJumpAttack[0][0], + {SPR_RIPPER_JUMP, 'A', RIPPER_JUMP_ATTACK_RATE, &AF(NullRipper), &s_RipperJumpAttack[1]}, + {SPR_RIPPER_JUMP, 'A', 0 | SF_QUICK_CALL, &AF(DoRipperBeginJumpAttack), &s_RipperJumpAttack[2]}, + {SPR_RIPPER_JUMP, 'B', RIPPER_JUMP_ATTACK_RATE, &AF(DoRipperMoveJump), &s_RipperJumpAttack[2]}, }; @@ -351,20 +274,13 @@ STATE* sg_RipperJumpAttack[] = #define RIPPER_HANG_JUMP_RATE 20 -STATE s_RipperHangJump[1][6] = +FState s_RipperHangJump[] = { - { - {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]}, - }, + {SPR_RIPPER_JUMP, 'A', RIPPER_HANG_JUMP_RATE, &AF(NullRipper), &s_RipperHangJump[1]}, + {SPR_RIPPER_JUMP, 'B', RIPPER_HANG_JUMP_RATE, &AF(DoRipperHangJF), &s_RipperHangJump[1]}, }; -STATE* sg_RipperHangJump[] = -{ - &s_RipperHangJump[0][0], -}; - ////////////////////// // // RIPPER HANG_FALL @@ -373,21 +289,12 @@ STATE* sg_RipperHangJump[] = #define RIPPER_FALL_RATE 25 -STATE s_RipperHangFall[1][6] = +FState s_RipperHangFall[] = { - { - {SPR_RIPPER_FALL, 'A', RIPPER_FALL_RATE, &AF(DoRipperHangJF), &s_RipperHangFall[0][0]}, - }, + {SPR_RIPPER_FALL, 'A', RIPPER_FALL_RATE, &AF(DoRipperHangJF), &s_RipperHangFall[0]}, }; -STATE* sg_RipperHangFall[] = -{ - &s_RipperHangFall[0][0], -}; - - - ////////////////////// // // RIPPER DIE @@ -396,7 +303,7 @@ STATE* sg_RipperHangFall[] = #define RIPPER_DIE_RATE 16 -STATE s_RipperDie[] = +FState s_RipperDie[] = { {SPR_RIPPER_DIE, 'A', RIPPER_DIE_RATE, &AF(NullRipper), &s_RipperDie[1]}, {SPR_RIPPER_DIE, 'B', RIPPER_DIE_RATE, &AF(NullRipper), &s_RipperDie[2]}, @@ -407,7 +314,7 @@ STATE s_RipperDie[] = #define RIPPER_DEAD_RATE 8 -STATE s_RipperDead[] = +FState s_RipperDead[] = { {SPR_RIPPER_DIE, 'C', RIPPER_DEAD_RATE, nullptr, &s_RipperDead[1]}, {SPR_RIPPER_DIE, 'D', RIPPER_DEAD_RATE, nullptr, &s_RipperDead[2]}, @@ -415,114 +322,93 @@ STATE s_RipperDead[] = {SPR_RIPPER_DEAD, 'A', RIPPER_DEAD_RATE, &AF(DoActorDebris), &s_RipperDead[3]}, }; -STATE* sg_RipperDie[] = -{ - s_RipperDie -}; - -STATE* sg_RipperDead[] = -{ - s_RipperDead -}; - -STATE s_RipperDeathJump[] = +FState s_RipperDeathJump[] = { {SPR_RIPPER_DIE, 'A', RIPPER_DIE_RATE, &AF(DoActorDeathMove), &s_RipperDeathJump[0]} }; -STATE s_RipperDeathFall[] = +FState s_RipperDeathFall[] = { {SPR_RIPPER_DIE, 'B', RIPPER_DIE_RATE, &AF(DoActorDeathMove), &s_RipperDeathFall[0]} }; -STATE* sg_RipperDeathJump[] = -{ - s_RipperDeathJump -}; - -STATE* sg_RipperDeathFall[] = -{ - s_RipperDeathFall -}; - - /* -STATE* *Stand[MAX_WEAPONS]; -STATE* *Run; -STATE* *Jump; -STATE* *Fall; -STATE* *Crawl; -STATE* *Swim; -STATE* *Fly; -STATE* *Rise; -STATE* *Sit; -STATE* *Look; -STATE* *Climb; -STATE* *Pain; -STATE* *Death1; -STATE* *Death2; -STATE* *Dead; -STATE* *DeathJump; -STATE* *DeathFall; -STATE* *CloseAttack[2]; -STATE* *Attack[6]; -STATE* *Special[2]; +FState* *Stand[MAX_WEAPONS]; +FState* *Run; +FState* *Jump; +FState* *Fall; +FState* *Crawl; +FState* *Swim; +FState* *Fly; +FState* *Rise; +FState* *Sit; +FState* *Look; +FState* *Climb; +FState* *Pain; +FState* *Death1; +FState* *Death2; +FState* *Dead; +FState* *DeathJump; +FState* *DeathFall; +FState* *CloseAttack[2]; +FState* *Attack[6]; +FState* *Special[2]; */ ACTOR_ACTION_SET RipperActionSet = { - sg_RipperStand, - sg_RipperRun, - sg_RipperJump, - sg_RipperFall, - nullptr, // sg_RipperCrawl, - nullptr, // sg_RipperSwim, - nullptr, // sg_RipperFly, - nullptr, // sg_RipperRise, - nullptr, // sg_RipperSit, - nullptr, // sg_RipperLook, + s_RipperStand, + s_RipperRun, + s_RipperJump, + s_RipperFall, + nullptr, // s_RipperCrawl, + nullptr, // s_RipperSwim, + nullptr, // s_RipperFly, + nullptr, // s_RipperRise, + nullptr, // s_RipperSit, + nullptr, // s_RipperLook, nullptr, // climb - sg_RipperPain, - sg_RipperDie, - nullptr, // sg_RipperHariKari, - sg_RipperDead, - sg_RipperDeathJump, - sg_RipperDeathFall, - {sg_RipperSwipe,sg_RipperSpew}, + s_RipperPain, + s_RipperDie, + nullptr, // s_RipperHariKari, + s_RipperDead, + s_RipperDeathJump, + s_RipperDeathFall, + {s_RipperSwipe,s_RipperSpew}, {800,1024}, - {sg_RipperJumpAttack, sg_RipperSpew}, + {s_RipperJumpAttack, s_RipperSpew}, {400, 1024}, - {sg_RipperHeart, sg_RipperHang}, + {s_RipperHeart, s_RipperHang}, nullptr, nullptr }; ACTOR_ACTION_SET RipperBrownActionSet = { - sg_RipperStand, - sg_RipperRun, - sg_RipperJump, - sg_RipperFall, - nullptr, // sg_RipperCrawl, - nullptr, // sg_RipperSwim, - nullptr, // sg_RipperFly, - nullptr, // sg_RipperRise, - nullptr, // sg_RipperSit, - nullptr, // sg_RipperLook, + s_RipperStand, + s_RipperRun, + s_RipperJump, + s_RipperFall, + nullptr, // s_RipperCrawl, + nullptr, // s_RipperSwim, + nullptr, // s_RipperFly, + nullptr, // s_RipperRise, + nullptr, // s_RipperSit, + nullptr, // s_RipperLook, nullptr, // climb - sg_RipperPain, // pain - sg_RipperDie, - nullptr, // sg_RipperHariKari, - sg_RipperDead, - sg_RipperDeathJump, - sg_RipperDeathFall, - {sg_RipperSwipe}, + s_RipperPain, // pain + s_RipperDie, + nullptr, // s_RipperHariKari, + s_RipperDead, + s_RipperDeathJump, + s_RipperDeathFall, + {s_RipperSwipe}, {1024}, - {sg_RipperJumpAttack, sg_RipperSwipe}, + {s_RipperJumpAttack, s_RipperSwipe}, {800, 1024}, - {sg_RipperHeart, sg_RipperHang}, + {s_RipperHeart, s_RipperHang}, nullptr, nullptr }; @@ -545,7 +431,7 @@ int SetupRipper(DSWActor* actor) actor->user.__legacyState.Attrib = &RipperAttrib; DoActorSetSpeed(actor, FAST_SPEED); actor->user.__legacyState.StateEnd = s_RipperDie; - actor->user.__legacyState.Rot = sg_RipperRun; + actor->user.__legacyState.Rot = s_RipperRun; actor->spr.scale = DVector2(1, 1); if (actor->spr.pal == PALETTE_BROWN_RIPPER) @@ -688,8 +574,8 @@ int InitRipperHang(DSWActor* actor) return 0; } - NewStateGroup(actor, sg_RipperHangJump); - actor->user.__legacyState.StateFallOverride = sg_RipperHangFall; + NewStateGroup(actor, s_RipperHangJump); + actor->user.__legacyState.StateFallOverride = s_RipperHangFall; DoActorSetSpeed(actor, FAST_SPEED); PickJumpMaxSpeed(actor, -800); @@ -716,7 +602,7 @@ int DoRipperHang(DSWActor* actor) if ((actor->user.WaitTics -= ACTORMOVETICS) > 0) return 0; - NewStateGroup(actor, sg_RipperJumpAttack); + NewStateGroup(actor, s_RipperJumpAttack); // move to the 2nd frame - past the pause frame actor->user.Tics += actor->user.__legacyState.State->Tics; return 0; @@ -861,7 +747,7 @@ int DoRipperQuickJump(DSWActor* actor) { if ((low->spr.extra & SPRX_PLAYER_OR_ENEMY)) { - NewStateGroup(actor, sg_RipperJumpAttack); + NewStateGroup(actor, s_RipperJumpAttack); // move past the first state actor->user.Tics = 30; return true; @@ -914,7 +800,7 @@ int DoRipperRipHeart(DSWActor* actor) { DSWActor* target = actor->user.targetActor; - NewStateGroup(actor, sg_RipperHeart); + NewStateGroup(actor, s_RipperHeart); actor->user.WaitTics = 6 * 120; // player face ripper @@ -934,7 +820,7 @@ int DoRipperStandHeart(DSWActor* actor) NullRipper(actor); if ((actor->user.WaitTics -= ACTORMOVETICS) <= 0) - NewStateGroup(actor, sg_RipperRun); + NewStateGroup(actor, s_RipperRun); return 0; } @@ -1035,37 +921,21 @@ static saveable_data saveable_ripper_data[] = SAVE_DATA(RipperAttrib), SAVE_DATA(s_RipperRun), - SAVE_DATA(sg_RipperRun), SAVE_DATA(s_RipperStand), - SAVE_DATA(sg_RipperStand), SAVE_DATA(s_RipperSwipe), - SAVE_DATA(sg_RipperSwipe), SAVE_DATA(s_RipperSpew), - SAVE_DATA(sg_RipperSpew), SAVE_DATA(s_RipperHeart), - SAVE_DATA(sg_RipperHeart), SAVE_DATA(s_RipperHang), - SAVE_DATA(sg_RipperHang), SAVE_DATA(s_RipperPain), - SAVE_DATA(sg_RipperPain), SAVE_DATA(s_RipperJump), - SAVE_DATA(sg_RipperJump), SAVE_DATA(s_RipperFall), - SAVE_DATA(sg_RipperFall), SAVE_DATA(s_RipperJumpAttack), - SAVE_DATA(sg_RipperJumpAttack), SAVE_DATA(s_RipperHangJump), - SAVE_DATA(sg_RipperHangJump), SAVE_DATA(s_RipperHangFall), - SAVE_DATA(sg_RipperHangFall), SAVE_DATA(s_RipperDie), SAVE_DATA(s_RipperDead), - SAVE_DATA(sg_RipperDie), - SAVE_DATA(sg_RipperDead), SAVE_DATA(s_RipperDeathJump), SAVE_DATA(s_RipperDeathFall), - SAVE_DATA(sg_RipperDeathJump), - SAVE_DATA(sg_RipperDeathFall), SAVE_DATA(RipperActionSet), SAVE_DATA(RipperBrownActionSet), diff --git a/source/games/sw/src/ripper2.cpp b/source/games/sw/src/ripper2.cpp index 1f79bc2d1..d32b6ef82 100644 --- a/source/games/sw/src/ripper2.cpp +++ b/source/games/sw/src/ripper2.cpp @@ -115,20 +115,12 @@ ATTRIBUTE Ripper2Attrib = #define RIPPER2_RUN_RATE 16 -STATE s_Ripper2Run[1][4] = +FState s_Ripper2Run[] = { - { - {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]}, - }, -}; - - -STATE* sg_Ripper2Run[] = -{ - &s_Ripper2Run[0][0], + {SPR_RIPPER2_RUN, 'A', RIPPER2_RUN_RATE | SF_TIC_ADJUST, &AF(DoRipper2Move), &s_Ripper2Run[1]}, + {SPR_RIPPER2_RUN, 'B', RIPPER2_RUN_RATE | SF_TIC_ADJUST, &AF(DoRipper2Move), &s_Ripper2Run[2]}, + {SPR_RIPPER2_RUN, 'C', RIPPER2_RUN_RATE | SF_TIC_ADJUST, &AF(DoRipper2Move), &s_Ripper2Run[3]}, + {SPR_RIPPER2_RUN, 'D', RIPPER2_RUN_RATE | SF_TIC_ADJUST, &AF(DoRipper2Move), &s_Ripper2Run[0]}, }; ////////////////////// @@ -139,22 +131,15 @@ STATE* sg_Ripper2Run[] = #define RIPPER2_RUNFAST_RATE 14 -STATE s_Ripper2RunFast[1][4] = +FState s_Ripper2RunFast[] = { - { - {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]}, - }, + {SPR_RIPPER2_RUNFAST, 'A', RIPPER2_RUNFAST_RATE | SF_TIC_ADJUST, &AF(DoRipper2Move), &s_Ripper2RunFast[1]}, + {SPR_RIPPER2_RUNFAST, 'B', RIPPER2_RUNFAST_RATE | SF_TIC_ADJUST, &AF(DoRipper2Move), &s_Ripper2RunFast[2]}, + {SPR_RIPPER2_RUNFAST, 'C', RIPPER2_RUNFAST_RATE | SF_TIC_ADJUST, &AF(DoRipper2Move), &s_Ripper2RunFast[3]}, + {SPR_RIPPER2_RUNFAST, 'D', RIPPER2_RUNFAST_RATE | SF_TIC_ADJUST, &AF(DoRipper2Move), &s_Ripper2RunFast[0]}, }; -STATE* sg_Ripper2RunFast[] = -{ - &s_Ripper2RunFast[0][0], -}; - ////////////////////// // // RIPPER2 STAND @@ -163,16 +148,9 @@ STATE* sg_Ripper2RunFast[] = #define RIPPER2_STAND_RATE 12 -STATE s_Ripper2Stand[1][1] = +FState s_Ripper2Stand[] = { - { - {SPR_RIPPER2_STAND, 'A', RIPPER2_STAND_RATE, &AF(DoRipper2Move), &s_Ripper2Stand[0][0]}, - }, -}; - -STATE* sg_Ripper2Stand[] = -{ - s_Ripper2Stand[0], + {SPR_RIPPER2_STAND, 'A', RIPPER2_STAND_RATE, &AF(DoRipper2Move), &s_Ripper2Stand[0]}, }; ////////////////////// @@ -183,26 +161,19 @@ STATE* sg_Ripper2Stand[] = #define RIPPER2_SWIPE_RATE 14 -STATE s_Ripper2Swipe[1][8] = +FState s_Ripper2Swipe[] = { - { - {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]}, - }, + {SPR_RIPPER2_SWIPE, 'A', RIPPER2_SWIPE_RATE, &AF(NullRipper2), &s_Ripper2Swipe[1]}, + {SPR_RIPPER2_SWIPE, 'B', RIPPER2_SWIPE_RATE, &AF(NullRipper2), &s_Ripper2Swipe[2]}, + {SPR_RIPPER2_SWIPE, 'B', 0 | SF_QUICK_CALL, &AF(InitRipperSlash), &s_Ripper2Swipe[3]}, + {SPR_RIPPER2_SWIPE, 'C', RIPPER2_SWIPE_RATE, &AF(NullRipper2), &s_Ripper2Swipe[4]}, + {SPR_RIPPER2_SWIPE, 'D', RIPPER2_SWIPE_RATE, &AF(NullRipper2), &s_Ripper2Swipe[5]}, + {SPR_RIPPER2_SWIPE, 'D', 0 | SF_QUICK_CALL, &AF(InitRipperSlash), &s_Ripper2Swipe[6]}, + {SPR_RIPPER2_SWIPE, 'D', 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_Ripper2Swipe[7]}, + {SPR_RIPPER2_SWIPE, 'D', RIPPER2_SWIPE_RATE, &AF(DoRipper2Move), &s_Ripper2Swipe[7]}, }; -STATE* sg_Ripper2Swipe[] = -{ - &s_Ripper2Swipe[0][0], -}; - ////////////////////// // // RIPPER2 KONG @@ -211,23 +182,15 @@ STATE* sg_Ripper2Swipe[] = #define RIPPER2_MEKONG_RATE 18 -STATE s_Ripper2Kong[1][7] = +FState s_Ripper2Kong[] = { - { - {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]}, - }, -}; - - -STATE* sg_Ripper2Kong[] = -{ - &s_Ripper2Kong[0][0], + {SPR_RIPPER2_MEKONG, 'A', RIPPER2_MEKONG_RATE, &AF(NullRipper2), &s_Ripper2Kong[1]}, + {SPR_RIPPER2_MEKONG, 'A', SF_QUICK_CALL, &AF(ChestRipper2), &s_Ripper2Kong[2]}, + {SPR_RIPPER2_MEKONG, 'B', RIPPER2_MEKONG_RATE, &AF(NullRipper2), &s_Ripper2Kong[3]}, + {SPR_RIPPER2_MEKONG, 'C', RIPPER2_MEKONG_RATE, &AF(NullRipper2), &s_Ripper2Kong[4]}, + {SPR_RIPPER2_MEKONG, 'D', RIPPER2_MEKONG_RATE, &AF(NullRipper2), &s_Ripper2Kong[5]}, + {SPR_RIPPER2_MEKONG, 'D', 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_Ripper2Kong[6]}, + {SPR_RIPPER2_MEKONG, 'A', RIPPER2_MEKONG_RATE, &AF(DoRipper2Move), &s_Ripper2Kong[6]}, }; @@ -239,20 +202,13 @@ STATE* sg_Ripper2Kong[] = #define RIPPER2_HEART_RATE 20 -STATE s_Ripper2Heart[1][4] = +FState s_Ripper2Heart[] = { - { - {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]}, - }, + {SPR_RIPPER2_HEART, 'A', RIPPER2_HEART_RATE, &AF(DoRipper2StandHeart), &s_Ripper2Heart[1]}, + {SPR_RIPPER2_HEART, 'B', RIPPER2_HEART_RATE, &AF(DoRipper2StandHeart), &s_Ripper2Heart[0]}, }; -STATE* sg_Ripper2Heart[] = -{ - &s_Ripper2Heart[0][0], -}; - ////////////////////// // // RIPPER2 HANG @@ -261,17 +217,9 @@ STATE* sg_Ripper2Heart[] = #define RIPPER2_HANG_RATE 14 -STATE s_Ripper2Hang[1][4] = +FState s_Ripper2Hang[] = { - { - {SPR_RIPPER2_HANG, 'A', RIPPER2_HANG_RATE, &AF(DoRipper2Hang), &s_Ripper2Hang[0][0]}, - }, -}; - - -STATE* sg_Ripper2Hang[] = -{ - &s_Ripper2Hang[0][0], + {SPR_RIPPER2_HANG, 'A', RIPPER2_HANG_RATE, &AF(DoRipper2Hang), &s_Ripper2Hang[0]}, }; @@ -283,16 +231,9 @@ STATE* sg_Ripper2Hang[] = #define RIPPER2_PAIN_RATE 38 -STATE s_Ripper2Pain[1][1] = +FState s_Ripper2Pain[] = { - { - {SPR_RIPPER_DIE, 'A', RIPPER2_PAIN_RATE, &AF(DoRipper2Pain), &s_Ripper2Pain[0][0]}, - }, -}; - -STATE* sg_Ripper2Pain[] = -{ - &s_Ripper2Pain[0][0], + {SPR_RIPPER_DIE, 'A', RIPPER2_PAIN_RATE, &AF(DoRipper2Pain), &s_Ripper2Pain[0]}, }; ////////////////////// @@ -303,18 +244,10 @@ STATE* sg_Ripper2Pain[] = #define RIPPER2_JUMP_RATE 25 -STATE s_Ripper2Jump[1][2] = +FState s_Ripper2Jump[] = { - { - {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]}, - }, -}; - - -STATE* sg_Ripper2Jump[] = -{ - &s_Ripper2Jump[0][0], + {SPR_RIPPER2_JUMP, 'A', RIPPER2_JUMP_RATE, &AF(NullRipper2), &s_Ripper2Jump[1]}, + {SPR_RIPPER2_JUMP, 'B', RIPPER2_JUMP_RATE, &AF(DoRipper2MoveJump), &s_Ripper2Jump[1]}, }; @@ -326,17 +259,9 @@ STATE* sg_Ripper2Jump[] = #define RIPPER2_FALL_RATE 25 -STATE s_Ripper2Fall[1][6] = +FState s_Ripper2Fall[] = { - { - {SPR_RIPPER2_FALL, 'A', RIPPER2_FALL_RATE, &AF(DoRipper2MoveJump), &s_Ripper2Fall[0][0]}, - }, -}; - - -STATE* sg_Ripper2Fall[] = -{ - &s_Ripper2Fall[0][0], + {SPR_RIPPER2_FALL, 'A', RIPPER2_FALL_RATE, &AF(DoRipper2MoveJump), &s_Ripper2Fall[0]}, }; @@ -349,20 +274,12 @@ STATE* sg_Ripper2Fall[] = #define RIPPER2_JUMP_ATTACK_RATE 35 int DoRipper2BeginJumpAttack(DSWActor* actor); -STATE s_Ripper2JumpAttack[1][6] = +FState s_Ripper2JumpAttack[] = { - { - {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]}, - }, -}; - - -STATE* sg_Ripper2JumpAttack[] = -{ - &s_Ripper2JumpAttack[0][0], + {SPR_RIPPER2_JUMP, 'A', RIPPER2_JUMP_ATTACK_RATE, &AF(NullRipper2), &s_Ripper2JumpAttack[1]}, + {SPR_RIPPER2_JUMP, 'A', 0 | SF_QUICK_CALL, &AF(DoRipper2BeginJumpAttack), &s_Ripper2JumpAttack[2]}, + {SPR_RIPPER2_JUMP, 'C', RIPPER2_JUMP_ATTACK_RATE, &AF(DoRipper2MoveJump), &s_Ripper2JumpAttack[3]}, + {SPR_RIPPER2_JUMP, 'B', RIPPER2_JUMP_ATTACK_RATE, &AF(DoRipper2MoveJump), &s_Ripper2JumpAttack[3]}, }; @@ -374,20 +291,13 @@ STATE* sg_Ripper2JumpAttack[] = #define RIPPER2_HANG_JUMP_RATE 20 -STATE s_Ripper2HangJump[1][6] = +FState s_Ripper2HangJump[] = { - { - {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]}, - }, + {SPR_RIPPER2_JUMP, 'A', RIPPER2_HANG_JUMP_RATE, &AF(NullRipper2), &s_Ripper2HangJump[1]}, + {SPR_RIPPER2_JUMP, 'B', RIPPER2_HANG_JUMP_RATE, &AF(DoRipper2HangJF), &s_Ripper2HangJump[1]}, }; -STATE* sg_Ripper2HangJump[] = -{ - &s_Ripper2HangJump[0][0], -}; - ////////////////////// // // RIPPER2 HANG_FALL @@ -396,21 +306,12 @@ STATE* sg_Ripper2HangJump[] = #define RIPPER2_FALL_RATE 25 -STATE s_Ripper2HangFall[1][6] = +FState s_Ripper2HangFall[] = { - { - {SPR_RIPPER2_FALL, 'A', RIPPER2_FALL_RATE, &AF(DoRipper2HangJF), &s_Ripper2HangFall[0][0]}, - }, + {SPR_RIPPER2_FALL, 'A', RIPPER2_FALL_RATE, &AF(DoRipper2HangJF), &s_Ripper2HangFall[0]}, }; -STATE* sg_Ripper2HangFall[] = -{ - &s_Ripper2HangFall[0][0], -}; - - - ////////////////////// // // RIPPER2 DIE @@ -419,7 +320,7 @@ STATE* sg_Ripper2HangFall[] = #define RIPPER2_DIE_RATE 18 -STATE s_Ripper2Die[] = +FState s_Ripper2Die[] = { {SPR_RIPPER2_DIE, 'A', RIPPER2_DIE_RATE, &AF(NullRipper2), &s_Ripper2Die[1]}, {SPR_RIPPER2_DIE, 'B', RIPPER2_DIE_RATE, &AF(NullRipper2), &s_Ripper2Die[2]}, @@ -433,7 +334,7 @@ STATE s_Ripper2Die[] = #define RIPPER2_DEAD_RATE 8 -STATE s_Ripper2Dead[] = +FState s_Ripper2Dead[] = { {SPR_RIPPER2_DIE, 'A', RIPPER2_DIE_RATE, &AF(NullRipper2), &s_Ripper2Dead[1]}, {SPR_RIPPER2_DIE, 'B', RIPPER2_DIE_RATE, &AF(NullRipper2), &s_Ripper2Dead[2]}, @@ -446,114 +347,93 @@ STATE s_Ripper2Dead[] = {SPR_RIPPER2_DEAD, 'A', RIPPER2_DEAD_RATE, &AF(DoActorDebris), &s_Ripper2Dead[8]}, }; -STATE* sg_Ripper2Die[] = -{ - s_Ripper2Die -}; - -STATE* sg_Ripper2Dead[] = -{ - s_Ripper2Dead -}; - -STATE s_Ripper2DeathJump[] = +FState s_Ripper2DeathJump[] = { {SPR_RIPPER2_DIE, 'A', RIPPER2_DIE_RATE, &AF(DoActorDeathMove), &s_Ripper2DeathJump[0]} }; -STATE s_Ripper2DeathFall[] = +FState s_Ripper2DeathFall[] = { {SPR_RIPPER2_DIE, 'B', RIPPER2_DIE_RATE, &AF(DoActorDeathMove), &s_Ripper2DeathFall[0]} }; -STATE* sg_Ripper2DeathJump[] = -{ - s_Ripper2DeathJump -}; - -STATE* sg_Ripper2DeathFall[] = -{ - s_Ripper2DeathFall -}; - - /* -STATE* *Stand[MAX_WEAPONS]; -STATE* *Run; -STATE* *Jump; -STATE* *Fall; -STATE* *Crawl; -STATE* *Swim; -STATE* *Fly; -STATE* *Rise; -STATE* *Sit; -STATE* *Look; -STATE* *Climb; -STATE* *Pain; -STATE* *Death1; -STATE* *Death2; -STATE* *Dead; -STATE* *DeathJump; -STATE* *DeathFall; -STATE* *CloseAttack[2]; -STATE* *Attack[6]; -STATE* *Special[2]; +FState* *Stand[MAX_WEAPONS]; +FState* *Run; +FState* *Jump; +FState* *Fall; +FState* *Crawl; +FState* *Swim; +FState* *Fly; +FState* *Rise; +FState* *Sit; +FState* *Look; +FState* *Climb; +FState* *Pain; +FState* *Death1; +FState* *Death2; +FState* *Dead; +FState* *DeathJump; +FState* *DeathFall; +FState* *CloseAttack[2]; +FState* *Attack[6]; +FState* *Special[2]; */ ACTOR_ACTION_SET Ripper2ActionSet = { - sg_Ripper2Stand, - sg_Ripper2Run, - sg_Ripper2Jump, - sg_Ripper2Fall, - nullptr, // sg_Ripper2Crawl, - nullptr, // sg_Ripper2Swim, - nullptr, // sg_Ripper2Fly, - nullptr, // sg_Ripper2Rise, - nullptr, // sg_Ripper2Sit, - nullptr, // sg_Ripper2Look, + s_Ripper2Stand, + s_Ripper2Run, + s_Ripper2Jump, + s_Ripper2Fall, + nullptr, // s_Ripper2Crawl, + nullptr, // s_Ripper2Swim, + nullptr, // s_Ripper2Fly, + nullptr, // s_Ripper2Rise, + nullptr, // s_Ripper2Sit, + nullptr, // s_Ripper2Look, nullptr, // climb - sg_Ripper2Pain, - sg_Ripper2Die, - nullptr, // sg_Ripper2HariKari, - sg_Ripper2Dead, - sg_Ripper2DeathJump, - sg_Ripper2DeathFall, - {sg_Ripper2Swipe}, + s_Ripper2Pain, + s_Ripper2Die, + nullptr, // s_Ripper2HariKari, + s_Ripper2Dead, + s_Ripper2DeathJump, + s_Ripper2DeathFall, + {s_Ripper2Swipe}, {1024}, - {sg_Ripper2JumpAttack, sg_Ripper2Kong}, + {s_Ripper2JumpAttack, s_Ripper2Kong}, {500, 1024}, - {sg_Ripper2Heart, sg_Ripper2Hang}, + {s_Ripper2Heart, s_Ripper2Hang}, nullptr, nullptr }; ACTOR_ACTION_SET Ripper2BrownActionSet = { - sg_Ripper2Stand, - sg_Ripper2Run, - sg_Ripper2Jump, - sg_Ripper2Fall, - nullptr, // sg_Ripper2Crawl, - nullptr, // sg_Ripper2Swim, - nullptr, // sg_Ripper2Fly, - nullptr, // sg_Ripper2Rise, - nullptr, // sg_Ripper2Sit, - nullptr, // sg_Ripper2Look, + s_Ripper2Stand, + s_Ripper2Run, + s_Ripper2Jump, + s_Ripper2Fall, + nullptr, // s_Ripper2Crawl, + nullptr, // s_Ripper2Swim, + nullptr, // s_Ripper2Fly, + nullptr, // s_Ripper2Rise, + nullptr, // s_Ripper2Sit, + nullptr, // s_Ripper2Look, nullptr, // climb - sg_Ripper2Pain, // pain - sg_Ripper2Die, - nullptr, // sg_Ripper2HariKari, - sg_Ripper2Dead, - sg_Ripper2DeathJump, - sg_Ripper2DeathFall, - {sg_Ripper2Swipe}, + s_Ripper2Pain, // pain + s_Ripper2Die, + nullptr, // s_Ripper2HariKari, + s_Ripper2Dead, + s_Ripper2DeathJump, + s_Ripper2DeathFall, + {s_Ripper2Swipe}, {1024}, - {sg_Ripper2JumpAttack, sg_Ripper2Kong}, + {s_Ripper2JumpAttack, s_Ripper2Kong}, {400, 1024}, - {sg_Ripper2Heart, sg_Ripper2Hang}, + {s_Ripper2Heart, s_Ripper2Hang}, nullptr, nullptr }; @@ -576,7 +456,7 @@ int SetupRipper2(DSWActor* actor) actor->user.__legacyState.Attrib = &Ripper2Attrib; DoActorSetSpeed(actor, NORM_SPEED); actor->user.__legacyState.StateEnd = s_Ripper2Die; - actor->user.__legacyState.Rot = sg_Ripper2Run; + actor->user.__legacyState.Rot = s_Ripper2Run; actor->clipdist = 32; // This actor is bigger, needs bigger box. actor->spr.scale = DVector2(0.859375, 0.859375); @@ -648,8 +528,8 @@ int InitRipper2Hang(DSWActor* actor) return 0; } - NewStateGroup(actor, sg_Ripper2HangJump); - actor->user.__legacyState.StateFallOverride = sg_Ripper2HangFall; + NewStateGroup(actor, s_Ripper2HangJump); + actor->user.__legacyState.StateFallOverride = s_Ripper2HangFall; DoActorSetSpeed(actor, FAST_SPEED); PickJumpMaxSpeed(actor, -(RandomRange(400)+100)); @@ -676,7 +556,7 @@ int DoRipper2Hang(DSWActor* actor) if ((actor->user.WaitTics -= ACTORMOVETICS) > 0) return 0; - NewStateGroup(actor, sg_Ripper2JumpAttack); + NewStateGroup(actor, s_Ripper2JumpAttack); // move to the 2nd frame - past the pause frame actor->user.Tics += actor->user.__legacyState.State->Tics; @@ -832,7 +712,7 @@ int DoRipper2QuickJump(DSWActor* actor) { if ((low->spr.extra & SPRX_PLAYER_OR_ENEMY)) { - NewStateGroup(actor, sg_Ripper2JumpAttack); + NewStateGroup(actor, s_Ripper2JumpAttack); // move past the first state actor->user.Tics = 30; return true; @@ -882,7 +762,7 @@ int DoRipper2Pain(DSWActor* actor) int DoRipper2RipHeart(DSWActor* actor) { DSWActor* target = actor->user.targetActor; - NewStateGroup(actor, sg_Ripper2Heart); + NewStateGroup(actor, s_Ripper2Heart); actor->user.WaitTics = 6 * 120; // player face ripper2 @@ -904,7 +784,7 @@ int DoRipper2StandHeart(DSWActor* actor) PlaySound(DIGI_RIPPER2HEARTOUT, actor, v3df_none, CHAN_RipHeart); if ((actor->user.WaitTics -= ACTORMOVETICS) <= 0) - NewStateGroup(actor, sg_Ripper2Run); + NewStateGroup(actor, s_Ripper2Run); return 0; } @@ -1008,7 +888,7 @@ int InitRipper2Charge(DSWActor* actor) InitActorMoveCloser(actor); - NewStateGroup(actor, sg_Ripper2RunFast); + NewStateGroup(actor, s_Ripper2RunFast); return 0; } @@ -1041,39 +921,22 @@ static saveable_data saveable_ripper2_data[] = SAVE_DATA(Ripper2Attrib), SAVE_DATA(s_Ripper2Run), - SAVE_DATA(sg_Ripper2Run), SAVE_DATA(s_Ripper2RunFast), - SAVE_DATA(sg_Ripper2RunFast), SAVE_DATA(s_Ripper2Stand), - SAVE_DATA(sg_Ripper2Stand), SAVE_DATA(s_Ripper2Swipe), - SAVE_DATA(sg_Ripper2Swipe), SAVE_DATA(s_Ripper2Kong), - SAVE_DATA(sg_Ripper2Kong), SAVE_DATA(s_Ripper2Heart), - SAVE_DATA(sg_Ripper2Heart), SAVE_DATA(s_Ripper2Hang), - SAVE_DATA(sg_Ripper2Hang), SAVE_DATA(s_Ripper2Pain), - SAVE_DATA(sg_Ripper2Pain), SAVE_DATA(s_Ripper2Jump), - SAVE_DATA(sg_Ripper2Jump), SAVE_DATA(s_Ripper2Fall), - SAVE_DATA(sg_Ripper2Fall), SAVE_DATA(s_Ripper2JumpAttack), - SAVE_DATA(sg_Ripper2JumpAttack), SAVE_DATA(s_Ripper2HangJump), - SAVE_DATA(sg_Ripper2HangJump), SAVE_DATA(s_Ripper2HangFall), - SAVE_DATA(sg_Ripper2HangFall), SAVE_DATA(s_Ripper2Die), SAVE_DATA(s_Ripper2Dead), - SAVE_DATA(sg_Ripper2Die), - SAVE_DATA(sg_Ripper2Dead), SAVE_DATA(s_Ripper2DeathJump), SAVE_DATA(s_Ripper2DeathFall), - SAVE_DATA(sg_Ripper2DeathJump), - SAVE_DATA(sg_Ripper2DeathFall), SAVE_DATA(Ripper2ActionSet), SAVE_DATA(Ripper2BrownActionSet), diff --git a/source/games/sw/src/save.cpp b/source/games/sw/src/save.cpp index 328dd2784..5c5fbd9b8 100644 --- a/source/games/sw/src/save.cpp +++ b/source/games/sw/src/save.cpp @@ -51,6 +51,7 @@ Prepared for public release: 03/28/2005 - Charlie Wiederhold, 3D Realms #include "savegamehelp.h" #include "raze_music.h" #include "mapinfo.h" +#include "serializer_raze.h" //void TimerFunc(task * Task); BEGIN_SW_NS @@ -82,7 +83,7 @@ extern bool bosswasseen[3]; #define ANIM_SAVE 1 -extern STATE s_NotRestored[]; +extern FState s_NotRestored[]; @@ -174,16 +175,6 @@ FSerializer& Serialize(FSerializer& arc, const char* keyname, PANEL_STATE*& w, P return SerializeDataPtr(arc, keyname, *(void**)&w, sizeof(PANEL_STATE)); } -FSerializer& Serialize(FSerializer& arc, const char* keyname, STATE*& w, STATE** def) -{ - return SerializeDataPtr(arc, keyname, *(void**)&w, sizeof(STATE)); -} - -FSerializer& Serialize(FSerializer& arc, const char* keyname, STATE**& w, STATE*** def) -{ - return SerializeDataPtr(arc, keyname, *(void**)&w, sizeof(STATE*)); -} - FSerializer& Serialize(FSerializer& arc, const char* keyname, ACTOR_ACTION_SET*& w, ACTOR_ACTION_SET** def) { return SerializeDataPtr(arc, keyname, *(void**)&w, sizeof(ACTOR_ACTION_SET)); @@ -594,10 +585,10 @@ FSerializer& Serialize(FSerializer& arc, const char* keyname, USER& w, USER* def { arc("WallP", w.WallP, def->WallP) ("State", w.__legacyState.State, def->__legacyState.State) - ("Rot", w.__legacyState.Rot, def->__legacyState.Rot) + //("Rot", w.__legacyState.Rot, def->__legacyState.Rot) ("StateStart", w.__legacyState.StateStart, def->__legacyState.StateStart) ("StateEnd", w.__legacyState.StateEnd, def->__legacyState.StateEnd) - ("StateFallOverride", w.__legacyState.StateFallOverride, def->__legacyState.StateFallOverride) + //("StateFallOverride", w.__legacyState.StateFallOverride, def->__legacyState.StateFallOverride) ("ActorActionSet", w.__legacyState.ActorActionSet, def->__legacyState.ActorActionSet) ("Personality", w.Personality, def->Personality) ("Attrib", w.__legacyState.Attrib, def->__legacyState.Attrib) diff --git a/source/games/sw/src/sector.cpp b/source/games/sw/src/sector.cpp index 898a04827..dfc0dd604 100644 --- a/source/games/sw/src/sector.cpp +++ b/source/games/sw/src/sector.cpp @@ -1503,10 +1503,10 @@ int OperateSprite(DSWActor* actor, short player_is_operating) DSWPlayer* pp = nullptr; short state; short key_num=0; - extern STATE s_Pachinko1Operate[]; - extern STATE s_Pachinko2Operate[]; - extern STATE s_Pachinko3Operate[]; - extern STATE s_Pachinko4Operate[]; + extern FState s_Pachinko1Operate[]; + extern FState s_Pachinko2Operate[]; + extern FState s_Pachinko3Operate[]; + extern FState s_Pachinko4Operate[]; if (Prediction) return false; diff --git a/source/games/sw/src/serp.cpp b/source/games/sw/src/serp.cpp index d5b62316a..c1a798d3d 100644 --- a/source/games/sw/src/serp.cpp +++ b/source/games/sw/src/serp.cpp @@ -128,22 +128,15 @@ ATTRIBUTE SerpPissedAttrib = #define SERP_RUN_RATE 24 -STATE s_SerpRun[1][4] = +FState s_SerpRun[] = { - { - {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]}, - }, + {SPR_SERP_RUN, 'A', SERP_RUN_RATE, &AF(DoSerpMove), &s_SerpRun[1]}, + {SPR_SERP_RUN, 'B', SERP_RUN_RATE, &AF(DoSerpMove), &s_SerpRun[2]}, + {SPR_SERP_RUN, 'C', SERP_RUN_RATE, &AF(DoSerpMove), &s_SerpRun[3]}, + {SPR_SERP_RUN, 'B', SERP_RUN_RATE, &AF(DoSerpMove), &s_SerpRun[0]}, }; -STATE* sg_SerpRun[] = -{ - &s_SerpRun[0][0], -}; - ////////////////////// // // SERP SLASH @@ -152,26 +145,18 @@ STATE* sg_SerpRun[] = #define SERP_SLASH_RATE 9 -STATE s_SerpSlash[1][10] = +FState s_SerpSlash[] = { - { - {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]}, - }, -}; - - -STATE* sg_SerpSlash[] = -{ - &s_SerpSlash[0][0], + {SPR_SERP_SLASH, 'C', SERP_SLASH_RATE, &AF(NullSerp), &s_SerpSlash[1]}, + {SPR_SERP_SLASH, 'B', SERP_SLASH_RATE, &AF(NullSerp), &s_SerpSlash[2]}, + {SPR_SERP_SLASH, 'A', SERP_SLASH_RATE*2, &AF(NullSerp), &s_SerpSlash[3]}, + {SPR_SERP_SLASH, 'B', SERP_SLASH_RATE, &AF(NullSerp), &s_SerpSlash[4]}, + {SPR_SERP_SLASH, 'C', SERP_SLASH_RATE, &AF(NullSerp), &s_SerpSlash[5]}, + {SPR_SERP_SLASH, 'D', SF_QUICK_CALL, &AF(InitSerpSlash), &s_SerpSlash[6]}, + {SPR_SERP_SLASH, 'D', SERP_SLASH_RATE, &AF(NullSerp), &s_SerpSlash[7]}, + {SPR_SERP_SLASH, 'E', SERP_SLASH_RATE, &AF(NullSerp), &s_SerpSlash[8]}, + {SPR_SERP_SLASH, 'E', 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_SerpSlash[9]}, + {SPR_SERP_SLASH, 'E', SERP_SLASH_RATE, &AF(DoSerpMove), &s_SerpSlash[9]}, }; @@ -183,28 +168,19 @@ STATE* sg_SerpSlash[] = #define SERP_SKULL_SPELL_RATE 18 -STATE s_SerpSkullSpell[1][8] = +FState s_SerpSkullSpell[] = { - { - {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]}, - }, + {SPR_SERP_SPELL, 'C', SERP_SKULL_SPELL_RATE*2, &AF(NullSerp), &s_SerpSkullSpell[1]}, + {SPR_SERP_SPELL, 'B', SERP_SKULL_SPELL_RATE, &AF(NullSerp), &s_SerpSkullSpell[2]}, + {SPR_SERP_SPELL, 'A', SERP_SKULL_SPELL_RATE*2, &AF(NullSerp), &s_SerpSkullSpell[3]}, + {SPR_SERP_SPELL, 'A', SF_QUICK_CALL, &AF(InitSerpRing), &s_SerpSkullSpell[4]}, + {SPR_SERP_SPELL, 'A', SERP_SKULL_SPELL_RATE, &AF(NullSerp), &s_SerpSkullSpell[5]}, + {SPR_SERP_SPELL, 'B', SERP_SKULL_SPELL_RATE, &AF(NullSerp), &s_SerpSkullSpell[6]}, + {SPR_SERP_SPELL, 'B', SF_QUICK_CALL, &AF(InitActorDecide), &s_SerpSkullSpell[7]}, + {SPR_SERP_SPELL, 'B', SERP_SKULL_SPELL_RATE, &AF(DoSerpMove), &s_SerpSkullSpell[7]}, }; -STATE* sg_SerpSkullSpell[] = -{ - &s_SerpSkullSpell[0][0], -}; - - - ////////////////////// // // SERP SPELL @@ -213,50 +189,35 @@ STATE* sg_SerpSkullSpell[] = #define SERP_SPELL_RATE 18 -STATE s_SerpSpell[1][8] = +FState s_SerpSpell[] = { - { - {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]}, - }, + {SPR_SERP_SPELL, 'C', SERP_SPELL_RATE*2, &AF(NullSerp), &s_SerpSpell[1]}, + {SPR_SERP_SPELL, 'B', SERP_SPELL_RATE, &AF(NullSerp), &s_SerpSpell[2]}, + {SPR_SERP_SPELL, 'A', SERP_SPELL_RATE*2, &AF(NullSerp), &s_SerpSpell[3]}, + {SPR_SERP_SPELL, 'A', SF_QUICK_CALL, &AF(InitSerpSpell), &s_SerpSpell[4]}, + {SPR_SERP_SPELL, 'A', SERP_SPELL_RATE, &AF(NullSerp), &s_SerpSpell[5]}, + {SPR_SERP_SPELL, 'B', SERP_SPELL_RATE, &AF(NullSerp), &s_SerpSpell[6]}, + {SPR_SERP_SPELL, 'B', SF_QUICK_CALL, &AF(InitActorDecide), &s_SerpSpell[7]}, + {SPR_SERP_SPELL, 'B', SERP_SPELL_RATE, &AF(DoSerpMove), &s_SerpSpell[7]}, }; -STATE* sg_SerpSpell[] = -{ - &s_SerpSpell[0][0], -}; - ////////////////////// // // SERP SPELL MONSTER // ////////////////////// -STATE s_SerpMonstSpell[1][8] = +FState s_SerpMonstSpell[] = { - { - {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]}, - }, -}; - - -STATE* sg_SerpMonstSpell[] = -{ - &s_SerpMonstSpell[0][0], + {SPR_SERP_SPELL, 'C', SERP_SPELL_RATE*2, &AF(NullSerp), &s_SerpMonstSpell[1]}, + {SPR_SERP_SPELL, 'B', SERP_SPELL_RATE, &AF(NullSerp), &s_SerpMonstSpell[2]}, + {SPR_SERP_SPELL, 'A', SERP_SPELL_RATE*2, &AF(NullSerp), &s_SerpMonstSpell[3]}, + {SPR_SERP_SPELL, 'A', SF_QUICK_CALL, &AF(InitSerpMonstSpell), &s_SerpMonstSpell[4]}, + {SPR_SERP_SPELL, 'A', SERP_SPELL_RATE, &AF(NullSerp), &s_SerpMonstSpell[5]}, + {SPR_SERP_SPELL, 'B', SERP_SPELL_RATE, &AF(NullSerp), &s_SerpMonstSpell[6]}, + {SPR_SERP_SPELL, 'B', SF_QUICK_CALL, &AF(InitActorDecide), &s_SerpMonstSpell[7]}, + {SPR_SERP_SPELL, 'B', SERP_SPELL_RATE, &AF(DoSerpMove), &s_SerpMonstSpell[7]}, }; @@ -268,28 +229,21 @@ STATE* sg_SerpMonstSpell[] = #define SERP_SPELL_RATE 18 -STATE s_SerpRapidSpell[1][10] = +FState s_SerpRapidSpell[] = { - { - {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]}, - }, + {SPR_SERP_SPELL, 'C', SERP_SPELL_RATE*2, &AF(NullSerp), &s_SerpRapidSpell[1]}, + {SPR_SERP_SPELL, 'B', SERP_SPELL_RATE, &AF(NullSerp), &s_SerpRapidSpell[2]}, + {SPR_SERP_SPELL, 'A', SERP_SPELL_RATE*2, &AF(NullSerp), &s_SerpRapidSpell[3]}, + {SPR_SERP_SPELL, 'A', SF_QUICK_CALL, &AF(InitSerpSpell), &s_SerpRapidSpell[4]}, + {SPR_SERP_SPELL, 'A', SERP_SPELL_RATE*2, &AF(NullSerp), &s_SerpRapidSpell[5]}, + {SPR_SERP_SPELL, 'A', SF_QUICK_CALL, &AF(InitSerpSpell), &s_SerpRapidSpell[6]}, + {SPR_SERP_SPELL, 'A', SERP_SPELL_RATE, &AF(NullSerp), &s_SerpRapidSpell[7]}, + {SPR_SERP_SPELL, 'B', SERP_SPELL_RATE, &AF(NullSerp), &s_SerpRapidSpell[8]}, + {SPR_SERP_SPELL, 'B', SF_QUICK_CALL, &AF(InitActorDecide), &s_SerpRapidSpell[9]}, + {SPR_SERP_SPELL, 'B', SERP_SPELL_RATE, &AF(DoSerpMove), &s_SerpRapidSpell[9]}, }; -STATE* sg_SerpRapidSpell[] = -{ - &s_SerpRapidSpell[0][0], -}; - ////////////////////// // // SERP STAND @@ -298,19 +252,12 @@ STATE* sg_SerpRapidSpell[] = #define SERP_STAND_RATE 12 -STATE s_SerpStand[1][1] = +FState s_SerpStand[] = { - { - {SPR_SERP_RUN, 'A', SERP_STAND_RATE, &AF(DoSerpMove), &s_SerpStand[0][0]}, - }, + {SPR_SERP_RUN, 'A', SERP_STAND_RATE, &AF(DoSerpMove), &s_SerpStand[0]}, }; -STATE* sg_SerpStand[] = -{ - s_SerpStand[0], -}; - ////////////////////// // // SERP DIE @@ -319,7 +266,7 @@ STATE* sg_SerpStand[] = #define SERP_DIE_RATE 20 -STATE s_SerpDie[] = +FState s_SerpDie[] = { {SPR_SERP_DIE, 'A', SERP_DIE_RATE, &AF(NullSerp), &s_SerpDie[1]}, {SPR_SERP_DIE, 'B', SERP_DIE_RATE, &AF(NullSerp), &s_SerpDie[2]}, @@ -334,67 +281,57 @@ STATE s_SerpDie[] = {SPR_SERP_DEAD, 'A', SERP_DIE_RATE, &AF(DoActorDebris), &s_SerpDie[10]} }; -STATE s_SerpDead[] = +FState s_SerpDead[] = { {SPR_SERP_DEAD, 'A', SERP_DIE_RATE, &AF(DoActorDebris), &s_SerpDead[0]}, }; -STATE* sg_SerpDie[] = -{ - s_SerpDie -}; - -STATE* sg_SerpDead[] = -{ - s_SerpDead -}; - /* -STATE* *Stand[MAX_WEAPONS]; -STATE* *Run; -STATE* *Jump; -STATE* *Fall; -STATE* *Crawl; -STATE* *Swim; -STATE* *Fly; -STATE* *Rise; -STATE* *Sit; -STATE* *Look; -STATE* *Climb; -STATE* *Pain; -STATE* *Death1; -STATE* *Death2; -STATE* *Dead; -STATE* *DeathJump; -STATE* *DeathFall; -STATE* *CloseAttack[2]; -STATE* *Attack[6]; -STATE* *Special[2]; +FState* *Stand[MAX_WEAPONS]; +FState* *Run; +FState* *Jump; +FState* *Fall; +FState* *Crawl; +FState* *Swim; +FState* *Fly; +FState* *Rise; +FState* *Sit; +FState* *Look; +FState* *Climb; +FState* *Pain; +FState* *Death1; +FState* *Death2; +FState* *Dead; +FState* *DeathJump; +FState* *DeathFall; +FState* *CloseAttack[2]; +FState* *Attack[6]; +FState* *Special[2]; */ ACTOR_ACTION_SET SerpActionSet = { - sg_SerpStand, - sg_SerpRun, - nullptr, //sg_SerpJump, - nullptr, //sg_SerpFall, - nullptr, //sg_SerpCrawl, - nullptr, //sg_SerpSwim, - nullptr, //sg_SerpFly, - nullptr, //sg_SerpRise, - nullptr, //sg_SerpSit, - nullptr, //sg_SerpLook, + s_SerpStand, + s_SerpRun, + nullptr, //s_SerpJump, + nullptr, //s_SerpFall, + nullptr, //s_SerpCrawl, + nullptr, //s_SerpSwim, + nullptr, //s_SerpFly, + nullptr, //s_SerpRise, + nullptr, //s_SerpSit, + nullptr, //s_SerpLook, nullptr, //climb nullptr, //pain - sg_SerpDie, - nullptr, //sg_SerpHariKari, - sg_SerpDead, - nullptr, //sg_SerpDeathJump, - nullptr, //sg_SerpDeathFall, - {sg_SerpSlash}, + s_SerpDie, + nullptr, //s_SerpHariKari, + s_SerpDead, + nullptr, //s_SerpDeathJump, + nullptr, //s_SerpDeathFall, + {s_SerpSlash}, {1024}, - {sg_SerpSlash, sg_SerpSpell, sg_SerpRapidSpell, sg_SerpRapidSpell}, + {s_SerpSlash, s_SerpSpell, s_SerpRapidSpell, s_SerpRapidSpell}, {256, 724, 900, 1024}, {nullptr}, nullptr, @@ -416,7 +353,7 @@ int SetupSerp(DSWActor* actor) actor->user.__legacyState.Attrib = &SerpAttrib; DoActorSetSpeed(actor, NORM_SPEED); actor->user.__legacyState.StateEnd = s_SerpDie; - actor->user.__legacyState.Rot = sg_SerpRun; + actor->user.__legacyState.Rot = s_SerpRun; EnemyDefaults(actor, &SerpActionSet, &SerpPersonality); @@ -483,7 +420,7 @@ int DoSerpMove(DSWActor* actor) case 0: if (actor->user.Health != actor->user.MaxHealth) { - NewStateGroup(actor, sg_SerpSkullSpell); + NewStateGroup(actor, s_SerpSkullSpell); actor->user.Counter2++; } break; @@ -491,7 +428,7 @@ int DoSerpMove(DSWActor* actor) case 1: { if (actor->user.Counter <= 0) - NewStateGroup(actor, sg_SerpSkullSpell); + NewStateGroup(actor, s_SerpSkullSpell); } break; } @@ -528,23 +465,14 @@ static saveable_data saveable_serp_data[] = SAVE_DATA(SerpPissedAttrib), SAVE_DATA(s_SerpRun), - SAVE_DATA(sg_SerpRun), SAVE_DATA(s_SerpSlash), - SAVE_DATA(sg_SerpSlash), SAVE_DATA(s_SerpSkullSpell), - SAVE_DATA(sg_SerpSkullSpell), SAVE_DATA(s_SerpSpell), - SAVE_DATA(sg_SerpSpell), SAVE_DATA(s_SerpMonstSpell), - SAVE_DATA(sg_SerpMonstSpell), SAVE_DATA(s_SerpRapidSpell), - SAVE_DATA(sg_SerpRapidSpell), SAVE_DATA(s_SerpStand), - SAVE_DATA(sg_SerpStand), SAVE_DATA(s_SerpDie), SAVE_DATA(s_SerpDead), - SAVE_DATA(sg_SerpDie), - SAVE_DATA(sg_SerpDead), SAVE_DATA(SerpActionSet), }; diff --git a/source/games/sw/src/skel.cpp b/source/games/sw/src/skel.cpp index 3a099d9a2..c47365fc1 100644 --- a/source/games/sw/src/skel.cpp +++ b/source/games/sw/src/skel.cpp @@ -115,22 +115,14 @@ ATTRIBUTE SkelAttrib = // +4 on frame #3 to add character -STATE s_SkelRun[1][6] = +FState s_SkelRun[] = { - { - {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]}, - }, -}; - - -STATE* sg_SkelRun[] = -{ - &s_SkelRun[0][0], + {SPR_SKEL_RUN, 'A', SKEL_RUN_RATE+4, &AF(DoSkelMove), &s_SkelRun[1]}, + {SPR_SKEL_RUN, 'B', SKEL_RUN_RATE, &AF(DoSkelMove), &s_SkelRun[2]}, + {SPR_SKEL_RUN, 'C', SKEL_RUN_RATE, &AF(DoSkelMove), &s_SkelRun[3]}, + {SPR_SKEL_RUN, 'D', SKEL_RUN_RATE+4, &AF(DoSkelMove), &s_SkelRun[4]}, + {SPR_SKEL_RUN, 'E', SKEL_RUN_RATE, &AF(DoSkelMove), &s_SkelRun[5]}, + {SPR_SKEL_RUN, 'F', SKEL_RUN_RATE, &AF(DoSkelMove), &s_SkelRun[0]}, }; ////////////////////// @@ -141,23 +133,15 @@ STATE* sg_SkelRun[] = #define SKEL_SLASH_RATE 20 -STATE s_SkelSlash[1][7] = +FState s_SkelSlash[] = { - { - {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]}, - }, -}; - - -STATE* sg_SkelSlash[] = -{ - &s_SkelSlash[0][0], + {SPR_SKEL_SLASH, 'A', SKEL_SLASH_RATE, &AF(NullSkel), &s_SkelSlash[1]}, + {SPR_SKEL_SLASH, 'B', SKEL_SLASH_RATE, &AF(NullSkel), &s_SkelSlash[2]}, + {SPR_SKEL_SLASH, 'C', 0|SF_QUICK_CALL, &AF(InitSkelSlash), &s_SkelSlash[3]}, + {SPR_SKEL_SLASH, 'C', SKEL_SLASH_RATE*2, &AF(NullSkel), &s_SkelSlash[4]}, + {SPR_SKEL_SLASH, 'B', SKEL_SLASH_RATE, &AF(NullSkel), &s_SkelSlash[5]}, + {SPR_SKEL_SLASH, 'B', 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_SkelSlash[6]}, + {SPR_SKEL_SLASH, 'B', SKEL_SLASH_RATE, &AF(DoSkelMove), &s_SkelSlash[6]}, }; @@ -169,25 +153,18 @@ STATE* sg_SkelSlash[] = #define SKEL_SPELL_RATE 20 -STATE s_SkelSpell[1][7] = +FState s_SkelSpell[] = { - { - {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]}, - }, + {SPR_SKEL_SPELL, 'A', SKEL_SPELL_RATE+9, &AF(NullSkel), &s_SkelSpell[1]}, + {SPR_SKEL_SPELL, 'B', SKEL_SPELL_RATE, &AF(NullSkel), &s_SkelSpell[2]}, + {SPR_SKEL_SPELL, 'C', SKEL_SPELL_RATE, &AF(NullSkel), &s_SkelSpell[3]}, + {SPR_SKEL_SPELL, 'D', SKEL_SPELL_RATE*2, &AF(NullSkel), &s_SkelSpell[4]}, + {SPR_SKEL_SPELL, 'D', 0|SF_QUICK_CALL, &AF(InitSkelSpell), &s_SkelSpell[5]}, + {SPR_SKEL_SPELL, 'D', 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_SkelSpell[6]}, + {SPR_SKEL_SPELL, 'D', SKEL_SPELL_RATE, &AF(DoSkelMove), &s_SkelSpell[6]}, }; -STATE* sg_SkelSpell[] = -{ - &s_SkelSpell[0][0], -}; - ////////////////////// // // SKEL PAIN @@ -196,20 +173,11 @@ STATE* sg_SkelSpell[] = #define SKEL_PAIN_RATE 38 -STATE s_SkelPain[1][1] = +FState s_SkelPain[] = { - { - {SPR_SKEL_PAIN, 'A', SKEL_PAIN_RATE, &AF(DoSkelPain), &s_SkelPain[0][0]}, - }, + {SPR_SKEL_PAIN, 'A', SKEL_PAIN_RATE, &AF(DoSkelPain), &s_SkelPain[0]}, }; -STATE* sg_SkelPain[] = -{ - &s_SkelPain[0][0], -}; - - - ////////////////////// // // SKEL TELEPORT @@ -218,7 +186,7 @@ STATE* sg_SkelPain[] = #define SKEL_TELEPORT_RATE 20 -STATE s_SkelTeleport[] = +FState s_SkelTeleport[] = { {SPR_SKEL_TELEPORT, 'A', 1, nullptr, &s_SkelTeleport[1]}, {SPR_SKEL_TELEPORT, 'A', 0|SF_QUICK_CALL, &AF(DoSkelInitTeleport), &s_SkelTeleport[2]}, @@ -239,11 +207,6 @@ STATE s_SkelTeleport[] = {SPR_SKEL_TELEPORT, 'A', SKEL_TELEPORT_RATE, &AF(DoSkelMove), &s_SkelTeleport[16]}, }; -STATE* sg_SkelTeleport[] = -{ - s_SkelTeleport, -}; - ////////////////////// // // SKEL STAND @@ -252,19 +215,12 @@ STATE* sg_SkelTeleport[] = #define SKEL_STAND_RATE 12 -STATE s_SkelStand[1][1] = +FState s_SkelStand[] = { - { - {SPR_SKEL_RUN, 'A', SKEL_STAND_RATE, &AF(DoSkelMove), &s_SkelStand[0][0]}, - }, + {SPR_SKEL_RUN, 'A', SKEL_STAND_RATE, &AF(DoSkelMove), &s_SkelStand[0]}, }; -STATE* sg_SkelStand[] = -{ - s_SkelStand[0], -}; - ////////////////////// // // SKEL DIE @@ -273,7 +229,7 @@ STATE* sg_SkelStand[] = #define SKEL_DIE_RATE 25 -STATE s_SkelDie[] = +FState s_SkelDie[] = { {SPR_SKEL_DIE, 'A', SKEL_DIE_RATE, nullptr, &s_SkelDie[1]}, {SPR_SKEL_DIE, 'B', SKEL_DIE_RATE, nullptr, &s_SkelDie[2]}, @@ -283,59 +239,54 @@ STATE s_SkelDie[] = {SPR_SKEL_DIE, 'F', SKEL_DIE_RATE, &AF(DoSuicide), &s_SkelDie[5]}, }; -STATE* sg_SkelDie[] = -{ - s_SkelDie -}; - /* -STATE* *Stand[MAX_WEAPONS]; -STATE* *Run; -STATE* *Jump; -STATE* *Fall; -STATE* *Crawl; -STATE* *Swim; -STATE* *Fly; -STATE* *Rise; -STATE* *Sit; -STATE* *Look; -STATE* *Climb; -STATE* *Pain; -STATE* *Death1; -STATE* *Death2; -STATE* *Dead; -STATE* *DeathJump; -STATE* *DeathFall; -STATE* *CloseAttack[2]; -STATE* *Attack[6]; -STATE* *Special[2]; +FState* *Stand[MAX_WEAPONS]; +FState* *Run; +FState* *Jump; +FState* *Fall; +FState* *Crawl; +FState* *Swim; +FState* *Fly; +FState* *Rise; +FState* *Sit; +FState* *Look; +FState* *Climb; +FState* *Pain; +FState* *Death1; +FState* *Death2; +FState* *Dead; +FState* *DeathJump; +FState* *DeathFall; +FState* *CloseAttack[2]; +FState* *Attack[6]; +FState* *Special[2]; */ ACTOR_ACTION_SET SkelActionSet = { - sg_SkelStand, - sg_SkelRun, - nullptr, //sg_SkelJump, - nullptr, //sg_SkelFall, - nullptr, //sg_SkelCrawl, - nullptr, //sg_SkelSwim, - nullptr, //sg_SkelFly, - nullptr, //sg_SkelRise, - nullptr, //sg_SkelSit, - nullptr, //sg_SkelLook, + s_SkelStand, + s_SkelRun, + nullptr, //s_SkelJump, + nullptr, //s_SkelFall, + nullptr, //s_SkelCrawl, + nullptr, //s_SkelSwim, + nullptr, //s_SkelFly, + nullptr, //s_SkelRise, + nullptr, //s_SkelSit, + nullptr, //s_SkelLook, nullptr, //climb - sg_SkelPain, //pain - sg_SkelDie, - nullptr, //sg_SkelHariKari, - nullptr, //sg_SkelDead, - nullptr, //sg_SkelDeathJump, - nullptr, //sg_SkelDeathFall, - {sg_SkelSlash}, + s_SkelPain, //pain + s_SkelDie, + nullptr, //s_SkelHariKari, + nullptr, //s_SkelDead, + nullptr, //s_SkelDeathJump, + nullptr, //s_SkelDeathFall, + {s_SkelSlash}, {1024}, - {sg_SkelSpell}, + {s_SkelSpell}, {1024}, {nullptr}, - sg_SkelTeleport, + s_SkelTeleport, nullptr }; @@ -357,7 +308,7 @@ int SetupSkel(DSWActor* actor) actor->user.__legacyState.Attrib = &SkelAttrib; DoActorSetSpeed(actor, NORM_SPEED); actor->user.__legacyState.StateEnd = s_SkelDie; - actor->user.__legacyState.Rot = sg_SkelRun; + actor->user.__legacyState.Rot = s_SkelRun; EnemyDefaults(actor, &SkelActionSet, &SkelPersonality); @@ -505,19 +456,12 @@ static saveable_data saveable_skel_data[] = SAVE_DATA(SkelAttrib), SAVE_DATA(s_SkelRun), - SAVE_DATA(sg_SkelRun), SAVE_DATA(s_SkelSlash), - SAVE_DATA(sg_SkelSlash), SAVE_DATA(s_SkelSpell), - SAVE_DATA(sg_SkelSpell), SAVE_DATA(s_SkelPain), - SAVE_DATA(sg_SkelPain), SAVE_DATA(s_SkelTeleport), - SAVE_DATA(sg_SkelTeleport), SAVE_DATA(s_SkelStand), - SAVE_DATA(sg_SkelStand), SAVE_DATA(s_SkelDie), - SAVE_DATA(sg_SkelDie), SAVE_DATA(SkelActionSet), }; diff --git a/source/games/sw/src/skull.cpp b/source/games/sw/src/skull.cpp index c2eb8a075..851e4edf1 100644 --- a/source/games/sw/src/skull.cpp +++ b/source/games/sw/src/skull.cpp @@ -50,19 +50,12 @@ extern DAMAGE_DATA DamageData[]; #define SKULL_RATE 10 -STATE s_SkullWait[1][1] = +FState s_SkullWait[] = { - { - {SPR_SKULL, 'A', SKULL_RATE, &AF(DoSkullWait), &s_SkullWait[0][0]}, - }, + {SPR_SKULL, 'A', SKULL_RATE, &AF(DoSkullWait), &s_SkullWait[0]}, }; -STATE* sg_SkullWait[] = -{ - &s_SkullWait[0][0], -}; - ATTRIBUTE SkullAttrib = { {60, 80, 100, 130}, // Speeds @@ -80,38 +73,21 @@ ATTRIBUTE SkullAttrib = // ////////////////////// -STATE s_SkullRing[1][1] = +FState s_SkullRing[] = { - { - {SPR_SKULL, 'A', SKULL_RATE, &AF(DoSerpRing), &s_SkullRing[0][0]}, - }, + {SPR_SKULL, 'A', SKULL_RATE, &AF(DoSerpRing), &s_SkullRing[0]}, }; -STATE* sg_SkullRing[] = -{ - &s_SkullRing[0][0], -}; - - - ////////////////////// // // SKULL Jump // ////////////////////// -STATE s_SkullJump[1][1] = +FState s_SkullJump[] = { - { - {SPR_SKULL, 'A', SKULL_RATE, &AF(DoSkullJump), &s_SkullJump[0][0]}, - }, -}; - - -STATE* sg_SkullJump[] = -{ - &s_SkullJump[0][0], + {SPR_SKULL, 'A', SKULL_RATE, &AF(DoSkullJump), &s_SkullJump[0]}, }; @@ -123,7 +99,7 @@ STATE* sg_SkullJump[] = #define SKULL_EXPLODE_RATE 11 -STATE s_SkullExplode[] = +FState s_SkullExplode[] = { {SPR_SKULL_EXPLODE, 'A', 1, nullptr, &s_SkullExplode[1]}, {SPR_SKULL_EXPLODE, 'A', SF_QUICK_CALL, &AF(DoDamageTest), &s_SkullExplode[2]}, @@ -145,12 +121,6 @@ STATE s_SkullExplode[] = {SPR_SKULL_EXPLODE, 'N', SKULL_EXPLODE_RATE, &AF(DoSuicide), &s_SkullExplode[17]} }; -STATE* sg_SkullExplode[] = -{ - s_SkullExplode, -}; - - //--------------------------------------------------------------------------- // // @@ -169,7 +139,7 @@ int SetupSkull(DSWActor* actor) actor->user.__legacyState.Attrib = &SkullAttrib; DoActorSetSpeed(actor, NORM_SPEED); actor->user.__legacyState.StateEnd = s_SkullExplode; - actor->user.__legacyState.Rot = sg_SkullWait; + actor->user.__legacyState.Rot = s_SkullWait; actor->user.ID = SKULL_R0; @@ -429,7 +399,7 @@ int DoSkullWait(DSWActor* actor) { actor->vel.X = 0; actor->user.jump_speed = -600; - NewStateGroup(actor, sg_SkullJump); + NewStateGroup(actor, s_SkullJump); DoBeginJump(actor); } } @@ -445,7 +415,7 @@ int DoSkullWait(DSWActor* actor) actor->spr.Angles.Yaw = (actor->user.targetActor->spr.pos - actor->spr.pos).Angle(); actor->vel.X = 8 + RandomRangeF(16); actor->user.jump_speed = -700; - NewStateGroup(actor, sg_SkullJump); + NewStateGroup(actor, s_SkullJump); DoBeginJump(actor); } } @@ -464,21 +434,14 @@ int DoSkullWait(DSWActor* actor) #define BETTY_RATE 10 -STATE s_BettyWait[1][3] = +FState s_BettyWait[] = { - { - {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]}, - }, + {SPR_BETTY, 'A', BETTY_RATE, &AF(DoBettyWait), &s_BettyWait[1]}, + {SPR_BETTY, 'B', BETTY_RATE, &AF(DoBettyWait), &s_BettyWait[2]}, + {SPR_BETTY, 'C', BETTY_RATE, &AF(DoBettyWait), &s_BettyWait[0]}, }; -STATE* sg_BettyWait[] = -{ - &s_BettyWait[0][0], -}; - ATTRIBUTE BettyAttrib = { {60, 80, 100, 130}, // Speeds @@ -493,17 +456,9 @@ ATTRIBUTE BettyAttrib = // ////////////////////// -STATE s_BettyJump[1][1] = +FState s_BettyJump[] = { - { - {SPR_BETTY, 'A', BETTY_RATE, &AF(DoBettyJump), &s_BettyJump[0][0]}, - }, -}; - - -STATE* sg_BettyJump[] = -{ - &s_BettyJump[0][0], + {SPR_BETTY, 'A', BETTY_RATE, &AF(DoBettyJump), &s_BettyJump[0]}, }; @@ -516,18 +471,12 @@ STATE* sg_BettyJump[] = #define BETTY_EXPLODE_RATE 11 #define BETTY_EXPLODE BETTY_R0 -STATE s_BettyExplode[] = +FState s_BettyExplode[] = { {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[] = -{ - s_BettyExplode, -}; - - //--------------------------------------------------------------------------- // // @@ -546,7 +495,7 @@ int SetupBetty(DSWActor* actor) actor->user.__legacyState.Attrib = &BettyAttrib; DoActorSetSpeed(actor, NORM_SPEED); actor->user.__legacyState.StateEnd = s_BettyExplode; - actor->user.__legacyState.Rot = sg_BettyWait; + actor->user.__legacyState.Rot = s_BettyWait; actor->user.ID = BETTY_R0; @@ -787,7 +736,7 @@ int DoBettyWait(DSWActor* actor) { actor->vel.X = 0; actor->user.jump_speed = -600; - NewStateGroup(actor, sg_BettyJump); + NewStateGroup(actor, s_BettyJump); DoBeginJump(actor); } } @@ -803,7 +752,7 @@ int DoBettyWait(DSWActor* actor) actor->spr.Angles.Yaw = (actor->user.targetActor->spr.pos - actor->spr.pos).Angle(); actor->vel.X = 8 + RandomRangeF(16); actor->user.jump_speed = -700; - NewStateGroup(actor, sg_BettyJump); + NewStateGroup(actor, s_BettyJump); DoBeginJump(actor); } } @@ -822,25 +771,18 @@ int DoBettyWait(DSWActor* actor) static saveable_data saveable_skull_data[] = { SAVE_DATA(s_SkullWait), - SAVE_DATA(sg_SkullWait), SAVE_DATA(SkullAttrib), SAVE_DATA(s_SkullRing), - SAVE_DATA(sg_SkullRing), SAVE_DATA(s_SkullJump), - SAVE_DATA(sg_SkullJump), SAVE_DATA(s_SkullExplode), - SAVE_DATA(sg_SkullExplode), SAVE_DATA(s_BettyWait), - SAVE_DATA(sg_BettyWait), SAVE_DATA(BettyAttrib), SAVE_DATA(s_BettyJump), - SAVE_DATA(sg_BettyJump), SAVE_DATA(s_BettyExplode), - SAVE_DATA(sg_BettyExplode), }; saveable_module saveable_skull = diff --git a/source/games/sw/src/sprite.cpp b/source/games/sw/src/sprite.cpp index a26bd274d..ac1788fd7 100644 --- a/source/games/sw/src/sprite.cpp +++ b/source/games/sw/src/sprite.cpp @@ -93,8 +93,8 @@ void InitWeaponUzi(DSWPlayer*); int MoveSkip4, MoveSkip2, MoveSkip8; int MinEnemySkill; -extern STATE s_CarryFlag[]; -extern STATE s_CarryFlagNoDet[]; +extern FState s_CarryFlag[]; +extern FState s_CarryFlagNoDet[]; // beware of mess... :( static double globhiz, globloz; @@ -118,86 +118,86 @@ int DirArr[] = {NORTH, NE, EAST, SE, SOUTH, SW, WEST, NW, NORTH, NE, EAST, SE, S #define SCROLL_RATE 20 #define SCROLL_FIRE_RATE 20 -STATE s_DebrisNinja[] = +FState s_DebrisNinja[] = { {SPR_NINJA_DIE, 'D', 100, &AF(DoActorDebris), &s_DebrisNinja[0]}, }; -STATE s_DebrisRat[] = +FState s_DebrisRat[] = { {SPR_RAT_DEBRIS, 'A', 100, &AF(DoActorDebris), &s_DebrisRat[0]}, }; -STATE s_DebrisCrab[] = +FState s_DebrisCrab[] = { {SPR_CRAB_DEBRIS, 'A', 100, &AF(DoActorDebris), &s_DebrisCrab[0]}, }; -STATE s_DebrisStarFish[] = +FState s_DebrisStarFish[] = { {SPR_STARFISH_DEBRIS, 'A', 100, &AF(DoActorDebris), &s_DebrisStarFish[0]}, }; // temporary #define REPAIR_KIT_RATE 1100 -STATE s_RepairKit[] = +FState s_RepairKit[] = { {SPR_ICON_REPAIR_KIT, 'A', REPAIR_KIT_RATE, &AF(DoGet), &s_RepairKit[0]} }; -STATE s_GoldSkelKey[] = +FState s_GoldSkelKey[] = { {SPR_GOLD_SKELKEY, 'A', 100, &AF(DoGet), &s_GoldSkelKey[0]} }; -STATE s_BlueKey[] = +FState s_BlueKey[] = { {SPR_BLUE_KEY, 'A', 100, &AF(DoGet), &s_BlueKey[0]} }; -STATE s_BlueCard[] = +FState s_BlueCard[] = { {SPR_BLUE_CARD, 'A', 100, &AF(DoGet), &s_BlueCard[0]} }; -STATE s_SilverSkelKey[] = +FState s_SilverSkelKey[] = { {SPR_SILVER_SKELKEY, 'A', 100, &AF(DoGet), &s_SilverSkelKey[0]} }; -STATE s_RedKey[] = +FState s_RedKey[] = { {SPR_RED_KEY, 'A', 100, &AF(DoGet), &s_RedKey[0]} }; -STATE s_RedCard[] = +FState s_RedCard[] = { {SPR_RED_CARD, 'A', 100, &AF(DoGet), &s_RedCard[0]} }; -STATE s_BronzeSkelKey[] = +FState s_BronzeSkelKey[] = { {SPR_BRONZE_SKELKEY, 'A', 100, &AF(DoGet), &s_BronzeSkelKey[0]} }; -STATE s_GreenKey[] = +FState s_GreenKey[] = { {SPR_GREEN_KEY, 'A', 100, &AF(DoGet), &s_GreenKey[0]} }; -STATE s_GreenCard[] = +FState s_GreenCard[] = { {SPR_GREEN_CARD, 'A', 100, &AF(DoGet), &s_GreenCard[0]} }; -STATE s_RedSkelKey[] = +FState s_RedSkelKey[] = { {SPR_RED_SKELKEY, 'A', 100, &AF(DoGet), &s_RedSkelKey[0]} }; -STATE s_YellowKey[] = +FState s_YellowKey[] = { {SPR_YELLOW_KEY, 'A', 100, &AF(DoGet), &s_YellowKey[0]} }; -STATE s_YellowCard[] = +FState s_YellowCard[] = { {SPR_YELLOW_CARD, 'A', 100, &AF(DoGet), &s_YellowCard[0]} }; -STATE* s_Key[] = +FState* s_Key[] = { s_RedKey, s_BlueKey, @@ -219,7 +219,7 @@ STATE* s_Key[] = #define RED_COIN_RATE 10 #define YELLOW_COIN_RATE 8 #define GREEN_COIN_RATE 6 -STATE s_RedCoin[] = +FState s_RedCoin[] = { {SPR_Red_COIN, 'A', RED_COIN_RATE, &AF(DoCoin), &s_RedCoin[1]}, {SPR_Red_COIN, 'B', RED_COIN_RATE, &AF(DoCoin), &s_RedCoin[2]}, @@ -232,7 +232,7 @@ STATE s_RedCoin[] = }; // !JIM! Frank, I made coins go progressively faster -STATE s_YellowCoin[] = +FState s_YellowCoin[] = { {SPR_Yellow_COIN, 'A', YELLOW_COIN_RATE, &AF(DoCoin), &s_YellowCoin[1]}, {SPR_Yellow_COIN, 'B', YELLOW_COIN_RATE, &AF(DoCoin), &s_YellowCoin[2]}, @@ -244,7 +244,7 @@ STATE s_YellowCoin[] = {SPR_Yellow_COIN, 'H', YELLOW_COIN_RATE, &AF(DoCoin), &s_YellowCoin[0]}, }; -STATE s_GreenCoin[] = +FState s_GreenCoin[] = { {SPR_Green_COIN, 'A', GREEN_COIN_RATE, &AF(DoCoin), &s_GreenCoin[1]}, {SPR_Green_COIN, 'B', GREEN_COIN_RATE, &AF(DoCoin), &s_GreenCoin[2]}, @@ -256,123 +256,123 @@ STATE s_GreenCoin[] = {SPR_Green_COIN, 'H', GREEN_COIN_RATE, &AF(DoCoin), &s_GreenCoin[0]}, }; -STATE s_FireFly[] = +FState s_FireFly[] = { {SPR_FIRE_FLY0, 'A', FIRE_FLY_RATE * 4, &AF(DoFireFly), &s_FireFly[0]} }; -STATE s_IconStar[] = +FState s_IconStar[] = { {SPR_ICON_STAR, 'A', 100, &AF(DoGet), &s_IconStar[0]} }; -STATE s_IconUzi[] = +FState s_IconUzi[] = { {SPR_ICON_UZI, 'A', 100, &AF(DoGet), &s_IconUzi[0]} }; -STATE s_IconLgUziAmmo[] = +FState s_IconLgUziAmmo[] = { {SPR_ICON_LG_UZI_AMMO, 'A', 100, &AF(DoGet), &s_IconLgUziAmmo[0]} }; -STATE s_IconUziFloor[] = +FState s_IconUziFloor[] = { {SPR_ICON_UZIFLOOR, 'A', 100, &AF(DoGet), &s_IconUziFloor[0]} }; -STATE s_IconRocket[] = +FState s_IconRocket[] = { {SPR_ICON_ROCKET, 'A', 100, &AF(DoGet), &s_IconRocket[0]} }; -STATE s_IconLgRocket[] = +FState s_IconLgRocket[] = { {SPR_ICON_LG_ROCKET, 'A', 100, &AF(DoGet), &s_IconLgRocket[0]} }; -STATE s_IconShotgun[] = +FState s_IconShotgun[] = { {SPR_ICON_SHOTGUN, 'A', 100, &AF(DoGet), &s_IconShotgun[0]} }; -STATE s_IconLgShotshell[] = +FState s_IconLgShotshell[] = { {SPR_ICON_LG_SHOTSHELL, 'A', 100, &AF(DoGet), &s_IconLgShotshell[0]} }; -STATE s_IconAutoRiot[] = +FState s_IconAutoRiot[] = { {SPR_ICON_AUTORIOT, 'A', 100, &AF(DoGet), &s_IconAutoRiot[0]} }; -STATE s_IconGrenadeLauncher[] = +FState s_IconGrenadeLauncher[] = { {SPR_ICON_GRENADE_LAUNCHER, 'A', 100, &AF(DoGet), &s_IconGrenadeLauncher[0]} }; -STATE s_IconLgGrenade[] = +FState s_IconLgGrenade[] = { {SPR_ICON_LG_GRENADE, 'A', 100, &AF(DoGet), &s_IconLgGrenade[0]} }; -STATE s_IconLgMine[] = +FState s_IconLgMine[] = { {SPR_ICON_LG_MINE, 'A', 100, &AF(DoGet), &s_IconLgMine[0]} }; -STATE s_IconGuardHead[] = +FState s_IconGuardHead[] = { {SPR_ICON_GUARD_HEAD, 'A', 15, &AF(DoGet), &s_IconGuardHead[0]}, }; #define FIREBALL_LG_AMMO_RATE 12 -STATE s_IconFireballLgAmmo[] = +FState s_IconFireballLgAmmo[] = { {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[] = +FState s_IconHeart[] = { {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[] = +FState s_IconHeartLgAmmo[] = { {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[] = +FState s_IconMicroGun[] = { {SPR_ICON_MICRO_GUN, 'A', 100, &AF(DoGet), &s_IconMicroGun[0]} }; -STATE s_IconMicroBattery[] = +FState s_IconMicroBattery[] = { {SPR_ICON_MICRO_BATTERY, 'A', 100, &AF(DoGet), &s_IconMicroBattery[0]} }; // !JIM! Added rail crap -STATE s_IconRailGun[] = +FState s_IconRailGun[] = { {SPR_ICON_RAIL_GUN, 'A', 100, &AF(DoGet), &s_IconRailGun[0]} }; -STATE s_IconRailAmmo[] = +FState s_IconRailAmmo[] = { {SPR_ICON_RAIL_AMMO, 'A', 100, &AF(DoGet), &s_IconRailAmmo[0]} }; -STATE s_IconElectro[] = +FState s_IconElectro[] = { {SPR_ICON_ELECTRO, 'A', 25, &AF(DoGet), &s_IconElectro[1]}, {SPR_ICON_ELECTRO, 'B', 25, &AF(DoGet), &s_IconElectro[0]}, @@ -380,7 +380,7 @@ STATE s_IconElectro[] = #define ICON_SPELL_RATE 8 -STATE s_IconSpell[] = +FState s_IconSpell[] = { {SPR_ICON_SPELL, 'A', ICON_SPELL_RATE, &AF(DoGet), &s_IconSpell[1]}, {SPR_ICON_SPELL, 'B', ICON_SPELL_RATE, &AF(DoGet), &s_IconSpell[2]}, @@ -400,67 +400,67 @@ STATE s_IconSpell[] = {SPR_ICON_SPELL, 'P', ICON_SPELL_RATE, &AF(DoGet), &s_IconSpell[0]}, }; -STATE s_IconArmor[] = +FState s_IconArmor[] = { {SPR_ICON_ARMOR, 'A', 15, &AF(DoGet), &s_IconArmor[0]}, }; -STATE s_IconMedkit[] = +FState s_IconMedkit[] = { {SPR_ICON_MEDKIT, 'A', 15, &AF(DoGet), &s_IconMedkit[0]}, }; -STATE s_IconChemBomb[] = +FState s_IconChemBomb[] = { {SPR_ICON_CHEMBOMB, 'A', 15, &AF(DoGet), &s_IconChemBomb[0]}, }; -STATE s_IconFlashBomb[] = +FState s_IconFlashBomb[] = { {SPR_ICON_FLASHBOMB, 'A', 15, &AF(DoGet), &s_IconFlashBomb[0]}, }; -STATE s_IconNuke[] = +FState s_IconNuke[] = { {SPR_ICON_NUKE, 'A', 15, &AF(DoGet), &s_IconNuke[0]}, }; -STATE s_IconCaltrops[] = +FState s_IconCaltrops[] = { {SPR_ICON_CALTROPS, 'A', 15, &AF(DoGet), &s_IconCaltrops[0]}, }; #define ICON_SM_MEDKIT 1802 -STATE s_IconSmMedkit[] = +FState s_IconSmMedkit[] = { {SPR_ICON_SM_MEDKIT, 'A', 15, &AF(DoGet), &s_IconSmMedkit[0]}, }; #define ICON_BOOSTER 1810 -STATE s_IconBooster[] = +FState s_IconBooster[] = { {SPR_ICON_BOOSTER, 'A', 15, &AF(DoGet), &s_IconBooster[0]}, }; #define ICON_HEAT_CARD 1819 -STATE s_IconHeatCard[] = +FState s_IconHeatCard[] = { {SPR_ICON_HEAT_CARD, 'A', 15, &AF(DoGet), &s_IconHeatCard[0]}, }; #if 0 -STATE s_IconEnvironSuit[] = +FState s_IconEnvironSuit[] = { {SPR_ICON_ENVIRON_SUIT, 'A', 20, &AF(DoGet), &s_IconEnvironSuit[0]}, }; #endif -STATE s_IconCloak[] = +FState s_IconCloak[] = { {SPR_ICON_CLOAK, 'A', 20, &AF(DoGet), &s_IconCloak[0]}, }; -STATE s_IconFly[] = +FState s_IconFly[] = { {SPR_ICON_FLY, 'A', 20, &AF(DoGet), &s_IconFly[1]}, {SPR_ICON_FLY, 'B', 20, &AF(DoGet), &s_IconFly[2]}, @@ -472,12 +472,12 @@ STATE s_IconFly[] = {SPR_ICON_FLY, 'H', 20, &AF(DoGet), &s_IconFly[0]} }; -STATE s_IconNightVision[] = +FState s_IconNightVision[] = { {SPR_ICON_NIGHT_VISION, 'A', 20, &AF(DoGet), &s_IconNightVision[0]}, }; -STATE s_IconFlag[] = +FState s_IconFlag[] = { {SPR_ICON_FLAG, 'A', 32, &AF(DoGet), &s_IconFlag[1]}, {SPR_ICON_FLAG, 'B', 32, &AF(DoGet), &s_IconFlag[2]}, @@ -684,7 +684,7 @@ void KillActor(DSWActor* actor) // //--------------------------------------------------------------------------- -void ChangeState(DSWActor* actor, STATE* statep) +void ChangeState(DSWActor* actor, FState* statep) { if (!actor->hasU()) return; @@ -751,7 +751,7 @@ void change_actor_stat(DSWActor* actor, int stat, bool quick) // //--------------------------------------------------------------------------- -void SpawnUser(DSWActor* actor, short id, STATE* state) +void SpawnUser(DSWActor* actor, short id, FState* state) { ASSERT(!Prediction); @@ -808,7 +808,7 @@ void SpawnUser(DSWActor* actor, short id, STATE* state) // //--------------------------------------------------------------------------- -DSWActor* SpawnActor(int stat, int id, STATE* state, sectortype* sect, const DVector3& pos, DAngle init_ang, double vel) +DSWActor* SpawnActor(int stat, int id, FState* state, sectortype* sect, const DVector3& pos, DAngle init_ang, double vel) { if (sect == nullptr) return nullptr; @@ -4189,7 +4189,7 @@ int SpawnItemsMatch(short match) // //--------------------------------------------------------------------------- -int NewStateGroup(DSWActor* actor, STATE* StateGroup[]) +int NewStateGroup(DSWActor* actor, FState* StateGroup) { if (!StateGroup) return 0; @@ -4198,11 +4198,11 @@ int NewStateGroup(DSWActor* actor, STATE* StateGroup[]) // Kind of a goofy check, but it should catch alot of invalid states! - if (actor->user.__legacyState.State && (actor->user.__legacyState.State->Sprite < 0 || actor->user.__legacyState.State->Sprite > SPR_MAX)) // 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; - actor->user.__legacyState.State = actor->user.__legacyState.StateStart = StateGroup[0]; + actor->user.__legacyState.State = actor->user.__legacyState.StateStart = StateGroup; actor->user.Tics = 0; @@ -4868,7 +4868,7 @@ int KillGetWeapon(DSWActor* actor) int DoSpawnItemTeleporterEffect(DSWActor* actor) { - extern STATE s_TeleportEffect[]; + extern FState s_TeleportEffect[]; auto effect = SpawnActor(STAT_MISSILE, 0, s_TeleportEffect, actor->sector(), actor->spr.pos.plusZ(-12), actor->spr.Angles.Yaw); @@ -5666,7 +5666,7 @@ KeyMain: { if (pp->WpnShotgunType != 1) { - extern PANEL_STATE ps_ShotgunFlash[]; + extern PANEL_FState ps_ShotgunFlash[]; pp->CurWpn->over[SHOTGUN_AUTO_NUM].tics = 0; pp->CurWpn->over[SHOTGUN_AUTO_NUM].State = ps_ShotgunFlash; } @@ -5969,9 +5969,9 @@ int StateControl(DSWActor* actor) if (!actor->hasU()) break; - if (!actor->user.__legacyState.State->Sprite) + if (actor->user.__legacyState.State->sprite == SPR_NULL) { - NewStateGroup(actor, (STATE* *) actor->user.__legacyState.State->NextState); + NewStateGroup(actor, actor->user.__legacyState.State->NextState); } } diff --git a/source/games/sw/src/sprite.h b/source/games/sw/src/sprite.h index ec4993d45..8fc260e23 100644 --- a/source/games/sw/src/sprite.h +++ b/source/games/sw/src/sprite.h @@ -31,7 +31,7 @@ Prepared for public release: 03/28/2005 - Charlie Wiederhold, 3D Realms BEGIN_SW_NS void KillActor(DSWActor* actor); -DSWActor* SpawnActor(int stat, int id, STATE* state, sectortype* sect, const DVector3& pos, DAngle ang, double vel = 0); +DSWActor* SpawnActor(int stat, int id, FState* state, sectortype* sect, const DVector3& pos, DAngle ang, double vel = 0); void SpriteSetup(void); int move_actor(DSWActor* actor, const DVector3& change); diff --git a/source/games/sw/src/sumo.cpp b/source/games/sw/src/sumo.cpp index 9a7b35e10..80fd69ae3 100644 --- a/source/games/sw/src/sumo.cpp +++ b/source/games/sw/src/sumo.cpp @@ -127,39 +127,23 @@ ATTRIBUTE SumoAttrib = #define SUMO_RATE 24 -STATE s_SumoRun[1][4] = +FState s_SumoRun[] = { - { - {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]} - }, + {SPR_SUMO_RUN, 'A', SUMO_RATE, &AF(DoSumoMove), &s_SumoRun[1]}, + {SPR_SUMO_RUN, 'B', SUMO_RATE, &AF(DoSumoMove), &s_SumoRun[2]}, + {SPR_SUMO_RUN, 'C', SUMO_RATE, &AF(DoSumoMove), &s_SumoRun[3]}, + {SPR_SUMO_RUN, 'D', SUMO_RATE, &AF(DoSumoMove), &s_SumoRun[0]} }; -STATE* sg_SumoRun[] = -{ - &s_SumoRun[0][0], -}; - - - ////////////////////// // // SUMO STAND // ////////////////////// -STATE s_SumoStand[1][1] = +FState s_SumoStand[] = { - { - {SPR_SUMO_RUN, 'A', SUMO_RATE, &AF(DoSumoMove), &s_SumoStand[0][0]} - }, -}; - -STATE* sg_SumoStand[] = -{ - &s_SumoStand[0][0], + {SPR_SUMO_RUN, 'A', SUMO_RATE, &AF(DoSumoMove), &s_SumoStand[0]} }; ////////////////////// @@ -170,17 +154,10 @@ STATE* sg_SumoStand[] = #define SUMO_PAIN_RATE 30 -STATE s_SumoPain[1][2] = +FState s_SumoPain[] = { - { - {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]} - }, -}; - -STATE* sg_SumoPain[] = -{ - &s_SumoPain[0][0], + {SPR_SUMO_PAIN, 'A', SUMO_PAIN_RATE, &AF(NullSumo), &s_SumoPain[1]}, + {SPR_SUMO_PAIN, 'A', 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_SumoPain[0]} }; ////////////////////// @@ -191,21 +168,14 @@ STATE* sg_SumoPain[] = #define SUMO_FART_RATE 12 -STATE s_SumoFart[1][6] = +FState s_SumoFart[] = { - { - {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]} - }, -}; - -STATE* sg_SumoFart[] = -{ - &s_SumoFart[0][0], + {SPR_SUMO_FART, 'A', SUMO_FART_RATE, &AF(NullSumo), &s_SumoFart[1]}, + {SPR_SUMO_FART, 'A', SF_QUICK_CALL, &AF(InitSumoFart), &s_SumoFart[2]}, + {SPR_SUMO_FART, 'B', SUMO_FART_RATE, &AF(NullSumo), &s_SumoFart[3]}, + {SPR_SUMO_FART, 'C', SUMO_FART_RATE, &AF(NullSumo), &s_SumoFart[4]}, + {SPR_SUMO_FART, 'D', SUMO_FART_RATE*10, &AF(NullSumo), &s_SumoFart[5]}, + {SPR_SUMO_FART, 'D', SF_QUICK_CALL, &AF(InitActorDecide), &s_SumoFart[0]} }; ////////////////////// @@ -216,21 +186,14 @@ STATE* sg_SumoFart[] = #define SUMO_CLAP_RATE 12 -STATE s_SumoClap[1][6] = +FState s_SumoClap[] = { - { - {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]} - }, -}; - -STATE* sg_SumoClap[] = -{ - &s_SumoClap[0][0], + {SPR_SUMO_CLAP, 'A', SUMO_CLAP_RATE, &AF(NullSumo), &s_SumoClap[1]}, + {SPR_SUMO_CLAP, 'B', SUMO_CLAP_RATE, &AF(NullSumo), &s_SumoClap[2]}, + {SPR_SUMO_CLAP, 'C', SUMO_CLAP_RATE, &AF(NullSumo), &s_SumoClap[3]}, + {SPR_SUMO_CLAP, 'C', SF_QUICK_CALL, &AF(InitSumoClap), &s_SumoClap[4]}, + {SPR_SUMO_CLAP, 'D', SUMO_CLAP_RATE*10, &AF(NullSumo), &s_SumoClap[5]}, + {SPR_SUMO_CLAP, 'D', SF_QUICK_CALL, &AF(InitActorDecide), &s_SumoClap[5]} }; ////////////////////// @@ -241,28 +204,16 @@ STATE* sg_SumoClap[] = #define SUMO_STOMP_RATE 30 -STATE s_SumoStomp[1][6] = +FState s_SumoStomp[] = { - { - {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]} - }, + {SPR_SUMO_STOMP, 'A', SUMO_STOMP_RATE, &AF(NullSumo), &s_SumoStomp[1]}, + {SPR_SUMO_STOMP, 'B', SUMO_STOMP_RATE*3, &AF(NullSumo), &s_SumoStomp[2]}, + {SPR_SUMO_STOMP, 'C', SUMO_STOMP_RATE, &AF(NullSumo), &s_SumoStomp[3]}, + {SPR_SUMO_STOMP, 'C', 0|SF_QUICK_CALL, &AF(InitSumoStomp), &s_SumoStomp[4]}, + {SPR_SUMO_STOMP, 'C', 8, &AF(NullSumo), &s_SumoStomp[5]}, + {SPR_SUMO_STOMP, 'C', 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_SumoStomp[5]} }; -STATE* sg_SumoStomp[] = -{ - &s_SumoStomp[0][0], - &s_SumoStomp[1][0], - &s_SumoStomp[2][0], - &s_SumoStomp[3][0], - &s_SumoStomp[4][0] -}; - - ////////////////////// // // SUMO DIE @@ -271,7 +222,7 @@ STATE* sg_SumoStomp[] = #define SUMO_DIE_RATE 30 -STATE s_SumoDie[] = +FState s_SumoDie[] = { {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]}, @@ -292,25 +243,15 @@ STATE s_SumoDie[] = {SPR_SUMO_DEAD, 'A', SUMO_DIE_RATE, &AF(DoActorDebris), &s_SumoDie[16]} }; -STATE* sg_SumoDie[] = -{ - s_SumoDie -}; - -STATE s_SumoDead[] = +FState s_SumoDead[] = { {SPR_SUMO_DEAD, 'A', SUMO_DIE_RATE, &AF(DoActorDebris), &s_SumoDead[0]}, }; -STATE* sg_SumoDead[] = -{ - s_SumoDead -}; - ACTOR_ACTION_SET SumoActionSet = { - sg_SumoStand, - sg_SumoRun, + s_SumoStand, + s_SumoRun, nullptr, nullptr, nullptr, @@ -320,15 +261,15 @@ ACTOR_ACTION_SET SumoActionSet = nullptr, nullptr, nullptr, //climb - sg_SumoPain, //pain - sg_SumoDie, + s_SumoPain, //pain + s_SumoDie, nullptr, - sg_SumoDead, + s_SumoDead, nullptr, nullptr, - {sg_SumoStomp,sg_SumoFart}, + {s_SumoStomp,s_SumoFart}, {800,1024}, - {sg_SumoClap,sg_SumoStomp,sg_SumoFart}, + {s_SumoClap,s_SumoStomp,s_SumoFart}, {400,750,1024}, {nullptr}, nullptr, @@ -337,8 +278,8 @@ ACTOR_ACTION_SET SumoActionSet = ACTOR_ACTION_SET MiniSumoActionSet = { - sg_SumoStand, - sg_SumoRun, + s_SumoStand, + s_SumoRun, nullptr, nullptr, nullptr, @@ -348,15 +289,15 @@ ACTOR_ACTION_SET MiniSumoActionSet = nullptr, nullptr, nullptr, //climb - sg_SumoPain, //pain - sg_SumoDie, + s_SumoPain, //pain + s_SumoDie, nullptr, - sg_SumoDead, + s_SumoDead, nullptr, nullptr, - {sg_SumoClap}, + {s_SumoClap}, {1024}, - {sg_SumoClap}, + {s_SumoClap}, {1024}, {nullptr}, nullptr, @@ -385,7 +326,7 @@ int SetupSumo(DSWActor* actor) actor->user.__legacyState.Attrib = &SumoAttrib; DoActorSetSpeed(actor, NORM_SPEED); actor->user.__legacyState.StateEnd = s_SumoDie; - actor->user.__legacyState.Rot = sg_SumoRun; + actor->user.__legacyState.Rot = s_SumoRun; EnemyDefaults(actor, &SumoActionSet, &SumoPersonality); @@ -692,21 +633,13 @@ static saveable_data saveable_sumo_data[] = SAVE_DATA(SumoAttrib), SAVE_DATA(s_SumoRun), - SAVE_DATA(sg_SumoRun), SAVE_DATA(s_SumoStand), - SAVE_DATA(sg_SumoStand), SAVE_DATA(s_SumoPain), - SAVE_DATA(sg_SumoPain), SAVE_DATA(s_SumoFart), - SAVE_DATA(sg_SumoFart), SAVE_DATA(s_SumoClap), - SAVE_DATA(sg_SumoClap), SAVE_DATA(s_SumoStomp), - SAVE_DATA(sg_SumoStomp), SAVE_DATA(s_SumoDie), - SAVE_DATA(sg_SumoDie), SAVE_DATA(s_SumoDead), - SAVE_DATA(sg_SumoDead), SAVE_DATA(SumoActionSet), SAVE_DATA(MiniSumoActionSet), diff --git a/source/games/sw/src/swactor.h b/source/games/sw/src/swactor.h index a36a148ea..20748e81e 100644 --- a/source/games/sw/src/swactor.h +++ b/source/games/sw/src/swactor.h @@ -6,9 +6,9 @@ BEGIN_SW_NS struct Personality; -FTextureID picFromState(STATE* s) +FTextureID picFromState(FState* s) { - auto& spritedef = SpriteDefs[s->Sprite]; + auto& spritedef = SpriteDefs[s->sprite]; unsigned framenum = s->Frame - 'A'; if (framenum >= spritedef.numframes) return FNullTextureID(); auto& frame = SpriteFrames[spritedef.spriteframes + framenum]; @@ -64,7 +64,6 @@ public: bool hasState(FName label, int substate = 0); void callAction(); void callStateAction(); - int callFunction(VMFunction* func); void setPicFromState() { spr.setspritetexture(picFromState(user.__legacyState.State)); } }; diff --git a/source/games/sw/src/track.cpp b/source/games/sw/src/track.cpp index 410d61947..55b043678 100644 --- a/source/games/sw/src/track.cpp +++ b/source/games/sw/src/track.cpp @@ -3187,7 +3187,7 @@ bool ActorTrackDecide(TRACK_POINT* tpoint, DSWActor* actor) case TRACK_ACTOR_ATTACK5: case TRACK_ACTOR_ATTACK6: { - STATE* **ap = &actor->user.__legacyState.ActorActionSet->Attack[0] + (tpoint->tag_low - TRACK_ACTOR_ATTACK1); + FState **ap = &actor->user.__legacyState.ActorActionSet->Attack[(tpoint->tag_low - TRACK_ACTOR_ATTACK1)]; if (*ap) diff --git a/source/games/sw/src/weapon.cpp b/source/games/sw/src/weapon.cpp index deccf9e3e..7c074df5a 100644 --- a/source/games/sw/src/weapon.cpp +++ b/source/games/sw/src/weapon.cpp @@ -147,34 +147,34 @@ short StatDamageList[STAT_DAMAGE_LIST_SIZE] = ////////////////////// // -// SPECIAL STATES +// SPECIAL FStateS // ////////////////////// // state for sprites that are not restored -STATE s_NotRestored[] = +FState s_NotRestored[] = { {SPR_NOTRESTORED, 'A', 100, nullptr, &s_NotRestored[0]} }; -STATE s_Suicide[] = +FState s_Suicide[] = { {SPR_SUICIDES, 'A', 100, &AF(DoSuicide), &s_Suicide[0]} }; -STATE s_DeadLoWang[] = +FState s_DeadLoWang[] = { {SPR_DEADLOWANG, 'A', 100, nullptr, &s_DeadLoWang[0]}, }; ////////////////////// // -// BREAKABLE STATES +// BREAKABLE FStateS // ////////////////////// #define BREAK_LIGHT_RATE 18 -STATE s_BreakLight[] = +FState s_BreakLight[] = { {SPR_BREAK_LIGHT_ANIM, 'A', BREAK_LIGHT_RATE, nullptr, &s_BreakLight[1]}, {SPR_BREAK_LIGHT_ANIM, 'B', BREAK_LIGHT_RATE, nullptr, &s_BreakLight[2]}, @@ -185,7 +185,7 @@ STATE s_BreakLight[] = }; #define BREAK_BARREL_RATE 18 -STATE s_BreakBarrel[] = +FState s_BreakBarrel[] = { {SPR_BREAK_BARREL, 'E', BREAK_BARREL_RATE, nullptr, &s_BreakBarrel[1]}, {SPR_BREAK_BARREL, 'F', BREAK_BARREL_RATE, nullptr, &s_BreakBarrel[2]}, @@ -196,7 +196,7 @@ STATE s_BreakBarrel[] = }; #define BREAK_PEDISTAL_RATE 28 -STATE s_BreakPedistal[] = +FState s_BreakPedistal[] = { {SPR_BREAK_PEDISTAL, 'B', BREAK_PEDISTAL_RATE, nullptr, &s_BreakPedistal[1]}, {SPR_BREAK_PEDISTAL, 'C', BREAK_PEDISTAL_RATE, nullptr, &s_BreakPedistal[2]}, @@ -205,7 +205,7 @@ STATE s_BreakPedistal[] = }; #define BREAK_BOTTLE1_RATE 18 -STATE s_BreakBottle1[] = +FState s_BreakBottle1[] = { {SPR_BREAK_BOTTLE1, 'B', BREAK_BOTTLE1_RATE, nullptr, &s_BreakBottle1[1]}, {SPR_BREAK_BOTTLE1, 'C', BREAK_BOTTLE1_RATE, nullptr, &s_BreakBottle1[2]}, @@ -216,7 +216,7 @@ STATE s_BreakBottle1[] = }; #define BREAK_BOTTLE2_RATE 18 -STATE s_BreakBottle2[] = +FState s_BreakBottle2[] = { {SPR_BREAK_BOTTLE2, 'B', BREAK_BOTTLE2_RATE, nullptr, &s_BreakBottle2[1]}, {SPR_BREAK_BOTTLE2, 'C', BREAK_BOTTLE2_RATE, nullptr, &s_BreakBottle2[2]}, @@ -228,7 +228,7 @@ STATE s_BreakBottle2[] = #define PUFF_RATE 8 -STATE s_Puff[] = +FState s_Puff[] = { {SPR_PUFF, 'A', PUFF_RATE, &AF(DoPuff), &s_Puff[1]}, {SPR_PUFF, 'B', PUFF_RATE, &AF(DoPuff), &s_Puff[2]}, @@ -242,37 +242,30 @@ STATE s_Puff[] = #define RAIL_PUFF_RATE 6 -STATE s_RailPuff[3][17] = +FState s_RailPuff[] = { - { - {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]}, - }, + {SPR_RAIL_PUFF, 'A', RAIL_PUFF_RATE, &AF(DoRailPuff), &s_RailPuff[1]}, + {SPR_RAIL_PUFF, 'B', RAIL_PUFF_RATE, &AF(DoRailPuff), &s_RailPuff[2]}, + {SPR_RAIL_PUFF, 'C', RAIL_PUFF_RATE, &AF(DoRailPuff), &s_RailPuff[3]}, + {SPR_RAIL_PUFF, 'D', RAIL_PUFF_RATE, &AF(DoRailPuff), &s_RailPuff[4]}, + {SPR_RAIL_PUFF, 'E', RAIL_PUFF_RATE, &AF(DoRailPuff), &s_RailPuff[5]}, + {SPR_RAIL_PUFF, 'F', RAIL_PUFF_RATE, &AF(DoRailPuff), &s_RailPuff[6]}, + {SPR_RAIL_PUFF, 'G', RAIL_PUFF_RATE, &AF(DoRailPuff), &s_RailPuff[7]}, + {SPR_RAIL_PUFF, 'H', RAIL_PUFF_RATE, &AF(DoRailPuff), &s_RailPuff[8]}, + {SPR_RAIL_PUFF, 'I', RAIL_PUFF_RATE, &AF(DoRailPuff), &s_RailPuff[9]}, + {SPR_RAIL_PUFF, 'J', RAIL_PUFF_RATE, &AF(DoRailPuff), &s_RailPuff[10]}, + {SPR_RAIL_PUFF, 'K', RAIL_PUFF_RATE, &AF(DoRailPuff), &s_RailPuff[11]}, + {SPR_RAIL_PUFF, 'L', RAIL_PUFF_RATE, &AF(DoRailPuff), &s_RailPuff[12]}, + {SPR_RAIL_PUFF, 'M', RAIL_PUFF_RATE, &AF(DoRailPuff), &s_RailPuff[13]}, + {SPR_RAIL_PUFF, 'N', RAIL_PUFF_RATE, &AF(DoRailPuff), &s_RailPuff[14]}, + {SPR_RAIL_PUFF, 'O', RAIL_PUFF_RATE, &AF(DoRailPuff), &s_RailPuff[15]}, + {SPR_RAIL_PUFF, 'P', RAIL_PUFF_RATE, &AF(DoRailPuff), &s_RailPuff[16]}, + {SPR_RAIL_PUFF, 'P', 100, &AF(DoSuicide), &s_RailPuff[0]}, }; -STATE* sg_RailPuff[] = -{ - &s_RailPuff[0][0], -}; - #define LASER_PUFF_RATE 8 -STATE s_LaserPuff[] = +FState s_LaserPuff[] = { {SPR_LASER_PUFF, 'A', LASER_PUFF_RATE, nullptr, &s_LaserPuff[1]}, {SPR_LASER_PUFF, 'A', 100, &AF(DoSuicide), &s_LaserPuff[0]} @@ -280,7 +273,7 @@ STATE s_LaserPuff[] = #define TRACER_RATE 6 -STATE s_Tracer[] = +FState s_Tracer[] = { {SPR_TRACER, 'A', TRACER_RATE, &AF(DoTracer), &s_Tracer[1]}, {SPR_TRACER, 'B', TRACER_RATE, &AF(DoTracer), &s_Tracer[2]}, @@ -291,7 +284,7 @@ STATE s_Tracer[] = }; #define EMP_RATE 6 -STATE s_EMP[] = +FState s_EMP[] = { {SPR_EMP, 'A', EMP_RATE, &AF(DoEMP), &s_EMP[1]}, {SPR_EMP, 'B', EMP_RATE, &AF(DoEMP), &s_EMP[2]}, @@ -299,14 +292,14 @@ STATE s_EMP[] = }; -STATE s_EMPBurst[] = +FState s_EMPBurst[] = { {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[] = +FState s_EMPShrap[] = { {SPR_EMP, 'A', EMP_RATE, &AF(DoFastShrapJumpFall), &s_EMPShrap[1]}, {SPR_EMP, 'B', EMP_RATE, &AF(DoFastShrapJumpFall), &s_EMPShrap[2]}, @@ -317,14 +310,14 @@ STATE s_EMPShrap[] = #define TANK_SHELL 3201 #define TANK_SHELL_RATE 6 -STATE s_TankShell[] = +FState s_TankShell[] = { {SPR_TRACER, 'A', 200, &AF(DoTankShell), &s_TankShell[0]} }; #define VEHICLE_SMOKE_RATE 18 -STATE s_VehicleSmoke[] = +FState s_VehicleSmoke[] = { {SPR_PUFF, 'A', VEHICLE_SMOKE_RATE, &AF(DoVehicleSmoke), &s_VehicleSmoke[1]}, {SPR_PUFF, 'B', VEHICLE_SMOKE_RATE, &AF(DoVehicleSmoke), &s_VehicleSmoke[2]}, @@ -337,7 +330,7 @@ STATE s_VehicleSmoke[] = #define WATER_SMOKE_RATE 18 -STATE s_WaterSmoke[] = +FState s_WaterSmoke[] = { {SPR_PUFF, 'A', WATER_SMOKE_RATE, &AF(DoWaterSmoke), &s_WaterSmoke[1]}, {SPR_PUFF, 'B', WATER_SMOKE_RATE, &AF(DoWaterSmoke), &s_WaterSmoke[2]}, @@ -351,7 +344,7 @@ STATE s_WaterSmoke[] = constexpr double UZI_SPARK_REPEAT = 0.375; constexpr double UZI_SMOKE_REPEAT = 0.375; #define UZI_SMOKE_RATE 16 // Was 9 -STATE s_UziSmoke[] = +FState s_UziSmoke[] = { {SPR_UZI_SMOKE, 'A', UZI_SMOKE_RATE, &AF(DoUziSmoke), &s_UziSmoke[1]}, {SPR_UZI_SMOKE, 'B', UZI_SMOKE_RATE, &AF(DoUziSmoke), &s_UziSmoke[2]}, @@ -362,7 +355,7 @@ STATE s_UziSmoke[] = #define SHOTGUN_SMOKE_RATE 16 #define SHOTGUN_SMOKE UZI_SMOKE+1 -STATE s_ShotgunSmoke[] = +FState s_ShotgunSmoke[] = { {SPR_UZI_SMOKE, 'A', SHOTGUN_SMOKE_RATE, &AF(DoShotgunSmoke), &s_ShotgunSmoke[1]}, {SPR_UZI_SMOKE, 'B', SHOTGUN_SMOKE_RATE, &AF(DoShotgunSmoke), &s_ShotgunSmoke[2]}, @@ -373,14 +366,14 @@ STATE s_ShotgunSmoke[] = #define UZI_BULLET_RATE 100 -STATE s_UziBullet[] = +FState s_UziBullet[] = { {SPR_UZI_BULLET, 'A', UZI_BULLET_RATE, &AF(DoUziBullet), &s_UziBullet[0]}, }; #define UZI_SPARK_RATE 8 -STATE s_UziSpark[] = +FState s_UziSpark[] = { {SPR_UZI_SPARK, 'A', UZI_SPARK_RATE, nullptr, &s_UziSpark[1]}, {SPR_UZI_SPARK, 'B', UZI_SPARK_RATE, nullptr, &s_UziSpark[2]}, @@ -390,7 +383,7 @@ STATE s_UziSpark[] = {SPR_UZI_SPARK, 'E', 100, &AF(DoSuicide), &s_UziSpark[0]}, }; -STATE s_UziPowerSpark[] = +FState s_UziPowerSpark[] = { {SPR_UZI_SPARK, 'A', UZI_SPARK_RATE, &AF(DoUziSmoke), &s_UziSpark[1]}, {SPR_UZI_SPARK, 'B', UZI_SPARK_RATE, &AF(DoUziSmoke), &s_UziSpark[2]}, @@ -402,7 +395,7 @@ STATE s_UziPowerSpark[] = #define BUBBLE_RATE 100 -STATE s_Bubble[] = +FState s_Bubble[] = { {SPR_BUBBLE, 'A', BUBBLE_RATE, &AF(DoBubble), &s_Bubble[0]} }; @@ -411,7 +404,7 @@ STATE s_Bubble[] = //#define SPLASH 2190 #define SPLASH_RATE 10 -STATE s_Splash[] = +FState s_Splash[] = { {SPR_SPLASH, 'A', SPLASH_RATE, nullptr, &s_Splash[1]}, {SPR_SPLASH, 'B', SPLASH_RATE, nullptr, &s_Splash[2]}, @@ -422,22 +415,15 @@ STATE s_Splash[] = }; #define CROSSBOLT_RATE 100 -STATE s_CrossBolt[1][1] = +FState s_CrossBolt[] = { - { - {SPR_CROSSBOLT, 'A', CROSSBOLT_RATE, &AF(DoCrossBolt), &s_CrossBolt[0][0]}, - }, -}; - -STATE* sg_CrossBolt[] = -{ - &s_CrossBolt[0][0], + {SPR_CROSSBOLT, 'A', CROSSBOLT_RATE, &AF(DoCrossBolt), &s_CrossBolt[0]}, }; #undef STAR #define STAR 2102 #define STAR_RATE 6 -STATE s_Star[] = +FState s_Star[] = { {SPR_STAR, 'A', STAR_RATE, &AF(DoStar), &s_Star[1]}, {SPR_STAR, 'B', STAR_RATE, &AF(DoStar), &s_Star[2]}, @@ -445,12 +431,12 @@ STATE s_Star[] = {SPR_STAR, 'D', STAR_RATE, &AF(DoStar), &s_Star[0]} }; -STATE s_StarStuck[] = +FState s_StarStuck[] = { {SPR_STAR, 'A', STAR_RATE, nullptr, &s_StarStuck[0]}, }; -STATE s_StarDown[] = +FState s_StarDown[] = { {SPR_STAR_DOWN, 'A', STAR_RATE, &AF(DoStar), &s_StarDown[1]}, {SPR_STAR_DOWN, 'B', STAR_RATE, &AF(DoStar), &s_StarDown[2]}, @@ -458,7 +444,7 @@ STATE s_StarDown[] = {SPR_STAR_DOWN, 'D', STAR_RATE, &AF(DoStar), &s_StarDown[0]} }; -STATE s_StarDownStuck[] = +FState s_StarDownStuck[] = { {SPR_STAR, 'A', STAR_RATE, nullptr, &s_StarDownStuck[0]}, }; @@ -471,7 +457,7 @@ STATE s_StarDownStuck[] = #define LAVA_BOULDER_RATE 6 -STATE s_LavaBoulder[] = +FState s_LavaBoulder[] = { {SPR_LAVA_BOULDER, 'B', LAVA_BOULDER_RATE, &AF(DoLavaBoulder), &s_LavaBoulder[1]}, {SPR_LAVA_BOULDER, 'C', LAVA_BOULDER_RATE, &AF(DoLavaBoulder), &s_LavaBoulder[2]}, @@ -485,7 +471,7 @@ STATE s_LavaBoulder[] = #define LAVA_SHARD (LAVA_BOULDER+1) -STATE s_LavaShard[] = +FState s_LavaShard[] = { {SPR_LAVA_BOULDER, 'B', LAVA_BOULDER_RATE, &AF(DoShrapDamage), &s_LavaShard[1]}, {SPR_LAVA_BOULDER, 'C', LAVA_BOULDER_RATE, &AF(DoShrapDamage), &s_LavaShard[2]}, @@ -497,7 +483,7 @@ STATE s_LavaShard[] = {SPR_LAVA_BOULDER, 'I', LAVA_BOULDER_RATE, &AF(DoShrapDamage), &s_LavaShard[0]}, }; -STATE s_VulcanBoulder[] = +FState s_VulcanBoulder[] = { {SPR_LAVA_BOULDER, 'B', LAVA_BOULDER_RATE, &AF(DoVulcanBoulder), &s_VulcanBoulder[1]}, {SPR_LAVA_BOULDER, 'C', LAVA_BOULDER_RATE, &AF(DoVulcanBoulder), &s_VulcanBoulder[2]}, @@ -523,18 +509,12 @@ STATE s_VulcanBoulder[] = #define GRENADE GRENADE_R0 #define GRENADE_RATE 8 -STATE s_Grenade[1][1] = +FState s_Grenade[] = { - { - {SPR_GRENADE, 'A', GRENADE_RATE, &AF(DoGrenade), &s_Grenade[0][0]}, - }, + {SPR_GRENADE, 'A', GRENADE_RATE, &AF(DoGrenade), &s_Grenade[0]}, }; -STATE* sg_Grenade[] = -{ - &s_Grenade[0][0], -}; #endif ////////////////////// @@ -548,19 +528,19 @@ STATE* sg_Grenade[] = #define MINE_SHRAP 5011 #define MINE_RATE 16 -STATE s_MineStuck[] = +FState s_MineStuck[] = { {SPR_MINE, 'A', MINE_RATE, &AF(DoMineStuck), &s_MineStuck[0]}, }; -STATE s_Mine[] = +FState s_Mine[] = { {SPR_MINE, 'A', MINE_RATE, &AF(DoMine), &s_Mine[1]}, {SPR_MINE, 'B', MINE_RATE, &AF(DoMine), &s_Mine[0]}, }; -STATE s_MineSpark[] = +FState s_MineSpark[] = { {SPR_UZI_SPARK, 'A', UZI_SPARK_RATE, &AF(DoMineSpark), &s_MineSpark[1]}, {SPR_UZI_SPARK, 'B', UZI_SPARK_RATE, &AF(DoMineSpark), &s_MineSpark[2]}, @@ -582,26 +562,19 @@ STATE s_MineSpark[] = #define METEOR_RATE 8 -STATE s_Meteor[1][4] = +FState s_Meteor[] = { - { - {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]}, - }, + {SPR_METEOR, 'A', METEOR_RATE, &AF(DoMeteor), &s_Meteor[1]}, + {SPR_METEOR, 'B', METEOR_RATE, &AF(DoMeteor), &s_Meteor[2]}, + {SPR_METEOR, 'C', METEOR_RATE, &AF(DoMeteor), &s_Meteor[3]}, + {SPR_METEOR, 'D', METEOR_RATE, &AF(DoMeteor), &s_Meteor[0]}, }; -STATE* sg_Meteor[] = -{ - &s_Meteor[0][0], -}; - #define METEOR_EXP 2115 #define METEOR_EXP_RATE 7 -STATE s_MeteorExp[] = +FState s_MeteorExp[] = { {SPR_METEOR_EXP, 'A', METEOR_EXP_RATE, nullptr, &s_MeteorExp[1]}, {SPR_METEOR_EXP, 'B', METEOR_EXP_RATE, nullptr, &s_MeteorExp[2]}, @@ -614,23 +587,16 @@ STATE s_MeteorExp[] = #define MIRV_METEOR 2098 //METEOR_R0 -STATE s_MirvMeteor[1][4] = +FState s_MirvMeteor[] = { - { - {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]}, - }, + {SPR_METEOR, 'A', METEOR_RATE, &AF(DoMirvMissile), &s_MirvMeteor[1]}, + {SPR_METEOR, 'B', METEOR_RATE, &AF(DoMirvMissile), &s_MirvMeteor[2]}, + {SPR_METEOR, 'C', METEOR_RATE, &AF(DoMirvMissile), &s_MirvMeteor[3]}, + {SPR_METEOR, 'D', METEOR_RATE, &AF(DoMirvMissile), &s_MirvMeteor[0]}, }; -STATE* sg_MirvMeteor[] = -{ - &s_MirvMeteor[0][0], -}; - -STATE s_MirvMeteorExp[] = +FState s_MirvMeteorExp[] = { {SPR_METEOR_EXP, 'A', METEOR_EXP_RATE, nullptr, &s_MirvMeteorExp[1]}, {SPR_METEOR_EXP, 'B', METEOR_EXP_RATE, nullptr, &s_MirvMeteorExp[2]}, @@ -643,24 +609,16 @@ STATE s_MirvMeteorExp[] = #define SERP_METEOR 2099// METEOR_R0+1 -STATE s_SerpMeteor[1][4] = +FState s_SerpMeteor[] = { - { - {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]}, - }, + {SPR_SERP_METEOR, 'A', METEOR_RATE, &AF(DoSerpMeteor), &s_SerpMeteor[1]}, + {SPR_SERP_METEOR, 'B', METEOR_RATE, &AF(DoSerpMeteor), &s_SerpMeteor[2]}, + {SPR_SERP_METEOR, 'C', METEOR_RATE, &AF(DoSerpMeteor), &s_SerpMeteor[3]}, + {SPR_SERP_METEOR, 'D', METEOR_RATE, &AF(DoSerpMeteor), &s_SerpMeteor[0]}, }; -STATE* sg_SerpMeteor[] = -{ - &s_SerpMeteor[0][0], -}; - - -STATE s_SerpMeteorExp[] = +FState s_SerpMeteorExp[] = { {SPR_METEOR_EXP, 'A', METEOR_EXP_RATE, nullptr, &s_SerpMeteorExp[1]}, {SPR_METEOR_EXP, 'B', METEOR_EXP_RATE, nullptr, &s_SerpMeteorExp[2]}, @@ -680,16 +638,9 @@ STATE s_SerpMeteorExp[] = #define SPEAR_RATE 8 -STATE s_Spear[1][1] = +FState s_Spear[] = { - { - {SPR_SPEAR, 'A', SPEAR_RATE, &AF(DoSpear), s_Spear[0]}, - }, -}; - -STATE* sg_Spear[] = -{ - s_Spear[0], + {SPR_SPEAR, 'A', SPEAR_RATE, &AF(DoSpear), &s_Spear[0]}, }; ////////////////////// @@ -700,16 +651,9 @@ STATE* sg_Spear[] = #define ROCKET_RATE 8 -STATE s_Rocket[1][1] = +FState s_Rocket[] = { - { - {SPR_ROCKET, 'A', ROCKET_RATE, &AF(DoRocket), &s_Rocket[0][0]}, - }, -}; - -STATE* sg_Rocket[] = -{ - &s_Rocket[0][0], + {SPR_ROCKET, 'A', ROCKET_RATE, &AF(DoRocket), &s_Rocket[0]}, }; ////////////////////// @@ -720,37 +664,22 @@ STATE* sg_Rocket[] = #define BUNNYROCKET_RATE 8 -STATE s_BunnyRocket[1][1] = +FState s_BunnyRocket[] = { - { - {SPR_BUNNYROCKET, 'A', BUNNYROCKET_RATE, &AF(DoRocket), &s_BunnyRocket[0][0]}, - }, -}; - -STATE* sg_BunnyRocket[] = -{ - &s_BunnyRocket[0][0], + {SPR_BUNNYROCKET, 'A', BUNNYROCKET_RATE, &AF(DoRocket), &s_BunnyRocket[0]}, }; #define RAIL_RATE 8 -STATE s_Rail[1][1] = +FState s_Rail[] = { - { - {SPR_ROCKET, 'A', RAIL_RATE, &AF(DoRail), &s_Rail[0][0]}, - }, + {SPR_ROCKET, 'A', RAIL_RATE, &AF(DoRail), &s_Rail[0]}, }; -STATE* sg_Rail[] = -{ - &s_Rail[0][0], -}; - - #define LASER_RATE 8 -STATE s_Laser[] = +FState s_Laser[] = { {SPR_ROCKET, 'A', LASER_RATE, &AF(DoLaser), &s_Laser[0]} }; @@ -763,29 +692,14 @@ STATE s_Laser[] = #define MICRO_RATE 8 -STATE s_Micro[1][1] = +FState s_Micro[] = { - { - {SPR_MICRO, 'A', MICRO_RATE, &AF(DoMicro), &s_Micro[0][0]}, - }, + {SPR_MICRO, 'A', MICRO_RATE, &AF(DoMicro), &s_Micro[0]}, }; -STATE* sg_Micro[] = +FState s_MicroMini[] = { - &s_Micro[0][0], -}; - - -STATE s_MicroMini[1][1] = -{ - { - {SPR_MICRO, 'A', MICRO_RATE, &AF(DoMicroMini), &s_MicroMini[0][0]}, - }, -}; - -STATE* sg_MicroMini[] = -{ - &s_MicroMini[0][0], + {SPR_MICRO, 'A', MICRO_RATE, &AF(DoMicroMini), &s_MicroMini[0]}, }; ////////////////////// @@ -797,38 +711,23 @@ STATE* sg_MicroMini[] = #define BOLT_THINMAN_RATE 8 -STATE s_BoltThinMan[1][1] = +FState s_BoltThinMan[] = { - { - {SPR_BOLT_THINMAN, 'A', BOLT_THINMAN_RATE, &AF(DoBoltThinMan), &s_BoltThinMan[0][0]}, - }, -}; - -STATE* sg_BoltThinMan[] = -{ - &s_BoltThinMan[0][0], + {SPR_BOLT_THINMAN, 'A', BOLT_THINMAN_RATE, &AF(DoBoltThinMan), &s_BoltThinMan[0]}, }; #define BOLT_SEEKER_RATE 8 -STATE s_BoltSeeker[1][1] = +FState s_BoltSeeker[] = { - { - {SPR_BOLT_THINMAN, 'A', BOLT_SEEKER_RATE, &AF(DoBoltSeeker), &s_BoltSeeker[0][0]}, - }, + {SPR_BOLT_THINMAN, 'A', BOLT_SEEKER_RATE, &AF(DoBoltSeeker), &s_BoltSeeker[0]}, }; -STATE* sg_BoltSeeker[] = -{ - &s_BoltSeeker[0][0], -}; - - #define BOLT_FATMAN_RATE 8 -STATE s_BoltFatMan[] = +FState s_BoltFatMan[] = { {SPR_BOLT_FATMAN, 'A', BOLT_FATMAN_RATE, &AF(DoBoltFatMan), &s_BoltFatMan[1]}, {SPR_BOLT_FATMAN, 'B', BOLT_FATMAN_RATE, &AF(DoBoltFatMan), &s_BoltFatMan[2]}, @@ -840,7 +739,7 @@ STATE s_BoltFatMan[] = #define BOLT_SHRAPNEL_RATE 8 -STATE s_BoltShrapnel[] = +FState s_BoltShrapnel[] = { {SPR_BOLT_SHRAPNEL, 'A', BOLT_SHRAPNEL_RATE, &AF(DoBoltShrapnel), &s_BoltShrapnel[1]}, {SPR_BOLT_SHRAPNEL, 'B', BOLT_SHRAPNEL_RATE, &AF(DoBoltShrapnel), &s_BoltShrapnel[2]}, @@ -853,7 +752,7 @@ STATE s_BoltShrapnel[] = #define COOLG_W_FIRE_RATE 8 -STATE s_CoolgFire[] = +FState s_CoolgFire[] = { {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]}, @@ -863,7 +762,7 @@ STATE s_CoolgFire[] = #define COOLG_FIRE_DONE_RATE 3 -STATE s_CoolgFireDone[] = +FState s_CoolgFireDone[] = { {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]}, @@ -875,13 +774,13 @@ STATE s_CoolgFireDone[] = #define COOLG_DRIP 1720 -STATE s_CoolgDrip[] = +FState s_CoolgDrip[] = { {SPR_COOLG_DRIP, 'A', 100, &AF(DoCoolgDrip), &s_CoolgDrip[0]} }; #define GORE_FLOOR_SPLASH_RATE 8 -STATE s_GoreFloorSplash[] = +FState s_GoreFloorSplash[] = { {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]}, @@ -894,7 +793,7 @@ STATE s_GoreFloorSplash[] = #define GORE_SPLASH_RATE 8 -STATE s_GoreSplash[] = +FState s_GoreSplash[] = { {SPR_GORE_SPLASH, 'A', GORE_SPLASH_RATE, nullptr, &s_GoreSplash[1]}, {SPR_GORE_SPLASH, 'B', GORE_SPLASH_RATE, nullptr, &s_GoreSplash[2]}, @@ -917,7 +816,7 @@ STATE s_GoreSplash[] = #define PLASMA_FOUNTAIN_TIME (3*120); // regular bolt from heart -STATE s_Plasma[] = +FState s_Plasma[] = { {SPR_PLASMA, 'A', PLASMA_RATE, &AF(DoPlasma), &s_Plasma[1]}, {SPR_PLASMA, 'B', PLASMA_RATE, &AF(DoPlasma), &s_Plasma[2]}, @@ -926,7 +825,7 @@ STATE s_Plasma[] = // follows actor spewing blood #define PLASMA_Drip 1562 //2420 -STATE s_PlasmaFountain[] = +FState s_PlasmaFountain[] = { {SPR_PLASMA_Drip, 'A', PLASMA_RATE, &AF(DoPlasmaFountain), &s_PlasmaFountain[1]}, {SPR_PLASMA_Drip, 'B', PLASMA_RATE, &AF(DoPlasmaFountain), &s_PlasmaFountain[2]}, @@ -935,7 +834,7 @@ STATE s_PlasmaFountain[] = }; #define PLASMA_Drip_RATE 12 -STATE s_PlasmaDrip[] = +FState s_PlasmaDrip[] = { {SPR_PLASMA_Drip, 'A', PLASMA_Drip_RATE, &AF(DoShrapJumpFall), &s_PlasmaDrip[1]}, {SPR_PLASMA_Drip, 'B', PLASMA_Drip_RATE, &AF(DoShrapJumpFall), &s_PlasmaDrip[2]}, @@ -950,7 +849,7 @@ STATE s_PlasmaDrip[] = #define PLASMA_DONE_RATE 15 -STATE s_PlasmaDone[] = +FState s_PlasmaDone[] = { {SPR_PLASMA, 'A', PLASMA_DONE_RATE, &AF(DoPlasmaDone), &s_PlasmaDone[1]}, {SPR_PLASMA, 'C', PLASMA_DONE_RATE, &AF(DoPlasmaDone), &s_PlasmaDone[2]}, @@ -959,7 +858,7 @@ STATE s_PlasmaDone[] = #define TELEPORT_EFFECT 3240 #define TELEPORT_EFFECT_RATE 6 -STATE s_TeleportEffect[] = +FState s_TeleportEffect[] = { {SPR_TELEPORT_EFFECT, 'A', TELEPORT_EFFECT_RATE, nullptr, &s_TeleportEffect[1]}, {SPR_TELEPORT_EFFECT, 'B', TELEPORT_EFFECT_RATE, nullptr, &s_TeleportEffect[2]}, @@ -983,7 +882,7 @@ STATE s_TeleportEffect[] = }; // Spawn a RIPPER teleport effect -STATE s_TeleportEffect2[] = +FState s_TeleportEffect2[] = { {SPR_TELEPORT_EFFECT, 'A', TELEPORT_EFFECT_RATE, nullptr, &s_TeleportEffect2[1]}, {SPR_TELEPORT_EFFECT, 'B', TELEPORT_EFFECT_RATE, nullptr, &s_TeleportEffect2[2]}, @@ -1013,7 +912,7 @@ STATE s_TeleportEffect2[] = #define ELECTRO_ENEMY (ELECTRO + 1) #define ELECTRO_SHARD (ELECTRO + 2) -STATE s_Electro[] = +FState s_Electro[] = { {SPR_ELECTRO, 'A', 12, &AF(DoElectro), &s_Electro[1]}, {SPR_ELECTRO, 'B', 12, &AF(DoElectro), &s_Electro[2]}, @@ -1021,7 +920,7 @@ STATE s_Electro[] = {SPR_ELECTRO, 'D', 12, &AF(DoElectro), &s_Electro[0]} }; -STATE s_ElectroShrap[] = +FState s_ElectroShrap[] = { {SPR_ELECTRO, 'A', 12, &AF(DoShrapDamage), &s_ElectroShrap[1]}, {SPR_ELECTRO, 'B', 12, &AF(DoShrapDamage), &s_ElectroShrap[2]}, @@ -1040,7 +939,7 @@ STATE s_ElectroShrap[] = #if 0 #else -STATE s_GrenadeSmallExp[] = +FState s_GrenadeSmallExp[] = { {SPR_GRENADE_EXP, 'A', GRENADE_EXP_RATE, nullptr, &s_GrenadeSmallExp[1]}, {SPR_GRENADE_EXP, 'B', GRENADE_EXP_RATE, nullptr, &s_GrenadeSmallExp[2]}, @@ -1067,7 +966,7 @@ STATE s_GrenadeSmallExp[] = {SPR_GRENADE_EXP, 'U', 100, &AF(DoSuicide), &s_GrenadeSmallExp[22]} }; -STATE s_GrenadeExp[] = +FState s_GrenadeExp[] = { {SPR_GRENADE_EXP, 'A', GRENADE_EXP_RATE, nullptr, &s_GrenadeExp[1]}, {SPR_GRENADE_EXP, 'B', GRENADE_EXP_RATE, nullptr, &s_GrenadeExp[2]}, @@ -1099,7 +998,7 @@ STATE s_GrenadeExp[] = #endif #define MINE_EXP GRENADE_EXP+1 -STATE s_MineExp[] = +FState s_MineExp[] = { {SPR_GRENADE_EXP, 'A', GRENADE_EXP_RATE, nullptr, &s_MineExp[1]}, {SPR_GRENADE_EXP, 'B', GRENADE_EXP_RATE, nullptr, &s_MineExp[2]}, @@ -1137,7 +1036,7 @@ STATE s_MineExp[] = #define TRACER_EXP EXP+6 #define TANK_SHELL_EXP EXP+7 -STATE s_BasicExp[] = +FState s_BasicExp[] = { {SPR_EXP, 'A', EXP_RATE_W, nullptr, &s_BasicExp[1]}, {SPR_EXP, 'B', EXP_RATE_W, nullptr, &s_BasicExp[2]}, @@ -1164,7 +1063,7 @@ STATE s_BasicExp[] = #define MICRO_EXP_RATE 3 -STATE s_MicroExp[] = +FState s_MicroExp[] = { {SPR_EXP, 'A', MICRO_EXP_RATE, nullptr, &s_MicroExp[1]}, {SPR_EXP, 'A', SF_QUICK_CALL, &AF(DoExpDamageTest), &s_MicroExp[2]}, @@ -1193,7 +1092,7 @@ STATE s_MicroExp[] = #define BIG_GUN_FLAME_RATE 15 -STATE s_BigGunFlame[] = +FState s_BigGunFlame[] = { // first 3 frames {SPR_EXP, 'A', BIG_GUN_FLAME_RATE, nullptr, &s_BigGunFlame[1]}, @@ -1207,7 +1106,7 @@ STATE s_BigGunFlame[] = {SPR_EXP, 'U', 100, &AF(DoSuicide), &s_BigGunFlame[0]} }; -STATE s_BoltExp[] = +FState s_BoltExp[] = { {SPR_EXP, 'A', EXP_RATE_W, nullptr, &s_BoltExp[1]}, {SPR_EXP, 'A', SF_QUICK_CALL, nullptr, &s_BoltExp[2]}, @@ -1236,7 +1135,7 @@ STATE s_BoltExp[] = {SPR_EXP, 'U', 100, &AF(DoSuicide), &s_BoltExp[0]} }; -STATE s_TankShellExp[] = +FState s_TankShellExp[] = { {SPR_EXP, 'A', EXP_RATE_W, nullptr, &s_TankShellExp[1]}, {SPR_EXP, 'A', SF_QUICK_CALL, nullptr, &s_TankShellExp[2]}, @@ -1266,7 +1165,7 @@ STATE s_TankShellExp[] = }; #define TRACER_EXP_RATE 4 -STATE s_TracerExp[] = +FState s_TracerExp[] = { {SPR_EXP, 'A', TRACER_EXP_RATE, nullptr, &s_TracerExp[1]}, {SPR_EXP, 'A', SF_QUICK_CALL, nullptr, &s_TracerExp[2]}, @@ -1297,7 +1196,7 @@ STATE s_TracerExp[] = #define EXP_RATE_W 7 -STATE s_SectorExp[] = +FState s_SectorExp[] = { {SPR_EXP, 'A', EXP_RATE_W, &AF(DoSectorExp), &s_SectorExp[1]}, {SPR_EXP, 'A', SF_QUICK_CALL, &AF(SpawnShrapX), &s_SectorExp[2]}, @@ -1329,7 +1228,7 @@ STATE s_SectorExp[] = #define FIREBALL_DISS 3196 #define FIREBALL_DISS_RATE 8 -STATE s_FireballExp[] = +FState s_FireballExp[] = { {SPR_FIREBALL_DISS, 'A', FIREBALL_DISS_RATE, nullptr, &s_FireballExp[1]}, {SPR_FIREBALL_DISS, 'B', FIREBALL_DISS_RATE, nullptr, &s_FireballExp[2]}, @@ -1342,7 +1241,7 @@ STATE s_FireballExp[] = #define NAP_EXP (3072) #define NAP_EXP_RATE 6 -STATE s_NapExp[] = +FState s_NapExp[] = { {SPR_NAP_EXP, 'A', NAP_EXP_RATE, nullptr, &s_NapExp[1]}, {SPR_NAP_EXP, 'A', 0 | SF_QUICK_CALL, &AF(DoDamageTest), &s_NapExp[2]}, @@ -1372,7 +1271,7 @@ STATE s_NapExp[] = #define FLAME_RATE 6 -STATE s_FireballFlames[] = +FState s_FireballFlames[] = { {SPR_FIREBALL_FLAMES, 'A', FLAME_RATE, &AF(DoFireballFlames), &s_FireballFlames[1]}, {SPR_FIREBALL_FLAMES, 'B', FLAME_RATE, &AF(DoFireballFlames), &s_FireballFlames[2]}, @@ -1392,7 +1291,7 @@ STATE s_FireballFlames[] = #define FLAME_RATE 6 -STATE s_BreakFlames[] = +FState s_BreakFlames[] = { {SPR_FIREBALL_FLAMES, 'A', FLAME_RATE, &AF(DoBreakFlames), &s_BreakFlames[1]}, {SPR_FIREBALL_FLAMES, 'B', FLAME_RATE, &AF(DoBreakFlames), &s_BreakFlames[2]}, @@ -1419,7 +1318,7 @@ STATE s_BreakFlames[] = #define FIREBALL_RATE 8 #define GORO_FIREBALL FIREBALL+1 -STATE s_Fireball[] = +FState s_Fireball[] = { {SPR_FIREBALL, 'A', 12, &AF(DoFireball), &s_Fireball[1]}, {SPR_FIREBALL, 'B', 12, &AF(DoFireball), &s_Fireball[2]}, @@ -1428,7 +1327,7 @@ STATE s_Fireball[] = }; -STATE s_Ring[] = +FState s_Ring[] = { {SPR_FIREBALL, 'A', 12, &AF(DoRing), &s_Ring[1]}, {SPR_FIREBALL, 'B', 12, &AF(DoRing), &s_Ring[2]}, @@ -1436,7 +1335,7 @@ STATE s_Ring[] = {SPR_FIREBALL, 'D', 12, &AF(DoRing), &s_Ring[0]} }; -STATE s_Ring2[] = +FState s_Ring2[] = { {SPR_SERP_METEOR, 'A', 12, &AF(DoRing), &s_Ring2[1]}, {SPR_SERP_METEOR, 'B', 12, &AF(DoRing), &s_Ring2[2]}, @@ -1444,7 +1343,7 @@ STATE s_Ring2[] = {SPR_SERP_METEOR, 'D', 12, &AF(DoRing), &s_Ring2[0]} }; -STATE s_Napalm[] = +FState s_Napalm[] = { {SPR_FIREBALL, 'A', 12, &AF(DoNapalm), &s_Napalm[1]}, {SPR_FIREBALL, 'B', 12, &AF(DoNapalm), &s_Napalm[2]}, @@ -1455,7 +1354,7 @@ STATE s_Napalm[] = #if 1 #define BLOOD_WORM 2106 -STATE s_BloodWorm[] = +FState s_BloodWorm[] = { {SPR_BLOOD_WORM, 'A', 12, &AF(DoBloodWorm), &s_BloodWorm[1]}, {SPR_BLOOD_WORM, 'B', 12, &AF(DoBloodWorm), &s_BloodWorm[2]}, @@ -1471,7 +1370,7 @@ STATE s_BloodWorm[] = #define PLASMA_EXP BLOOD_WORM+1 #define PLASMA_EXP_RATE 8 -STATE s_PlasmaExp[] = +FState s_PlasmaExp[] = { {SPR_BLOOD_WORM, 'A', PLASMA_EXP_RATE, nullptr, &s_PlasmaExp[1]}, {SPR_BLOOD_WORM, 'B', PLASMA_EXP_RATE, nullptr, &s_PlasmaExp[2]}, @@ -1491,7 +1390,7 @@ STATE s_PlasmaExp[] = #endif -STATE s_Mirv[] = +FState s_Mirv[] = { {SPR_FIREBALL, 'A', 12, &AF(DoMirv), &s_Mirv[1]}, {SPR_FIREBALL, 'B', 12, &AF(DoMirv), &s_Mirv[2]}, @@ -1499,7 +1398,7 @@ STATE s_Mirv[] = {SPR_FIREBALL, 'D', 12, &AF(DoMirv), &s_Mirv[0]} }; -STATE s_MirvMissile[] = +FState s_MirvMissile[] = { {SPR_FIREBALL, 'A', 12, &AF(DoMirvMissile), &s_MirvMissile[1]}, {SPR_FIREBALL, 'B', 12, &AF(DoMirvMissile), &s_MirvMissile[2]}, @@ -1515,17 +1414,17 @@ STATE s_MirvMissile[] = #define VomitSplash 1711 #define Vomit_RATE 16 -STATE s_Vomit1[] = +FState s_Vomit1[] = { {SPR_Vomit1, 'A', Vomit_RATE, &AF(DoVomit), &s_Vomit1[0]} }; -STATE s_Vomit2[] = +FState s_Vomit2[] = { {SPR_Vomit2, 'A', Vomit_RATE, &AF(DoVomit), &s_Vomit2[0]} }; -STATE s_VomitSplash[] = +FState s_VomitSplash[] = { {SPR_VomitSplash, 'A', Vomit_RATE, &AF(DoVomitSplash), &s_VomitSplash[0]} }; @@ -1533,7 +1432,7 @@ STATE s_VomitSplash[] = #define GORE_Head 1670 #define GORE_Head_RATE 16 -STATE s_GoreHead[] = +FState s_GoreHead[] = { {SPR_GORE_Head, 'A', GORE_Head_RATE, &AF(DoShrapJumpFall), &s_GoreHead[1]}, {SPR_GORE_Head, 'B', GORE_Head_RATE, &AF(DoShrapJumpFall), &s_GoreHead[2]}, @@ -1552,7 +1451,7 @@ STATE s_GoreHead[] = #define GORE_Leg 1689 #define GORE_Leg_RATE 16 -STATE s_GoreLeg[] = +FState s_GoreLeg[] = { {SPR_GORE_Leg, 'A', GORE_Leg_RATE, &AF(DoShrapJumpFall), &s_GoreLeg[1]}, {SPR_GORE_Leg, 'B', GORE_Leg_RATE, &AF(DoShrapJumpFall), &s_GoreLeg[2]}, @@ -1562,7 +1461,7 @@ STATE s_GoreLeg[] = #define GORE_Eye 1692 #define GORE_Eye_RATE 16 -STATE s_GoreEye[] = +FState s_GoreEye[] = { {SPR_GORE_Eye, 'A', GORE_Eye_RATE, &AF(DoShrapJumpFall), &s_GoreEye[1]}, {SPR_GORE_Eye, 'B', GORE_Eye_RATE, &AF(DoShrapJumpFall), &s_GoreEye[2]}, @@ -1573,7 +1472,7 @@ STATE s_GoreEye[] = #define GORE_Torso 1696 #define GORE_Torso_RATE 16 -STATE s_GoreTorso[] = +FState s_GoreTorso[] = { {SPR_GORE_Torso, 'A', GORE_Torso_RATE, &AF(DoShrapJumpFall), &s_GoreTorso[1]}, {SPR_GORE_Torso, 'B', GORE_Torso_RATE, &AF(DoShrapJumpFall), &s_GoreTorso[2]}, @@ -1589,7 +1488,7 @@ STATE s_GoreTorso[] = #define GORE_Arm 1550 #define GORE_Arm_RATE 16 -STATE s_GoreArm[] = +FState s_GoreArm[] = { {SPR_GORE_Arm, 'A', GORE_Arm_RATE, &AF(DoShrapJumpFall), &s_GoreArm[1]}, {SPR_GORE_Arm, 'B', GORE_Arm_RATE, &AF(DoShrapJumpFall), &s_GoreArm[2]}, @@ -1608,7 +1507,7 @@ STATE s_GoreArm[] = #define GORE_Lung 903 #define GORE_Lung_RATE 16 -STATE s_GoreLung[] = +FState s_GoreLung[] = { {SPR_GORE_Lung, 'A', GORE_Lung_RATE, &AF(DoShrapJumpFall), &s_GoreLung[1]}, {SPR_GORE_Lung, 'B', GORE_Lung_RATE, &AF(DoShrapJumpFall), &s_GoreLung[2]}, @@ -1627,7 +1526,7 @@ STATE s_GoreLung[] = #define GORE_Liver 918 #define GORE_Liver_RATE 16 -STATE s_GoreLiver[] = +FState s_GoreLiver[] = { {SPR_GORE_Liver, 'A', GORE_Liver_RATE, &AF(DoShrapJumpFall), &s_GoreLiver[1]}, {SPR_GORE_Liver, 'B', GORE_Liver_RATE, &AF(DoShrapJumpFall), &s_GoreLiver[2]}, @@ -1646,7 +1545,7 @@ STATE s_GoreLiver[] = #define GORE_SkullCap 933 #define GORE_SkullCap_RATE 16 -STATE s_GoreSkullCap[] = +FState s_GoreSkullCap[] = { {SPR_GORE_SkullCap, 'A', GORE_SkullCap_RATE, &AF(DoShrapJumpFall), &s_GoreSkullCap[1]}, {SPR_GORE_SkullCap, 'B', GORE_SkullCap_RATE, &AF(DoShrapJumpFall), &s_GoreSkullCap[2]}, @@ -1666,7 +1565,7 @@ STATE s_GoreSkullCap[] = #define GORE_ChunkS 2430 #define GORE_ChunkS_RATE 16 -STATE s_GoreChunkS[] = +FState s_GoreChunkS[] = { {SPR_GORE_ChunkS, 'A', GORE_ChunkS_RATE, &AF(DoShrapJumpFall), &s_GoreChunkS[1]}, {SPR_GORE_ChunkS, 'B', GORE_ChunkS_RATE, &AF(DoShrapJumpFall), &s_GoreChunkS[2]}, @@ -1677,7 +1576,7 @@ STATE s_GoreChunkS[] = #define GORE_Drip 1562 //2430 #define GORE_Drip_RATE 16 -STATE s_GoreDrip[] = +FState s_GoreDrip[] = { {SPR_GORE_Drip, 'A', GORE_Drip_RATE, &AF(DoShrapJumpFall), &s_GoreDrip[1]}, {SPR_GORE_Drip, 'B', GORE_Drip_RATE, &AF(DoShrapJumpFall), &s_GoreDrip[2]}, @@ -1685,7 +1584,7 @@ STATE s_GoreDrip[] = {SPR_GORE_Drip, 'D', GORE_Drip_RATE, &AF(DoShrapJumpFall), &s_GoreDrip[0]}, }; -STATE s_FastGoreDrip[] = +FState s_FastGoreDrip[] = { {SPR_GORE_Drip, 'A', GORE_Drip_RATE, &AF(DoFastShrapJumpFall), &s_FastGoreDrip[1]}, {SPR_GORE_Drip, 'B', GORE_Drip_RATE, &AF(DoFastShrapJumpFall), &s_FastGoreDrip[2]}, @@ -1702,7 +1601,7 @@ STATE s_FastGoreDrip[] = #define GORE_Flame 847 #define GORE_Flame_RATE 8 -STATE s_GoreFlame[] = +FState s_GoreFlame[] = { {SPR_GORE_Flame, 'A', GORE_Flame_RATE, &AF(DoFastShrapJumpFall), &s_GoreFlame[1]}, {SPR_GORE_Flame, 'B', GORE_Flame_RATE, &AF(DoFastShrapJumpFall), &s_GoreFlame[2]}, @@ -1714,7 +1613,7 @@ STATE s_GoreFlame[] = {SPR_GORE_Flame, 'H', GORE_Flame_RATE, &AF(DoFastShrapJumpFall), &s_GoreFlame[0]}, }; -STATE s_TracerShrap[] = +FState s_TracerShrap[] = { {SPR_GORE_Flame, 'A', GORE_Flame_RATE, &AF(DoTracerShrap), &s_TracerShrap[1]}, {SPR_GORE_Flame, 'B', GORE_Flame_RATE, &AF(DoTracerShrap), &s_TracerShrap[2]}, @@ -1728,7 +1627,7 @@ STATE s_TracerShrap[] = #define UZI_SHELL 2152 #define UZISHELL_RATE 8 -STATE s_UziShellShrap[] = +FState s_UziShellShrap[] = { {SPR_UZI_SHELL, 'A', UZISHELL_RATE, &AF(DoShrapJumpFall), &s_UziShellShrap[1]}, {SPR_UZI_SHELL, 'B', UZISHELL_RATE, &AF(DoShrapJumpFall), &s_UziShellShrap[2]}, @@ -1738,34 +1637,34 @@ STATE s_UziShellShrap[] = {SPR_UZI_SHELL, 'F', UZISHELL_RATE, &AF(DoShrapJumpFall), &s_UziShellShrap[0]}, }; -STATE s_UziShellShrapStill1[] = +FState s_UziShellShrapStill1[] = { {SPR_UZI_SHELL, 'A', UZISHELL_RATE, nullptr, &s_UziShellShrapStill1[0]} }; -STATE s_UziShellShrapStill2[] = +FState s_UziShellShrapStill2[] = { {SPR_UZI_SHELL, 'B', UZISHELL_RATE, nullptr, &s_UziShellShrapStill2[0]} }; -STATE s_UziShellShrapStill3[] = +FState s_UziShellShrapStill3[] = { {SPR_UZI_SHELL, 'C', UZISHELL_RATE, nullptr, &s_UziShellShrapStill3[0]} }; -STATE s_UziShellShrapStill4[] = +FState s_UziShellShrapStill4[] = { {SPR_UZI_SHELL, 'D', UZISHELL_RATE, nullptr, &s_UziShellShrapStill4[0]} }; -STATE s_UziShellShrapStill5[] = +FState s_UziShellShrapStill5[] = { {SPR_UZI_SHELL, 'E', UZISHELL_RATE, nullptr, &s_UziShellShrapStill5[0]} }; -STATE s_UziShellShrapStill6[] = +FState s_UziShellShrapStill6[] = { {SPR_UZI_SHELL, 'F', UZISHELL_RATE, nullptr, &s_UziShellShrapStill6[0]} }; #define SHOT_SHELL 2180 #define SHOTSHELL_RATE 8 -STATE s_ShotgunShellShrap[] = +FState s_ShotgunShellShrap[] = { {SPR_SHOT_SHELL, 'A', SHOTSHELL_RATE, &AF(DoShrapJumpFall), &s_ShotgunShellShrap[1]}, {SPR_SHOT_SHELL, 'B', SHOTSHELL_RATE, &AF(DoShrapJumpFall), &s_ShotgunShellShrap[2]}, @@ -1777,15 +1676,15 @@ STATE s_ShotgunShellShrap[] = {SPR_SHOT_SHELL, 'H', SHOTSHELL_RATE, &AF(DoShrapJumpFall), &s_ShotgunShellShrap[0]}, }; -STATE s_ShotgunShellShrapStill1[] = +FState s_ShotgunShellShrapStill1[] = { {SPR_SHOT_SHELL, 'B', SHOTSHELL_RATE, nullptr, &s_ShotgunShellShrapStill1[0]} }; -STATE s_ShotgunShellShrapStill2[] = +FState s_ShotgunShellShrapStill2[] = { {SPR_SHOT_SHELL, 'D', SHOTSHELL_RATE, nullptr, &s_ShotgunShellShrapStill2[0]} }; -STATE s_ShotgunShellShrapStill3[] = +FState s_ShotgunShellShrapStill3[] = { {SPR_SHOT_SHELL, 'H', SHOTSHELL_RATE, nullptr, &s_ShotgunShellShrapStill3[0]} }; @@ -1793,7 +1692,7 @@ STATE s_ShotgunShellShrapStill3[] = #define GORE_FlameChunkA 839 #define GORE_FlameChunkA_RATE 8 -STATE s_GoreFlameChunkA[] = +FState s_GoreFlameChunkA[] = { {SPR_GORE_FlameChunkA, 'A', GORE_FlameChunkA_RATE, &AF(DoShrapJumpFall), &s_GoreFlameChunkA[1]}, {SPR_GORE_FlameChunkA, 'B', GORE_FlameChunkA_RATE, &AF(DoShrapJumpFall), &s_GoreFlameChunkA[2]}, @@ -1804,7 +1703,7 @@ STATE s_GoreFlameChunkA[] = #define GORE_FlameChunkB 843 #define GORE_FlameChunkB_RATE 8 -STATE s_GoreFlameChunkB[] = +FState s_GoreFlameChunkB[] = { {SPR_GORE_FlameChunkB, 'A', GORE_FlameChunkB_RATE, &AF(DoShrapJumpFall), &s_GoreFlameChunkB[1]}, {SPR_GORE_FlameChunkB, 'B', GORE_FlameChunkB_RATE, &AF(DoShrapJumpFall), &s_GoreFlameChunkB[2]}, @@ -1821,7 +1720,7 @@ STATE s_GoreFlameChunkB[] = #define COIN_SHRAP 2530 #define CoinShrap_RATE 12 -STATE s_CoinShrap[] = +FState s_CoinShrap[] = { {SPR_COIN_SHRAP, 'A', CoinShrap_RATE, &AF(DoShrapJumpFall), &s_CoinShrap[1]}, {SPR_COIN_SHRAP, 'B', CoinShrap_RATE, &AF(DoShrapJumpFall), &s_CoinShrap[2]}, @@ -1832,7 +1731,7 @@ STATE s_CoinShrap[] = #define MARBEL 5096 #define Marbel_RATE 12 -STATE s_Marbel[] = +FState s_Marbel[] = { {SPR_MARBEL, 'A', Marbel_RATE, &AF(DoShrapJumpFall), &s_Marbel[0]}, }; @@ -1844,7 +1743,7 @@ STATE s_Marbel[] = #define GLASS_SHRAP_A 3864 #define GlassShrapA_RATE 12 -STATE s_GlassShrapA[] = +FState s_GlassShrapA[] = { {SPR_GLASS_SHRAP_A, 'A', GlassShrapA_RATE, &AF(DoShrapJumpFall), &s_GlassShrapA[1]}, {SPR_GLASS_SHRAP_A, 'B', GlassShrapA_RATE, &AF(DoShrapJumpFall), &s_GlassShrapA[2]}, @@ -1859,7 +1758,7 @@ STATE s_GlassShrapA[] = #define GLASS_SHRAP_B 3872 #define GlassShrapB_RATE 12 -STATE s_GlassShrapB[] = +FState s_GlassShrapB[] = { {SPR_GLASS_SHRAP_B, 'A', GlassShrapB_RATE, &AF(DoShrapJumpFall), &s_GlassShrapB[1]}, {SPR_GLASS_SHRAP_B, 'B', GlassShrapB_RATE, &AF(DoShrapJumpFall), &s_GlassShrapB[2]}, @@ -1874,7 +1773,7 @@ STATE s_GlassShrapB[] = #define GLASS_SHRAP_C 3880 #define GlassShrapC_RATE 12 -STATE s_GlassShrapC[] = +FState s_GlassShrapC[] = { {SPR_GLASS_SHRAP_C, 'A', GlassShrapC_RATE, &AF(DoShrapJumpFall), &s_GlassShrapC[1]}, {SPR_GLASS_SHRAP_C, 'B', GlassShrapC_RATE, &AF(DoShrapJumpFall), &s_GlassShrapC[2]}, @@ -1893,7 +1792,7 @@ STATE s_GlassShrapC[] = #define WOOD_SHRAP_A 3924 #define WoodShrapA_RATE 12 -STATE s_WoodShrapA[] = +FState s_WoodShrapA[] = { {SPR_WOOD_SHRAP_A, 'A', WoodShrapA_RATE, &AF(DoShrapJumpFall), &s_WoodShrapA[1]}, {SPR_WOOD_SHRAP_A, 'B', WoodShrapA_RATE, &AF(DoShrapJumpFall), &s_WoodShrapA[2]}, @@ -1908,7 +1807,7 @@ STATE s_WoodShrapA[] = #define WOOD_SHRAP_B 3932 #define WoodShrapB_RATE 12 -STATE s_WoodShrapB[] = +FState s_WoodShrapB[] = { {SPR_WOOD_SHRAP_B, 'A', WoodShrapB_RATE, &AF(DoShrapJumpFall), &s_WoodShrapB[1]}, {SPR_WOOD_SHRAP_B, 'B', WoodShrapB_RATE, &AF(DoShrapJumpFall), &s_WoodShrapB[2]}, @@ -1923,7 +1822,7 @@ STATE s_WoodShrapB[] = #define WOOD_SHRAP_C 3941 #define WoodShrapC_RATE 12 -STATE s_WoodShrapC[] = +FState s_WoodShrapC[] = { {SPR_WOOD_SHRAP_C, 'A', WoodShrapC_RATE, &AF(DoShrapJumpFall), &s_WoodShrapC[1]}, {SPR_WOOD_SHRAP_C, 'B', WoodShrapC_RATE, &AF(DoShrapJumpFall), &s_WoodShrapC[2]}, @@ -1942,7 +1841,7 @@ STATE s_WoodShrapC[] = #define STONE_SHRAP_A 3840 #define StoneShrapA_RATE 12 -STATE s_StoneShrapA[] = +FState s_StoneShrapA[] = { {SPR_STONE_SHRAP_A, 'A', StoneShrapA_RATE, &AF(DoShrapJumpFall), &s_StoneShrapA[1]}, {SPR_STONE_SHRAP_A, 'B', StoneShrapA_RATE, &AF(DoShrapJumpFall), &s_StoneShrapA[2]}, @@ -1957,7 +1856,7 @@ STATE s_StoneShrapA[] = #define STONE_SHRAP_B 3848 #define StoneShrapB_RATE 12 -STATE s_StoneShrapB[] = +FState s_StoneShrapB[] = { {SPR_STONE_SHRAP_B, 'A', StoneShrapB_RATE, &AF(DoShrapJumpFall), &s_StoneShrapB[1]}, {SPR_STONE_SHRAP_B, 'B', StoneShrapB_RATE, &AF(DoShrapJumpFall), &s_StoneShrapB[2]}, @@ -1972,7 +1871,7 @@ STATE s_StoneShrapB[] = #define STONE_SHRAP_C 3856 #define StoneShrapC_RATE 12 -STATE s_StoneShrapC[] = +FState s_StoneShrapC[] = { {SPR_STONE_SHRAP_C, 'A', StoneShrapC_RATE, &AF(DoShrapJumpFall), &s_StoneShrapC[1]}, {SPR_STONE_SHRAP_C, 'B', StoneShrapC_RATE, &AF(DoShrapJumpFall), &s_StoneShrapC[2]}, @@ -1991,7 +1890,7 @@ STATE s_StoneShrapC[] = #define METAL_SHRAP_A 3888 #define MetalShrapA_RATE 12 -STATE s_MetalShrapA[] = +FState s_MetalShrapA[] = { {SPR_METAL_SHRAP_A, 'A', MetalShrapA_RATE, &AF(DoShrapJumpFall), &s_MetalShrapA[1]}, {SPR_METAL_SHRAP_A, 'B', MetalShrapA_RATE, &AF(DoShrapJumpFall), &s_MetalShrapA[2]}, @@ -2006,7 +1905,7 @@ STATE s_MetalShrapA[] = #define METAL_SHRAP_B 3896 #define MetalShrapB_RATE 12 -STATE s_MetalShrapB[] = +FState s_MetalShrapB[] = { {SPR_METAL_SHRAP_B, 'A', MetalShrapB_RATE, &AF(DoShrapJumpFall), &s_MetalShrapB[1]}, {SPR_METAL_SHRAP_B, 'B', MetalShrapB_RATE, &AF(DoShrapJumpFall), &s_MetalShrapB[2]}, @@ -2021,7 +1920,7 @@ STATE s_MetalShrapB[] = #define METAL_SHRAP_C 3904 #define MetalShrapC_RATE 12 -STATE s_MetalShrapC[] = +FState s_MetalShrapC[] = { {SPR_METAL_SHRAP_C, 'A', MetalShrapC_RATE, &AF(DoShrapJumpFall), &s_MetalShrapC[1]}, {SPR_METAL_SHRAP_C, 'B', MetalShrapC_RATE, &AF(DoShrapJumpFall), &s_MetalShrapC[2]}, @@ -2040,7 +1939,7 @@ STATE s_MetalShrapC[] = #define PAPER_SHRAP_A 3924 #define PaperShrapA_RATE 12 -STATE s_PaperShrapA[] = +FState s_PaperShrapA[] = { {SPR_PAPER_SHRAP_A, 'A', PaperShrapA_RATE, &AF(DoShrapJumpFall), &s_PaperShrapA[1]}, {SPR_PAPER_SHRAP_A, 'B', PaperShrapA_RATE, &AF(DoShrapJumpFall), &s_PaperShrapA[2]}, @@ -2051,7 +1950,7 @@ STATE s_PaperShrapA[] = #define PAPER_SHRAP_B 3932 #define PaperShrapB_RATE 12 -STATE s_PaperShrapB[] = +FState s_PaperShrapB[] = { {SPR_PAPER_SHRAP_B, 'A', PaperShrapB_RATE, &AF(DoShrapJumpFall), &s_PaperShrapB[1]}, {SPR_PAPER_SHRAP_B, 'B', PaperShrapB_RATE, &AF(DoShrapJumpFall), &s_PaperShrapB[2]}, @@ -2062,7 +1961,7 @@ STATE s_PaperShrapB[] = #define PAPER_SHRAP_C 3941 #define PaperShrapC_RATE 12 -STATE s_PaperShrapC[] = +FState s_PaperShrapC[] = { {SPR_PAPER_SHRAP_C, 'A', PaperShrapC_RATE, &AF(DoShrapJumpFall), &s_PaperShrapC[1]}, {SPR_PAPER_SHRAP_C, 'B', PaperShrapC_RATE, &AF(DoShrapJumpFall), &s_PaperShrapC[2]}, @@ -2965,9 +2864,9 @@ AutoShrap: break; case NINJA_Head_R0: { - extern STATE* sg_PlayerHeadHurl[]; + extern FState s_PlayerHeadHurl[]; - if (parentActor->user.__legacyState.Rot == sg_PlayerHeadHurl) + if (parentActor->user.__legacyState.Rot == s_PlayerHeadHurl) { p = PlayerHeadHurl1; } @@ -3791,7 +3690,7 @@ bool WeaponMoveHit(DSWActor* actor) { if (actor->user.ID == STAR1) { - extern STATE s_TrashCanPain[]; + extern FState s_TrashCanPain[]; switch (hitActor->user.ID) { case TRASHCAN: @@ -4530,8 +4429,8 @@ int ActorHealth(DSWActor* actor, short amt) { case NINJA_RUN_R0: { - extern STATE* sg_NinjaGrabThroat[]; - extern STATE* sg_NinjaHariKari[]; + extern FState s_NinjaGrabThroat[]; + extern FState s_NinjaHariKari[]; if (actor->user.Flags2 & (SPR2_DYING)) return true; if (actor->user.Flags & (SPR_FALLING | SPR_JUMPING | SPR_CLIMBING)) return true; @@ -4552,9 +4451,9 @@ int ActorHealth(DSWActor* actor, short amt) actor->spr.Angles.Yaw = (actor->user.targetActor->spr.pos.XY() - actor->spr.pos.XY()).Angle() + DAngle90; actor->spr.cstat &= ~(CSTAT_SPRITE_YFLIP); if (sw_ninjahack) - NewStateGroup(actor, sg_NinjaHariKari); + NewStateGroup(actor, s_NinjaHariKari); else - NewStateGroup(actor, sg_NinjaGrabThroat); + NewStateGroup(actor, s_NinjaGrabThroat); } break; } @@ -7751,7 +7650,7 @@ bool SlopeBounce(DSWActor* actor, bool* hit_wall) // //--------------------------------------------------------------------------- -extern STATE s_Phosphorus[]; +extern FState s_Phosphorus[]; int DoGrenade(DSWActor* actor) { @@ -8848,13 +8747,13 @@ int DoRail(DSWActor* actor) spawn_count++; if (spawn_count < 128) { - auto actorNew = SpawnActor(STAT_MISSILE, PUFF, &s_RailPuff[0][0], actor->sector(), actor->spr.pos, actor->spr.Angles.Yaw, 1.25); + auto actorNew = SpawnActor(STAT_MISSILE, PUFF, &s_RailPuff[0], actor->sector(), actor->spr.pos, actor->spr.Angles.Yaw, 1.25); actorNew->vel.X += RandomRangeF(140 / 16.) - RandomRangeF(140 / 16.); actorNew->vel.Z += RandomRangeF(140 / 256.) - RandomRangeF(140 / 256.); - NewStateGroup(actorNew, sg_RailPuff); + NewStateGroup(actorNew, s_RailPuff); actorNew->spr.shade = -40; actorNew->spr.scale = DVector2(0.15625, 0.15625); @@ -9007,7 +8906,7 @@ int DoMicroMini(DSWActor* actor) int SpawnExtraMicroMini(DSWActor* actor) { - auto actorNew = SpawnActor(STAT_MISSILE, BOLT_THINMAN_R0, &s_Micro[0][0], actor->sector(), actor->spr.pos, actor->spr.Angles.Yaw, actor->vel.X); + auto actorNew = SpawnActor(STAT_MISSILE, BOLT_THINMAN_R0, &s_Micro[0], actor->sector(), actor->spr.pos, actor->spr.Angles.Yaw, actor->vel.X); SetOwner(GetOwner(actor), actorNew); actorNew->spr.scale = DVector2(actor->spr.scale.X, actor->spr.scale.X); @@ -9015,7 +8914,7 @@ int SpawnExtraMicroMini(DSWActor* actor) actorNew->copy_clipdist(actor); - NewStateGroup(actorNew, &sg_MicroMini[0]); + NewStateGroup(actorNew, &s_MicroMini[0]); actorNew->user.WeaponNum = actor->user.WeaponNum; actorNew->user.Radius = actor->user.Radius; actorNew->user.ceiling_dist = actor->user.ceiling_dist; @@ -9071,7 +8970,7 @@ int DoMicro(DSWActor* actor) if ((actor->user.WaitTics -= MISSILEMOVETICS) <= 0) { SetActorZ(actorNew, actorNew->spr.pos); - NewStateGroup(actor, &sg_MicroMini[0]); + NewStateGroup(actor, &s_MicroMini[0]); actor->spr.scale = DVector2(0.15625, 0.15625); actor->spr.cstat &= ~(CSTAT_SPRITE_INVISIBLE); SpawnExtraMicroMini(actor); @@ -10753,11 +10652,11 @@ int DoMirv(DSWActor* actor) for (i = 0; i < 2; i++) { - auto actorNew = SpawnActor(STAT_MISSILE, MIRV_METEOR, &sg_MirvMeteor[0][0], actor->sector(), + auto actorNew = SpawnActor(STAT_MISSILE, MIRV_METEOR, &s_MirvMeteor[0], actor->sector(), actor->spr.pos, actor->spr.Angles.Yaw + angs[i], 50); - NewStateGroup(actorNew, &sg_MirvMeteor[0]); + NewStateGroup(actorNew, &s_MirvMeteor[0]); actorNew->user.__legacyState.StateEnd = s_MirvMeteorExp; SetOwner(actor, actorNew); @@ -11110,13 +11009,13 @@ int DoSerpRing(DSWActor* actor) // if (valid sector and can see target) if (sect != nullptr && CanSeePlayer(actor)) { - extern STATE* sg_SkullJump[]; + extern FState s_SkullJump[]; actor->user.ID = SKULL_R0; actor->spr.Angles.Yaw = (actor->user.targetActor->spr.pos.XY() - actor->spr.pos.XY()).Angle(); actor->vel.X = dist * (3. / 64) + RandomRangeF(16); actor->user.jump_speed = -800; change_actor_stat(actor, STAT_ENEMY); - NewStateGroup(actor, sg_SkullJump); + NewStateGroup(actor, s_SkullJump); DoBeginJump(actor); return 0; } @@ -11278,9 +11177,8 @@ int InitSerpRing(DSWActor* actor) const int SERP_RING_DIST = 175; - extern STATE s_SkullExplode[]; - extern STATE s_SkullRing[1][1]; - extern STATE* sg_SkullRing[]; + extern FState s_SkullExplode[]; + extern FState s_SkullRing[]; max_missiles = 12; @@ -11294,7 +11192,7 @@ int InitSerpRing(DSWActor* actor) for (missiles = 0, ang = ang_start; missiles < max_missiles; ang += ang_diff, missiles++) { - auto actorNew = SpawnActor(STAT_SKIP4, SKULL_SERP, &s_SkullRing[0][0], actor->sector(), actor->spr.pos, ang, 0); + auto actorNew = SpawnActor(STAT_SKIP4, SKULL_SERP, &s_SkullRing[0], actor->sector(), actor->spr.pos, ang, 0); actorNew->vel.X = 31.25; SetOwner(actor, actorNew); @@ -11321,7 +11219,7 @@ int InitSerpRing(DSWActor* actor) actorNew->user.Counter2 = 0; actorNew->user.__legacyState.StateEnd = s_SkullExplode; - actorNew->user.__legacyState.Rot = sg_SkullRing; + actorNew->user.__legacyState.Rot = s_SkullRing; // defaults do change the statnum EnemyDefaults(actorNew, nullptr, nullptr); @@ -11660,7 +11558,7 @@ int InitSwordAttack(DSWPlayer* pp) if (hit.actor() != nullptr) { - extern STATE s_TrashCanPain[]; + extern FState s_TrashCanPain[]; auto hitActor = hit.actor(); if (hitActor->hasU()) // JBF: added null check @@ -11838,7 +11736,7 @@ int InitFistAttack(DSWPlayer* pp) if (hit.actor() != nullptr) { - extern STATE s_TrashCanPain[]; + extern FState s_TrashCanPain[]; auto hitActor = hit.actor(); if (hitActor->hasU()) // JBF: added null check @@ -12014,15 +11912,14 @@ int InitSumoNapalm(DSWActor* actor) int InitSumoSkull(DSWActor* actor) { - extern STATE s_SkullExplode[]; - extern STATE s_SkullWait[1][1]; - extern STATE* sg_SkullWait[]; + extern FState s_SkullExplode[]; + extern FState s_SkullWait[]; extern ATTRIBUTE SkullAttrib; PlaySound(DIGI_SERPSUMMONHEADS, actor, v3df_none); - auto actorNew = SpawnActor(STAT_ENEMY, SKULL_R0, &s_SkullWait[0][0], actor->sector(), ActorVectOfMiddle(actor), actor->spr.Angles.Yaw, 0); + auto actorNew = SpawnActor(STAT_ENEMY, SKULL_R0, &s_SkullWait[0], actor->sector(), ActorVectOfMiddle(actor), actor->spr.Angles.Yaw, 0); actorNew->vel.X = 31.25; SetOwner(actor, actorNew); @@ -12038,7 +11935,7 @@ int InitSumoSkull(DSWActor* actor) actorNew->user.Flags |= (actor->user.Flags & (SPR_BOUNCE)); actorNew->user.__legacyState.StateEnd = s_SkullExplode; - actorNew->user.__legacyState.Rot = sg_SkullWait; + actorNew->user.__legacyState.Rot = s_SkullWait; actorNew->user.__legacyState.Attrib = &SkullAttrib; DoActorSetSpeed(actor, NORM_SPEED); @@ -12721,7 +12618,7 @@ int InitShotgun(DSWPlayer* pp) if (hitActor->hasU() && hitActor->user.ID == TRASHCAN) // JBF: added null check { - extern STATE s_TrashCanPain[]; + extern FState s_TrashCanPain[]; PlaySound(DIGI_TRASHLID, hitActor, v3df_none); if (hitActor->user.WaitTics <= 0) @@ -12881,7 +12778,7 @@ int InitRail(DSWPlayer* pp) // Spawn a shot // Inserting and setting up variables - auto actorNew = SpawnActor(STAT_MISSILE, BOLT_THINMAN_R1, &s_Rail[0][0], pp->cursector, pos, pp->GetActor()->spr.Angles.Yaw, 75); + auto actorNew = SpawnActor(STAT_MISSILE, BOLT_THINMAN_R1, &s_Rail[0], pp->cursector, pos, pp->GetActor()->spr.Angles.Yaw, 75); SetOwner(pp->GetActor(), actorNew); @@ -12890,7 +12787,7 @@ int InitRail(DSWPlayer* pp) setFreeAimVelocity(actorNew->vel.X, zvel, pp->Angles.getPitchWithView(), (HORIZ_MULT + 17) * 0.5); - NewStateGroup(actorNew, &sg_Rail[0]); + NewStateGroup(actorNew, &s_Rail[0]); actorNew->user.WeaponNum = actor->user.WeaponNum; actorNew->user.Radius = RAIL_RADIUS; @@ -12955,7 +12852,7 @@ int InitZillaRail(DSWActor* actor) // Spawn a shot // Inserting and setting up variables - auto actorNew = SpawnActor(STAT_MISSILE, BOLT_THINMAN_R1, &s_Rail[0][0], actor->sector(), pos, actor->spr.Angles.Yaw, 75); + auto actorNew = SpawnActor(STAT_MISSILE, BOLT_THINMAN_R1, &s_Rail[0], actor->sector(), pos, actor->spr.Angles.Yaw, 75); SetOwner(actor, actorNew); actorNew->spr.scale = DVector2(0.8125, 0.8125); @@ -12963,7 +12860,7 @@ int InitZillaRail(DSWActor* actor) double zvel = (100 * (HORIZ_MULT+17)) / 256.; - NewStateGroup(actorNew, &sg_Rail[0]); + NewStateGroup(actorNew, &s_Rail[0]); actorNew->user.WeaponNum = actor->user.WeaponNum; actorNew->user.Radius = RAIL_RADIUS; @@ -13046,7 +12943,7 @@ int InitRocket(DSWPlayer* pp) // Spawn a shot // Inserting and setting up variables - auto actorNew = SpawnActor(STAT_MISSILE, BOLT_THINMAN_R0, &s_Rocket[0][0], pp->cursector, pos, pp->GetActor()->spr.Angles.Yaw, ROCKET_VELOCITY); + auto actorNew = SpawnActor(STAT_MISSILE, BOLT_THINMAN_R0, &s_Rocket[0], pp->cursector, pos, pp->GetActor()->spr.Angles.Yaw, ROCKET_VELOCITY); SetOwner(pp->GetActor(), actorNew); actorNew->spr.scale = DVector2(1.40626, 1.40625); @@ -13056,7 +12953,7 @@ int InitRocket(DSWPlayer* pp) actorNew->clipdist = 4; - NewStateGroup(actorNew, &sg_Rocket[0]); + NewStateGroup(actorNew, &s_Rocket[0]); actorNew->user.WeaponNum = actor->user.WeaponNum; actorNew->user.Radius = 2000; @@ -13153,7 +13050,7 @@ int InitBunnyRocket(DSWPlayer* pp) // Spawn a shot // Inserting and setting up variables - auto actorNew = SpawnActor(STAT_MISSILE, BOLT_THINMAN_R4, &s_BunnyRocket[0][0], pp->cursector, pos, pp->GetActor()->spr.Angles.Yaw, ROCKET_VELOCITY); + auto actorNew = SpawnActor(STAT_MISSILE, BOLT_THINMAN_R4, &s_BunnyRocket[0], pp->cursector, pos, pp->GetActor()->spr.Angles.Yaw, ROCKET_VELOCITY); SetOwner(pp->GetActor(), actorNew); actorNew->spr.scale = DVector2(1, 1); @@ -13163,7 +13060,7 @@ int InitBunnyRocket(DSWPlayer* pp) actorNew->clipdist = 4; - NewStateGroup(actorNew, &sg_BunnyRocket[0]); + NewStateGroup(actorNew, &s_BunnyRocket[0]); actorNew->user.WeaponNum = actor->user.WeaponNum; actorNew->user.Radius = 2000; @@ -13255,7 +13152,7 @@ int InitNuke(DSWPlayer* pp) // Spawn a shot // Inserting and setting up variables - auto actorNew = SpawnActor(STAT_MISSILE, BOLT_THINMAN_R0, &s_Rocket[0][0], pp->cursector, pos, pp->GetActor()->spr.Angles.Yaw, 700/16.); + auto actorNew = SpawnActor(STAT_MISSILE, BOLT_THINMAN_R0, &s_Rocket[0], pp->cursector, pos, pp->GetActor()->spr.Angles.Yaw, 700/16.); SetOwner(pp->GetActor(), actorNew); actorNew->spr.scale = DVector2(2, 2); @@ -13267,7 +13164,7 @@ int InitNuke(DSWPlayer* pp) actorNew->spr.pal = actorNew->user.spal = 19; - NewStateGroup(actorNew, &sg_Rocket[0]); + NewStateGroup(actorNew, &s_Rocket[0]); actorNew->user.WeaponNum = actor->user.WeaponNum; actorNew->user.Radius = NUKE_RADIUS; @@ -13333,7 +13230,7 @@ int InitEnemyNuke(DSWActor* actor) auto npos = actor->spr.pos.plusZ(40); // Spawn a shot - auto actorNew = SpawnActor(STAT_MISSILE, BOLT_THINMAN_R0, &s_Rocket[0][0], actor->sector(), npos, actor->spr.Angles.Yaw, 700/16.); + auto actorNew = SpawnActor(STAT_MISSILE, BOLT_THINMAN_R0, &s_Rocket[0], actor->sector(), npos, actor->spr.Angles.Yaw, 700/16.); if (actor->user.ID == ZOMBIE_RUN_R0) SetOwner(GetOwner(actor), actorNew); @@ -13349,7 +13246,7 @@ int InitEnemyNuke(DSWActor* actor) actorNew->spr.pal = actorNew->user.spal = 19; - NewStateGroup(actorNew, &sg_Rocket[0]); + NewStateGroup(actorNew, &s_Rocket[0]); actorNew->user.WeaponNum = actor->user.WeaponNum; actorNew->user.Radius = NUKE_RADIUS; @@ -13439,7 +13336,7 @@ int InitMicro(DSWPlayer* pp) // Spawn a shot // Inserting and setting up variables - auto actorNew = SpawnActor(STAT_MISSILE, BOLT_THINMAN_R0, &s_Micro[0][0], pp->cursector, pos, angle, vel); + auto actorNew = SpawnActor(STAT_MISSILE, BOLT_THINMAN_R0, &s_Micro[0], pp->cursector, pos, angle, vel); SetOwner(pp->GetActor(), actorNew); actorNew->spr.scale = DVector2(0.375, 0.375); @@ -13451,7 +13348,7 @@ int InitMicro(DSWPlayer* pp) actorNew->vel.Z += RandomRangeF(8) - 5; - NewStateGroup(actorNew, &sg_Micro[0]); + NewStateGroup(actorNew, &s_Micro[0]); actorNew->user.WeaponNum = actor->user.WeaponNum; actorNew->user.Radius = 200; @@ -13852,12 +13749,12 @@ int InitSerpSpell(DSWActor* actor) { actor->spr.Angles.Yaw = (actor->user.targetActor->spr.pos.XY() - actor->spr.pos.XY()).Angle(); - auto actorNew = SpawnActor(STAT_MISSILE, SERP_METEOR, &sg_SerpMeteor[0][0], actor->sector(), actor->spr.pos, actor->spr.Angles.Yaw, 93.75); + auto actorNew = SpawnActor(STAT_MISSILE, SERP_METEOR, &s_SerpMeteor[0], actor->sector(), actor->spr.pos, actor->spr.Angles.Yaw, 93.75); actorNew->spr.pos.Z = ActorZOfTop(actor); - NewStateGroup(actorNew, &sg_SerpMeteor[0]); + NewStateGroup(actorNew, &s_SerpMeteor[0]); actorNew->user.__legacyState.StateEnd = s_MirvMeteorExp; SetOwner(actor, actorNew); @@ -13954,13 +13851,13 @@ int InitSerpMonstSpell(DSWActor* actor) { actor->spr.Angles.Yaw = (actor->user.targetActor->spr.pos.XY() - actor->spr.pos.XY()).Angle(); - auto actorNew = SpawnActor(STAT_MISSILE, SERP_METEOR, &sg_SerpMeteor[0][0], actor->sector(), actor->spr.pos, actor->spr.Angles.Yaw, 31.25); + auto actorNew = SpawnActor(STAT_MISSILE, SERP_METEOR, &s_SerpMeteor[0], actor->sector(), actor->spr.pos, actor->spr.Angles.Yaw, 31.25); actorNew->user.spal = actorNew->spr.pal = 25; // Bright Red actorNew->spr.pos.Z = ActorZOfTop(actor); - NewStateGroup(actorNew, &sg_SerpMeteor[0]); + NewStateGroup(actorNew, &s_SerpMeteor[0]); actorNew->user.__legacyState.StateEnd = s_TeleportEffect2; SetOwner(actor, actorNew); @@ -14031,7 +13928,7 @@ int InitEnemyRocket(DSWActor* actor) // Spawn a shot - auto actorNew = SpawnActor(STAT_MISSILE, BOLT_THINMAN_R2, &s_Rocket[0][0], actor->sector(), + auto actorNew = SpawnActor(STAT_MISSILE, BOLT_THINMAN_R2, &s_Rocket[0], actor->sector(), actor->spr.pos.plusZ(-(ActorSizeZ(actor) * 0.5)-16), actor->user.targetActor->spr.Angles.Yaw, NINJA_BOLT_VELOCITY); // Set default palette @@ -14049,7 +13946,7 @@ int InitEnemyRocket(DSWActor* actor) actorNew->clipdist = 4; - NewStateGroup(actorNew, &sg_Rocket[0]); + NewStateGroup(actorNew, &s_Rocket[0]); actorNew->user.Radius = 200; actorNew->spr.cstat |= (CSTAT_SPRITE_YCENTER); @@ -14108,7 +14005,7 @@ int InitEnemyRail(DSWActor* actor) // Spawn a shot // Inserting and setting up variables - auto actorNew = SpawnActor(STAT_MISSILE, BOLT_THINMAN_R1, &s_Rail[0][0], actor->sector(), + auto actorNew = SpawnActor(STAT_MISSILE, BOLT_THINMAN_R1, &s_Rail[0], actor->sector(), actor->spr.pos.plusZ(-(ActorSizeZ(actor) * 0.5) - 8), actor->spr.Angles.Yaw, 75); if (actor->user.ID == ZOMBIE_RUN_R0) @@ -14121,7 +14018,7 @@ int InitEnemyRail(DSWActor* actor) actorNew->vel.Z = 0; - NewStateGroup(actorNew, &sg_Rail[0]); + NewStateGroup(actorNew, &s_Rail[0]); actorNew->user.Radius = 200; actorNew->user.ceiling_dist = (1); @@ -14176,7 +14073,7 @@ int InitZillaRocket(DSWActor* actor) for (int i = 0; i < (int)SIZ(mp); i++) { // Spawn a shot - auto actorNew = SpawnActor(STAT_MISSILE, BOLT_THINMAN_R2, &s_Rocket[0][0], actor->sector(), + auto actorNew = SpawnActor(STAT_MISSILE, BOLT_THINMAN_R2, &s_Rocket[0], actor->sector(), actor->spr.pos.plusZ(-(ActorSizeZ(actor) * 0.5) - 16), actor->user.targetActor->spr.Angles.Yaw, NINJA_BOLT_VELOCITY); SetOwner(actor, actorNew); @@ -14187,7 +14084,7 @@ int InitZillaRocket(DSWActor* actor) actorNew->clipdist = 4; - NewStateGroup(actorNew, &sg_Rocket[0]); + NewStateGroup(actorNew, &s_Rocket[0]); actorNew->user.Radius = 200; actorNew->spr.cstat |= (CSTAT_SPRITE_YCENTER); @@ -14267,7 +14164,7 @@ int InitEnemyCrossbow(DSWActor* actor) actor->spr.Angles.Yaw = (actor->user.targetActor->spr.pos.XY() - actor->spr.pos.XY()).Angle(); // Spawn a shot - auto actorNew = SpawnActor(STAT_MISSILE, CROSSBOLT, &s_CrossBolt[0][0], actor->sector(), + auto actorNew = SpawnActor(STAT_MISSILE, CROSSBOLT, &s_CrossBolt[0], actor->sector(), ActorVectOfMiddle(actor).plusZ(-14), actor->user.targetActor->spr.Angles.Yaw, 50); SetOwner(actor, actorNew); @@ -14278,7 +14175,7 @@ int InitEnemyCrossbow(DSWActor* actor) actorNew->clipdist = 4; - NewStateGroup(actorNew, &sg_CrossBolt[0]); + NewStateGroup(actorNew, &s_CrossBolt[0]); UpdateChange(actorNew); @@ -14545,7 +14442,7 @@ void InitBoltTrap(DSWActor* actor) PlaySound(DIGI_RIOTFIRE, actor, v3df_none); // Spawn a shot - auto actorNew = SpawnActor(STAT_MISSILE, BOLT_THINMAN_R0, &s_Rocket[0][0], actor->sector(), actor->spr.pos.plusZ(-ActorSizeZ(actor)), actor->spr.Angles.Yaw, BOLT_TRAP_VELOCITY); + auto actorNew = SpawnActor(STAT_MISSILE, BOLT_THINMAN_R0, &s_Rocket[0], actor->sector(), actor->spr.pos.plusZ(-ActorSizeZ(actor)), actor->spr.Angles.Yaw, BOLT_TRAP_VELOCITY); SetOwner(actor, actorNew); actorNew->spr.scale = DVector2(0.5, 0.5); @@ -14554,7 +14451,7 @@ void InitBoltTrap(DSWActor* actor) actorNew->spr.cstat |= (CSTAT_SPRITE_YCENTER); - NewStateGroup(actorNew, &sg_Rocket[0]); + NewStateGroup(actorNew, &s_Rocket[0]); actorNew->user.Radius = 200; UpdateChange(actorNew); @@ -14570,7 +14467,7 @@ void InitBoltTrap(DSWActor* actor) void InitSpearTrap(DSWActor* actor) { // Spawn a shot - auto actorNew = SpawnActor(STAT_MISSILE, CROSSBOLT, &s_CrossBolt[0][0], actor->sector(), ActorVectOfMiddle(actor), actor->spr.Angles.Yaw, 750/16.); + auto actorNew = SpawnActor(STAT_MISSILE, CROSSBOLT, &s_CrossBolt[0], actor->sector(), ActorVectOfMiddle(actor), actor->spr.Angles.Yaw, 750/16.); SetOwner(actor, actorNew); actorNew->spr.scale = DVector2(0.25, 0.40625); @@ -14578,7 +14475,7 @@ void InitSpearTrap(DSWActor* actor) actorNew->clipdist = 4; - NewStateGroup(actorNew, &sg_CrossBolt[0]); + NewStateGroup(actorNew, &s_CrossBolt[0]); UpdateChange(actorNew); @@ -15006,7 +14903,7 @@ int InitUzi(DSWPlayer* pp) if (hitActor->hasU()) // JBF: added null check if (hitActor->user.ID == TRASHCAN) { - extern STATE s_TrashCanPain[]; + extern FState s_TrashCanPain[]; PlaySound(DIGI_TRASHLID, hitActor, v3df_none); if (hitActor->user.WaitTics <= 0) @@ -15159,7 +15056,7 @@ int InitTurretMicro(DSWActor* actor, DSWPlayer* pp) // Spawn a shot // Inserting and setting up variables - auto actorNew = SpawnActor(STAT_MISSILE, BOLT_THINMAN_R0, &s_Micro[0][0], actor->sector(), + auto actorNew = SpawnActor(STAT_MISSILE, BOLT_THINMAN_R0, &s_Micro[0], actor->sector(), actor->spr.pos.plusZ(10 + RandomRangeF(20)), angle, 75); SetOwner(plActor, actorNew); @@ -15170,7 +15067,7 @@ int InitTurretMicro(DSWActor* actor, DSWPlayer* pp) - NewStateGroup(actorNew, &sg_Micro[0]); + NewStateGroup(actorNew, &s_Micro[0]); actorNew->user.WeaponNum = plActor->user.WeaponNum; actorNew->user.Radius = 200; @@ -15219,7 +15116,7 @@ int InitTurretRocket(DSWActor* actor, DSWPlayer* pp) { if (SW_SHAREWARE) return false; // JBF: verify - auto actorNew = SpawnActor(STAT_MISSILE, BOLT_THINMAN_R0, &s_Rocket[0][0], actor->sector(), actor->spr.pos, actor->spr.Angles.Yaw, ROCKET_VELOCITY); + auto actorNew = SpawnActor(STAT_MISSILE, BOLT_THINMAN_R0, &s_Rocket[0], actor->sector(), actor->spr.pos, actor->spr.Angles.Yaw, ROCKET_VELOCITY); SetOwner(pp->GetActor(), actorNew); actorNew->spr.scale = DVector2(0.625, 0.625); @@ -15305,7 +15202,7 @@ int InitTurretRail(DSWActor* actor, DSWPlayer* pp) // Spawn a shot // Inserting and setting up variables - auto actorNew = SpawnActor(STAT_MISSILE, BOLT_THINMAN_R1, &s_Rail[0][0], pp->cursector, actor->spr.pos, actor->spr.Angles.Yaw, 75); + auto actorNew = SpawnActor(STAT_MISSILE, BOLT_THINMAN_R1, &s_Rail[0], pp->cursector, actor->spr.pos, actor->spr.Angles.Yaw, 75); SetOwner(pp->GetActor(), actorNew); actorNew->spr.scale = DVector2(0.8125, 0.8125); @@ -15313,7 +15210,7 @@ int InitTurretRail(DSWActor* actor, DSWPlayer* pp) setFreeAimVelocity(actorNew->vel.X, actorNew->vel.Z, pp->Angles.getPitchWithView(), HORIZ_MULTF); - NewStateGroup(actorNew, &sg_Rail[0]); + NewStateGroup(actorNew, &s_Rail[0]); actorNew->user.Radius = 200; actorNew->user.ceiling_dist = (1); @@ -16067,7 +15964,7 @@ int InitGrenade(DSWPlayer* pp) // Spawn a shot // Inserting and setting up variables - auto actorNew = SpawnActor(STAT_MISSILE, GRENADE, &s_Grenade[0][0], pp->cursector, pos, pp->GetActor()->spr.Angles.Yaw, GRENADE_VELOCITY); + auto actorNew = SpawnActor(STAT_MISSILE, GRENADE, &s_Grenade[0], pp->cursector, pos, pp->GetActor()->spr.Angles.Yaw, GRENADE_VELOCITY); // don't throw it as far if crawling if (pp->Flags & (PF_CRAWLING)) @@ -16076,7 +15973,7 @@ int InitGrenade(DSWPlayer* pp) } - NewStateGroup(actorNew, &sg_Grenade[0]); + NewStateGroup(actorNew, &s_Grenade[0]); actorNew->user.Flags |= (SPR_XFLIP_TOGGLE); SetOwner(pp->GetActor(), actorNew); @@ -16143,11 +16040,11 @@ int InitSpriteGrenade(DSWActor* actor) // Spawn a shot // Inserting and setting up variables - auto actorNew = SpawnActor(STAT_MISSILE, GRENADE, &s_Grenade[0][0], actor->sector(), + auto actorNew = SpawnActor(STAT_MISSILE, GRENADE, &s_Grenade[0], actor->sector(), actor->spr.pos.plusZ(-40), actor->spr.Angles.Yaw, GRENADE_VELOCITY); - NewStateGroup(actorNew, &sg_Grenade[0]); + NewStateGroup(actorNew, &s_Grenade[0]); actorNew->user.Flags |= (SPR_XFLIP_TOGGLE); if (actor->user.ID == ZOMBIE_RUN_R0) @@ -17263,7 +17160,7 @@ void QueueHole(sectortype* hit_sect, walltype* hit_wall, const DVector3& pos) enum { FLOORBLOOD_RATE = 30 }; -STATE s_FloorBlood1[] = +FState s_FloorBlood1[] = { {SPR_FLOORBLOOD1, 'A', SF_QUICK_CALL, &AF(DoFloorBlood), &s_FloorBlood1[1]}, {SPR_FLOORBLOOD1, 'A', FLOORBLOOD_RATE, nullptr, &s_FloorBlood1[0]}, @@ -17342,15 +17239,15 @@ enum FOOTPRINT3 = 2492, FOOTPRINT_RATE = 30, }; -STATE s_FootPrint1[] = +FState s_FootPrint1[] = { {SPR_FOOTPRINT1, 'A', FOOTPRINT_RATE, nullptr, &s_FootPrint1[0]}, }; -STATE s_FootPrint2[] = +FState s_FootPrint2[] = { {SPR_FOOTPRINT2, 'A', FOOTPRINT_RATE, nullptr, &s_FootPrint2[0]}, }; -STATE s_FootPrint3[] = +FState s_FootPrint3[] = { {SPR_FOOTPRINT3, 'A', FOOTPRINT_RATE, nullptr, &s_FootPrint3[0]}, }; @@ -17469,22 +17366,22 @@ enum WALLBLOOD4 = 2503, WALLBLOOD_RATE = 1, }; -STATE s_WallBlood1[] = +FState s_WallBlood1[] = { {SPR_WALLBLOOD1, 'A', SF_QUICK_CALL, &AF(DoWallBlood), &s_WallBlood1[1]}, {SPR_WALLBLOOD1, 'A', WALLBLOOD_RATE, nullptr, &s_WallBlood1[0]}, }; -STATE s_WallBlood2[] = +FState s_WallBlood2[] = { {SPR_WALLBLOOD2, 'A', SF_QUICK_CALL, &AF(DoWallBlood), &s_WallBlood2[1]}, {SPR_WALLBLOOD2, 'A', WALLBLOOD_RATE, nullptr, &s_WallBlood2[0]}, }; -STATE s_WallBlood3[] = +FState s_WallBlood3[] = { {SPR_WALLBLOOD3, 'A', SF_QUICK_CALL, &AF(DoWallBlood), &s_WallBlood3[1]}, {SPR_WALLBLOOD3, 'A', WALLBLOOD_RATE, nullptr, &s_WallBlood3[0]}, }; -STATE s_WallBlood4[] = +FState s_WallBlood4[] = { {SPR_WALLBLOOD4, 'A', SF_QUICK_CALL, &AF(DoWallBlood), &s_WallBlood4[1]}, {SPR_WALLBLOOD4, 'A', WALLBLOOD_RATE, nullptr, &s_WallBlood4[0]}, @@ -18218,7 +18115,6 @@ static saveable_data saveable_weapon_data[] = SAVE_DATA(s_BreakBottle2), SAVE_DATA(s_Puff), SAVE_DATA(s_RailPuff), - SAVE_DATA(sg_RailPuff), SAVE_DATA(s_LaserPuff), SAVE_DATA(s_Tracer), SAVE_DATA(s_EMP), @@ -18235,7 +18131,6 @@ static saveable_data saveable_weapon_data[] = SAVE_DATA(s_Bubble), SAVE_DATA(s_Splash), SAVE_DATA(s_CrossBolt), - SAVE_DATA(sg_CrossBolt), SAVE_DATA(s_Star), SAVE_DATA(s_StarStuck), SAVE_DATA(s_StarDown), @@ -18245,37 +18140,25 @@ static saveable_data saveable_weapon_data[] = SAVE_DATA(s_VulcanBoulder), SAVE_DATA(s_Grenade), SAVE_DATA(s_Grenade), - SAVE_DATA(sg_Grenade), SAVE_DATA(s_MineStuck), SAVE_DATA(s_Mine), SAVE_DATA(s_MineSpark), SAVE_DATA(s_Meteor), - SAVE_DATA(sg_Meteor), SAVE_DATA(s_MeteorExp), SAVE_DATA(s_MirvMeteor), - SAVE_DATA(sg_MirvMeteor), SAVE_DATA(s_MirvMeteorExp), SAVE_DATA(s_SerpMeteor), - SAVE_DATA(sg_SerpMeteor), SAVE_DATA(s_SerpMeteorExp), SAVE_DATA(s_Spear), - SAVE_DATA(sg_Spear), SAVE_DATA(s_Rocket), - SAVE_DATA(sg_Rocket), SAVE_DATA(s_BunnyRocket), - SAVE_DATA(sg_BunnyRocket), SAVE_DATA(s_Rail), - SAVE_DATA(sg_Rail), SAVE_DATA(s_Laser), //SAVE_DATA(s_MicroPuff), SAVE_DATA(s_Micro), - SAVE_DATA(sg_Micro), SAVE_DATA(s_MicroMini), - SAVE_DATA(sg_MicroMini), SAVE_DATA(s_BoltThinMan), - SAVE_DATA(sg_BoltThinMan), SAVE_DATA(s_BoltSeeker), - SAVE_DATA(sg_BoltSeeker), SAVE_DATA(s_BoltFatMan), SAVE_DATA(s_BoltShrapnel), SAVE_DATA(s_CoolgFire), diff --git a/source/games/sw/src/weapon.h b/source/games/sw/src/weapon.h index 34753e0dd..7ae352b40 100644 --- a/source/games/sw/src/weapon.h +++ b/source/games/sw/src/weapon.h @@ -80,7 +80,11 @@ extern TObjPtr GenericQueue[MAX_GENERIC_QUEUE]; extern int LoWangsQueueHead; extern TObjPtr LoWangsQueue[MAX_LOWANGS_QUEUE]; -void ChangeState(DSWActor* actor, STATE* statep); +void ChangeState(DSWActor* actor, FState* statep); +inline void ChangeState(DSWActor* actor, FState& statep) +{ + ChangeState(actor, &statep); +} void DoPlayerBeginRecoil(DSWPlayer* pp, double pix_amt); SECTOR_OBJECT* DetectSectorObject(sectortype*); SECTOR_OBJECT* DetectSectorObjectByWall(walltype*); @@ -173,7 +177,7 @@ int DoDamageTest(DSWActor*); extern short StatDamageList[STAT_DAMAGE_LIST_SIZE]; -extern STATE s_NukeMushroom[]; +extern FState s_NukeMushroom[]; void WallBounce(DSWActor*, DAngle ang); @@ -190,7 +194,7 @@ int DoFlamesDamageTest(DSWActor*); struct SHRAP { - STATE* state; + FState* state; short id, num, zlevel, min_jspeed, max_jspeed, min_vel, max_vel, random_disperse, ang_range; // state, id, num, min_jspeed, max_jspeed, min_vel, max_vel, size, // random_disperse, ang_range diff --git a/source/games/sw/src/zilla.cpp b/source/games/sw/src/zilla.cpp index 6f1bf9023..f7c30f323 100644 --- a/source/games/sw/src/zilla.cpp +++ b/source/games/sw/src/zilla.cpp @@ -116,40 +116,25 @@ ATTRIBUTE ZillaAttrib = #define ZILLA_RATE 48 -STATE s_ZillaRun[1][6] = +FState s_ZillaRun[] = { - { - {SPR_ZILLA_RUN, 'A', ZILLA_RATE, &AF(DoZillaMove), &s_ZillaRun[0][1]}, - {SPR_ZILLA_RUN, 'B', SF_QUICK_CALL, &AF(DoZillaStomp), &s_ZillaRun[0][2]}, - {SPR_ZILLA_RUN, 'B', ZILLA_RATE, &AF(DoZillaMove), &s_ZillaRun[0][3]}, - {SPR_ZILLA_RUN, 'C', ZILLA_RATE, &AF(DoZillaMove), &s_ZillaRun[0][4]}, - {SPR_ZILLA_RUN, 'D', SF_QUICK_CALL, &AF(DoZillaStomp), &s_ZillaRun[0][5]}, - {SPR_ZILLA_RUN, 'D', ZILLA_RATE, &AF(DoZillaMove), &s_ZillaRun[0][0]} - }, + {SPR_ZILLA_RUN, 'A', ZILLA_RATE, &AF(DoZillaMove), &s_ZillaRun[1]}, + {SPR_ZILLA_RUN, 'B', SF_QUICK_CALL, &AF(DoZillaStomp), &s_ZillaRun[2]}, + {SPR_ZILLA_RUN, 'B', ZILLA_RATE, &AF(DoZillaMove), &s_ZillaRun[3]}, + {SPR_ZILLA_RUN, 'C', ZILLA_RATE, &AF(DoZillaMove), &s_ZillaRun[4]}, + {SPR_ZILLA_RUN, 'D', SF_QUICK_CALL, &AF(DoZillaStomp), &s_ZillaRun[5]}, + {SPR_ZILLA_RUN, 'D', ZILLA_RATE, &AF(DoZillaMove), &s_ZillaRun[0]} }; -STATE* sg_ZillaRun[] = -{ - &s_ZillaRun[0][0], -}; - - ////////////////////// // // ZILLA STAND // ////////////////////// -STATE s_ZillaStand[1][1] = +FState s_ZillaStand[] = { - { - {SPR_ZILLA_RUN, 'A', ZILLA_RATE, &AF(DoZillaMove), &s_ZillaStand[0][0]} - }, -}; - -STATE* sg_ZillaStand[] = -{ - &s_ZillaStand[0][0], + {SPR_ZILLA_RUN, 'A', ZILLA_RATE, &AF(DoZillaMove), &s_ZillaStand[0]} }; ////////////////////// @@ -160,17 +145,10 @@ STATE* sg_ZillaStand[] = #define ZILLA_PAIN_RATE 30 -STATE s_ZillaPain[1][2] = +FState s_ZillaPain[] = { - { - {SPR_ZILLA_PAIN, 'A', ZILLA_PAIN_RATE, &AF(NullZilla), &s_ZillaPain[0][1]}, - {SPR_ZILLA_PAIN, 'A', 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_ZillaPain[0][0]} - }, -}; - -STATE* sg_ZillaPain[] = -{ - &s_ZillaPain[0][0], + {SPR_ZILLA_PAIN, 'A', ZILLA_PAIN_RATE, &AF(NullZilla), &s_ZillaPain[1]}, + {SPR_ZILLA_PAIN, 'A', 0|SF_QUICK_CALL, &AF(InitActorDecide), &s_ZillaPain[0]} }; ////////////////////// @@ -181,29 +159,22 @@ STATE* sg_ZillaPain[] = #define ZILLA_RAIL_RATE 12 -STATE s_ZillaRail[1][14] = +FState s_ZillaRail[] = { - { - {SPR_ZILLA_RAIL, 'A', ZILLA_RAIL_RATE, &AF(NullZilla), &s_ZillaRail[0][1]}, - {SPR_ZILLA_RAIL, 'B', ZILLA_RAIL_RATE, &AF(NullZilla), &s_ZillaRail[0][2]}, - {SPR_ZILLA_RAIL, 'C', ZILLA_RAIL_RATE, &AF(NullZilla), &s_ZillaRail[0][3]}, - {SPR_ZILLA_RAIL, 'D', SF_QUICK_CALL, &AF(InitZillaRail), &s_ZillaRail[0][4]}, - {SPR_ZILLA_RAIL, 'A', ZILLA_RAIL_RATE, &AF(NullZilla), &s_ZillaRail[0][5]}, - {SPR_ZILLA_RAIL, 'B', ZILLA_RAIL_RATE, &AF(NullZilla), &s_ZillaRail[0][6]}, - {SPR_ZILLA_RAIL, 'C', ZILLA_RAIL_RATE, &AF(NullZilla), &s_ZillaRail[0][7]}, - {SPR_ZILLA_RAIL, 'D', SF_QUICK_CALL, &AF(InitZillaRail), &s_ZillaRail[0][8]}, - {SPR_ZILLA_RAIL, 'A', ZILLA_RAIL_RATE, &AF(NullZilla), &s_ZillaRail[0][9]}, - {SPR_ZILLA_RAIL, 'B', ZILLA_RAIL_RATE, &AF(NullZilla), &s_ZillaRail[0][10]}, - {SPR_ZILLA_RAIL, 'C', ZILLA_RAIL_RATE, &AF(NullZilla), &s_ZillaRail[0][11]}, - {SPR_ZILLA_RAIL, 'D', SF_QUICK_CALL, &AF(InitZillaRail), &s_ZillaRail[0][12]}, - {SPR_ZILLA_RAIL, 'D', ZILLA_RAIL_RATE, &AF(NullZilla), &s_ZillaRail[0][13]}, - {SPR_ZILLA_RAIL, 'D', SF_QUICK_CALL, &AF(InitActorDecide), &s_ZillaRail[0][0]} - }, -}; - -STATE* sg_ZillaRail[] = -{ - &s_ZillaRail[0][0], + {SPR_ZILLA_RAIL, 'A', ZILLA_RAIL_RATE, &AF(NullZilla), &s_ZillaRail[1]}, + {SPR_ZILLA_RAIL, 'B', ZILLA_RAIL_RATE, &AF(NullZilla), &s_ZillaRail[2]}, + {SPR_ZILLA_RAIL, 'C', ZILLA_RAIL_RATE, &AF(NullZilla), &s_ZillaRail[3]}, + {SPR_ZILLA_RAIL, 'D', SF_QUICK_CALL, &AF(InitZillaRail), &s_ZillaRail[4]}, + {SPR_ZILLA_RAIL, 'A', ZILLA_RAIL_RATE, &AF(NullZilla), &s_ZillaRail[5]}, + {SPR_ZILLA_RAIL, 'B', ZILLA_RAIL_RATE, &AF(NullZilla), &s_ZillaRail[6]}, + {SPR_ZILLA_RAIL, 'C', ZILLA_RAIL_RATE, &AF(NullZilla), &s_ZillaRail[7]}, + {SPR_ZILLA_RAIL, 'D', SF_QUICK_CALL, &AF(InitZillaRail), &s_ZillaRail[8]}, + {SPR_ZILLA_RAIL, 'A', ZILLA_RAIL_RATE, &AF(NullZilla), &s_ZillaRail[9]}, + {SPR_ZILLA_RAIL, 'B', ZILLA_RAIL_RATE, &AF(NullZilla), &s_ZillaRail[10]}, + {SPR_ZILLA_RAIL, 'C', ZILLA_RAIL_RATE, &AF(NullZilla), &s_ZillaRail[11]}, + {SPR_ZILLA_RAIL, 'D', SF_QUICK_CALL, &AF(InitZillaRail), &s_ZillaRail[12]}, + {SPR_ZILLA_RAIL, 'D', ZILLA_RAIL_RATE, &AF(NullZilla), &s_ZillaRail[13]}, + {SPR_ZILLA_RAIL, 'D', SF_QUICK_CALL, &AF(InitActorDecide), &s_ZillaRail[0]} }; ////////////////////// @@ -214,22 +185,15 @@ STATE* sg_ZillaRail[] = #define ZILLA_ROCKET_RATE 12 -STATE s_ZillaRocket[1][7] = +FState s_ZillaRocket[] = { - { - {SPR_ZILLA_ROCKET, 'A', ZILLA_ROCKET_RATE, &AF(NullZilla), &s_ZillaRocket[0][1]}, - {SPR_ZILLA_ROCKET, 'B', ZILLA_ROCKET_RATE, &AF(NullZilla), &s_ZillaRocket[0][2]}, - {SPR_ZILLA_ROCKET, 'C', ZILLA_ROCKET_RATE*4, &AF(NullZilla), &s_ZillaRocket[0][3]}, - {SPR_ZILLA_ROCKET, 'C', SF_QUICK_CALL, &AF(InitZillaRocket), &s_ZillaRocket[0][4]}, - {SPR_ZILLA_ROCKET, 'C', ZILLA_ROCKET_RATE*4, &AF(NullZilla), &s_ZillaRocket[0][5]}, - {SPR_ZILLA_ROCKET, 'D', SF_QUICK_CALL, &AF(InitActorDecide), &s_ZillaRocket[0][6]}, - {SPR_ZILLA_ROCKET, 'D', ZILLA_ROCKET_RATE*10, &AF(NullZilla), &s_ZillaRocket[0][5]} - }, -}; - -STATE* sg_ZillaRocket[] = -{ - &s_ZillaRocket[0][0], + {SPR_ZILLA_ROCKET, 'A', ZILLA_ROCKET_RATE, &AF(NullZilla), &s_ZillaRocket[1]}, + {SPR_ZILLA_ROCKET, 'B', ZILLA_ROCKET_RATE, &AF(NullZilla), &s_ZillaRocket[2]}, + {SPR_ZILLA_ROCKET, 'C', ZILLA_ROCKET_RATE*4, &AF(NullZilla), &s_ZillaRocket[3]}, + {SPR_ZILLA_ROCKET, 'C', SF_QUICK_CALL, &AF(InitZillaRocket), &s_ZillaRocket[4]}, + {SPR_ZILLA_ROCKET, 'C', ZILLA_ROCKET_RATE*4, &AF(NullZilla), &s_ZillaRocket[5]}, + {SPR_ZILLA_ROCKET, 'D', SF_QUICK_CALL, &AF(InitActorDecide), &s_ZillaRocket[6]}, + {SPR_ZILLA_ROCKET, 'D', ZILLA_ROCKET_RATE*10, &AF(NullZilla), &s_ZillaRocket[5]} }; ////////////////////// @@ -240,37 +204,25 @@ STATE* sg_ZillaRocket[] = #define ZILLA_UZI_RATE 8 -STATE s_ZillaUzi[1][17] = +FState s_ZillaUzi[] = { - { - {SPR_ZILLA_SHOOT, 'A', ZILLA_UZI_RATE, &AF(NullZilla), &s_ZillaUzi[0][1]}, - {SPR_ZILLA_SHOOT, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZillaUzi[0][2]}, - {SPR_ZILLA_SHOOT, 'A', ZILLA_UZI_RATE, &AF(NullZilla), &s_ZillaUzi[0][3]}, - {SPR_ZILLA_SHOOT, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZillaUzi[0][4]}, - {SPR_ZILLA_SHOOT, 'A', ZILLA_UZI_RATE, &AF(NullZilla), &s_ZillaUzi[0][5]}, - {SPR_ZILLA_SHOOT, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZillaUzi[0][6]}, - {SPR_ZILLA_SHOOT, 'A', ZILLA_UZI_RATE, &AF(NullZilla), &s_ZillaUzi[0][7]}, - {SPR_ZILLA_SHOOT, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZillaUzi[0][8]}, - {SPR_ZILLA_SHOOT, 'A', ZILLA_UZI_RATE, &AF(NullZilla), &s_ZillaUzi[0][9]}, - {SPR_ZILLA_SHOOT, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZillaUzi[0][10]}, - {SPR_ZILLA_SHOOT, 'A', ZILLA_UZI_RATE, &AF(NullZilla), &s_ZillaUzi[0][11]}, - {SPR_ZILLA_SHOOT, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZillaUzi[0][12]}, - {SPR_ZILLA_SHOOT, 'A', ZILLA_UZI_RATE, &AF(NullZilla), &s_ZillaUzi[0][13]}, - {SPR_ZILLA_SHOOT, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZillaUzi[0][14]}, - {SPR_ZILLA_SHOOT, 'A', ZILLA_UZI_RATE, &AF(NullZilla), &s_ZillaUzi[0][15]}, - {SPR_ZILLA_SHOOT, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZillaUzi[0][16]}, - {SPR_ZILLA_SHOOT, 'A', 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_ZillaUzi[0][16]}, - }, -}; - - -STATE* sg_ZillaUzi[] = -{ - s_ZillaUzi[0], - s_ZillaUzi[1], - s_ZillaUzi[2], - s_ZillaUzi[3], - s_ZillaUzi[4] + {SPR_ZILLA_SHOOT, 'A', ZILLA_UZI_RATE, &AF(NullZilla), &s_ZillaUzi[1]}, + {SPR_ZILLA_SHOOT, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZillaUzi[2]}, + {SPR_ZILLA_SHOOT, 'A', ZILLA_UZI_RATE, &AF(NullZilla), &s_ZillaUzi[3]}, + {SPR_ZILLA_SHOOT, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZillaUzi[4]}, + {SPR_ZILLA_SHOOT, 'A', ZILLA_UZI_RATE, &AF(NullZilla), &s_ZillaUzi[5]}, + {SPR_ZILLA_SHOOT, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZillaUzi[6]}, + {SPR_ZILLA_SHOOT, 'A', ZILLA_UZI_RATE, &AF(NullZilla), &s_ZillaUzi[7]}, + {SPR_ZILLA_SHOOT, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZillaUzi[8]}, + {SPR_ZILLA_SHOOT, 'A', ZILLA_UZI_RATE, &AF(NullZilla), &s_ZillaUzi[9]}, + {SPR_ZILLA_SHOOT, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZillaUzi[10]}, + {SPR_ZILLA_SHOOT, 'A', ZILLA_UZI_RATE, &AF(NullZilla), &s_ZillaUzi[11]}, + {SPR_ZILLA_SHOOT, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZillaUzi[12]}, + {SPR_ZILLA_SHOOT, 'A', ZILLA_UZI_RATE, &AF(NullZilla), &s_ZillaUzi[13]}, + {SPR_ZILLA_SHOOT, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZillaUzi[14]}, + {SPR_ZILLA_SHOOT, 'A', ZILLA_UZI_RATE, &AF(NullZilla), &s_ZillaUzi[15]}, + {SPR_ZILLA_SHOOT, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZillaUzi[16]}, + {SPR_ZILLA_SHOOT, 'A', 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_ZillaUzi[16]}, }; @@ -282,7 +234,7 @@ STATE* sg_ZillaUzi[] = #define ZILLA_DIE_RATE 30 -STATE s_ZillaDie[] = +FState s_ZillaDie[] = { {SPR_ZILLA_DIE, 'A', ZILLA_DIE_RATE*15, &AF(DoZillaDeathMelt), &s_ZillaDie[1]}, {SPR_ZILLA_DIE, 'B', ZILLA_DIE_RATE, &AF(NullZilla), &s_ZillaDie[2]}, @@ -295,25 +247,15 @@ STATE s_ZillaDie[] = {SPR_ZILLA_DEAD, 'A', ZILLA_DIE_RATE, &AF(DoActorDebris), &s_ZillaDie[8]} }; -STATE* sg_ZillaDie[] = -{ - s_ZillaDie -}; - -STATE s_ZillaDead[] = +FState s_ZillaDead[] = { {SPR_ZILLA_DEAD, 'A', ZILLA_DIE_RATE, &AF(DoActorDebris), &s_ZillaDead[0]}, }; -STATE* sg_ZillaDead[] = -{ - s_ZillaDead -}; - ACTOR_ACTION_SET ZillaActionSet = { - sg_ZillaStand, - sg_ZillaRun, + s_ZillaStand, + s_ZillaRun, nullptr, nullptr, nullptr, @@ -323,15 +265,15 @@ ACTOR_ACTION_SET ZillaActionSet = nullptr, nullptr, nullptr, //climb - sg_ZillaPain, //pain - sg_ZillaDie, + s_ZillaPain, //pain + s_ZillaDie, nullptr, - sg_ZillaDead, + s_ZillaDead, nullptr, nullptr, - {sg_ZillaUzi,sg_ZillaRail}, + {s_ZillaUzi,s_ZillaRail}, {950,1024}, - {sg_ZillaUzi,sg_ZillaRocket,sg_ZillaRail}, + {s_ZillaUzi,s_ZillaRocket,s_ZillaRail}, {400,950,1024}, {nullptr}, nullptr, @@ -359,7 +301,7 @@ int SetupZilla(DSWActor* actor) actor->user.__legacyState.Attrib = &ZillaAttrib; DoActorSetSpeed(actor, NORM_SPEED); actor->user.__legacyState.StateEnd = s_ZillaDie; - actor->user.__legacyState.Rot = sg_ZillaRun; + actor->user.__legacyState.Rot = s_ZillaRun; EnemyDefaults(actor, &ZillaActionSet, &ZillaPersonality); @@ -490,23 +432,6 @@ static saveable_data saveable_zilla_data[] = SAVE_DATA(ZillaAttrib), - SAVE_DATA(s_ZillaRun), - SAVE_DATA(sg_ZillaRun), - SAVE_DATA(s_ZillaStand), - SAVE_DATA(sg_ZillaStand), - SAVE_DATA(s_ZillaPain), - SAVE_DATA(sg_ZillaPain), - SAVE_DATA(s_ZillaRail), - SAVE_DATA(sg_ZillaRail), - SAVE_DATA(s_ZillaRocket), - SAVE_DATA(sg_ZillaRocket), - SAVE_DATA(s_ZillaUzi), - SAVE_DATA(sg_ZillaUzi), - SAVE_DATA(s_ZillaDie), - SAVE_DATA(sg_ZillaDie), - SAVE_DATA(s_ZillaDead), - SAVE_DATA(sg_ZillaDead), - SAVE_DATA(ZillaActionSet), }; diff --git a/source/games/sw/src/zombie.cpp b/source/games/sw/src/zombie.cpp index fc897fd5f..4f673cb9e 100644 --- a/source/games/sw/src/zombie.cpp +++ b/source/games/sw/src/zombie.cpp @@ -117,19 +117,12 @@ ATTRIBUTE ZombieAttrib = #define ZOMBIE_RATE 32 -STATE s_ZombieRun[1][4] = +FState s_ZombieRun[] = { - { - {SPR_PLAYER_NINJA_RUN, 'A', ZOMBIE_RATE | SF_TIC_ADJUST, &AF(DoZombieMove), &s_ZombieRun[0][1]}, - {SPR_PLAYER_NINJA_RUN, 'B', ZOMBIE_RATE | SF_TIC_ADJUST, &AF(DoZombieMove), &s_ZombieRun[0][2]}, - {SPR_PLAYER_NINJA_RUN, 'C', ZOMBIE_RATE | SF_TIC_ADJUST, &AF(DoZombieMove), &s_ZombieRun[0][3]}, - {SPR_PLAYER_NINJA_RUN, 'D', ZOMBIE_RATE | SF_TIC_ADJUST, &AF(DoZombieMove), &s_ZombieRun[0][0]}, - }, -}; - -STATE* sg_ZombieRun[] = -{ - s_ZombieRun[0], + {SPR_PLAYER_NINJA_RUN, 'A', ZOMBIE_RATE | SF_TIC_ADJUST, &AF(DoZombieMove), &s_ZombieRun[1]}, + {SPR_PLAYER_NINJA_RUN, 'B', ZOMBIE_RATE | SF_TIC_ADJUST, &AF(DoZombieMove), &s_ZombieRun[2]}, + {SPR_PLAYER_NINJA_RUN, 'C', ZOMBIE_RATE | SF_TIC_ADJUST, &AF(DoZombieMove), &s_ZombieRun[3]}, + {SPR_PLAYER_NINJA_RUN, 'D', ZOMBIE_RATE | SF_TIC_ADJUST, &AF(DoZombieMove), &s_ZombieRun[0]}, }; ////////////////////// @@ -140,16 +133,9 @@ STATE* sg_ZombieRun[] = #define ZOMBIE_STAND_RATE 10 -STATE s_ZombieStand[1][1] = +FState s_ZombieStand[] = { - { - {SPR_PLAYER_NINJA_STAND, 'A', ZOMBIE_STAND_RATE, &AF(NullZombie), &s_ZombieStand[0][0]}, - }, -}; - -STATE* sg_ZombieStand[] = -{ - s_ZombieStand[0], + {SPR_PLAYER_NINJA_STAND, 'A', ZOMBIE_STAND_RATE, &AF(NullZombie), &s_ZombieStand[0]}, }; ////////////////////// @@ -160,17 +146,10 @@ STATE* sg_ZombieStand[] = #define ZOMBIE_PAIN_RATE 15 -STATE s_ZombiePain[1][2] = +FState s_ZombiePain[] = { - { - {SPR_PLAYER_NINJA_STAND, 'A', ZOMBIE_PAIN_RATE, &AF(DoZombiePain), &s_ZombiePain[0][1]}, - {SPR_PLAYER_NINJA_STAND, 'B', ZOMBIE_PAIN_RATE, &AF(DoZombiePain), &s_ZombiePain[0][1]}, - }, -}; - -STATE* sg_ZombiePain[] = -{ - s_ZombiePain[0], + {SPR_PLAYER_NINJA_STAND, 'A', ZOMBIE_PAIN_RATE, &AF(DoZombiePain), &s_ZombiePain[1]}, + {SPR_PLAYER_NINJA_STAND, 'B', ZOMBIE_PAIN_RATE, &AF(DoZombiePain), &s_ZombiePain[1]}, }; ////////////////////// @@ -181,24 +160,16 @@ STATE* sg_ZombiePain[] = #define ZOMBIE_NUKE_RATE 18 -STATE s_ZombieNuke[1][6] = +FState s_ZombieNuke[] = { - { - {SPR_PLAYER_NINJA_SHOOT, 'A', ZOMBIE_NUKE_RATE * 2, &AF(NullZombie), &s_ZombieNuke[0][1]}, - {SPR_PLAYER_NINJA_SHOOT, 'A', ZOMBIE_NUKE_RATE, &AF(NullZombie), &s_ZombieNuke[0][2]}, - {SPR_PLAYER_NINJA_SHOOT, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyNuke), &s_ZombieNuke[0][3]}, - {SPR_PLAYER_NINJA_SHOOT, 'A', ZOMBIE_NUKE_RATE * 2, &AF(NullZombie), &s_ZombieNuke[0][4]}, - {SPR_PLAYER_NINJA_SHOOT, 'A', 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_ZombieNuke[0][5]}, - {SPR_PLAYER_NINJA_SHOOT, 'A', ZOMBIE_NUKE_RATE, &AF(DoZombieMove), &s_ZombieNuke[0][5]}, - }, + {SPR_PLAYER_NINJA_SHOOT, 'A', ZOMBIE_NUKE_RATE * 2, &AF(NullZombie), &s_ZombieNuke[1]}, + {SPR_PLAYER_NINJA_SHOOT, 'A', ZOMBIE_NUKE_RATE, &AF(NullZombie), &s_ZombieNuke[2]}, + {SPR_PLAYER_NINJA_SHOOT, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyNuke), &s_ZombieNuke[3]}, + {SPR_PLAYER_NINJA_SHOOT, 'A', ZOMBIE_NUKE_RATE * 2, &AF(NullZombie), &s_ZombieNuke[4]}, + {SPR_PLAYER_NINJA_SHOOT, 'A', 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_ZombieNuke[5]}, + {SPR_PLAYER_NINJA_SHOOT, 'A', ZOMBIE_NUKE_RATE, &AF(DoZombieMove), &s_ZombieNuke[5]}, }; -STATE* sg_ZombieNuke[] = -{ - s_ZombieNuke[0], -}; - - ////////////////////// // // ZOMBIE ROCKET @@ -207,23 +178,16 @@ STATE* sg_ZombieNuke[] = #define ZOMBIE_ROCKET_RATE 14 -STATE s_ZombieRocket[1][5] = +FState s_ZombieRocket[] = { - { - {SPR_PLAYER_NINJA_STAND, 'A', ZOMBIE_ROCKET_RATE * 2, &AF(NullZombie), &s_ZombieRocket[0][1]}, - {SPR_PLAYER_NINJA_STAND, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyRocket), &s_ZombieRocket[0][2]}, - {SPR_PLAYER_NINJA_STAND, 'A', ZOMBIE_ROCKET_RATE, &AF(NullZombie), &s_ZombieRocket[0][3]}, - {SPR_PLAYER_NINJA_STAND, 'A', 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_ZombieRocket[0][4]}, - {SPR_PLAYER_NINJA_STAND, 'A', ZOMBIE_ROCKET_RATE, &AF(DoZombieMove), &s_ZombieRocket[0][4]}, - }, + {SPR_PLAYER_NINJA_STAND, 'A', ZOMBIE_ROCKET_RATE * 2, &AF(NullZombie), &s_ZombieRocket[1]}, + {SPR_PLAYER_NINJA_STAND, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyRocket), &s_ZombieRocket[2]}, + {SPR_PLAYER_NINJA_STAND, 'A', ZOMBIE_ROCKET_RATE, &AF(NullZombie), &s_ZombieRocket[3]}, + {SPR_PLAYER_NINJA_STAND, 'A', 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_ZombieRocket[4]}, + {SPR_PLAYER_NINJA_STAND, 'A', ZOMBIE_ROCKET_RATE, &AF(DoZombieMove), &s_ZombieRocket[4]}, }; -STATE* sg_ZombieRocket[] = -{ - s_ZombieRocket[0], -}; - ////////////////////// // // ZOMBIE ROCKET @@ -232,23 +196,16 @@ STATE* sg_ZombieRocket[] = #define ZOMBIE_RAIL_RATE 14 -STATE s_ZombieRail[1][5] = +FState s_ZombieRail[] = { - { - {SPR_PLAYER_NINJA_STAND, 'A', ZOMBIE_RAIL_RATE * 2, &AF(NullZombie), &s_ZombieRail[0][1]}, - {SPR_PLAYER_NINJA_STAND, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyRail), &s_ZombieRail[0][2]}, - {SPR_PLAYER_NINJA_STAND, 'A', ZOMBIE_RAIL_RATE, &AF(NullZombie), &s_ZombieRail[0][3]}, - {SPR_PLAYER_NINJA_STAND, 'A', 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_ZombieRail[0][4]}, - {SPR_PLAYER_NINJA_STAND, 'A', ZOMBIE_RAIL_RATE, &AF(DoZombieMove), &s_ZombieRail[0][4]}, - }, + {SPR_PLAYER_NINJA_STAND, 'A', ZOMBIE_RAIL_RATE * 2, &AF(NullZombie), &s_ZombieRail[1]}, + {SPR_PLAYER_NINJA_STAND, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyRail), &s_ZombieRail[2]}, + {SPR_PLAYER_NINJA_STAND, 'A', ZOMBIE_RAIL_RATE, &AF(NullZombie), &s_ZombieRail[3]}, + {SPR_PLAYER_NINJA_STAND, 'A', 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_ZombieRail[4]}, + {SPR_PLAYER_NINJA_STAND, 'A', ZOMBIE_RAIL_RATE, &AF(DoZombieMove), &s_ZombieRail[4]}, }; -STATE* sg_ZombieRail[] = -{ - s_ZombieRail[0], -}; - ////////////////////// // // ZOMBIE GRENADE @@ -257,23 +214,16 @@ STATE* sg_ZombieRail[] = #define ZOMBIE_ROCKET_RATE 14 -STATE s_ZombieGrenade[1][5] = +FState s_ZombieGrenade[] = { - { - {SPR_PLAYER_NINJA_STAND, 'A', ZOMBIE_ROCKET_RATE * 2, &AF(NullZombie), &s_ZombieGrenade[0][1]}, - {SPR_PLAYER_NINJA_STAND, 'A', 0 | SF_QUICK_CALL, &AF(InitSpriteGrenade), &s_ZombieGrenade[0][2]}, - {SPR_PLAYER_NINJA_STAND, 'A', ZOMBIE_ROCKET_RATE, &AF(NullZombie), &s_ZombieGrenade[0][3]}, - {SPR_PLAYER_NINJA_STAND, 'A', 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_ZombieGrenade[0][4]}, - {SPR_PLAYER_NINJA_STAND, 'A', ZOMBIE_ROCKET_RATE, &AF(DoZombieMove), &s_ZombieGrenade[0][4]}, - }, + {SPR_PLAYER_NINJA_STAND, 'A', ZOMBIE_ROCKET_RATE * 2, &AF(NullZombie), &s_ZombieGrenade[1]}, + {SPR_PLAYER_NINJA_STAND, 'A', 0 | SF_QUICK_CALL, &AF(InitSpriteGrenade), &s_ZombieGrenade[2]}, + {SPR_PLAYER_NINJA_STAND, 'A', ZOMBIE_ROCKET_RATE, &AF(NullZombie), &s_ZombieGrenade[3]}, + {SPR_PLAYER_NINJA_STAND, 'A', 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_ZombieGrenade[4]}, + {SPR_PLAYER_NINJA_STAND, 'A', ZOMBIE_ROCKET_RATE, &AF(DoZombieMove), &s_ZombieGrenade[4]}, }; -STATE* sg_ZombieGrenade[] = -{ - s_ZombieGrenade[0], -}; - ////////////////////// // @@ -283,23 +233,16 @@ STATE* sg_ZombieGrenade[] = #define ZOMBIE_FLASHBOMB_RATE 14 -STATE s_ZombieFlashBomb[1][5] = +FState s_ZombieFlashBomb[] = { - { - {SPR_PLAYER_NINJA_STAND, 'A', ZOMBIE_FLASHBOMB_RATE * 2, &AF(NullZombie), &s_ZombieFlashBomb[0][1]}, - {SPR_PLAYER_NINJA_STAND, 'A', 0 | SF_QUICK_CALL, &AF(InitFlashBomb), &s_ZombieFlashBomb[0][2]}, - {SPR_PLAYER_NINJA_STAND, 'A', ZOMBIE_FLASHBOMB_RATE, &AF(NullZombie), &s_ZombieFlashBomb[0][3]}, - {SPR_PLAYER_NINJA_STAND, 'A', 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_ZombieFlashBomb[0][4]}, - {SPR_PLAYER_NINJA_STAND, 'A', ZOMBIE_FLASHBOMB_RATE, &AF(DoZombieMove), &s_ZombieFlashBomb[0][4]}, - }, + {SPR_PLAYER_NINJA_STAND, 'A', ZOMBIE_FLASHBOMB_RATE * 2, &AF(NullZombie), &s_ZombieFlashBomb[1]}, + {SPR_PLAYER_NINJA_STAND, 'A', 0 | SF_QUICK_CALL, &AF(InitFlashBomb), &s_ZombieFlashBomb[2]}, + {SPR_PLAYER_NINJA_STAND, 'A', ZOMBIE_FLASHBOMB_RATE, &AF(NullZombie), &s_ZombieFlashBomb[3]}, + {SPR_PLAYER_NINJA_STAND, 'A', 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_ZombieFlashBomb[4]}, + {SPR_PLAYER_NINJA_STAND, 'A', ZOMBIE_FLASHBOMB_RATE, &AF(DoZombieMove), &s_ZombieFlashBomb[4]}, }; -STATE* sg_ZombieFlashBomb[] = -{ - s_ZombieFlashBomb[0], -}; - ////////////////////// // // ZOMBIE UZI @@ -308,35 +251,28 @@ STATE* sg_ZombieFlashBomb[] = #define ZOMBIE_UZI_RATE 8 -STATE s_ZombieUzi[1][17] = +FState s_ZombieUzi[] = { - { - {SPR_PLAYER_NINJA_SHOOT, 'A', ZOMBIE_UZI_RATE, &AF(NullZombie), &s_ZombieUzi[0][1]}, - {SPR_PLAYER_NINJA_SHOOT, 'A', 0 | SF_QUICK_CALL, &AF(CheckFire), &s_ZombieUzi[0][2]}, - {SPR_PLAYER_NINJA_SHOOT, 'A', ZOMBIE_UZI_RATE, &AF(NullZombie), &s_ZombieUzi[0][3]}, - {SPR_PLAYER_NINJA_SHOOT, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZombieUzi[0][4]}, - {SPR_PLAYER_NINJA_SHOOT, 'A', ZOMBIE_UZI_RATE, &AF(NullZombie), &s_ZombieUzi[0][5]}, - {SPR_PLAYER_NINJA_SHOOT, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZombieUzi[0][6]}, - {SPR_PLAYER_NINJA_SHOOT, 'A', ZOMBIE_UZI_RATE, &AF(NullZombie), &s_ZombieUzi[0][7]}, - {SPR_PLAYER_NINJA_SHOOT, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZombieUzi[0][8]}, - {SPR_PLAYER_NINJA_SHOOT, 'A', ZOMBIE_UZI_RATE, &AF(NullZombie), &s_ZombieUzi[0][9]}, - {SPR_PLAYER_NINJA_SHOOT, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZombieUzi[0][10]}, - {SPR_PLAYER_NINJA_SHOOT, 'A', ZOMBIE_UZI_RATE, &AF(NullZombie), &s_ZombieUzi[0][11]}, - {SPR_PLAYER_NINJA_SHOOT, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZombieUzi[0][12]}, - {SPR_PLAYER_NINJA_SHOOT, 'A', ZOMBIE_UZI_RATE, &AF(NullZombie), &s_ZombieUzi[0][13]}, - {SPR_PLAYER_NINJA_SHOOT, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZombieUzi[0][14]}, - {SPR_PLAYER_NINJA_SHOOT, 'A', ZOMBIE_UZI_RATE, &AF(NullZombie), &s_ZombieUzi[0][15]}, - {SPR_PLAYER_NINJA_SHOOT, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZombieUzi[0][16]}, - {SPR_PLAYER_NINJA_SHOOT, 'A', 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_ZombieUzi[0][16]}, - }, + {SPR_PLAYER_NINJA_SHOOT, 'A', ZOMBIE_UZI_RATE, &AF(NullZombie), &s_ZombieUzi[1]}, + {SPR_PLAYER_NINJA_SHOOT, 'A', 0 | SF_QUICK_CALL, &AF(CheckFire), &s_ZombieUzi[2]}, + {SPR_PLAYER_NINJA_SHOOT, 'A', ZOMBIE_UZI_RATE, &AF(NullZombie), &s_ZombieUzi[3]}, + {SPR_PLAYER_NINJA_SHOOT, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZombieUzi[4]}, + {SPR_PLAYER_NINJA_SHOOT, 'A', ZOMBIE_UZI_RATE, &AF(NullZombie), &s_ZombieUzi[5]}, + {SPR_PLAYER_NINJA_SHOOT, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZombieUzi[6]}, + {SPR_PLAYER_NINJA_SHOOT, 'A', ZOMBIE_UZI_RATE, &AF(NullZombie), &s_ZombieUzi[7]}, + {SPR_PLAYER_NINJA_SHOOT, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZombieUzi[8]}, + {SPR_PLAYER_NINJA_SHOOT, 'A', ZOMBIE_UZI_RATE, &AF(NullZombie), &s_ZombieUzi[9]}, + {SPR_PLAYER_NINJA_SHOOT, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZombieUzi[10]}, + {SPR_PLAYER_NINJA_SHOOT, 'A', ZOMBIE_UZI_RATE, &AF(NullZombie), &s_ZombieUzi[11]}, + {SPR_PLAYER_NINJA_SHOOT, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZombieUzi[12]}, + {SPR_PLAYER_NINJA_SHOOT, 'A', ZOMBIE_UZI_RATE, &AF(NullZombie), &s_ZombieUzi[13]}, + {SPR_PLAYER_NINJA_SHOOT, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZombieUzi[14]}, + {SPR_PLAYER_NINJA_SHOOT, 'A', ZOMBIE_UZI_RATE, &AF(NullZombie), &s_ZombieUzi[15]}, + {SPR_PLAYER_NINJA_SHOOT, 'A', 0 | SF_QUICK_CALL, &AF(InitEnemyUzi), &s_ZombieUzi[16]}, + {SPR_PLAYER_NINJA_SHOOT, 'A', 0 | SF_QUICK_CALL, &AF(InitActorDecide), &s_ZombieUzi[16]}, }; -STATE* sg_ZombieUzi[] = -{ - s_ZombieUzi[0], -}; - ////////////////////// // // ZOMBIE FALL @@ -345,70 +281,63 @@ STATE* sg_ZombieUzi[] = #define ZOMBIE_FALL_RATE 25 -STATE s_ZombieFall[1][1] = +FState s_ZombieFall[] = { - { - {SPR_PLAYER_NINJA_JUMP, 'D', ZOMBIE_FALL_RATE, &AF(DoZombieMove), &s_ZombieFall[0][0]}, - }, + {SPR_PLAYER_NINJA_JUMP, 'D', ZOMBIE_FALL_RATE, &AF(DoZombieMove), &s_ZombieFall[0]}, }; -STATE* sg_ZombieFall[] = -{ - &s_ZombieFall[0][0], -}; - /* -STATE* *Stand[MAX_WEAPONS]; -STATE* *Run; -STATE* *Jump; -STATE* *Fall; -STATE* *Crawl; -STATE* *Swim; -STATE* *Fly; -STATE* *Rise; -STATE* *Sit; -STATE* *Look; -STATE* *Climb; -STATE* *Pain; -STATE* *Death1; -STATE* *Death2; -STATE* *Dead; -STATE* *DeathJump; -STATE* *DeathFall; -STATE* *CloseAttack[2]; -STATE* *Attack[6]; -STATE* *Special[2]; +FState* *Stand[MAX_WEAPONS]; +FState* *Run; +FState* *Jump; +FState* *Fall; +FState* *Crawl; +FState* *Swim; +FState* *Fly; +FState* *Rise; +FState* *Sit; +FState* *Look; +FState* *Climb; +FState* *Pain; +FState* *Death1; +FState* *Death2; +FState* *Dead; +FState* *DeathJump; +FState* *DeathFall; +FState* *CloseAttack[2]; +FState* *Attack[6]; +FState* *Special[2]; */ ACTOR_ACTION_SET ZombieActionSet = { - sg_ZombieStand, - sg_ZombieRun, + s_ZombieStand, + s_ZombieRun, nullptr, - sg_ZombieFall, + s_ZombieFall, nullptr, nullptr, nullptr, - sg_ZombieRun, - sg_ZombieRun, + s_ZombieRun, + s_ZombieRun, nullptr, nullptr, - sg_ZombiePain, - sg_ZombieRun, + s_ZombiePain, + s_ZombieRun, nullptr, nullptr, nullptr, nullptr, #if 0 - {sg_ZombieUzi}, + {s_ZombieUzi}, {1024}, - {sg_ZombieUzi, sg_ZombieRocket, sg_ZombieGrenade, sg_ZombieNuke}, + {s_ZombieUzi, s_ZombieRocket, s_ZombieGrenade, s_ZombieNuke}, {400, 750, 1000, 1024}, #endif - {sg_ZombieRail}, + {s_ZombieRail}, {1024}, - {sg_ZombieRail}, + {s_ZombieRail}, {1024}, {nullptr}, nullptr, @@ -425,8 +354,8 @@ int SetupZombie(DSWActor* actor) { actor->user.Health = 100; - actor->user.__legacyState.StateEnd = &s_ZombiePain[0][0]; - actor->user.__legacyState.Rot = sg_ZombieRun; + actor->user.__legacyState.StateEnd = &s_ZombiePain[0]; + actor->user.__legacyState.Rot = s_ZombieRun; actor->spr.scale = DVector2(PLAYER_NINJA_XREPEAT, PLAYER_NINJA_YREPEAT); actor->user.__legacyState.Attrib = &ZombieAttrib; @@ -454,7 +383,7 @@ void SpawnZombie(DSWPlayer* pp, DSWActor* weaponActor) if (ownerActor == nullptr) return; - auto actorNew = SpawnActor(STAT_ENEMY, ZOMBIE_RUN_R0, s_ZombieRun[0], pp->cursector, pp->GetActor()->getPosWithOffsetZ(), pp->GetActor()->spr.Angles.Yaw, 0); + auto actorNew = SpawnActor(STAT_ENEMY, ZOMBIE_RUN_R0, &s_ZombieRun[0], pp->cursector, pp->GetActor()->getPosWithOffsetZ(), pp->GetActor()->spr.Angles.Yaw, 0); SetOwner(actorNew, ownerActor); actorNew->spr.pal = actorNew->user.spal = ownerActor->user.spal; actorNew->spr.Angles.Yaw = RandomAngle(); @@ -506,7 +435,7 @@ void SpawnZombie2(DSWActor* actor) } - auto actorNew = SpawnActor(STAT_ENEMY, ZOMBIE_RUN_R0, s_ZombieRun[0], actor->sector(), actor->spr.pos, actor->spr.Angles.Yaw, 0); + auto actorNew = SpawnActor(STAT_ENEMY, ZOMBIE_RUN_R0, &s_ZombieRun[0], actor->sector(), actor->spr.pos, actor->spr.Angles.Yaw, 0); actorNew->user.Counter3 = 0; SetOwner(ownerActor, actorNew); actorNew->spr.pal = actorNew->user.spal = ownerActor->user.spal; @@ -655,27 +584,6 @@ static saveable_data saveable_zombie_data[] = SAVE_DATA(ZombieAttrib), - SAVE_DATA(s_ZombieRun), - SAVE_DATA(sg_ZombieRun), - SAVE_DATA(s_ZombieStand), - SAVE_DATA(sg_ZombieStand), - SAVE_DATA(s_ZombiePain), - SAVE_DATA(sg_ZombiePain), - SAVE_DATA(s_ZombieNuke), - SAVE_DATA(sg_ZombieNuke), - SAVE_DATA(s_ZombieRocket), - SAVE_DATA(sg_ZombieRocket), - SAVE_DATA(s_ZombieRail), - SAVE_DATA(sg_ZombieRail), - SAVE_DATA(s_ZombieGrenade), - SAVE_DATA(sg_ZombieGrenade), - SAVE_DATA(s_ZombieFlashBomb), - SAVE_DATA(sg_ZombieFlashBomb), - SAVE_DATA(s_ZombieUzi), - SAVE_DATA(sg_ZombieUzi), - SAVE_DATA(s_ZombieFall), - SAVE_DATA(sg_ZombieFall), - SAVE_DATA(ZombieActionSet), };