zdoom/gzdoom
0
0
Fork 0
mirror of https://github.com/ZDoom/gzdoom.git synced 2024-11-15 08:52:02 +00:00
Code Issues Projects Releases Packages Wiki Activity

- Changed state calls to use the VM's standard return value mechanism. StateCallData has been

Browse source 
removed as a result, so now action functions take a minimum of three parameters rather than four.

SVN r3770 (scripting)
This commit is contained in:
Randy Heit 2012-07-17 05:31:41 +00:00
parent e1a2f3b546
commit fcceeb814a
7 changed files with 165 additions and 163 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
src/actor.h
View file

@ -268,7 +268,7 @@ enum
// --- mobj.flags5 --- // --- mobj.flags5 ---
/* = 0x00000001, */ MF5_INSTATECALL = 0x00000001, // This actor is being run through CallStateChain
/* = 0x00000002, */ /* = 0x00000002, */
MF5_NODROPOFF = 0x00000004, // cannot drop off under any circumstances. MF5_NODROPOFF = 0x00000004, // cannot drop off under any circumstances.
/* = 0x00000008, */ /* = 0x00000008, */

5
src/info.cpp
View file

@ -57,13 +57,12 @@ extern void ClearStrifeTypes();
TArray<PClassActor *> PClassActor::AllActorClasses; TArray<PClassActor *> PClassActor::AllActorClasses;
bool FState::CallAction(AActor *self, AActor *stateowner, StateCallData *statecall) bool FState::CallAction(AActor *self, AActor *stateowner)
{ {
if (ActionFunc != NULL) if (ActionFunc != NULL)
{ {
//ActionFunc(self, stateowner, this, ParameterIndex-1, statecall);
VMFrameStack stack; VMFrameStack stack;
VMValue params[4] = { self, stateowner, VMValue(this, ATAG_STATE), statecall }; VMValue params[3] = { self, stateowner, VMValue(this, ATAG_STATE) };
stack.Call(ActionFunc, params, countof(params), NULL, 0, NULL); stack.Call(ActionFunc, params, countof(params), NULL, 0, NULL);
return true; return true;
} }

8
src/info.h
View file

@ -109,7 +109,7 @@ struct FState
Frame = frame - 'A'; Frame = frame - 'A';
} }
void SetAction(VMFunction *func) { ActionFunc = func; } void SetAction(VMFunction *func) { ActionFunc = func; }
bool CallAction(AActor *self, AActor *stateowner, StateCallData *statecall = NULL); bool CallAction(AActor *self, AActor *stateowner);
static PClassActor *StaticFindStateOwner (const FState *state); static PClassActor *StaticFindStateOwner (const FState *state);
static PClassActor *StaticFindStateOwner (const FState *state, PClassActor *info); static PClassActor *StaticFindStateOwner (const FState *state, PClassActor *info);
}; };
@ -294,19 +294,17 @@ void AddStateLight(FState *state, const char *lname);
// Standard parameters for all action functons // Standard parameters for all action functons
// self - Actor this action is to operate on (player if a weapon) // self - Actor this action is to operate on (player if a weapon)
// stateowner - Actor this action really belongs to (may be a weapon) // stateowner - Actor this action really belongs to (may be an item)
// callingstate - State this action was called from // callingstate - State this action was called from
// statecall - CustomInventory stuff
#define PARAM_ACTION_PROLOGUE_TYPE(type) \ #define PARAM_ACTION_PROLOGUE_TYPE(type) \
PARAM_PROLOGUE; \ PARAM_PROLOGUE; \
PARAM_OBJECT (self, type); \ PARAM_OBJECT (self, type); \
PARAM_OBJECT_OPT (stateowner, AActor) { stateowner = self; } \ PARAM_OBJECT_OPT (stateowner, AActor) { stateowner = self; } \
PARAM_STATE_OPT (callingstate) { callingstate = NULL; } \ PARAM_STATE_OPT (callingstate) { callingstate = NULL; } \
PARAM_POINTER_OPT(statecall, StateCallData) { statecall = NULL; }
#define PARAM_ACTION_PROLOGUE PARAM_ACTION_PROLOGUE_TYPE(AActor) #define PARAM_ACTION_PROLOGUE PARAM_ACTION_PROLOGUE_TYPE(AActor)
// Number of action paramaters // Number of action paramaters
#define NAP 4 #define NAP 3
#endif // __INFO_H__ #endif // __INFO_H__

5
src/thingdef/thingdef.cpp
View file

@ -286,13 +286,12 @@ static void FinishThingdef()
} }
VMFunctionBuilder buildit; VMFunctionBuilder buildit;
// Allocate registers used to pass parameters in. // Allocate registers used to pass parameters in.
// self, stateowner, state, statecalldata (all are pointers) // self, stateowner, state (all are pointers)
buildit.Registers[REGT_POINTER].Get(4); buildit.Registers[REGT_POINTER].Get(3);
// Emit code to pass the standard action function parameters. // Emit code to pass the standard action function parameters.
buildit.Emit(OP_PARAM, 0, REGT_POINTER, 0); buildit.Emit(OP_PARAM, 0, REGT_POINTER, 0);
buildit.Emit(OP_PARAM, 0, REGT_POINTER, 1); buildit.Emit(OP_PARAM, 0, REGT_POINTER, 1);
buildit.Emit(OP_PARAM, 0, REGT_POINTER, 2); buildit.Emit(OP_PARAM, 0, REGT_POINTER, 2);
buildit.Emit(OP_PARAM, 0, REGT_POINTER, 3);
// Emit code for action parameters. // Emit code for action parameters.
for (j = 0; j < tcall->Parameters.Size(); ++j) for (j = 0; j < tcall->Parameters.Size(); ++j)
{ {

16
src/thingdef/thingdef.h
View file

@ -350,14 +350,6 @@ int MatchString (const char *in, const char **strings);
MSVC_MSEG FVariableInfo *infoptr_GlobalDef__##name GCC_MSEG = &GlobalDef__##name; MSVC_MSEG FVariableInfo *infoptr_GlobalDef__##name GCC_MSEG = &GlobalDef__##name;
struct StateCallData
{
FState *State;
bool Result;
};
// Macros to handle action functions. These are here so that I don't have to // Macros to handle action functions. These are here so that I don't have to
// change every single use in case the parameters change. // change every single use in case the parameters change.
#define DECLARE_ACTION(name) extern VMNativeFunction *name##_VMPtr; #define DECLARE_ACTION(name) extern VMNativeFunction *name##_VMPtr;
@ -378,7 +370,7 @@ struct StateCallData
//#define PUSH_PARAMINFO self, stateowner, CallingState, ParameterIndex, statecall //#define PUSH_PARAMINFO self, stateowner, CallingState, ParameterIndex, statecall
#define CALL_ACTION(name,self) { /*AF_##name(self, self, NULL, 0, NULL)*/ \ #define CALL_ACTION(name,self) { /*AF_##name(self, self, NULL, 0, NULL)*/ \
VMValue params[5] = { self, self, VMValue(NULL, ATAG_STATE), VMValue(NULL, ATAG_GENERIC) }; \ VMValue params[3] = { self, self, VMValue(NULL, ATAG_STATE) }; \
stack->Call(name##_VMPtr, params, countof(params), NULL, 0, NULL); \ stack->Call(name##_VMPtr, params, countof(params), NULL, 0, NULL); \
} }
@ -421,10 +413,10 @@ FName EvalExpressionName (DWORD x, AActor *self);
angle_t var = angle_t(EvalExpressionF(ParameterIndex+i, self)*ANGLE_90/90.f); angle_t var = angle_t(EvalExpressionF(ParameterIndex+i, self)*ANGLE_90/90.f);
#endif #endif
#define ACTION_SET_RESULT(v) if (statecall != NULL) statecall->Result = v; #define ACTION_SET_RESULT(v) do { if (numret > 0) { assert(ret != NULL); ret->SetInt(v); numret = 1; } } while(0)
// Checks to see what called the current action function // Checks to see what called the current action function
#define ACTION_CALL_FROM_ACTOR() (callingstate == self->state) #define ACTION_CALL_FROM_ACTOR() (callingstate == self->state)
#define ACTION_CALL_FROM_WEAPON() (self->player && callingstate != self->state && statecall == NULL) #define ACTION_CALL_FROM_WEAPON() (self->player && callingstate != self->state && !(stateowner->flags5 & MF5_INSTATECALL))
#define ACTION_CALL_FROM_INVENTORY() (statecall != NULL) #define ACTION_CALL_FROM_INVENTORY() (!(stateowner->flags5 & MF5_INSTATECALL))
#endif #endif

288
src/thingdef/thingdef_codeptr.cpp
View file

@ -94,46 +94,59 @@ static FRandom pr_teleport("A_Teleport");
// //
//========================================================================== //==========================================================================
bool ACustomInventory::CallStateChain (AActor *actor, FState * State) bool ACustomInventory::CallStateChain (AActor *actor, FState *state)
{ {
StateCallData StateCall; INTBOOL result = false;
bool result = false;
int counter = 0; int counter = 0;
int retval, numret;
VMReturn ret;
ret.IntAt(&retval);
VMValue params[3] = { actor, this, 0 };
while (State != NULL) this->flags5 |= MF5_INSTATECALL;
FState *savedstate = this->state;
while (state != NULL)
{ {
// Assume success. The code pointer will set this to false if necessary this->state = state;
StateCall.State = State;
StateCall.Result = true;
if (State->CallAction(actor, this, &StateCall))
{
// collect all the results. Even one successful call signifies overall success.
result |= StateCall.Result;
}
if (state->ActionFunc != NULL)
{
VMFrameStack stack;
params[2] = VMValue(state, ATAG_STATE);
retval = true; // assume success
numret = stack.Call(state->ActionFunc, params, countof(params), &ret, 1);
// As long as even one state succeeds, the whole chain succeeds unless aborted below.
result |= retval;
}
// Since there are no delays it is a good idea to check for infinite loops here! // Since there are no delays it is a good idea to check for infinite loops here!
counter++; counter++;
if (counter >= 10000) break; if (counter >= 10000) break;
if (StateCall.State == State) if (this->state == state)
{ {
// Abort immediately if the state jumps to itself! FState *next = state->GetNextState();
if (State == State->GetNextState())
{ if (state == next)
return false; { // Abort immediately if the state jumps to itself!
result = false;
break;
} }
// If both variables are still the same there was no jump // If both variables are still the same there was no jump
// so we must advance to the next state. // so we must advance to the next state.
State = State->GetNextState(); state = next;
} }
else else
{ {
State = StateCall.State; state = this->state;
} }
} }
return result; this->flags5 &= ~MF5_INSTATECALL;
this->state = savedstate;
return !!result;
} }
//========================================================================== //==========================================================================
@ -579,13 +592,13 @@ DEFINE_ACTION_FUNCTION(AActor, A_BulletAttack)
// Do the state jump // Do the state jump
// //
//========================================================================== //==========================================================================
static void DoJump(AActor *self, FState *callingstate, FState *jumpto, StateCallData *statecall) static void DoJump(AActor *self, AActor *stateowner, FState *callingstate, FState *jumpto)
{ {
if (jumpto == NULL) return; if (jumpto == NULL) return;
if (statecall != NULL) if (stateowner->flags5 & MF5_INSTATECALL)
{ {
statecall->State = jumpto; stateowner->state = jumpto;
} }
else if (self->player != NULL && callingstate == self->player->psprites[ps_weapon].state) else if (self->player != NULL && callingstate == self->player->psprites[ps_weapon].state)
{ {
@ -600,15 +613,14 @@ static void DoJump(AActor *self, FState *callingstate, FState *jumpto, StateCall
self->SetState(jumpto); self->SetState(jumpto);
} }
else else
{ { // something went very wrong. This should never happen.
// something went very wrong. This should never happen.
assert(false); assert(false);
} }
} }
// This is just to avoid having to directly reference the internally defined // This is just to avoid having to directly reference the internally defined
// CallingState and statecall parameters in the code below. // CallingState and statecall parameters in the code below.
#define ACTION_JUMP(offset) DoJump(self, callingstate, offset, statecall) #define ACTION_JUMP(offset) DoJump(self, stateowner, callingstate, offset)
//========================================================================== //==========================================================================
// //
@ -629,7 +641,7 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_Jump)
ACTION_JUMP(jumpto); ACTION_JUMP(jumpto);
} }
ACTION_SET_RESULT(false); // Jumps should never set the result for inventory state chains! ACTION_SET_RESULT(false); // Jumps should never set the result for inventory state chains!
return 0; return numret;
} }
//========================================================================== //==========================================================================
@ -648,7 +660,7 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_JumpIfHealthLower)
ACTION_JUMP(jump); ACTION_JUMP(jump);
} }
ACTION_SET_RESULT(false); // Jumps should never set the result for inventory state chains! ACTION_SET_RESULT(false); // Jumps should never set the result for inventory state chains!
return 0; return numret;
} }
//========================================================================== //==========================================================================
@ -656,7 +668,7 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_JumpIfHealthLower)
// State jump function // State jump function
// //
//========================================================================== //==========================================================================
void DoJumpIfCloser(AActor *target, VM_ARGS) static int DoJumpIfCloser(AActor *target, VM_ARGS)
{ {
PARAM_ACTION_PROLOGUE; PARAM_ACTION_PROLOGUE;
PARAM_FIXED (dist); PARAM_FIXED (dist);
@ -673,6 +685,7 @@ void DoJumpIfCloser(AActor *target, VM_ARGS)
{ {
ACTION_JUMP(jump); ACTION_JUMP(jump);
} }
return numret;
} }
DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_JumpIfCloser) DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_JumpIfCloser)
@ -690,22 +703,19 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_JumpIfCloser)
// Does the player aim at something that can be shot? // Does the player aim at something that can be shot?
P_BulletSlope(self, &target); P_BulletSlope(self, &target);
} }
DoJumpIfCloser(target, VM_ARGS_NAMES); return DoJumpIfCloser(target, VM_ARGS_NAMES);
return 0;
} }
DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_JumpIfTracerCloser) DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_JumpIfTracerCloser)
{ {
PARAM_ACTION_PROLOGUE; PARAM_ACTION_PROLOGUE;
DoJumpIfCloser(self->tracer, VM_ARGS_NAMES); return DoJumpIfCloser(self->tracer, VM_ARGS_NAMES);
return 0;
} }
DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_JumpIfMasterCloser) DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_JumpIfMasterCloser)
{ {
PARAM_ACTION_PROLOGUE; PARAM_ACTION_PROLOGUE;
DoJumpIfCloser(self->master, VM_ARGS_NAMES); return DoJumpIfCloser(self->master, VM_ARGS_NAMES);
return 0;
} }
//========================================================================== //==========================================================================
@ -713,7 +723,7 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_JumpIfMasterCloser)
// State jump function // State jump function
// //
//========================================================================== //==========================================================================
int DoJumpIfInventory(AActor *owner, AActor *self, StateCallData *statecall, FState *callingstate, VMValue *param, int numparam) int DoJumpIfInventory(AActor *owner, AActor *self, AActor *stateowner, FState *callingstate, VMValue *param, int numparam, VMReturn *ret, int numret)
{ {
int paramnum = NAP-1; int paramnum = NAP-1;
PARAM_CLASS (itemtype, AInventory); PARAM_CLASS (itemtype, AInventory);
@ -725,12 +735,12 @@ int DoJumpIfInventory(AActor *owner, AActor *self, StateCallData *statecall, FSt
if (itemtype == NULL) if (itemtype == NULL)
{ {
return 0; return numret;
} }
owner = COPY_AAPTR(owner, setowner); owner = COPY_AAPTR(owner, setowner);
if (owner == NULL) if (owner == NULL)
{ {
return 0; return numret;
} }
AInventory *item = owner->FindInventory(itemtype); AInventory *item = owner->FindInventory(itemtype);
@ -747,19 +757,19 @@ int DoJumpIfInventory(AActor *owner, AActor *self, StateCallData *statecall, FSt
ACTION_JUMP(label); ACTION_JUMP(label);
} }
} }
return 0; return numret;
} }
DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_JumpIfInventory) DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_JumpIfInventory)
{ {
PARAM_ACTION_PROLOGUE; PARAM_ACTION_PROLOGUE;
return DoJumpIfInventory(self, self, statecall, callingstate, param, numparam); return DoJumpIfInventory(self, self, stateowner, callingstate, param, numparam, ret, numret);
} }
DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_JumpIfInTargetInventory) DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_JumpIfInTargetInventory)
{ {
PARAM_ACTION_PROLOGUE; PARAM_ACTION_PROLOGUE;
return DoJumpIfInventory(self->target, self, statecall, callingstate, param, numparam); return DoJumpIfInventory(self->target, self, stateowner, callingstate, param, numparam, ret, numret);
} }
//========================================================================== //==========================================================================
@ -780,7 +790,7 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_JumpIfArmorType)
if (armor && armor->ArmorType == type && armor->Amount >= amount) if (armor && armor->ArmorType == type && armor->Amount >= amount)
ACTION_JUMP(label); ACTION_JUMP(label);
return 0; return numret;
} }
//========================================================================== //==========================================================================
@ -906,7 +916,7 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_CallSpecial)
bool res = !!P_ExecuteSpecial(special, NULL, self, false, arg1, arg2, arg3, arg4, arg5); bool res = !!P_ExecuteSpecial(special, NULL, self, false, arg1, arg2, arg3, arg4, arg5);
ACTION_SET_RESULT(res); ACTION_SET_RESULT(res);
return 0; return numret;
} }
//========================================================================== //==========================================================================
@ -1229,13 +1239,13 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_JumpIfNoAmmo)
ACTION_SET_RESULT(false); // Jumps should never set the result for inventory state chains! ACTION_SET_RESULT(false); // Jumps should never set the result for inventory state chains!
if (!ACTION_CALL_FROM_WEAPON()) if (!ACTION_CALL_FROM_WEAPON())
return 0; return numret;
if (!self->player->ReadyWeapon->CheckAmmo(self->player->ReadyWeapon->bAltFire, false, true)) if (!self->player->ReadyWeapon->CheckAmmo(self->player->ReadyWeapon->bAltFire, false, true))
{ {
ACTION_JUMP(jump); ACTION_JUMP(jump);
} }
return 0; return numret;
} }
@ -1659,7 +1669,7 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_CustomRailgun)
// //
//=========================================================================== //===========================================================================
static int DoGiveInventory(AActor *receiver, StateCallData *statecall, VM_ARGS) static int DoGiveInventory(AActor *receiver, VM_ARGS)
{ {
int paramnum = NAP-1; int paramnum = NAP-1;
PARAM_CLASS (mi, AInventory); PARAM_CLASS (mi, AInventory);
@ -1668,8 +1678,9 @@ static int DoGiveInventory(AActor *receiver, StateCallData *statecall, VM_ARGS)
receiver = COPY_AAPTR(receiver, setreceiver); receiver = COPY_AAPTR(receiver, setreceiver);
if (receiver == NULL) if (receiver == NULL)
{ { // If there's nothing to receive it, it's obviously a fail, right?
return 0; ACTION_SET_RESULT(false);
return numret;
} }
bool res = true; bool res = true;
@ -1706,19 +1717,19 @@ static int DoGiveInventory(AActor *receiver, StateCallData *statecall, VM_ARGS)
res = false; res = false;
} }
ACTION_SET_RESULT(res); ACTION_SET_RESULT(res);
return 0; return numret;
} }
DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_GiveInventory) DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_GiveInventory)
{ {
PARAM_ACTION_PROLOGUE; PARAM_ACTION_PROLOGUE;
return DoGiveInventory(self, statecall, VM_ARGS_NAMES); return DoGiveInventory(self, VM_ARGS_NAMES);
} }
DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_GiveToTarget) DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_GiveToTarget)
{ {
PARAM_ACTION_PROLOGUE; PARAM_ACTION_PROLOGUE;
return DoGiveInventory(self->target, statecall, VM_ARGS_NAMES); return DoGiveInventory(self->target, VM_ARGS_NAMES);
} }
//=========================================================================== //===========================================================================
@ -1732,7 +1743,7 @@ enum
TIF_NOTAKEINFINITE = 1, TIF_NOTAKEINFINITE = 1,
}; };
int DoTakeInventory(AActor *receiver, StateCallData *statecall, VM_ARGS) int DoTakeInventory(AActor *receiver, VM_ARGS)
{ {
int paramnum = NAP-1; int paramnum = NAP-1;
PARAM_CLASS (itemtype, AInventory); PARAM_CLASS (itemtype, AInventory);
@ -1742,12 +1753,14 @@ int DoTakeInventory(AActor *receiver, StateCallData *statecall, VM_ARGS)
if (itemtype == NULL) if (itemtype == NULL)
{ {
return 0; ACTION_SET_RESULT(true);
return numret;
} }
receiver = COPY_AAPTR(receiver, setreceiver); receiver = COPY_AAPTR(receiver, setreceiver);
if (receiver == NULL) if (receiver == NULL)
{ {
return 0; ACTION_SET_RESULT(false);
return numret;
} }
bool res = false; bool res = false;
@ -1779,19 +1792,19 @@ int DoTakeInventory(AActor *receiver, StateCallData *statecall, VM_ARGS)
} }
} }
ACTION_SET_RESULT(res); ACTION_SET_RESULT(res);
return 0; return numret;
} }
DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_TakeInventory) DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_TakeInventory)
{ {
PARAM_ACTION_PROLOGUE; PARAM_ACTION_PROLOGUE;
return DoTakeInventory(self, statecall, VM_ARGS_NAMES); return DoTakeInventory(self, VM_ARGS_NAMES);
} }
DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_TakeFromTarget) DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_TakeFromTarget)
{ {
PARAM_ACTION_PROLOGUE; PARAM_ACTION_PROLOGUE;
return DoTakeInventory(self->target, statecall, VM_ARGS_NAMES); return DoTakeInventory(self->target, VM_ARGS_NAMES);
} }
//=========================================================================== //===========================================================================
@ -1908,12 +1921,15 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_SpawnItem)
if (missile == NULL) if (missile == NULL)
{ {
ACTION_SET_RESULT(false); ACTION_SET_RESULT(false);
return 0; return numret;
} }
ACTION_SET_RESULT(true);
// Don't spawn monsters if this actor has been massacred // Don't spawn monsters if this actor has been massacred
if (self->DamageType == NAME_Massacre && (GetDefaultByType(missile)->flags3 & MF3_ISMONSTER)) if (self->DamageType == NAME_Massacre && (GetDefaultByType(missile)->flags3 & MF3_ISMONSTER))
return 0; {
return numret;
}
if (distance == 0) if (distance == 0)
{ {
@ -1927,9 +1943,9 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_SpawnItem)
AWeapon *weapon = self->player->ReadyWeapon; AWeapon *weapon = self->player->ReadyWeapon;
if (weapon == NULL) if (weapon == NULL)
return 0; return numret;
if (useammo && !weapon->DepleteAmmo(weapon->bAltFire)) if (useammo && !weapon->DepleteAmmo(weapon->bAltFire))
return 0; return numret;
} }
AActor *mo = Spawn(missile, AActor *mo = Spawn(missile,
@ -1940,7 +1956,7 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_SpawnItem)
int flags = (transfer_translation ? SIXF_TRANSFERTRANSLATION : 0) + (useammo ? SIXF_SETMASTER : 0); int flags = (transfer_translation ? SIXF_TRANSFERTRANSLATION : 0) + (useammo ? SIXF_SETMASTER : 0);
bool res = InitSpawnedItem(self, mo, flags); bool res = InitSpawnedItem(self, mo, flags);
ACTION_SET_RESULT(res); // for an inventory item's use state ACTION_SET_RESULT(res); // for an inventory item's use state
return 0; return numret;
} }
//=========================================================================== //===========================================================================
@ -1967,15 +1983,16 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_SpawnItemEx)
if (missile == NULL) if (missile == NULL)
{ {
ACTION_SET_RESULT(false); ACTION_SET_RESULT(false);
return 0; return numret;
} }
ACTION_SET_RESULT(true);
if (chance > 0 && pr_spawnitemex() < chance) if (chance > 0 && pr_spawnitemex() < chance)
return 0; return numret;
// Don't spawn monsters if this actor has been massacred // Don't spawn monsters if this actor has been massacred
if (self->DamageType == NAME_Massacre && (GetDefaultByType(missile)->flags3 & MF3_ISMONSTER)) if (self->DamageType == NAME_Massacre && (GetDefaultByType(missile)->flags3 & MF3_ISMONSTER))
return 0; return numret;
fixed_t x, y; fixed_t x, y;
@ -2019,7 +2036,7 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_SpawnItemEx)
if (flags & SIXF_TRANSFERAMBUSHFLAG) if (flags & SIXF_TRANSFERAMBUSHFLAG)
mo->flags = (mo->flags & ~MF_AMBUSH) | (self->flags & MF_AMBUSH); mo->flags = (mo->flags & ~MF_AMBUSH) | (self->flags & MF_AMBUSH);
} }
return 0; return numret;
} }
//=========================================================================== //===========================================================================
@ -2038,8 +2055,9 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_ThrowGrenade)
PARAM_FIXED_OPT (zvel) { zvel = 0; } PARAM_FIXED_OPT (zvel) { zvel = 0; }
PARAM_BOOL_OPT (useammo) { useammo = true; } PARAM_BOOL_OPT (useammo) { useammo = true; }
ACTION_SET_RESULT(true);
if (missile == NULL) if (missile == NULL)
return 0; return numret;
if (ACTION_CALL_FROM_WEAPON()) if (ACTION_CALL_FROM_WEAPON())
{ {
@ -2047,9 +2065,9 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_ThrowGrenade)
AWeapon *weapon = self->player->ReadyWeapon; AWeapon *weapon = self->player->ReadyWeapon;
if (weapon == NULL) if (weapon == NULL)
return 0; return numret;
if (useammo && !weapon->DepleteAmmo(weapon->bAltFire)) if (useammo && !weapon->DepleteAmmo(weapon->bAltFire))
return 0; return numret;
} }
AActor *bo; AActor *bo;
@ -2093,7 +2111,7 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_ThrowGrenade)
{ {
ACTION_SET_RESULT(false); ACTION_SET_RESULT(false);
} }
return 0; return numret;
} }
@ -2128,7 +2146,7 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_SelectWeapon)
if (cls == NULL || self->player == NULL) if (cls == NULL || self->player == NULL)
{ {
ACTION_SET_RESULT(false); ACTION_SET_RESULT(false);
return 0; return numret;
} }
AWeapon *weaponitem = static_cast<AWeapon*>(self->FindInventory(cls)); AWeapon *weaponitem = static_cast<AWeapon*>(self->FindInventory(cls));
@ -2139,12 +2157,13 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_SelectWeapon)
{ {
self->player->PendingWeapon = weaponitem; self->player->PendingWeapon = weaponitem;
} }
ACTION_SET_RESULT(true);
} }
else else
{ {
ACTION_SET_RESULT(false); ACTION_SET_RESULT(false);
} }
return 0; return numret;
} }
@ -2181,7 +2200,7 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_Print)
con_midtime = saved; con_midtime = saved;
} }
ACTION_SET_RESULT(false); // Prints should never set the result for inventory state chains! ACTION_SET_RESULT(false); // Prints should never set the result for inventory state chains!
return 0; return numret;
} }
//=========================================================================== //===========================================================================
@ -2212,7 +2231,7 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_PrintBold)
C_MidPrintBold(font != NULL ? font : SmallFont, formatted.GetChars()); C_MidPrintBold(font != NULL ? font : SmallFont, formatted.GetChars());
con_midtime = saved; con_midtime = saved;
ACTION_SET_RESULT(false); // Prints should never set the result for inventory state chains! ACTION_SET_RESULT(false); // Prints should never set the result for inventory state chains!
return 0; return numret;
} }
//=========================================================================== //===========================================================================
@ -2227,7 +2246,7 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_Log)
PARAM_STRING(text); PARAM_STRING(text);
Printf("%s\n", text); Printf("%s\n", text);
ACTION_SET_RESULT(false); // Prints should never set the result for inventory state chains! ACTION_SET_RESULT(false); // Prints should never set the result for inventory state chains!
return 0; return numret;
} }
//=========================================================================== //===========================================================================
@ -2242,7 +2261,7 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_LogInt)
PARAM_INT(num); PARAM_INT(num);
Printf("%d\n", num); Printf("%d\n", num);
ACTION_SET_RESULT(false); // Prints should never set the result for inventory state chains! ACTION_SET_RESULT(false); // Prints should never set the result for inventory state chains!
return 0; return numret;
} }
//=========================================================================== //===========================================================================
@ -2453,19 +2472,19 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_CheckSight)
// Always check sight from each player. // Always check sight from each player.
if (P_CheckSight(players[i].mo, self, SF_IGNOREVISIBILITY)) if (P_CheckSight(players[i].mo, self, SF_IGNOREVISIBILITY))
{ {
return 0; return numret;
} }
// If a player is viewing from a non-player, then check that too. // If a player is viewing from a non-player, then check that too.
if (players[i].camera != NULL && players[i].camera->player == NULL && if (players[i].camera != NULL && players[i].camera->player == NULL &&
P_CheckSight(players[i].camera, self, SF_IGNOREVISIBILITY)) P_CheckSight(players[i].camera, self, SF_IGNOREVISIBILITY))
{ {
return 0; return numret;
} }
} }
} }
ACTION_JUMP(jump); ACTION_JUMP(jump);
return 0; return numret;
} }
//=========================================================================== //===========================================================================
@ -2527,18 +2546,18 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_CheckSightOrRange)
// Always check from each player. // Always check from each player.
if (DoCheckSightOrRange(self, players[i].mo, range)) if (DoCheckSightOrRange(self, players[i].mo, range))
{ {
return 0; return numret;
} }
// If a player is viewing from a non-player, check that too. // If a player is viewing from a non-player, check that too.
if (players[i].camera != NULL && players[i].camera->player == NULL && if (players[i].camera != NULL && players[i].camera->player == NULL &&
DoCheckSightOrRange(self, players[i].camera, range)) DoCheckSightOrRange(self, players[i].camera, range))
{ {
return 0; return numret;
} }
} }
} }
ACTION_JUMP(jump); ACTION_JUMP(jump);
return 0; return numret;
} }
@ -2605,7 +2624,7 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_JumpIf)
ACTION_SET_RESULT(false); // Jumps should never set the result for inventory state chains! ACTION_SET_RESULT(false); // Jumps should never set the result for inventory state chains!
if (condition) if (condition)
ACTION_JUMP(jump); ACTION_JUMP(jump);
return 0; return numret;
} }
//=========================================================================== //===========================================================================
@ -2781,7 +2800,7 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_CheckFloor)
{ {
ACTION_JUMP(jump); ACTION_JUMP(jump);
} }
return 0; return numret;
} }
//=========================================================================== //===========================================================================
@ -2801,7 +2820,7 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_CheckCeiling)
{ {
ACTION_JUMP(jump); ACTION_JUMP(jump);
} }
return 0; return numret;
} }
//=========================================================================== //===========================================================================
@ -2945,7 +2964,7 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_PlayerSkinCheck)
{ {
ACTION_JUMP(jump); ACTION_JUMP(jump);
} }
return 0; return numret;
} }
//=========================================================================== //===========================================================================
@ -3045,11 +3064,11 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_JumpIfTargetInLOS)
} }
if (target == NULL) if (target == NULL)
return 0; // [KS] Let's not call P_CheckSight unnecessarily in this case. return numret; // [KS] Let's not call P_CheckSight unnecessarily in this case.
if ((flags & JLOSF_DEADNOJUMP) && (target->health <= 0)) if ((flags & JLOSF_DEADNOJUMP) && (target->health <= 0))
{ {
return 0; return numret;
} }
doCheckSight = !(flags & JLOSF_NOSIGHT); doCheckSight = !(flags & JLOSF_NOSIGHT);
@ -3059,7 +3078,7 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_JumpIfTargetInLOS)
// Does the player aim at something that can be shot? // Does the player aim at something that can be shot?
P_BulletSlope(self, &target); P_BulletSlope(self, &target);
if (!target) return 0; if (!target) return numret;
switch (flags & (JLOSF_TARGETLOS|JLOSF_FLIPFOV)) switch (flags & (JLOSF_TARGETLOS|JLOSF_FLIPFOV))
{ {
@ -3082,22 +3101,22 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_JumpIfTargetInLOS)
// [FDARI] If target is not a combatant, don't jump // [FDARI] If target is not a combatant, don't jump
if ( (flags & JLOSF_COMBATANTONLY) && (!target->player) && !(target->flags3 & MF3_ISMONSTER)) if ( (flags & JLOSF_COMBATANTONLY) && (!target->player) && !(target->flags3 & MF3_ISMONSTER))
return 0; return numret;
// [FDARI] If actors share team, don't jump // [FDARI] If actors share team, don't jump
if ((flags & JLOSF_ALLYNOJUMP) && self->IsFriend(target)) if ((flags & JLOSF_ALLYNOJUMP) && self->IsFriend(target))
return 0; return numret;
fixed_t distance = P_AproxDistance(target->x - self->x, target->y - self->y); fixed_t distance = P_AproxDistance(target->x - self->x, target->y - self->y);
distance = P_AproxDistance(distance, target->z - self->z); distance = P_AproxDistance(distance, target->z - self->z);
if (dist_max && (distance > dist_max)) if (dist_max && (distance > dist_max))
return 0; return numret;
if (dist_close && (distance < dist_close)) if (dist_close && (distance < dist_close))
{ {
if (flags & JLOSF_CLOSENOJUMP) if (flags & JLOSF_CLOSENOJUMP)
return 0; return numret;
if (flags & JLOSF_CLOSENOFOV) if (flags & JLOSF_CLOSENOFOV)
fov = 0; fov = 0;
@ -3110,7 +3129,7 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_JumpIfTargetInLOS)
else { viewport = self; } else { viewport = self; }
if (doCheckSight && !P_CheckSight (viewport, target, SF_IGNOREVISIBILITY)) if (doCheckSight && !P_CheckSight (viewport, target, SF_IGNOREVISIBILITY))
return 0; return numret;
if (flags & JLOSF_FLIPFOV) if (flags & JLOSF_FLIPFOV)
{ {
@ -3128,13 +3147,13 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_JumpIfTargetInLOS)
if (an > (fov / 2) && an < (ANGLE_MAX - (fov / 2))) if (an > (fov / 2) && an < (ANGLE_MAX - (fov / 2)))
{ {
return 0; // [KS] Outside of FOV - return return numret; // [KS] Outside of FOV - return
} }
} }
ACTION_JUMP(jump); ACTION_JUMP(jump);
return 0; return numret;
} }
@ -3177,12 +3196,12 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_JumpIfInTargetLOS)
if (target == NULL) if (target == NULL)
{ // [KS] Let's not call P_CheckSight unnecessarily in this case. { // [KS] Let's not call P_CheckSight unnecessarily in this case.
return 0; return numret;
} }
if ((flags & JLOSF_DEADNOJUMP) && (target->health <= 0)) if ((flags & JLOSF_DEADNOJUMP) && (target->health <= 0))
{ {
return 0; return numret;
} }
fixed_t distance = P_AproxDistance(target->x - self->x, target->y - self->y); fixed_t distance = P_AproxDistance(target->x - self->x, target->y - self->y);
@ -3190,7 +3209,7 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_JumpIfInTargetLOS)
if (dist_max && (distance > dist_max)) if (dist_max && (distance > dist_max))
{ {
return 0; return numret;
} }
bool doCheckSight = !(flags & JLOSF_NOSIGHT); bool doCheckSight = !(flags & JLOSF_NOSIGHT);
@ -3198,7 +3217,7 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_JumpIfInTargetLOS)
if (dist_close && (distance < dist_close)) if (dist_close && (distance < dist_close))
{ {
if (flags & JLOSF_CLOSENOJUMP) if (flags & JLOSF_CLOSENOJUMP)
return 0; return numret;
if (flags & JLOSF_CLOSENOFOV) if (flags & JLOSF_CLOSENOFOV)
fov = 0; fov = 0;
@ -3217,14 +3236,14 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_JumpIfInTargetLOS)
if (an > (fov / 2) && an < (ANGLE_MAX - (fov / 2))) if (an > (fov / 2) && an < (ANGLE_MAX - (fov / 2)))
{ {
return 0; // [KS] Outside of FOV - return return numret; // [KS] Outside of FOV - return
} }
} }
if (doCheckSight && !P_CheckSight (target, self, SF_IGNOREVISIBILITY)) if (doCheckSight && !P_CheckSight (target, self, SF_IGNOREVISIBILITY))
return 0; return numret;
ACTION_JUMP(jump); ACTION_JUMP(jump);
return 0; return numret;
} }
@ -3510,7 +3529,7 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_CheckFlag)
AActor *owner = COPY_AAPTR(self, checkpointer); AActor *owner = COPY_AAPTR(self, checkpointer);
if (owner == NULL) if (owner == NULL)
{ {
return 0; return numret;
} }
long dot = flagname.IndexOf('.'); long dot = flagname.IndexOf('.');
@ -3545,7 +3564,7 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_CheckFlag)
{ {
Printf("Unknown flag '%s' in '%s'\n", flagname, cls->TypeName.GetChars()); Printf("Unknown flag '%s' in '%s'\n", flagname, cls->TypeName.GetChars());
} }
return 0; return numret;
} }
@ -3686,7 +3705,7 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_MonsterRefire)
A_FaceTarget(self); A_FaceTarget(self);
if (pr_monsterrefire() < prob) if (pr_monsterrefire() < prob)
return 0; return numret;
if (self->target == NULL if (self->target == NULL
|| P_HitFriend (self) || P_HitFriend (self)
@ -3695,7 +3714,7 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_MonsterRefire)
{ {
ACTION_JUMP(jump); ACTION_JUMP(jump);
} }
return 0; return numret;
} }
//=========================================================================== //===========================================================================
@ -3956,6 +3975,8 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_Teleport)
PARAM_FIXED_OPT (mindist) { mindist = 128 << FRACBITS; } PARAM_FIXED_OPT (mindist) { mindist = 128 << FRACBITS; }
PARAM_FIXED_OPT (maxdist) { maxdist = 128 << FRACBITS; } PARAM_FIXED_OPT (maxdist) { maxdist = 128 << FRACBITS; }
ACTION_SET_RESULT(true);
// Randomly choose not to teleport like A_Srcr2Decide. // Randomly choose not to teleport like A_Srcr2Decide.
if (flags & TF_RANDOMDECIDE) if (flags & TF_RANDOMDECIDE)
{ {
@ -3973,7 +3994,7 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_Teleport)
if (pr_teleport() >= chance[chanceindex]) if (pr_teleport() >= chance[chanceindex])
{ {
return 0; return numret;
} }
} }
@ -3984,14 +4005,14 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_Teleport)
// If still nothing, then return. // If still nothing, then return.
if (teleport_state == NULL) if (teleport_state == NULL)
{ {
return 0; return numret;
} }
} }
DSpotState *state = DSpotState::GetSpotState(); DSpotState *state = DSpotState::GetSpotState();
if (state == NULL) if (state == NULL)
{ {
return 0; return numret;
} }
if (target_type == NULL) if (target_type == NULL)
@ -4002,7 +4023,7 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_Teleport)
AActor *spot = state->GetSpotWithMinMaxDistance(target_type, self->x, self->y, mindist, maxdist); AActor *spot = state->GetSpotWithMinMaxDistance(target_type, self->x, self->y, mindist, maxdist);
if (spot == NULL) if (spot == NULL)
{ {
return 0; return numret;
} }
fixed_t prevX = self->x; fixed_t prevX = self->x;
@ -4023,7 +4044,7 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_Teleport)
self->angle = spot->angle; self->angle = spot->angle;
self->velx = self->vely = self->velz = 0; self->velx = self->vely = self->velz = 0;
} }
return 0; return numret;
} }
//=========================================================================== //===========================================================================
@ -4153,7 +4174,7 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_LineEffect)
} }
} }
ACTION_SET_RESULT(res); ACTION_SET_RESULT(res);
return 0; return numret;
} }
//========================================================================== //==========================================================================
@ -4320,7 +4341,7 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_Warp)
if (!reference) if (!reference)
{ {
ACTION_SET_RESULT(false); ACTION_SET_RESULT(false);
return 0; return numret;
} }
if (!(flags & WARPF_ABSOLUTEANGLE)) if (!(flags & WARPF_ABSOLUTEANGLE))
@ -4424,7 +4445,7 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_Warp)
ACTION_SET_RESULT(false); // Jumps should never set the result for inventory state chains! ACTION_SET_RESULT(false); // Jumps should never set the result for inventory state chains!
// in this case, you have the statejump to help you handle all the success anyway. // in this case, you have the statejump to help you handle all the success anyway.
ACTION_JUMP(success_state); ACTION_JUMP(success_state);
return 0; return numret;
} }
ACTION_SET_RESULT(true); ACTION_SET_RESULT(true);
@ -4434,7 +4455,7 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_Warp)
self->SetOrigin(oldx, oldy, oldz); self->SetOrigin(oldx, oldy, oldz);
ACTION_SET_RESULT(false); ACTION_SET_RESULT(false);
} }
return 0; return numret;
} }
//========================================================================== //==========================================================================
@ -4458,10 +4479,9 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, ACS_NamedExecuteWithResult)
PARAM_INT_OPT (arg3) { arg3 = 0; } PARAM_INT_OPT (arg3) { arg3 = 0; }
PARAM_INT_OPT (arg4) { arg4 = 0; } PARAM_INT_OPT (arg4) { arg4 = 0; }
bool res = !!P_ExecuteSpecial(ACS_ExecuteWithResult, NULL, self, false, -scriptname, arg1, arg2, arg3, arg4); int res = P_ExecuteSpecial(ACS_ExecuteWithResult, NULL, self, false, -scriptname, arg1, arg2, arg3, arg4);
ACTION_SET_RESULT(res); ACTION_SET_RESULT(res);
return 0; return numret;
} }
DEFINE_ACTION_FUNCTION_PARAMS(AActor, ACS_NamedExecute) DEFINE_ACTION_FUNCTION_PARAMS(AActor, ACS_NamedExecute)
@ -4473,10 +4493,9 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, ACS_NamedExecute)
PARAM_INT_OPT (arg2) { arg2 = 0; } PARAM_INT_OPT (arg2) { arg2 = 0; }
PARAM_INT_OPT (arg3) { arg3 = 0; } PARAM_INT_OPT (arg3) { arg3 = 0; }
bool res = !!P_ExecuteSpecial(ACS_Execute, NULL, self, false, -scriptname, mapnum, arg1, arg2, arg3); int res = P_ExecuteSpecial(ACS_Execute, NULL, self, false, -scriptname, mapnum, arg1, arg2, arg3);
ACTION_SET_RESULT(res); ACTION_SET_RESULT(res);
return 0; return numret;
} }
DEFINE_ACTION_FUNCTION_PARAMS(AActor, ACS_NamedExecuteAlways) DEFINE_ACTION_FUNCTION_PARAMS(AActor, ACS_NamedExecuteAlways)
@ -4488,10 +4507,9 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, ACS_NamedExecuteAlways)
PARAM_INT_OPT (arg2) { arg2 = 0; } PARAM_INT_OPT (arg2) { arg2 = 0; }
PARAM_INT_OPT (arg3) { arg3 = 0; } PARAM_INT_OPT (arg3) { arg3 = 0; }
bool res = !!P_ExecuteSpecial(ACS_ExecuteAlways, NULL, self, false, -scriptname, mapnum, arg1, arg2, arg3); int res = P_ExecuteSpecial(ACS_ExecuteAlways, NULL, self, false, -scriptname, mapnum, arg1, arg2, arg3);
ACTION_SET_RESULT(res); ACTION_SET_RESULT(res);
return 0; return numret;
} }
DEFINE_ACTION_FUNCTION_PARAMS(AActor, ACS_NamedLockedExecute) DEFINE_ACTION_FUNCTION_PARAMS(AActor, ACS_NamedLockedExecute)
@ -4503,10 +4521,9 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, ACS_NamedLockedExecute)
PARAM_INT_OPT (arg2) { arg2 = 0; } PARAM_INT_OPT (arg2) { arg2 = 0; }
PARAM_INT_OPT (lock) { lock = 0; } PARAM_INT_OPT (lock) { lock = 0; }
bool res = !!P_ExecuteSpecial(ACS_LockedExecute, NULL, self, false, -scriptname, mapnum, arg1, arg2, lock); int res = P_ExecuteSpecial(ACS_LockedExecute, NULL, self, false, -scriptname, mapnum, arg1, arg2, lock);
ACTION_SET_RESULT(res); ACTION_SET_RESULT(res);
return 0; return numret;
} }
DEFINE_ACTION_FUNCTION_PARAMS(AActor, ACS_NamedLockedExecuteDoor) DEFINE_ACTION_FUNCTION_PARAMS(AActor, ACS_NamedLockedExecuteDoor)
@ -4518,10 +4535,9 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, ACS_NamedLockedExecuteDoor)
PARAM_INT_OPT (arg2) { arg2 = 0; } PARAM_INT_OPT (arg2) { arg2 = 0; }
PARAM_INT_OPT (lock) { lock = 0; } PARAM_INT_OPT (lock) { lock = 0; }
bool res = !!P_ExecuteSpecial(ACS_LockedExecuteDoor, NULL, self, false, -scriptname, mapnum, arg1, arg2, lock); int res = P_ExecuteSpecial(ACS_LockedExecuteDoor, NULL, self, false, -scriptname, mapnum, arg1, arg2, lock);
ACTION_SET_RESULT(res); ACTION_SET_RESULT(res);
return 0; return numret;
} }
DEFINE_ACTION_FUNCTION_PARAMS(AActor, ACS_NamedSuspend) DEFINE_ACTION_FUNCTION_PARAMS(AActor, ACS_NamedSuspend)
@ -4530,10 +4546,9 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, ACS_NamedSuspend)
PARAM_NAME (scriptname); PARAM_NAME (scriptname);
PARAM_INT_OPT (mapnum) { mapnum = 0; } PARAM_INT_OPT (mapnum) { mapnum = 0; }
bool res = !!P_ExecuteSpecial(ACS_Suspend, NULL, self, false, -scriptname, mapnum, 0, 0, 0); int res = P_ExecuteSpecial(ACS_Suspend, NULL, self, false, -scriptname, mapnum, 0, 0, 0);
ACTION_SET_RESULT(res); ACTION_SET_RESULT(res);
return 0; return numret;
} }
DEFINE_ACTION_FUNCTION_PARAMS(AActor, ACS_NamedTerminate) DEFINE_ACTION_FUNCTION_PARAMS(AActor, ACS_NamedTerminate)
@ -4542,10 +4557,9 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, ACS_NamedTerminate)
PARAM_NAME (scriptname); PARAM_NAME (scriptname);
PARAM_INT_OPT (mapnum) { mapnum = 0; } PARAM_INT_OPT (mapnum) { mapnum = 0; }
bool res = !!P_ExecuteSpecial(ACS_Terminate, NULL, self, false, -scriptname, mapnum, 0, 0, 0); int res = P_ExecuteSpecial(ACS_Terminate, NULL, self, false, -scriptname, mapnum, 0, 0, 0);
ACTION_SET_RESULT(res); ACTION_SET_RESULT(res);
return 0; return numret;
} }

4
src/zscript/vmdisasm.cpp
View file

@ -223,7 +223,7 @@ void VMDisasm(FILE *out, const VMOP *code, int codesize, const VMScriptFunction
col = printf_wrapper(out, "%.23s,%d", callname, code[i].b); col = printf_wrapper(out, "%.23s,%d", callname, code[i].b);
if (code[i].op == OP_CALL_K) if (code[i].op == OP_CALL_K)
{ {
printf_wrapper(out, ",%d", code[i].c); col += printf_wrapper(out, ",%d", code[i].c);
} }
break; break;
@ -328,7 +328,7 @@ void VMDisasm(FILE *out, const VMOP *code, int codesize, const VMScriptFunction
printf_wrapper(out, "%d,%d,%d", code[i].a, code[i].b, code[i].c); printf_wrapper(out, "%d,%d,%d", code[i].a, code[i].b, code[i].c);
if (code[i].op == OP_CALL_K || code[i].op == OP_TAIL_K) if (code[i].op == OP_CALL_K || code[i].op == OP_TAIL_K)
{ {
printf_wrapper(out, " [%p]\n", callfunc); printf_wrapper(out, " [%p]\n", callfunc);
} }
else else
{ {