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

migrate to engine states.

Browse source 
Savegames do not work for this yet.
This commit is contained in:
Christoph Oelckers 2023-06-27 16:43:46 +02:00
parent 031fb2ea4e
commit a1cbeb1b0d
38 changed files with 1988 additions and 3630 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
source/common/objects/dobject.h
View file

@ -179,8 +179,6 @@ public: \
#include "dobjgc.h"
class AActor;
class DObject
{
public:

1
source/common/scripting/frontend/zcc_compile.h
View file

@ -6,7 +6,6 @@
struct Baggage;
struct FPropertyInfo;
class AActor;
class FxExpression;
typedef TDeletingArray<FxExpression*> FArgumentList;

11
source/core/actorlist.cpp
View file

@ -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;
}

3
source/core/coreactor.h
View file

@ -220,6 +220,9 @@ public:
clipdist = other->clipdist;
}
int callFunction(VMFunction* func);
};
// holds pointers to the game-side actors.

2
source/core/serializer_raze.h
View file

@ -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);

9
source/core/states.cpp
View file

@ -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<FStateDefine> & sta
//
//===========================================================================
void FStateDefinitions::InstallStates(PClassActor *info, AActor *defaults)
void FStateDefinitions::InstallStates(PClassActor *info, DCoreActor *defaults)
{
if (defaults == nullptr)
{

27
source/core/states.h
View file

@ -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);

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

@ -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

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

@ -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),
};

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

@ -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),
};

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

@ -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),
};

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

@ -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)

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

@ -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)
};

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

@ -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);

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

@ -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),
};

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

@ -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),
};

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

@ -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),
};

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

@ -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)
{

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

@ -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),
};

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

@ -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]}

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

File diff suppressed because it is too large Load diff

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

@ -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 =

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

@ -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),

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

@ -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),

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

@ -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)

8
source/games/sw/src/sector.cpp
View file

@ -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;

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

@ -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),
};

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

@ -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),
};

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

@ -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 =

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

@ -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);
}
}

2
source/games/sw/src/sprite.h
View file

@ -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);

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

@ -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),

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

@ -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)); }
};

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

@ -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)

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

File diff suppressed because it is too large Load diff

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

@ -80,7 +80,11 @@ extern TObjPtr<DSWActor*> GenericQueue[MAX_GENERIC_QUEUE];
extern int LoWangsQueueHead;
extern TObjPtr<DSWActor*> 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

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

@ -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),
};

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

@ -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),
};