zdoom/gzdoom-gles
0
0
Fork 0
mirror of https://github.com/ZDoom/gzdoom-gles.git synced 2024-11-28 06:53:40 +00:00
Code Issues Projects Releases Packages Wiki Activity

- removed the default parameter handling from all native script functions because it is no longer needed.

Browse source
This commit is contained in:
Christoph Oelckers 2018-11-17 10:03:40 +01:00
parent e643582957
commit 94ed30e782
45 changed files with 736 additions and 769 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
src/c_console.cpp
View file

@ -1294,7 +1294,7 @@ DEFINE_ACTION_FUNCTION(_Console, HideConsole)
DEFINE_ACTION_FUNCTION(_Console, Printf)
{
PARAM_PROLOGUE;
FString s = FStringFormat(param, defaultparam, numparam, ret, numret);
FString s = FStringFormat(param, numparam, ret, numret);
Printf("%s\n", s.GetChars());
return 0;
}
@ -1788,7 +1788,7 @@ DEFINE_ACTION_FUNCTION(_Console, MidPrint)
PARAM_PROLOGUE;
PARAM_POINTER_NOT_NULL(fnt, FFont);
PARAM_STRING(text);
PARAM_BOOL_DEF(bold);
PARAM_BOOL(bold);
const char *txt = text[0] == '$'? GStrings(&text[1]) : text.GetChars();
if (!bold) C_MidPrint(fnt, txt);

2
src/c_cvars.cpp
View file

@ -1589,7 +1589,7 @@ DEFINE_ACTION_FUNCTION(_CVar, GetCVar)
{
PARAM_PROLOGUE;
PARAM_NAME(name);
PARAM_POINTER_DEF(plyr, player_t);
PARAM_POINTER(plyr, player_t);
ACTION_RETURN_POINTER(GetCVar(plyr ? plyr->mo : nullptr, name));
}

2
src/dsectoreffect.cpp
View file

@ -287,7 +287,7 @@ DEFINE_ACTION_FUNCTION(_Sector, MoveFloor)
PARAM_INT(crush);
PARAM_INT(dir);
PARAM_BOOL(hex);
PARAM_BOOL_DEF(inst);
PARAM_BOOL(inst);
ACTION_RETURN_INT((int)self->MoveFloor(speed, dest, crush, dir, hex, inst));
}

4
src/dthinker.cpp
View file

@ -979,8 +979,8 @@ IMPLEMENT_CLASS(DThinkerIterator, true, false);
DEFINE_ACTION_FUNCTION(DThinkerIterator, Create)
{
PARAM_PROLOGUE;
PARAM_CLASS_DEF(type, DThinker);
PARAM_INT_DEF(statnum);
PARAM_CLASS(type, DThinker);
PARAM_INT(statnum);
ACTION_RETURN_OBJECT(Create<DThinkerIterator>(type, statnum));
}

6
src/events.cpp
View file

@ -636,9 +636,9 @@ DEFINE_ACTION_FUNCTION(DEventHandler, SendNetworkEvent)
{
PARAM_PROLOGUE;
PARAM_STRING(name);
PARAM_INT_DEF(arg1);
PARAM_INT_DEF(arg2);
PARAM_INT_DEF(arg3);
PARAM_INT(arg1);
PARAM_INT(arg2);
PARAM_INT(arg3);
//
ACTION_RETURN_BOOL(E_SendNetworkEvent(name, arg1, arg2, arg3, false));

4
src/g_game.cpp
View file

@ -1656,7 +1656,7 @@ DEFINE_ACTION_FUNCTION(DObject, G_PickPlayerStart)
{
PARAM_PROLOGUE;
PARAM_INT(playernum);
PARAM_INT_DEF(flags);
PARAM_INT(flags);
auto ps = G_PickPlayerStart(playernum, flags);
if (numret > 1)
{
@ -2976,7 +2976,7 @@ void G_StartSlideshow(FName whichone)
DEFINE_ACTION_FUNCTION(FLevelLocals, StartSlideshow)
{
PARAM_PROLOGUE;
PARAM_NAME_DEF(whichone);
PARAM_NAME(whichone);
G_StartSlideshow(whichone);
return 0;
}

2
src/g_inventory/a_keys.cpp
View file

@ -522,7 +522,7 @@ DEFINE_ACTION_FUNCTION(AActor, CheckKeys)
PARAM_SELF_PROLOGUE(AActor);
PARAM_INT(locknum);
PARAM_BOOL(remote);
PARAM_BOOL_DEF(quiet);
PARAM_BOOL(quiet);
ACTION_RETURN_BOOL(P_CheckKeys(self, locknum, remote, quiet));
}

8
src/g_inventory/a_weapons.cpp
View file

@ -298,8 +298,8 @@ DEFINE_ACTION_FUNCTION(AWeapon, CheckAmmo)
PARAM_SELF_PROLOGUE(AWeapon);
PARAM_INT(mode);
PARAM_BOOL(autoswitch);
PARAM_BOOL_DEF(require);
PARAM_INT_DEF(ammocnt);
PARAM_BOOL(require);
PARAM_INT(ammocnt);
ACTION_RETURN_BOOL(self->DoCheckAmmo(mode, autoswitch, require, ammocnt));
}
@ -376,8 +376,8 @@ DEFINE_ACTION_FUNCTION(AWeapon, DepleteAmmo)
{
PARAM_SELF_PROLOGUE(AWeapon);
PARAM_BOOL(altfire);
PARAM_BOOL_DEF(checkenough);
PARAM_INT_DEF(ammouse);
PARAM_BOOL(checkenough);
PARAM_INT(ammouse);
ACTION_RETURN_BOOL(self->DoDepleteAmmo(altfire, checkenough, ammouse));
}

12
src/g_level.cpp
View file

@ -2097,9 +2097,9 @@ DEFINE_ACTION_FUNCTION(FLevelLocals, SphericalCoords)
PARAM_FLOAT(targetX);
PARAM_FLOAT(targetY);
PARAM_FLOAT(targetZ);
PARAM_ANGLE_DEF(viewYaw);
PARAM_ANGLE_DEF(viewPitch);
PARAM_BOOL_DEF(absolute);
PARAM_ANGLE(viewYaw);
PARAM_ANGLE(viewPitch);
PARAM_BOOL(absolute);
DVector3 viewpoint(viewpointX, viewpointY, viewpointZ);
DVector3 target(targetX, targetY, targetZ);
@ -2119,7 +2119,7 @@ DEFINE_ACTION_FUNCTION(FLevelLocals, Vec2Offset)
PARAM_FLOAT(y);
PARAM_FLOAT(dx);
PARAM_FLOAT(dy);
PARAM_BOOL_DEF(absolute);
PARAM_BOOL(absolute);
if (absolute)
{
ACTION_RETURN_VEC2(DVector2(x + dx, y + dy));
@ -2139,7 +2139,7 @@ DEFINE_ACTION_FUNCTION(FLevelLocals, Vec2OffsetZ)
PARAM_FLOAT(dx);
PARAM_FLOAT(dy);
PARAM_FLOAT(atz);
PARAM_BOOL_DEF(absolute);
PARAM_BOOL(absolute);
if (absolute)
{
ACTION_RETURN_VEC3(DVector3(x + dx, y + dy, atz));
@ -2160,7 +2160,7 @@ DEFINE_ACTION_FUNCTION(FLevelLocals, Vec3Offset)
PARAM_FLOAT(dx);
PARAM_FLOAT(dy);
PARAM_FLOAT(dz);
PARAM_BOOL_DEF(absolute);
PARAM_BOOL(absolute);
if (absolute)
{
ACTION_RETURN_VEC3(DVector3(x + dx, y + dy, z + dz));

2
src/g_shared/a_action.cpp
View file

@ -84,7 +84,7 @@ void A_Unblock(AActor *self, bool drop)
DEFINE_ACTION_FUNCTION(AActor, A_NoBlocking)
{
PARAM_SELF_PROLOGUE(AActor);
PARAM_BOOL_DEF(drop);
PARAM_BOOL(drop);
A_Unblock(self, drop);
return 0;
}

20
src/g_shared/a_morph.cpp
View file

@ -180,8 +180,8 @@ DEFINE_ACTION_FUNCTION(_PlayerInfo, MorphPlayer)
PARAM_CLASS(spawntype, APlayerPawn);
PARAM_INT(duration);
PARAM_INT(style);
PARAM_CLASS_DEF(enter_flash, AActor);
PARAM_CLASS_DEF(exit_flash, AActor);
PARAM_CLASS(enter_flash, AActor);
PARAM_CLASS(exit_flash, AActor);
ACTION_RETURN_BOOL(P_MorphPlayer(activator, self, spawntype, duration, style, enter_flash, exit_flash));
}
@ -396,8 +396,8 @@ DEFINE_ACTION_FUNCTION(_PlayerInfo, UndoPlayerMorph)
{
PARAM_SELF_STRUCT_PROLOGUE(player_t);
PARAM_POINTER_NOT_NULL(player, player_t);
PARAM_INT_DEF(unmorphflag);
PARAM_BOOL_DEF(force);
PARAM_INT(unmorphflag);
PARAM_BOOL(force);
ACTION_RETURN_BOOL(P_UndoPlayerMorph(self, player, unmorphflag, force));
}
@ -466,8 +466,8 @@ DEFINE_ACTION_FUNCTION(AActor, MorphMonster)
PARAM_CLASS(spawntype, AActor);
PARAM_INT(duration);
PARAM_INT(style);
PARAM_CLASS_DEF(enter_flash, AActor);
PARAM_CLASS_DEF(exit_flash, AActor);
PARAM_CLASS(enter_flash, AActor);
PARAM_CLASS(exit_flash, AActor);
ACTION_RETURN_BOOL(P_MorphMonster(self, spawntype, duration, style, enter_flash, exit_flash));
}
@ -725,10 +725,10 @@ DEFINE_ACTION_FUNCTION(AActor, A_Morph)
{
PARAM_SELF_PROLOGUE(AActor);
PARAM_CLASS(type, AActor);
PARAM_INT_DEF(duration);
PARAM_INT_DEF(flags);
PARAM_CLASS_DEF(enter_flash, AActor);
PARAM_CLASS_DEF(exit_flash, AActor);
PARAM_INT(duration);
PARAM_INT(flags);
PARAM_CLASS(enter_flash, AActor);
PARAM_CLASS(exit_flash, AActor);
bool res = false;
if (self->player)
{

6
src/g_shared/a_specialspot.cpp
View file

@ -404,9 +404,9 @@ DEFINE_ACTION_FUNCTION(ASpecialSpot, A_SpawnSingleItem)
{
PARAM_SELF_PROLOGUE(ASpecialSpot);
PARAM_CLASS_NOT_NULL(cls, AActor);
PARAM_INT_DEF (fail_sp)
PARAM_INT_DEF (fail_co)
PARAM_INT_DEF (fail_dm)
PARAM_INT (fail_sp)
PARAM_INT (fail_co)
PARAM_INT (fail_dm)
AActor *spot = NULL;
DSpotState *state = DSpotState::GetSpotState();

90
src/g_statusbar/shared_sbar.cpp
View file

@ -417,8 +417,8 @@ DEFINE_ACTION_FUNCTION(DBaseStatusBar, SetSize)
PARAM_INT(rt);
PARAM_INT(vw);
PARAM_INT(vh);
PARAM_INT_DEF(hvw);
PARAM_INT_DEF(hvh);
PARAM_INT(hvw);
PARAM_INT(hvh);
self->SetSize(rt, vw, vh, hvw, hvh);
return 0;
}
@ -555,10 +555,10 @@ void DBaseStatusBar::BeginStatusBar(int resW, int resH, int relTop, bool forceSc
DEFINE_ACTION_FUNCTION(DBaseStatusBar, BeginStatusBar)
{
PARAM_SELF_PROLOGUE(DBaseStatusBar);
PARAM_BOOL_DEF(fs);
PARAM_INT_DEF(w);
PARAM_INT_DEF(h);
PARAM_INT_DEF(r);
PARAM_BOOL(fs);
PARAM_INT(w);
PARAM_INT(h);
PARAM_INT(r);
self->BeginStatusBar(w, h, r, fs);
return 0;
}
@ -580,10 +580,10 @@ void DBaseStatusBar::BeginHUD(int resW, int resH, double Alpha, bool forcescaled
DEFINE_ACTION_FUNCTION(DBaseStatusBar, BeginHUD)
{
PARAM_SELF_PROLOGUE(DBaseStatusBar);
PARAM_FLOAT_DEF(a);
PARAM_BOOL_DEF(fs);
PARAM_INT_DEF(w);
PARAM_INT_DEF(h);
PARAM_FLOAT(a);
PARAM_BOOL(fs);
PARAM_INT(w);
PARAM_INT(h);
self->BeginHUD(w, h, a, fs);
return 0;
}
@ -736,8 +736,8 @@ DEFINE_ACTION_FUNCTION(DBaseStatusBar, AttachMessage)
{
PARAM_SELF_PROLOGUE(DBaseStatusBar);
PARAM_OBJECT(msg, DHUDMessageBase);
PARAM_UINT_DEF(id);
PARAM_INT_DEF(layer);
PARAM_UINT(id);
PARAM_INT(layer);
self->AttachMessage(msg, id, layer);
return 0;
}
@ -1508,9 +1508,9 @@ DEFINE_ACTION_FUNCTION(DBaseStatusBar, StatusbarToRealCoords)
{
PARAM_SELF_PROLOGUE(DBaseStatusBar);
PARAM_FLOAT(x);
PARAM_FLOAT_DEF(y);
PARAM_FLOAT_DEF(w);
PARAM_FLOAT_DEF(h);
PARAM_FLOAT(y);
PARAM_FLOAT(w);
PARAM_FLOAT(h);
self->StatusbarToRealCoords(x, y, w, h);
if (numret > 0) ret[0].SetFloat(x);
if (numret > 1) ret[1].SetFloat(y);
@ -1657,12 +1657,12 @@ DEFINE_ACTION_FUNCTION(DBaseStatusBar, DrawTexture)
PARAM_INT(texid);
PARAM_FLOAT(x);
PARAM_FLOAT(y);
PARAM_INT_DEF(flags);
PARAM_FLOAT_DEF(alpha);
PARAM_FLOAT_DEF(w);
PARAM_FLOAT_DEF(h);
PARAM_FLOAT_DEF(scaleX);
PARAM_FLOAT_DEF(scaleY);
PARAM_INT(flags);
PARAM_FLOAT(alpha);
PARAM_FLOAT(w);
PARAM_FLOAT(h);
PARAM_FLOAT(scaleX);
PARAM_FLOAT(scaleY);
if (!screen->HasBegun2D()) ThrowAbortException(X_OTHER, "Attempt to draw to screen outside a draw function");
self->DrawGraphic(FSetTextureID(texid), x, y, flags, alpha, w, h, scaleX, scaleY);
return 0;
@ -1674,12 +1674,12 @@ DEFINE_ACTION_FUNCTION(DBaseStatusBar, DrawImage)
PARAM_STRING(texid);
PARAM_FLOAT(x);
PARAM_FLOAT(y);
PARAM_INT_DEF(flags);
PARAM_FLOAT_DEF(alpha);
PARAM_FLOAT_DEF(w);
PARAM_FLOAT_DEF(h);
PARAM_FLOAT_DEF(scaleX);
PARAM_FLOAT_DEF(scaleY);
PARAM_INT(flags);
PARAM_FLOAT(alpha);
PARAM_FLOAT(w);
PARAM_FLOAT(h);
PARAM_FLOAT(scaleX);
PARAM_FLOAT(scaleY);
if (!screen->HasBegun2D()) ThrowAbortException(X_OTHER, "Attempt to draw to screen outside a draw function");
self->DrawGraphic(TexMan.CheckForTexture(texid, ETextureType::Any), x, y, flags, alpha, w, h, scaleX, scaleY);
return 0;
@ -1714,10 +1714,10 @@ DEFINE_ACTION_FUNCTION(DHUDFont, Create)
{
PARAM_PROLOGUE;
PARAM_POINTER(fnt, FFont);
PARAM_INT_DEF(spac);
PARAM_BOOL_DEF(mono);
PARAM_INT_DEF(sx);
PARAM_INT_DEF(sy);
PARAM_INT(spac);
PARAM_BOOL(mono);
PARAM_INT(sx);
PARAM_INT(sy);
ACTION_RETURN_POINTER(Create<DHUDFont>(fnt, spac, mono, sy, sy));
}
@ -1860,11 +1860,11 @@ DEFINE_ACTION_FUNCTION(DBaseStatusBar, DrawString)
PARAM_STRING(string);
PARAM_FLOAT(x);
PARAM_FLOAT(y);
PARAM_INT_DEF(flags);
PARAM_INT_DEF(trans);
PARAM_FLOAT_DEF(alpha);
PARAM_INT_DEF(wrapwidth);
PARAM_INT_DEF(linespacing);
PARAM_INT(flags);
PARAM_INT(trans);
PARAM_FLOAT(alpha);
PARAM_INT(wrapwidth);
PARAM_INT(linespacing);
if (!screen->HasBegun2D()) ThrowAbortException(X_OTHER, "Attempt to draw to screen outside a draw function");
@ -1958,7 +1958,7 @@ DEFINE_ACTION_FUNCTION(DBaseStatusBar, TransformRect)
PARAM_FLOAT(y);
PARAM_FLOAT(w);
PARAM_FLOAT(h);
PARAM_INT_DEF(flags);
PARAM_INT(flags);
self->TransformRect(x, y, w, h, flags);
if (numret > 0) ret[0].SetFloat(x);
if (numret > 1) ret[1].SetFloat(y);
@ -1997,7 +1997,7 @@ DEFINE_ACTION_FUNCTION(DBaseStatusBar, Fill)
PARAM_FLOAT(y);
PARAM_FLOAT(w);
PARAM_FLOAT(h);
PARAM_INT_DEF(flags);
PARAM_INT(flags);
if (!screen->HasBegun2D()) ThrowAbortException(X_OTHER, "Attempt to draw to screen outside a draw function");
self->Fill(color, x, y, w, h, flags);
return 0;
@ -2027,7 +2027,7 @@ DEFINE_ACTION_FUNCTION(DBaseStatusBar, SetClipRect)
PARAM_FLOAT(y);
PARAM_FLOAT(w);
PARAM_FLOAT(h);
PARAM_INT_DEF(flags);
PARAM_INT(flags);
self->SetClipRect(x, y, w, h, flags);
return 0;
}
@ -2126,10 +2126,10 @@ DEFINE_ACTION_FUNCTION(DBaseStatusBar, FormatNumber)
{
PARAM_PROLOGUE;
PARAM_INT(number);
PARAM_INT_DEF(minsize);
PARAM_INT_DEF(maxsize);
PARAM_INT_DEF(flags);
PARAM_STRING_DEF(prefix);
PARAM_INT(minsize);
PARAM_INT(maxsize);
PARAM_INT(flags);
PARAM_STRING(prefix);
static int maxvals[] = { 1, 9, 99, 999, 9999, 99999, 999999, 9999999, 99999999, 999999999 };
if (number == 0 && (flags & FNF_WHENNOTZERO)) ACTION_RETURN_STRING("");
@ -2155,8 +2155,8 @@ DEFINE_ACTION_FUNCTION(DBaseStatusBar, GetMugshot)
{
PARAM_SELF_PROLOGUE(DBaseStatusBar);
PARAM_INT(accuracy);
PARAM_INT_DEF(stateflags);
PARAM_STRING_DEF(def_face);
PARAM_INT(stateflags);
PARAM_STRING(def_face);
auto tex = self->mugshot.GetFace(self->CPlayer, def_face, accuracy, (FMugShot::StateFlags)stateflags);
ACTION_RETURN_INT(tex ? tex->id.GetIndex() : -1);
}

26
src/hwrenderer/postprocessing/hw_postprocessshader.cpp
View file

@ -38,9 +38,9 @@ static bool IsConsolePlayer(player_t *player)
DEFINE_ACTION_FUNCTION(_Shader, SetEnabled)
{
PARAM_PROLOGUE;
PARAM_POINTER_DEF(player, player_t);
PARAM_POINTER(player, player_t);
PARAM_STRING(shaderName);
PARAM_BOOL_DEF(value);
PARAM_BOOL(value);
if (IsConsolePlayer(player))
{
@ -57,10 +57,10 @@ DEFINE_ACTION_FUNCTION(_Shader, SetEnabled)
DEFINE_ACTION_FUNCTION(_Shader, SetUniform1f)
{
PARAM_PROLOGUE;
PARAM_POINTER_DEF(player, player_t);
PARAM_POINTER(player, player_t);
PARAM_STRING(shaderName);
PARAM_STRING(uniformName);
PARAM_FLOAT_DEF(value);
PARAM_FLOAT(value);
if (IsConsolePlayer(player))
{
@ -83,11 +83,11 @@ DEFINE_ACTION_FUNCTION(_Shader, SetUniform1f)
DEFINE_ACTION_FUNCTION(_Shader, SetUniform2f)
{
PARAM_PROLOGUE;
PARAM_POINTER_DEF(player, player_t);
PARAM_POINTER(player, player_t);
PARAM_STRING(shaderName);
PARAM_STRING(uniformName);
PARAM_FLOAT_DEF(x);
PARAM_FLOAT_DEF(y);
PARAM_FLOAT(x);
PARAM_FLOAT(y);
if (IsConsolePlayer(player))
{
@ -110,12 +110,12 @@ DEFINE_ACTION_FUNCTION(_Shader, SetUniform2f)
DEFINE_ACTION_FUNCTION(_Shader, SetUniform3f)
{
PARAM_PROLOGUE;
PARAM_POINTER_DEF(player, player_t);
PARAM_POINTER(player, player_t);
PARAM_STRING(shaderName);
PARAM_STRING(uniformName);
PARAM_FLOAT_DEF(x);
PARAM_FLOAT_DEF(y);
PARAM_FLOAT_DEF(z);
PARAM_FLOAT(x);
PARAM_FLOAT(y);
PARAM_FLOAT(z);
if (IsConsolePlayer(player))
{
@ -138,10 +138,10 @@ DEFINE_ACTION_FUNCTION(_Shader, SetUniform3f)
DEFINE_ACTION_FUNCTION(_Shader, SetUniform1i)
{
PARAM_PROLOGUE;
PARAM_POINTER_DEF(player, player_t);
PARAM_POINTER(player, player_t);
PARAM_STRING(shaderName);
PARAM_STRING(uniformName);
PARAM_INT_DEF(value);
PARAM_INT(value);
if (IsConsolePlayer(player))
{

2
src/menu/menu.cpp
View file

@ -535,7 +535,7 @@ DEFINE_ACTION_FUNCTION(DMenu, SetMenu)
{
PARAM_PROLOGUE;
PARAM_NAME(menu);
PARAM_INT_DEF(mparam);
PARAM_INT(mparam);
M_SetMenu(menu, mparam);
return 0;
}

4
src/menu/messagebox.cpp
View file

@ -270,8 +270,8 @@ DEFINE_ACTION_FUNCTION(DMenu, StartMessage)
{
PARAM_PROLOGUE;
PARAM_STRING(msg);
PARAM_INT_DEF(mode);
PARAM_NAME_DEF(action);
PARAM_INT(mode);
PARAM_NAME(action);
M_StartMessage(msg, mode, action);
return 0;
}

798
src/p_actionfunctions.cpp
View file

File diff suppressed because it is too large Load diff

10
src/p_ceiling.cpp
View file

@ -473,11 +473,11 @@ DEFINE_ACTION_FUNCTION(DCeiling, CreateCeiling)
PARAM_POINTER(ln, line_t);
PARAM_FLOAT(speed);
PARAM_FLOAT(speed2);
PARAM_FLOAT_DEF(height);
PARAM_INT_DEF(crush);
PARAM_INT_DEF(silent);
PARAM_INT_DEF(change);
PARAM_INT_DEF(crushmode);
PARAM_FLOAT(height);
PARAM_INT(crush);
PARAM_INT(silent);
PARAM_INT(change);
PARAM_INT(crushmode);
ACTION_RETURN_BOOL(P_CreateCeiling(sec, (DCeiling::ECeiling)type, ln, 0, speed, speed2, height, crush, silent, change, (DCeiling::ECrushMode)crushmode));
}

48
src/p_enemy.cpp
View file

@ -261,8 +261,8 @@ DEFINE_ACTION_FUNCTION(AActor, SoundAlert)
{
PARAM_SELF_PROLOGUE(AActor);
PARAM_OBJECT(target, AActor);
PARAM_BOOL_DEF(splash);
PARAM_FLOAT_DEF(maxdist);
PARAM_BOOL(splash);
PARAM_FLOAT(maxdist);
// Note that the emitter is self, not the target of the alert! Target can be NULL.
P_NoiseAlert(target, self, splash, maxdist);
return 0;
@ -1350,7 +1350,7 @@ DEFINE_ACTION_FUNCTION(AActor, IsVisible)
PARAM_SELF_PROLOGUE(AActor);
PARAM_OBJECT(other, AActor);
PARAM_BOOL(allaround);
PARAM_POINTER_DEF(params, FLookExParams);
PARAM_POINTER(params, FLookExParams);
ACTION_RETURN_BOOL(P_IsVisible(self, other, allaround, params));
}
@ -1589,7 +1589,7 @@ DEFINE_ACTION_FUNCTION(AActor, LookForTID)
{
PARAM_SELF_PROLOGUE(AActor);
PARAM_BOOL(allaround);
PARAM_POINTER_DEF(params, FLookExParams);
PARAM_POINTER(params, FLookExParams);
ACTION_RETURN_BOOL(P_LookForTID(self, allaround, params));
}
@ -1736,7 +1736,7 @@ DEFINE_ACTION_FUNCTION(AActor, LookForEnemies)
{
PARAM_SELF_PROLOGUE(AActor);
PARAM_BOOL(allaround);
PARAM_POINTER_DEF(params, FLookExParams);
PARAM_POINTER(params, FLookExParams);
ACTION_RETURN_BOOL(P_LookForEnemies(self, allaround, params));
}
@ -1931,7 +1931,7 @@ DEFINE_ACTION_FUNCTION(AActor, LookForPlayers)
{
PARAM_SELF_PROLOGUE(AActor);
PARAM_BOOL(allaround);
PARAM_POINTER_DEF(params, FLookExParams);
PARAM_POINTER(params, FLookExParams);
ACTION_RETURN_BOOL(P_LookForPlayers(self, allaround, params));
}
@ -2067,12 +2067,12 @@ DEFINE_ACTION_FUNCTION(AActor, A_Look)
DEFINE_ACTION_FUNCTION(AActor, A_LookEx)
{
PARAM_SELF_PROLOGUE(AActor);
PARAM_INT_DEF (flags)
PARAM_FLOAT_DEF (minseedist)
PARAM_FLOAT_DEF (maxseedist)
PARAM_FLOAT_DEF (maxheardist)
PARAM_ANGLE_DEF (fov)
PARAM_STATE_DEF (seestate)
PARAM_INT (flags)
PARAM_FLOAT (minseedist)
PARAM_FLOAT (maxseedist)
PARAM_FLOAT (maxheardist)
PARAM_ANGLE (fov)
PARAM_STATE (seestate)
AActor *targ = NULL; // Shuts up gcc
double dist;
@ -2284,7 +2284,7 @@ enum ChaseFlags
DEFINE_ACTION_FUNCTION(AActor, A_Wander)
{
PARAM_SELF_PROLOGUE(AActor);
PARAM_INT_DEF(flags);
PARAM_INT(flags);
A_Wander(self, flags);
return 0;
}
@ -2972,9 +2972,9 @@ static bool P_CheckForResurrection(AActor *self, bool usevilestates)
DEFINE_ACTION_FUNCTION(AActor, A_Chase)
{
PARAM_SELF_PROLOGUE(AActor);
PARAM_STATE_DEF (melee)
PARAM_STATE_DEF (missile)
PARAM_INT_DEF (flags)
PARAM_STATE (melee)
PARAM_STATE (missile)
PARAM_INT (flags)
if (melee != nullptr || missile != nullptr || flags != 0x40000000)
{
@ -3013,8 +3013,8 @@ DEFINE_ACTION_FUNCTION(AActor, A_ExtChase)
PARAM_SELF_PROLOGUE(AActor);
PARAM_BOOL (domelee);
PARAM_BOOL (domissile);
PARAM_BOOL_DEF (playactive);
PARAM_BOOL_DEF (nightmarefast);
PARAM_BOOL (playactive);
PARAM_BOOL (nightmarefast);
// Now that A_Chase can handle state label parameters, this function has become rather useless...
A_DoChase(self, false,
@ -3158,12 +3158,12 @@ DEFINE_ACTION_FUNCTION(AActor, A_Face)
{
PARAM_SELF_PROLOGUE(AActor);
PARAM_OBJECT(faceto, AActor)
PARAM_ANGLE_DEF(max_turn)
PARAM_ANGLE_DEF(max_pitch)
PARAM_ANGLE_DEF(ang_offset)
PARAM_ANGLE_DEF(pitch_offset)
PARAM_INT_DEF(flags)
PARAM_FLOAT_DEF(z_add)
PARAM_ANGLE(max_turn)
PARAM_ANGLE(max_pitch)
PARAM_ANGLE(ang_offset)
PARAM_ANGLE(pitch_offset)
PARAM_INT(flags)
PARAM_FLOAT(z_add)
A_Face(self, faceto, max_turn, max_pitch, ang_offset, pitch_offset, flags, z_add);
return 0;

10
src/p_floor.cpp
View file

@ -509,11 +509,11 @@ DEFINE_ACTION_FUNCTION(DFloor, CreateFloor)
PARAM_INT(floortype);
PARAM_POINTER(ln, line_t);
PARAM_FLOAT(speed);
PARAM_FLOAT_DEF(height);
PARAM_INT_DEF(crush);
PARAM_INT_DEF(change);
PARAM_BOOL_DEF(hereticlower);
PARAM_BOOL_DEF(hexencrush);
PARAM_FLOAT(height);
PARAM_INT(crush);
PARAM_INT(change);
PARAM_BOOL(hereticlower);
PARAM_BOOL(hexencrush);
ACTION_RETURN_BOOL(P_CreateFloor(sec, (DFloor::EFloor)floortype, ln, speed, height, crush, change, hexencrush, hereticlower));
}

8
src/p_interaction.cpp
View file

@ -728,8 +728,8 @@ DEFINE_ACTION_FUNCTION(AActor, Die)
PARAM_SELF_PROLOGUE(AActor);
PARAM_OBJECT(source, AActor);
PARAM_OBJECT(inflictor, AActor);
PARAM_INT_DEF(dmgflags);
PARAM_NAME_DEF(MeansOfDeath);
PARAM_INT(dmgflags);
PARAM_NAME(MeansOfDeath);
self->Die(source, inflictor, dmgflags, MeansOfDeath);
return 0;
}
@ -1635,8 +1635,8 @@ DEFINE_ACTION_FUNCTION(AActor, DamageMobj)
PARAM_OBJECT(source, AActor);
PARAM_INT(damage);
PARAM_NAME(mod);
PARAM_INT_DEF(flags);
PARAM_FLOAT_DEF(angle);
PARAM_INT(flags);
PARAM_FLOAT(angle);
// [ZZ] event handlers need the result.
bool needevent = true;

10
src/p_lnspec.cpp
View file

@ -3955,11 +3955,11 @@ DEFINE_ACTION_FUNCTION(FLevelLocals, ExecuteSpecial)
PARAM_OBJECT(activator, AActor);
PARAM_POINTER(linedef, line_t);
PARAM_BOOL(lineside);
PARAM_INT_DEF(arg1);
PARAM_INT_DEF(arg2);
PARAM_INT_DEF(arg3);
PARAM_INT_DEF(arg4);
PARAM_INT_DEF(arg5);
PARAM_INT(arg1);
PARAM_INT(arg2);
PARAM_INT(arg3);
PARAM_INT(arg4);
PARAM_INT(arg5);
bool res = !!P_ExecuteSpecial(special, linedef, activator, lineside, arg1, arg2, arg3, arg4, arg5);

52
src/p_map.cpp
View file

@ -417,7 +417,7 @@ void P_FindFloorCeiling(AActor *actor, int flags)
DEFINE_ACTION_FUNCTION(AActor, FindFloorCeiling)
{
PARAM_SELF_PROLOGUE(AActor);
PARAM_INT_DEF(flags);
PARAM_INT(flags);
P_FindFloorCeiling(self, flags);
return 0;
}
@ -583,7 +583,7 @@ DEFINE_ACTION_FUNCTION(AActor, TeleportMove)
PARAM_FLOAT(y);
PARAM_FLOAT(z);
PARAM_BOOL(telefrag);
PARAM_BOOL_DEF(modify);
PARAM_BOOL(modify);
ACTION_RETURN_BOOL(P_TeleportMove(self, DVector3(x, y, z), telefrag, modify));
}
@ -1959,8 +1959,8 @@ DEFINE_ACTION_FUNCTION(AActor, CheckPosition)
PARAM_SELF_PROLOGUE(AActor);
PARAM_FLOAT(x);
PARAM_FLOAT(y);
PARAM_BOOL_DEF(actorsonly);
PARAM_POINTER_DEF(tm, FCheckPosition);
PARAM_BOOL(actorsonly);
PARAM_POINTER(tm, FCheckPosition);
if (tm)
{
ACTION_RETURN_BOOL(P_CheckPosition(self, DVector2(x, y), *tm, actorsonly));
@ -2117,7 +2117,7 @@ bool P_TestMobjZ(AActor *actor, bool quick, AActor **pOnmobj)
DEFINE_ACTION_FUNCTION(AActor, TestMobjZ)
{
PARAM_SELF_PROLOGUE(AActor);
PARAM_BOOL_DEF(quick);
PARAM_BOOL(quick);
AActor *on = nullptr;;
bool retv = P_TestMobjZ(self, quick, &on);
@ -2773,8 +2773,8 @@ DEFINE_ACTION_FUNCTION(AActor, TryMove)
PARAM_FLOAT(x);
PARAM_FLOAT(y);
PARAM_INT(dropoff);
PARAM_BOOL_DEF(missilecheck);
PARAM_POINTER_DEF(tm, FCheckPosition);
PARAM_BOOL(missilecheck);
PARAM_POINTER(tm, FCheckPosition);
if (tm == nullptr)
{
ACTION_RETURN_BOOL(P_TryMove(self, DVector2(x, y), dropoff, nullptr, missilecheck));
@ -2898,8 +2898,8 @@ DEFINE_ACTION_FUNCTION(AActor, CheckMove)
PARAM_SELF_PROLOGUE(AActor);
PARAM_FLOAT(x);
PARAM_FLOAT(y);
PARAM_INT_DEF(flags);
PARAM_POINTER_DEF(tm, FCheckPosition);
PARAM_INT(flags);
PARAM_POINTER(tm, FCheckPosition);
if (tm == nullptr)
{
ACTION_RETURN_BOOL(P_CheckMove(self, DVector2(x, y), flags));
@ -4489,11 +4489,11 @@ DEFINE_ACTION_FUNCTION(AActor, AimLineAttack)
PARAM_SELF_PROLOGUE(AActor);
PARAM_ANGLE(angle);
PARAM_FLOAT(distance);
PARAM_POINTER_DEF(pLineTarget, FTranslatedLineTarget);
PARAM_ANGLE_DEF(vrange);
PARAM_INT_DEF(flags);
PARAM_OBJECT_DEF(target, AActor);
PARAM_OBJECT_DEF(friender, AActor);
PARAM_POINTER(pLineTarget, FTranslatedLineTarget);
PARAM_ANGLE(vrange);
PARAM_INT(flags);
PARAM_OBJECT(target, AActor);
PARAM_OBJECT(friender, AActor);
ACTION_RETURN_FLOAT(P_AimLineAttack(self, angle, distance, pLineTarget, vrange, flags, target, friender).Degrees);
}
@ -4925,11 +4925,11 @@ DEFINE_ACTION_FUNCTION(AActor, LineAttack)
PARAM_INT(damage);
PARAM_NAME(damageType);
PARAM_CLASS(puffType, AActor);
PARAM_INT_DEF(flags);
PARAM_POINTER_DEF(victim, FTranslatedLineTarget);
PARAM_FLOAT_DEF(offsetz);
PARAM_FLOAT_DEF(offsetforward);
PARAM_FLOAT_DEF(offsetside);
PARAM_INT(flags);
PARAM_POINTER(victim, FTranslatedLineTarget);
PARAM_FLOAT(offsetz);
PARAM_FLOAT(offsetforward);
PARAM_FLOAT(offsetside);
int acdmg;
if (puffType == nullptr) puffType = PClass::FindActor("BulletPuff"); // P_LineAttack does not work without a puff to take info from.
@ -5088,11 +5088,11 @@ DEFINE_ACTION_FUNCTION(AActor, LineTrace)
PARAM_ANGLE(angle);
PARAM_FLOAT(distance);
PARAM_ANGLE(pitch);
PARAM_INT_DEF(flags);
PARAM_FLOAT_DEF(offsetz);
PARAM_FLOAT_DEF(offsetforward);
PARAM_FLOAT_DEF(offsetside);
PARAM_POINTER_DEF(data, FLineTraceData);
PARAM_INT(flags);
PARAM_FLOAT(offsetz);
PARAM_FLOAT(offsetforward);
PARAM_FLOAT(offsetside);
PARAM_POINTER(data, FLineTraceData);
ACTION_RETURN_BOOL(P_LineTrace(self,angle,distance,pitch,flags,offsetz,offsetforward,offsetside,data));
}
@ -6117,8 +6117,8 @@ DEFINE_ACTION_FUNCTION(AActor, GetRadiusDamage)
PARAM_OBJECT(thing, AActor);
PARAM_INT(damage);
PARAM_INT(distance);
PARAM_INT_DEF(fulldmgdistance);
PARAM_BOOL_DEF(oldradiusdmg);
PARAM_INT(fulldmgdistance);
PARAM_BOOL(oldradiusdmg);
if (!thing)
{

16
src/p_maputl.cpp
View file

@ -348,7 +348,7 @@ void AActor::UnlinkFromWorld (FLinkContext *ctx)
DEFINE_ACTION_FUNCTION(AActor, UnlinkFromWorld)
{
PARAM_SELF_PROLOGUE(AActor);
PARAM_POINTER_DEF(ctx, FLinkContext);
PARAM_POINTER(ctx, FLinkContext);
self->UnlinkFromWorld(ctx); // fixme
return 0;
}
@ -567,7 +567,7 @@ void AActor::LinkToWorld(FLinkContext *ctx, bool spawningmapthing, sector_t *sec
DEFINE_ACTION_FUNCTION(AActor, LinkToWorld)
{
PARAM_SELF_PROLOGUE(AActor);
PARAM_POINTER_DEF(ctx, FLinkContext);
PARAM_POINTER(ctx, FLinkContext);
self->LinkToWorld(ctx);
return 0;
}
@ -980,7 +980,7 @@ DEFINE_ACTION_FUNCTION(DBlockLinesIterator, Create)
{
PARAM_PROLOGUE;
PARAM_OBJECT_NOT_NULL(origin, AActor);
PARAM_FLOAT_DEF(radius);
PARAM_FLOAT(radius);
ACTION_RETURN_OBJECT(Create<DBlockLinesIterator>(origin, radius));
}
@ -992,7 +992,7 @@ DEFINE_ACTION_FUNCTION(DBlockLinesIterator, CreateFromPos)
PARAM_FLOAT(z);
PARAM_FLOAT(h);
PARAM_FLOAT(radius);
PARAM_POINTER_DEF(sec, sector_t);
PARAM_POINTER(sec, sector_t);
ACTION_RETURN_OBJECT(Create<DBlockLinesIterator>(x, y, z, h, radius, sec));
}
@ -1319,8 +1319,8 @@ DEFINE_ACTION_FUNCTION(DBlockThingsIterator, Create)
{
PARAM_PROLOGUE;
PARAM_OBJECT_NOT_NULL(origin, AActor);
PARAM_FLOAT_DEF(radius);
PARAM_BOOL_DEF(ignore);
PARAM_FLOAT(radius);
PARAM_BOOL(ignore);
ACTION_RETURN_OBJECT(Create<DBlockThingsIterator>(origin, radius, ignore));
}
@ -2028,8 +2028,8 @@ DEFINE_ACTION_FUNCTION(AActor, RoughMonsterSearch)
{
PARAM_SELF_PROLOGUE(AActor);
PARAM_INT(distance);
PARAM_BOOL_DEF(onlyseekable);
PARAM_BOOL_DEF(frontonly);
PARAM_BOOL(onlyseekable);
PARAM_BOOL(frontonly);
ACTION_RETURN_OBJECT(P_RoughMonsterSearch(self, distance, onlyseekable, frontonly));
}

108
src/p_mobj.cpp
View file

@ -748,7 +748,7 @@ DEFINE_ACTION_FUNCTION(AActor, SetState)
{
PARAM_SELF_PROLOGUE(AActor);
PARAM_POINTER(state, FState);
PARAM_BOOL_DEF(nofunction);
PARAM_BOOL(nofunction);
ACTION_RETURN_BOOL(self->SetState(state, nofunction));
};
@ -862,7 +862,7 @@ DEFINE_ACTION_FUNCTION(AActor, GiveInventory)
PARAM_SELF_PROLOGUE(AActor);
PARAM_CLASS(type, AInventory);
PARAM_INT(amount);
PARAM_BOOL_DEF(givecheat);
PARAM_BOOL(givecheat);
ACTION_RETURN_BOOL(self->GiveInventory(type, amount, givecheat));
}
@ -962,8 +962,8 @@ DEFINE_ACTION_FUNCTION(AActor, TakeInventory)
PARAM_SELF_PROLOGUE(AActor);
PARAM_CLASS_NOT_NULL(item, AInventory);
PARAM_INT(amount);
PARAM_BOOL_DEF(fromdecorate);
PARAM_BOOL_DEF(notakeinfinite);
PARAM_BOOL(fromdecorate);
PARAM_BOOL(notakeinfinite);
ACTION_RETURN_BOOL(self->TakeInventory(item, amount, fromdecorate, notakeinfinite));
}
@ -1032,7 +1032,7 @@ DEFINE_ACTION_FUNCTION(AActor, SetInventory)
PARAM_SELF_PROLOGUE(AActor);
PARAM_CLASS_NOT_NULL(item, AInventory);
PARAM_INT(amount);
PARAM_BOOL_DEF(beyondMax);
PARAM_BOOL(beyondMax);
ACTION_RETURN_BOOL(self->SetInventory(item, amount, beyondMax));
}
@ -1182,7 +1182,7 @@ DEFINE_ACTION_FUNCTION(AActor, DropInventory)
{
PARAM_SELF_PROLOGUE(AActor);
PARAM_OBJECT_NOT_NULL(item, AInventory);
PARAM_INT_DEF(amt);
PARAM_INT(amt);
ACTION_RETURN_OBJECT(self->DropInventory(item, amt));
}
@ -1229,7 +1229,7 @@ DEFINE_ACTION_FUNCTION(AActor, FindInventory)
{
PARAM_SELF_PROLOGUE(AActor);
PARAM_CLASS(type, AInventory);
PARAM_BOOL_DEF(subclass);
PARAM_BOOL(subclass);
ACTION_RETURN_OBJECT(self->FindInventory(type, subclass));
}
@ -1390,8 +1390,8 @@ DEFINE_ACTION_FUNCTION(AActor, CopyFriendliness)
{
PARAM_SELF_PROLOGUE(AActor);
PARAM_OBJECT_NOT_NULL(other, AActor);
PARAM_BOOL_DEF(changetarget);
PARAM_BOOL_DEF(resethealth);
PARAM_BOOL(changetarget);
PARAM_BOOL(resethealth);
self->CopyFriendliness(other, changetarget, resethealth);
return 0;
}
@ -1566,7 +1566,7 @@ DEFINE_ACTION_FUNCTION(AActor, GiveBody)
{
PARAM_SELF_PROLOGUE(AActor);
PARAM_INT(num);
PARAM_INT_DEF(max);
PARAM_INT(max);
ACTION_RETURN_BOOL(P_GiveBody(self, num, max));
}
@ -2088,8 +2088,8 @@ void P_ExplodeMissile (AActor *mo, line_t *line, AActor *target, bool onsky)
DEFINE_ACTION_FUNCTION(AActor, ExplodeMissile)
{
PARAM_SELF_PROLOGUE(AActor);
PARAM_POINTER_DEF(line, line_t);
PARAM_OBJECT_DEF(target, AActor);
PARAM_POINTER(line, line_t);
PARAM_OBJECT(target, AActor);
P_ExplodeMissile(self, line, target);
return 0;
}
@ -3339,7 +3339,7 @@ DEFINE_ACTION_FUNCTION(AActor, CheckFakeFloorTriggers)
{
PARAM_SELF_PROLOGUE(AActor);
PARAM_FLOAT(oldz);
PARAM_BOOL_DEF(oldz_has_viewh);
PARAM_BOOL(oldz_has_viewh);
P_CheckFakeFloorTriggers(self, oldz, oldz_has_viewh);
return 0;
}
@ -3652,8 +3652,8 @@ int P_FindUniqueTID(int start_tid, int limit)
DEFINE_ACTION_FUNCTION(AActor, FindUniqueTid)
{
PARAM_PROLOGUE;
PARAM_INT_DEF(start);
PARAM_INT_DEF(limit);
PARAM_INT(start);
PARAM_INT(limit);
ACTION_RETURN_INT(P_FindUniqueTID(start, limit));
}
@ -4098,7 +4098,7 @@ void AActor::CheckPortalTransition(bool islinked)
DEFINE_ACTION_FUNCTION(AActor, CheckPortalTransition)
{
PARAM_SELF_PROLOGUE(AActor);
PARAM_BOOL_DEF(linked);
PARAM_BOOL(linked);
self->CheckPortalTransition(linked);
return 0;
}
@ -4976,7 +4976,7 @@ bool AActor::UpdateWaterLevel(bool dosplash)
DEFINE_ACTION_FUNCTION(AActor, UpdateWaterLevel)
{
PARAM_SELF_PROLOGUE(AActor);
PARAM_BOOL_DEF(splash);
PARAM_BOOL(splash);
ACTION_RETURN_BOOL(self->UpdateWaterLevel(splash));
}
@ -5176,10 +5176,10 @@ DEFINE_ACTION_FUNCTION(AActor, Spawn)
{
PARAM_PROLOGUE;
PARAM_CLASS_NOT_NULL(type, AActor);
PARAM_FLOAT_DEF(x);
PARAM_FLOAT_DEF(y);
PARAM_FLOAT_DEF(z);
PARAM_INT_DEF(flags);
PARAM_FLOAT(x);
PARAM_FLOAT(y);
PARAM_FLOAT(z);
PARAM_INT(flags);
ACTION_RETURN_OBJECT(AActor::StaticSpawn(type, DVector3(x, y, z), replace_t(flags)));
}
@ -6291,8 +6291,8 @@ DEFINE_ACTION_FUNCTION(AActor, SpawnPuff)
PARAM_ANGLE(hitdir);
PARAM_ANGLE(particledir);
PARAM_INT(updown);
PARAM_INT_DEF(flags);
PARAM_OBJECT_DEF(victim, AActor);
PARAM_INT(flags);
PARAM_OBJECT(victim, AActor);
ACTION_RETURN_OBJECT(P_SpawnPuff(self, pufftype, DVector3(x, y, z), hitdir, particledir, updown, flags, victim));
}
@ -6491,7 +6491,7 @@ DEFINE_ACTION_FUNCTION(AActor, BloodSplatter)
PARAM_FLOAT(y);
PARAM_FLOAT(z);
PARAM_ANGLE(dir);
PARAM_BOOL_DEF(axe);
PARAM_BOOL(axe);
if (axe) P_BloodSplatter2(DVector3(x, y, z), self, dir);
else P_BloodSplatter(DVector3(x, y, z), self, dir);
return 0;
@ -6723,9 +6723,9 @@ DEFINE_ACTION_FUNCTION(AActor, HitWater)
PARAM_FLOAT(x);
PARAM_FLOAT(y);
PARAM_FLOAT(z);
PARAM_BOOL_DEF(checkabove);
PARAM_BOOL_DEF(alert);
PARAM_BOOL_DEF(force);
PARAM_BOOL(checkabove);
PARAM_BOOL(alert);
PARAM_BOOL(force);
ACTION_RETURN_BOOL(P_HitWater(self, sec, DVector3(x, y, z), checkabove, alert, force));
}
@ -7062,8 +7062,8 @@ DEFINE_ACTION_FUNCTION(AActor, SpawnMissileXYZ)
PARAM_FLOAT(z);
PARAM_OBJECT_NOT_NULL(dest, AActor);
PARAM_CLASS(type, AActor);
PARAM_BOOL_DEF(check);
PARAM_OBJECT_DEF(owner, AActor);
PARAM_BOOL(check);
PARAM_OBJECT(owner, AActor);
ACTION_RETURN_OBJECT(P_SpawnMissileXYZ(DVector3(x,y,z), self, dest, type, check, owner));
}
@ -7081,7 +7081,7 @@ DEFINE_ACTION_FUNCTION(AActor, SpawnMissile)
PARAM_SELF_PROLOGUE(AActor);
PARAM_OBJECT_NOT_NULL(dest, AActor);
PARAM_CLASS(type, AActor);
PARAM_OBJECT_DEF(owner, AActor);
PARAM_OBJECT(owner, AActor);
ACTION_RETURN_OBJECT(P_SpawnMissile(self, dest, type, owner));
}
@ -7137,7 +7137,7 @@ DEFINE_ACTION_FUNCTION(AActor, OldSpawnMissile)
PARAM_SELF_PROLOGUE(AActor);
PARAM_OBJECT_NOT_NULL(dest, AActor);
PARAM_CLASS(type, AActor);
PARAM_OBJECT_DEF(owner, AActor);
PARAM_OBJECT(owner, AActor);
ACTION_RETURN_OBJECT(P_OldSpawnMissile(self, owner, dest, type));
}
@ -7250,8 +7250,8 @@ DEFINE_ACTION_FUNCTION(AActor, SpawnMissileAngleZSpeed)
PARAM_ANGLE(angle);
PARAM_FLOAT(vz);
PARAM_FLOAT(speed);
PARAM_OBJECT_DEF(owner, AActor);
PARAM_BOOL_DEF(checkspawn);
PARAM_OBJECT(owner, AActor);
PARAM_BOOL(checkspawn);
ACTION_RETURN_OBJECT(P_SpawnMissileAngleZSpeed(self, z, type, angle, vz, speed, owner, checkspawn));
}
@ -7424,14 +7424,14 @@ DEFINE_ACTION_FUNCTION(AActor, SpawnPlayerMissile)
{
PARAM_SELF_PROLOGUE(AActor);
PARAM_CLASS(type, AActor);
PARAM_ANGLE_DEF(angle);
PARAM_FLOAT_DEF(x);
PARAM_FLOAT_DEF(y);
PARAM_FLOAT_DEF(z);
PARAM_POINTER_DEF(lt, FTranslatedLineTarget);
PARAM_BOOL_DEF(nofreeaim);
PARAM_BOOL_DEF(noautoaim);
PARAM_INT_DEF(aimflags);
PARAM_ANGLE(angle);
PARAM_FLOAT(x);
PARAM_FLOAT(y);
PARAM_FLOAT(z);
PARAM_POINTER(lt, FTranslatedLineTarget);
PARAM_BOOL(nofreeaim);
PARAM_BOOL(noautoaim);
PARAM_INT(aimflags);
AActor *missileactor;
if (angle == 1e37) angle = self->Angles.Yaw;
AActor *misl = P_SpawnPlayerMissile(self, x, y, z, type, angle, lt, &missileactor, nofreeaim, noautoaim, aimflags);
@ -7773,7 +7773,7 @@ void AActor::SetIdle(bool nofunction)
DEFINE_ACTION_FUNCTION(AActor, SetIdle)
{
PARAM_SELF_PROLOGUE(AActor);
PARAM_BOOL_DEF(nofunction);
PARAM_BOOL(nofunction);
self->SetIdle(nofunction);
return 0;
}
@ -7950,7 +7950,7 @@ const char *AActor::GetTag(const char *def) const
DEFINE_ACTION_FUNCTION(AActor, GetTag)
{
PARAM_SELF_PROLOGUE(AActor);
PARAM_STRING_DEF(def);
PARAM_STRING(def);
ACTION_RETURN_STRING(self->GetTag(def.Len() == 0? nullptr : def.GetChars()));
}
@ -8171,7 +8171,7 @@ double AActor::GetBobOffset(double ticfrac) const
DEFINE_ACTION_FUNCTION(AActor, GetBobOffset)
{
PARAM_SELF_PROLOGUE(AActor);
PARAM_FLOAT_DEF(frac);
PARAM_FLOAT(frac);
ACTION_RETURN_FLOAT(self->GetBobOffset(frac));
}
@ -8194,7 +8194,7 @@ DEFINE_ACTION_FUNCTION(DActorIterator, Create)
{
PARAM_PROLOGUE;
PARAM_INT(tid);
PARAM_CLASS_DEF(type, AActor);
PARAM_CLASS(type, AActor);
ACTION_RETURN_OBJECT(Create<DActorIterator>(type, tid));
}
@ -8261,7 +8261,7 @@ DEFINE_ACTION_FUNCTION(AActor, AddZ)
{
PARAM_SELF_PROLOGUE(AActor);
PARAM_FLOAT(addz);
PARAM_BOOL_DEF(moving);
PARAM_BOOL(moving);
self->AddZ(addz, moving);
return 0;
}
@ -8355,7 +8355,7 @@ DEFINE_ACTION_FUNCTION(AActor, AngleTo)
{
PARAM_SELF_PROLOGUE(AActor);
PARAM_OBJECT_NOT_NULL(targ, AActor);
PARAM_BOOL_DEF(absolute);
PARAM_BOOL(absolute);
ACTION_RETURN_FLOAT(self->AngleTo(targ, absolute).Degrees);
}
@ -8363,7 +8363,7 @@ DEFINE_ACTION_FUNCTION(AActor, AngleToVector)
{
PARAM_PROLOGUE;
PARAM_ANGLE(angle);
PARAM_FLOAT_DEF(length);
PARAM_FLOAT(length);
ACTION_RETURN_VEC2(angle.ToVector(length));
}
@ -8406,7 +8406,7 @@ DEFINE_ACTION_FUNCTION(AActor, Vec2Angle)
PARAM_SELF_PROLOGUE(AActor);
PARAM_FLOAT(length);
PARAM_ANGLE(angle);
PARAM_BOOL_DEF(absolute);
PARAM_BOOL(absolute);
ACTION_RETURN_VEC2(self->Vec2Angle(length, angle, absolute));
}
@ -8430,8 +8430,8 @@ DEFINE_ACTION_FUNCTION(AActor, Vec3Angle)
PARAM_SELF_PROLOGUE(AActor);
PARAM_FLOAT(length)
PARAM_ANGLE(angle);
PARAM_FLOAT_DEF(z);
PARAM_BOOL_DEF(absolute);
PARAM_FLOAT(z);
PARAM_BOOL(absolute);
ACTION_RETURN_VEC3(self->Vec3Angle(length, angle, z, absolute));
}
@ -8441,7 +8441,7 @@ DEFINE_ACTION_FUNCTION(AActor, Vec2OffsetZ)
PARAM_FLOAT(x);
PARAM_FLOAT(y);
PARAM_FLOAT(z);
PARAM_BOOL_DEF(absolute);
PARAM_BOOL(absolute);
ACTION_RETURN_VEC3(self->Vec2OffsetZ(x, y, z, absolute));
}
@ -8450,7 +8450,7 @@ DEFINE_ACTION_FUNCTION(AActor, Vec2Offset)
PARAM_SELF_PROLOGUE(AActor);
PARAM_FLOAT(x);
PARAM_FLOAT(y);
PARAM_BOOL_DEF(absolute);
PARAM_BOOL(absolute);
ACTION_RETURN_VEC2(self->Vec2Offset(x, y, absolute));
}
@ -8460,7 +8460,7 @@ DEFINE_ACTION_FUNCTION(AActor, Vec3Offset)
PARAM_FLOAT(x);
PARAM_FLOAT(y);
PARAM_FLOAT(z);
PARAM_BOOL_DEF(absolute);
PARAM_BOOL(absolute);
ACTION_RETURN_VEC3(self->Vec3Offset(x, y, z, absolute));
}

40
src/p_pspr.cpp
View file

@ -240,7 +240,7 @@ DEFINE_ACTION_FUNCTION(_PlayerInfo, SetPSprite) // the underscore is needed to g
PARAM_SELF_STRUCT_PROLOGUE(player_t);
PARAM_INT(id);
PARAM_POINTER(state, FState);
PARAM_BOOL_DEF(pending);
PARAM_BOOL(pending);
P_SetPsprite(self, (PSPLayers)id, state, pending);
return 0;
}
@ -540,7 +540,7 @@ DEFINE_ACTION_FUNCTION(DPSprite, SetState)
{
PARAM_SELF_PROLOGUE(DPSprite);
PARAM_POINTER(state, FState);
PARAM_BOOL_DEF(pending);
PARAM_BOOL(pending);
self->SetState(state, pending);
return 0;
}
@ -856,7 +856,7 @@ void DoReadyWeaponToGeneric(AActor *self, int paramflags)
DEFINE_ACTION_FUNCTION(AStateProvider, A_WeaponReady)
{
PARAM_ACTION_PROLOGUE(AStateProvider);
PARAM_INT_DEF(flags);
PARAM_INT(flags);
DoReadyWeaponToSwitch(self, !(flags & WRF_NoSwitch));
if ((flags & WRF_NoFire) != WRF_NoFire) DoReadyWeaponToFire(self, !(flags & WRF_NoPrimary), !(flags & WRF_NoSecondary));
@ -972,10 +972,10 @@ void A_OverlayOffset(AActor *self, int layer, double wx, double wy, int flags)
DEFINE_ACTION_FUNCTION(AActor, A_OverlayOffset)
{
PARAM_ACTION_PROLOGUE(AActor);
PARAM_INT_DEF(layer)
PARAM_FLOAT_DEF(wx)
PARAM_FLOAT_DEF(wy)
PARAM_INT_DEF(flags)
PARAM_INT(layer)
PARAM_FLOAT(wx)
PARAM_FLOAT(wy)
PARAM_INT(flags)
A_OverlayOffset(self, ((layer != 0) ? layer : stateinfo->mPSPIndex), wx, wy, flags);
return 0;
}
@ -983,9 +983,9 @@ DEFINE_ACTION_FUNCTION(AActor, A_OverlayOffset)
DEFINE_ACTION_FUNCTION(AActor, A_WeaponOffset)
{
PARAM_SELF_PROLOGUE(AActor);
PARAM_FLOAT_DEF(wx)
PARAM_FLOAT_DEF(wy)
PARAM_INT_DEF(flags)
PARAM_FLOAT(wx)
PARAM_FLOAT(wy)
PARAM_INT(flags)
A_OverlayOffset(self, PSP_WEAPON, wx, wy, flags);
return 0;
}
@ -1042,7 +1042,7 @@ static double GetOverlayPosition(AActor *self, int layer, bool gety)
DEFINE_ACTION_FUNCTION(AActor, OverlayX)
{
PARAM_ACTION_PROLOGUE(AActor);
PARAM_INT_DEF(layer);
PARAM_INT(layer);
if (ACTION_CALL_FROM_PSPRITE())
{
@ -1055,7 +1055,7 @@ DEFINE_ACTION_FUNCTION(AActor, OverlayX)
DEFINE_ACTION_FUNCTION(AActor, OverlayY)
{
PARAM_ACTION_PROLOGUE(AActor);
PARAM_INT_DEF(layer);
PARAM_INT(layer);
if (ACTION_CALL_FROM_PSPRITE())
{
@ -1108,7 +1108,7 @@ DEFINE_ACTION_FUNCTION(AActor, A_OverlayAlpha)
DEFINE_ACTION_FUNCTION(AActor, OverlayAlpha)
{
PARAM_ACTION_PROLOGUE(AActor);
PARAM_INT_DEF(layer);
PARAM_INT(layer);
if (ACTION_CALL_FROM_PSPRITE())
{
@ -1156,8 +1156,8 @@ DEFINE_ACTION_FUNCTION(AActor, A_Overlay)
{
PARAM_ACTION_PROLOGUE(AActor);
PARAM_INT (layer);
PARAM_STATE_ACTION_DEF(state);
PARAM_BOOL_DEF(dontoverride);
PARAM_STATE_ACTION(state);
PARAM_BOOL(dontoverride);
player_t *player = self->player;
@ -1175,9 +1175,9 @@ DEFINE_ACTION_FUNCTION(AActor, A_Overlay)
DEFINE_ACTION_FUNCTION(AActor, A_ClearOverlays)
{
PARAM_SELF_PROLOGUE(AActor);
PARAM_INT_DEF(start);
PARAM_INT_DEF(stop);
PARAM_BOOL_DEF(safety)
PARAM_INT(start);
PARAM_INT(stop);
PARAM_BOOL(safety)
if (self->player == nullptr)
ACTION_RETURN_INT(0);
@ -1255,8 +1255,8 @@ DAngle P_BulletSlope (AActor *mo, FTranslatedLineTarget *pLineTarget, int aimfla
DEFINE_ACTION_FUNCTION(AActor, BulletSlope)
{
PARAM_SELF_PROLOGUE(AActor);
PARAM_POINTER_DEF(t, FTranslatedLineTarget);
PARAM_INT_DEF(aimflags);
PARAM_POINTER(t, FTranslatedLineTarget);
PARAM_INT(aimflags);
ACTION_RETURN_FLOAT(P_BulletSlope(self, t, aimflags).Degrees);
}

14
src/p_sectors.cpp
View file

@ -1300,7 +1300,7 @@ DEFINE_ACTION_FUNCTION(_Sector, NextHighestCeilingAt)
PARAM_FLOAT(y);
PARAM_FLOAT(bottomz);
PARAM_FLOAT(topz);
PARAM_INT_DEF(flags);
PARAM_INT(flags);
sector_t *resultsec;
F3DFloor *resultff;
double resultheight = self->NextHighestCeilingAt(x, y, bottomz, topz, flags, &resultsec, &resultff);
@ -1377,8 +1377,8 @@ DEFINE_ACTION_FUNCTION(_Sector, NextLowestFloorAt)
PARAM_FLOAT(x);
PARAM_FLOAT(y);
PARAM_FLOAT(z);
PARAM_INT_DEF(flags);
PARAM_FLOAT_DEF(steph);
PARAM_INT(flags);
PARAM_FLOAT(steph);
sector_t *resultsec;
F3DFloor *resultff;
double resultheight = self->NextLowestFloorAt(x, y, z, flags, steph, &resultsec, &resultff);
@ -1723,7 +1723,7 @@ DEFINE_ACTION_FUNCTION(_Sector, NextLowestFloorAt)
{
PARAM_SELF_STRUCT_PROLOGUE(sector_t);
PARAM_INT(pos);
PARAM_BOOL_DEF(addbase);
PARAM_BOOL(addbase);
ACTION_RETURN_FLOAT(self->GetYOffset(pos, addbase));
}
@ -1773,7 +1773,7 @@ DEFINE_ACTION_FUNCTION(_Sector, NextLowestFloorAt)
{
PARAM_SELF_STRUCT_PROLOGUE(sector_t);
PARAM_INT(pos);
PARAM_BOOL_DEF(addbase);
PARAM_BOOL(addbase);
ACTION_RETURN_FLOAT(self->GetAngle(pos, addbase).Degrees);
}
@ -1848,7 +1848,7 @@ DEFINE_ACTION_FUNCTION(_Sector, NextLowestFloorAt)
PARAM_SELF_STRUCT_PROLOGUE(sector_t);
PARAM_INT(pos);
PARAM_INT(o);
PARAM_BOOL_DEF(adj);
PARAM_BOOL(adj);
self->SetTexture(pos, FSetTextureID(o), adj);
return 0;
}
@ -1865,7 +1865,7 @@ DEFINE_ACTION_FUNCTION(_Sector, NextLowestFloorAt)
PARAM_SELF_STRUCT_PROLOGUE(sector_t);
PARAM_INT(pos);
PARAM_FLOAT(o);
PARAM_BOOL_DEF(dirty);
PARAM_BOOL(dirty);
self->SetPlaneTexZ(pos, o, true); // not setting 'dirty' here is a guaranteed cause for problems.
return 0;
}

2
src/p_sight.cpp
View file

@ -940,7 +940,7 @@ DEFINE_ACTION_FUNCTION(AActor, CheckSight)
{
PARAM_SELF_PROLOGUE(AActor);
PARAM_OBJECT_NOT_NULL(target, AActor);
PARAM_INT_DEF(flags);
PARAM_INT(flags);
ACTION_RETURN_BOOL(P_CheckSight(self, target, flags));
}

8
src/p_spec.cpp
View file

@ -618,8 +618,8 @@ void P_GiveSecret(AActor *actor, bool printmessage, bool playsound, int sectornu
DEFINE_ACTION_FUNCTION(AActor, GiveSecret)
{
PARAM_SELF_PROLOGUE(AActor);
PARAM_BOOL_DEF(printmessage);
PARAM_BOOL_DEF(playsound);
PARAM_BOOL(printmessage);
PARAM_BOOL(playsound);
P_GiveSecret(self, printmessage, playsound, -1);
return 0;
}
@ -629,8 +629,8 @@ DEFINE_ACTION_FUNCTION(FLevelLocals, GiveSecret)
{
PARAM_PROLOGUE;
PARAM_OBJECT(activator, AActor);
PARAM_BOOL_DEF(printmessage);
PARAM_BOOL_DEF(playsound);
PARAM_BOOL(printmessage);
PARAM_BOOL(playsound);
P_GiveSecret(activator, printmessage, playsound, -1);
return 0;
}

8
src/p_states.cpp
View file

@ -61,9 +61,9 @@ DEFINE_ACTION_FUNCTION(FState, GetSpriteTexture)
{
PARAM_SELF_STRUCT_PROLOGUE(FState);
PARAM_INT(rotation);
PARAM_INT_DEF(skin);
PARAM_FLOAT_DEF(scalex);
PARAM_FLOAT_DEF(scaley);
PARAM_INT(skin);
PARAM_FLOAT(scalex);
PARAM_FLOAT(scaley);
spriteframe_t *sprframe;
if (skin == 0)
@ -378,7 +378,7 @@ DEFINE_ACTION_FUNCTION(AActor, FindState)
{
PARAM_SELF_PROLOGUE(AActor);
PARAM_INT(newstate);
PARAM_BOOL_DEF(exact)
PARAM_BOOL(exact)
ACTION_RETURN_STATE(StateLabels.GetState(newstate, self->GetClass(), exact));
}

2
src/p_tags.cpp
View file

@ -381,7 +381,7 @@ DEFINE_ACTION_FUNCTION(DSectorTagIterator, Create)
{
PARAM_PROLOGUE;
PARAM_INT(tag);
PARAM_POINTER_DEF(line, line_t);
PARAM_POINTER(line, line_t);
ACTION_RETURN_POINTER(Create<DSectorTagIterator>(tag, line));
}

24
src/p_things.cpp
View file

@ -234,9 +234,9 @@ DEFINE_ACTION_FUNCTION(AActor, VelIntercept)
{
PARAM_SELF_PROLOGUE(AActor);
PARAM_OBJECT_NOT_NULL(targ, AActor);
PARAM_FLOAT_DEF(speed);
PARAM_BOOL_DEF(aimpitch);
PARAM_BOOL_DEF(oldvel);
PARAM_FLOAT(speed);
PARAM_BOOL(aimpitch);
PARAM_BOOL(oldvel);
if (speed < 0) speed = self->Speed;
VelIntercept(targ, self, speed, aimpitch, oldvel);
return 0;
@ -993,15 +993,15 @@ int P_Thing_Warp(AActor *caller, AActor *reference, double xofs, double yofs, do
DEFINE_ACTION_FUNCTION(AActor, Warp)
{
PARAM_SELF_PROLOGUE(AActor)
PARAM_OBJECT_DEF(destination, AActor)
PARAM_FLOAT_DEF(xofs)
PARAM_FLOAT_DEF(yofs)
PARAM_FLOAT_DEF(zofs)
PARAM_ANGLE_DEF(angle)
PARAM_INT_DEF(flags)
PARAM_FLOAT_DEF(heightoffset)
PARAM_FLOAT_DEF(radiusoffset)
PARAM_ANGLE_DEF(pitch)
PARAM_OBJECT(destination, AActor)
PARAM_FLOAT(xofs)
PARAM_FLOAT(yofs)
PARAM_FLOAT(zofs)
PARAM_ANGLE(angle)
PARAM_INT(flags)
PARAM_FLOAT(heightoffset)
PARAM_FLOAT(radiusoffset)
PARAM_ANGLE(pitch)
ACTION_RETURN_INT(!!P_Thing_Warp(self, destination, xofs, yofs, zofs, angle, flags, heightoffset, radiusoffset, pitch));
}

6
src/p_user.cpp
View file

@ -1385,7 +1385,7 @@ int APlayerPawn::GetMaxHealth(bool withupgrades) const
DEFINE_ACTION_FUNCTION(APlayerPawn, GetMaxHealth)
{
PARAM_SELF_PROLOGUE(APlayerPawn);
PARAM_BOOL_DEF(withupgrades);
PARAM_BOOL(withupgrades);
ACTION_RETURN_INT(self->GetMaxHealth(withupgrades));
}
@ -1445,7 +1445,7 @@ bool APlayerPawn::ResetAirSupply (bool playgasp)
DEFINE_ACTION_FUNCTION(APlayerPawn, ResetAirSupply)
{
PARAM_SELF_PROLOGUE(APlayerPawn);
PARAM_BOOL_DEF(playgasp);
PARAM_BOOL(playgasp);
ACTION_RETURN_BOOL(self->ResetAirSupply(playgasp));
}
@ -1771,7 +1771,7 @@ DEFINE_ACTION_FUNCTION(AActor, A_PlayerScream)
DEFINE_ACTION_FUNCTION(AActor, A_SkullPop)
{
PARAM_SELF_PROLOGUE(AActor);
PARAM_CLASS_DEF(spawntype, APlayerPawn);
PARAM_CLASS(spawntype, APlayerPawn);
APlayerPawn *mo;
player_t *player;

4
src/s_sndseq.cpp
View file

@ -900,7 +900,7 @@ DEFINE_ACTION_FUNCTION(AActor, StartSoundSequenceID)
PARAM_INT(seq);
PARAM_INT(type);
PARAM_INT(modenum);
PARAM_BOOL_DEF(nostop);
PARAM_BOOL(nostop);
ACTION_RETURN_POINTER(SN_StartSequence(self, seq, seqtype_t(type), modenum, nostop));
}
@ -924,7 +924,7 @@ DEFINE_ACTION_FUNCTION(_Sector, StartSoundSequenceID)
PARAM_INT(seq);
PARAM_INT(type);
PARAM_INT(modenum);
PARAM_BOOL_DEF(nostop);
PARAM_BOOL(nostop);
ACTION_RETURN_POINTER(SN_StartSequence(self, chan, seq, seqtype_t(type), modenum, nostop));
}

10
src/s_sound.cpp
View file

@ -1342,8 +1342,8 @@ DEFINE_ACTION_FUNCTION(DObject, S_Sound)
PARAM_PROLOGUE;
PARAM_SOUND(id);
PARAM_INT(channel);
PARAM_FLOAT_DEF(volume);
PARAM_FLOAT_DEF(attn);
PARAM_FLOAT(volume);
PARAM_FLOAT(attn);
S_Sound(channel, id, static_cast<float>(volume), static_cast<float>(attn));
return 0;
}
@ -2736,9 +2736,9 @@ DEFINE_ACTION_FUNCTION(DObject, S_ChangeMusic)
{
PARAM_PROLOGUE;
PARAM_STRING(music);
PARAM_INT_DEF(order);
PARAM_BOOL_DEF(looping);
PARAM_BOOL_DEF(force);
PARAM_INT(order);
PARAM_BOOL(looping);
PARAM_BOOL(force);
ACTION_RETURN_BOOL(S_ChangeMusic(music, order, looping, force));
}

24
src/scripting/backend/codegen.cpp
View file

@ -5512,7 +5512,7 @@ FxExpression *FxRandom::Resolve(FCompileContext &ctx)
//
//==========================================================================
int BuiltinRandom(VMValue *param, TArray<VMValue> &defaultparam, int numparam, VMReturn *ret, int numret)
int BuiltinRandom(VMValue *param, int numparam, VMReturn *ret, int numret)
{
PARAM_PROLOGUE;
PARAM_POINTER(rng, FRandom);
@ -5744,7 +5744,7 @@ FxFRandom::FxFRandom(FRandom *r, FxExpression *mi, FxExpression *ma, const FScri
//
//==========================================================================
int BuiltinFRandom(VMValue *param, TArray<VMValue> &defaultparam, int numparam, VMReturn *ret, int numret)
int BuiltinFRandom(VMValue *param, int numparam, VMReturn *ret, int numret)
{
PARAM_PROLOGUE;
PARAM_POINTER(rng, FRandom);
@ -5850,7 +5850,7 @@ FxExpression *FxRandom2::Resolve(FCompileContext &ctx)
//
//==========================================================================
int BuiltinRandom2(VMValue *param, TArray<VMValue> &defaultparam, int numparam, VMReturn *ret, int numret)
int BuiltinRandom2(VMValue *param, int numparam, VMReturn *ret, int numret)
{
PARAM_PROLOGUE;
PARAM_POINTER(rng, FRandom);
@ -5938,7 +5938,7 @@ FxExpression *FxRandomSeed::Resolve(FCompileContext &ctx)
//
//==========================================================================
int BuiltinRandomSeed(VMValue *param, TArray<VMValue> &defaultparam, int numparam, VMReturn *ret, int numret)
int BuiltinRandomSeed(VMValue *param, int numparam, VMReturn *ret, int numret)
{
PARAM_PROLOGUE;
PARAM_POINTER(rng, FRandom)
@ -8624,16 +8624,16 @@ FxExpression *FxActionSpecialCall::Resolve(FCompileContext& ctx)
//
//==========================================================================
int BuiltinCallLineSpecial(VMValue *param, TArray<VMValue> &defaultparam, int numparam, VMReturn *ret, int numret)
int BuiltinCallLineSpecial(VMValue *param, int numparam, VMReturn *ret, int numret)
{
PARAM_PROLOGUE;
PARAM_INT(special);
PARAM_OBJECT(activator, AActor);
PARAM_INT_DEF(arg1);
PARAM_INT_DEF(arg2);
PARAM_INT_DEF(arg3);
PARAM_INT_DEF(arg4);
PARAM_INT_DEF(arg5);
PARAM_INT(arg1);
PARAM_INT(arg2);
PARAM_INT(arg3);
PARAM_INT(arg4);
PARAM_INT(arg5);
ACTION_RETURN_INT(P_ExecuteSpecial(special, nullptr, activator, 0, arg1, arg2, arg3, arg4, arg5));
}
@ -10898,7 +10898,7 @@ FxExpression *FxClassTypeCast::Resolve(FCompileContext &ctx)
//
//==========================================================================
int BuiltinNameToClass(VMValue *param, TArray<VMValue> &defaultparam, int numparam, VMReturn *ret, int numret)
int BuiltinNameToClass(VMValue *param, int numparam, VMReturn *ret, int numret)
{
PARAM_PROLOGUE;
PARAM_NAME(clsname);
@ -11023,7 +11023,7 @@ FxExpression *FxClassPtrCast::Resolve(FCompileContext &ctx)
//
//==========================================================================
int BuiltinClassCast(VMValue *param, TArray<VMValue> &defaultparam, int numparam, VMReturn *ret, int numret)
int BuiltinClassCast(VMValue *param, int numparam, VMReturn *ret, int numret)
{
PARAM_PROLOGUE;
PARAM_CLASS(from, DObject);

16
src/scripting/backend/dynarrays.cpp
View file

@ -114,7 +114,7 @@ DEFINE_ACTION_FUNCTION(FDynArray_I8, Delete)
{
PARAM_SELF_STRUCT_PROLOGUE(FDynArray_I8);
PARAM_INT(index);
PARAM_INT_DEF(count);
PARAM_INT(count);
self->Delete(index, count);
return 0;
}
@ -219,7 +219,7 @@ DEFINE_ACTION_FUNCTION(FDynArray_I16, Delete)
{
PARAM_SELF_STRUCT_PROLOGUE(FDynArray_I16);
PARAM_INT(index);
PARAM_INT_DEF(count);
PARAM_INT(count);
self->Delete(index, count);
return 0;
}
@ -324,7 +324,7 @@ DEFINE_ACTION_FUNCTION(FDynArray_I32, Delete)
{
PARAM_SELF_STRUCT_PROLOGUE(FDynArray_I32);
PARAM_INT(index);
PARAM_INT_DEF(count);
PARAM_INT(count);
self->Delete(index, count);
return 0;
}
@ -429,7 +429,7 @@ DEFINE_ACTION_FUNCTION(FDynArray_F32, Delete)
{
PARAM_SELF_STRUCT_PROLOGUE(FDynArray_F32);
PARAM_INT(index);
PARAM_INT_DEF(count);
PARAM_INT(count);
self->Delete(index, count);
return 0;
}
@ -534,7 +534,7 @@ DEFINE_ACTION_FUNCTION(FDynArray_F64, Delete)
{
PARAM_SELF_STRUCT_PROLOGUE(FDynArray_F64);
PARAM_INT(index);
PARAM_INT_DEF(count);
PARAM_INT(count);
self->Delete(index, count);
return 0;
}
@ -639,7 +639,7 @@ DEFINE_ACTION_FUNCTION(FDynArray_Ptr, Delete)
{
PARAM_SELF_STRUCT_PROLOGUE(FDynArray_Ptr);
PARAM_INT(index);
PARAM_INT_DEF(count);
PARAM_INT(count);
self->Delete(index, count);
return 0;
}
@ -746,7 +746,7 @@ DEFINE_ACTION_FUNCTION(FDynArray_Obj, Delete)
{
PARAM_SELF_STRUCT_PROLOGUE(FDynArray_Obj);
PARAM_INT(index);
PARAM_INT_DEF(count);
PARAM_INT(count);
self->Delete(index, count);
return 0;
}
@ -853,7 +853,7 @@ DEFINE_ACTION_FUNCTION(FDynArray_String, Delete)
{
PARAM_SELF_STRUCT_PROLOGUE(FDynArray_String);
PARAM_INT(index);
PARAM_INT_DEF(count);
PARAM_INT(count);
self->Delete(index, count);
return 0;
}

20
src/scripting/thingdef_data.cpp
View file

@ -1008,7 +1008,7 @@ DEFINE_ACTION_FUNCTION(FStringTable, Localize)
{
PARAM_PROLOGUE;
PARAM_STRING(label);
PARAM_BOOL_DEF(prefixed);
PARAM_BOOL(prefixed);
if (!prefixed) ACTION_RETURN_STRING(GStrings(label));
if (label[0] != '$') ACTION_RETURN_STRING(label);
ACTION_RETURN_STRING(GStrings(&label[1]));
@ -1184,7 +1184,7 @@ FString FStringFormat(VM_ARGS)
DEFINE_ACTION_FUNCTION(FStringStruct, Format)
{
PARAM_PROLOGUE;
FString s = FStringFormat(param, defaultparam, numparam, ret, numret);
FString s = FStringFormat(param, numparam, ret, numret);
ACTION_RETURN_STRING(s);
}
@ -1192,7 +1192,7 @@ DEFINE_ACTION_FUNCTION(FStringStruct, AppendFormat)
{
PARAM_SELF_STRUCT_PROLOGUE(FString);
// first parameter is the self pointer
FString s = FStringFormat(param+1, defaultparam, numparam-1, ret, numret);
FString s = FStringFormat(param+1, numparam-1, ret, numret);
(*self) += s;
return 0;
}
@ -1200,8 +1200,8 @@ DEFINE_ACTION_FUNCTION(FStringStruct, AppendFormat)
DEFINE_ACTION_FUNCTION(FStringStruct, Mid)
{
PARAM_SELF_STRUCT_PROLOGUE(FString);
PARAM_UINT_DEF(pos);
PARAM_UINT_DEF(len);
PARAM_UINT(pos);
PARAM_UINT(len);
FString s = self->Mid(pos, len);
ACTION_RETURN_STRING(s);
}
@ -1262,7 +1262,7 @@ DEFINE_ACTION_FUNCTION(FStringStruct, IndexOf)
{
PARAM_SELF_STRUCT_PROLOGUE(FString);
PARAM_STRING(substr);
PARAM_INT_DEF(startIndex);
PARAM_INT(startIndex);
ACTION_RETURN_INT(self->IndexOf(substr, startIndex));
}
@ -1270,7 +1270,7 @@ DEFINE_ACTION_FUNCTION(FStringStruct, LastIndexOf)
{
PARAM_SELF_STRUCT_PROLOGUE(FString);
PARAM_STRING(substr);
PARAM_INT_DEF(endIndex);
PARAM_INT(endIndex);
ACTION_RETURN_INT(self->LastIndexOfBroken(substr, endIndex));
}
@ -1278,7 +1278,7 @@ DEFINE_ACTION_FUNCTION(FStringStruct, RightIndexOf)
{
PARAM_SELF_STRUCT_PROLOGUE(FString);
PARAM_STRING(substr);
PARAM_INT_DEF(endIndex);
PARAM_INT(endIndex);
ACTION_RETURN_INT(self->LastIndexOf(substr, endIndex));
}
@ -1299,7 +1299,7 @@ DEFINE_ACTION_FUNCTION(FStringStruct, ToLower)
DEFINE_ACTION_FUNCTION(FStringStruct, ToInt)
{
PARAM_SELF_STRUCT_PROLOGUE(FString);
PARAM_INT_DEF(base);
PARAM_INT(base);
ACTION_RETURN_INT(self->ToLong(base));
}
@ -1314,7 +1314,7 @@ DEFINE_ACTION_FUNCTION(FStringStruct, Split)
PARAM_SELF_STRUCT_PROLOGUE(FString);
PARAM_POINTER(tokens, TArray<FString>);
PARAM_STRING(delimiter);
PARAM_INT_DEF(keepEmpty);
PARAM_INT(keepEmpty);
self->Split(*tokens, delimiter, static_cast<FString::EmptyTokenType>(keepEmpty));
return 0;
}

41
src/scripting/vm/vm.h
View file

@ -359,7 +359,7 @@ protected:
class VMNativeFunction : public VMFunction
{
public:
typedef int (*NativeCallType)(VMValue *param, TArray<VMValue> &defaultparam, int numparam, VMReturn *ret, int numret);
typedef int (*NativeCallType)(VMValue *param, int numparam, VMReturn *ret, int numret);
// 8 is VARF_Native. I can't write VARF_Native because of circular references between this and dobject/dobjtype.
VMNativeFunction() : NativeCall(NULL) { VarFlags = 8; ScriptCall = &VMNativeFunction::NativeScriptCall; }
@ -382,8 +382,8 @@ inline int VMCallAction(VMFunction *func, VMValue *params, int numparams, VMRetu
}
// Use this in the prototype for a native function.
#define VM_ARGS VMValue *param, TArray<VMValue> &defaultparam, int numparam, VMReturn *ret, int numret
#define VM_ARGS_NAMES param, defaultparam, numparam, ret, numret
#define VM_ARGS VMValue *param, int numparam, VMReturn *ret, int numret
#define VM_ARGS_NAMES param, numparam, ret, numret
// Use these to collect the parameters in a native function.
// variable name <x> at position <p>
@ -421,23 +421,6 @@ bool AssertObject(void * ob);
#define PARAM_OBJECT_NOT_NULL_AT(p,x,type) assert((p) < numparam); assert(param[p].Type == REGT_POINTER && (AssertObject(param[p].a))); type *x = (type *)PARAM_NULLCHECK(param[p].a, #x); assert(x == NULL || x->IsKindOf(RUNTIME_CLASS(type)));
#define PARAM_CLASS_NOT_NULL_AT(p,x,base) assert((p) < numparam); assert(param[p].Type == REGT_POINTER); base::MetaClass *x = (base::MetaClass *)PARAM_NULLCHECK(param[p].a, #x); assert(x == NULL || x->IsDescendantOf(RUNTIME_CLASS(base)));
#define PARAM_EXISTS(p) ((p) < numparam)
#define PARAM_INT_DEF_AT(p,x) int x; if (PARAM_EXISTS(p)) { ASSERTINT(param[p]); x = param[p].i; } else { ASSERTINT(defaultparam[p]); x = defaultparam[p].i; }
#define PARAM_UINT_DEF_AT(p,x) unsigned x; if (PARAM_EXISTS(p)) { ASSERTINT(param[p]); x = param[p].i; } else { ASSERTINT(defaultparam[p]); x = defaultparam[p].i; }
#define PARAM_BOOL_DEF_AT(p,x) bool x; if (PARAM_EXISTS(p)) { ASSERTINT(param[p]); x = !!param[p].i; } else { ASSERTINT(defaultparam[p]); x = !!defaultparam[p].i; }
#define PARAM_NAME_DEF_AT(p,x) FName x; if (PARAM_EXISTS(p)) { ASSERTINT(param[p]); x = ENamedName(param[p].i); } else { ASSERTINT(defaultparam[p]); x = ENamedName(defaultparam[p].i); }
#define PARAM_SOUND_DEF_AT(p,x) FSoundID x; if (PARAM_EXISTS(p)) { ASSERTINT(param[p]); x = FSoundID(param[p].i); } else { ASSERTINT(defaultparam[p]); x = FSoundID(defaultparam[p].i); }
#define PARAM_COLOR_DEF_AT(p,x) PalEntry x; if (PARAM_EXISTS(p)) { ASSERTINT(param[p]); x = param[p].i; } else { ASSERTINT(defaultparam[p]); x = defaultparam[p].i; }
#define PARAM_FLOAT_DEF_AT(p,x) double x; if (PARAM_EXISTS(p)) { ASSERTFLOAT(param[p]); x = param[p].f; } else { ASSERTFLOAT(defaultparam[p]); x = defaultparam[p].f; }
#define PARAM_ANGLE_DEF_AT(p,x) DAngle x; if (PARAM_EXISTS(p)) { ASSERTFLOAT(param[p]); x = param[p].f; } else { ASSERTFLOAT(defaultparam[p]); x = defaultparam[p].f; }
#define PARAM_STRING_DEF_AT(p,x) FString x; if (PARAM_EXISTS(p)) { ASSERTSTRING(param[p]); x = param[p].s(); } else { ASSERTSTRING(defaultparam[p]); x = defaultparam[p].s(); }
#define PARAM_STATE_DEF_AT(p,x) FState *x; if (PARAM_EXISTS(p)) { ASSERTINT(param[p]); x = (FState*)StateLabels.GetState(param[p].i, self->GetClass()); } else { ASSERTINT(defaultparam[p]); x = (FState*)StateLabels.GetState(defaultparam[p].i, self->GetClass()); }
#define PARAM_STATE_ACTION_DEF_AT(p,x) FState *x; if (PARAM_EXISTS(p)) { ASSERTINT(param[p]); x = (FState*)StateLabels.GetState(param[p].i, stateowner->GetClass()); } else { ASSERTINT(defaultparam[p]); x = (FState*)StateLabels.GetState(defaultparam[p].i, stateowner->GetClass()); }
#define PARAM_POINTER_DEF_AT(p,x,t) t *x; if (PARAM_EXISTS(p)) { ASSERTPOINTER(param[p]); x = (t*)param[p].a; } else { ASSERTPOINTER(defaultparam[p]); x = (t*)defaultparam[p].a; }
#define PARAM_OBJECT_DEF_AT(p,x,t) t *x; if (PARAM_EXISTS(p)) { ASSERTOBJECT(param[p]); x = (t*)param[p].a; } else { ASSERTOBJECT(defaultparam[p]); x = (t*)defaultparam[p].a; }
#define PARAM_CLASS_DEF_AT(p,x,t) t::MetaClass *x; if (PARAM_EXISTS(p)) { x = (t::MetaClass*)param[p].a; } else { ASSERTPOINTER(defaultparam[p]); x = (t::MetaClass*)defaultparam[p].a; }
#define PARAM_CLASS_DEF_NOT_NULL_AT(p,x,t) t::MetaClass *x; if (PARAM_EXISTS(p)) { x = (t::MetaClass*)PARAM_NULLCHECK(param[p].a, #x); } else { x = (t::MetaClass*)PARAM_NULLCHECK(defaultparam[p].a, #x); }
// The above, but with an automatically increasing position index.
#define PARAM_PROLOGUE int paramnum = -1;
@ -462,23 +445,7 @@ bool AssertObject(void * ob);
#define PARAM_OBJECT_NOT_NULL(x,type) ++paramnum; PARAM_OBJECT_NOT_NULL_AT(paramnum,x,type)
#define PARAM_CLASS_NOT_NULL(x,base) ++paramnum; PARAM_CLASS_NOT_NULL_AT(paramnum,x,base)
#define PARAM_INT_DEF(x) ++paramnum; PARAM_INT_DEF_AT(paramnum,x)
#define PARAM_UINT_DEF(x) ++paramnum; PARAM_UINT_DEF_AT(paramnum,x)
#define PARAM_BOOL_DEF(x) ++paramnum; PARAM_BOOL_DEF_AT(paramnum,x)
#define PARAM_NAME_DEF(x) ++paramnum; PARAM_NAME_DEF_AT(paramnum,x)
#define PARAM_SOUND_DEF(x) ++paramnum; PARAM_SOUND_DEF_AT(paramnum,x)
#define PARAM_COLOR_DEF(x) ++paramnum; PARAM_COLOR_DEF_AT(paramnum,x)
#define PARAM_FLOAT_DEF(x) ++paramnum; PARAM_FLOAT_DEF_AT(paramnum,x)
#define PARAM_ANGLE_DEF(x) ++paramnum; PARAM_ANGLE_DEF_AT(paramnum,x)
#define PARAM_STRING_DEF(x) ++paramnum; PARAM_STRING_DEF_AT(paramnum,x)
#define PARAM_STATE_DEF(x) ++paramnum; PARAM_STATE_DEF_AT(paramnum,x)
#define PARAM_STATE_ACTION_DEF(x) ++paramnum; PARAM_STATE_ACTION_DEF_AT(paramnum,x)
#define PARAM_POINTER_DEF(x,type) ++paramnum; PARAM_POINTER_DEF_AT(paramnum,x,type)
#define PARAM_OBJECT_DEF(x,type) ++paramnum; PARAM_OBJECT_DEF_AT(paramnum,x,type)
#define PARAM_CLASS_DEF(x,base) ++paramnum; PARAM_CLASS_DEF_AT(paramnum,x,base)
#define PARAM_CLASS_DEF_NOT_NULL(x,base) ++paramnum; PARAM_CLASS_DEF_NOT_NULL_AT(paramnum,x,base)
typedef int(*actionf_p)(VMValue *param, TArray<VMValue> &defaultparam, int numparam, VMReturn *ret, int numret);/*(VM_ARGS)*/
typedef int(*actionf_p)(VMValue *param, int numparam, VMReturn *ret, int numret);/*(VM_ARGS)*/
struct FieldDesc
{

4
src/scripting/vm/vmexec.h
View file

@ -697,7 +697,7 @@ static int ExecScriptFunc(VMFrameStack *stack, VMReturn *ret, int numret)
try
{
VMCycles[0].Unclock();
numret = static_cast<VMNativeFunction *>(call)->NativeCall(reg.param + f->NumParam - b, call->DefaultArgs, b, returns, C);
numret = static_cast<VMNativeFunction *>(call)->NativeCall(reg.param + f->NumParam - b, b, returns, C);
VMCycles[0].Clock();
}
catch (CVMAbortException &err)
@ -738,7 +738,7 @@ static int ExecScriptFunc(VMFrameStack *stack, VMReturn *ret, int numret)
try
{
VMCycles[0].Unclock();
auto r = static_cast<VMNativeFunction *>(call)->NativeCall(reg.param + f->NumParam - B, call->DefaultArgs, B, ret, numret);
auto r = static_cast<VMNativeFunction *>(call)->NativeCall(reg.param + f->NumParam - B, B, ret, numret);
VMCycles[0].Clock();
return r;
}

6
src/scripting/vm/vmframe.cpp
View file

@ -260,7 +260,7 @@ int VMNativeFunction::NativeScriptCall(VMFunction *func, VMValue *params, int nu
try
{
VMCycles[0].Unclock();
numret = static_cast<VMNativeFunction *>(func)->NativeCall(params, func->DefaultArgs, numparams, returns, numret);
numret = static_cast<VMNativeFunction *>(func)->NativeCall(params, numparams, returns, numret);
VMCycles[0].Clock();
return numret;
@ -535,7 +535,7 @@ int VMCall(VMFunction *func, VMValue *params, int numparams, VMReturn *results,
{
if (func->VarFlags & VARF_Native)
{
return static_cast<VMNativeFunction *>(func)->NativeCall(params, func->DefaultArgs, numparams, results, numresults);
return static_cast<VMNativeFunction *>(func)->NativeCall(params, numparams, results, numresults);
}
else
{
@ -694,7 +694,7 @@ void ThrowAbortException(VMScriptFunction *sfunc, VMOP *line, EVMAbortException
DEFINE_ACTION_FUNCTION(DObject, ThrowAbortException)
{
PARAM_PROLOGUE;
FString s = FStringFormat(param, defaultparam, numparam, ret, numret);
FString s = FStringFormat(param, numparam, ret, numret);
ThrowAbortException(X_OTHER, s.GetChars());
return 0;
}

2
src/textures/texturemanager.cpp
View file

@ -265,7 +265,7 @@ DEFINE_ACTION_FUNCTION(_TexMan, CheckForTexture)
PARAM_PROLOGUE;
PARAM_STRING(name);
PARAM_INT(type);
PARAM_INT_DEF(flags);
PARAM_INT(flags);
ACTION_RETURN_INT(TexMan.CheckForTexture(name, static_cast<ETextureType>(type), flags).GetIndex());
}

2
src/v_2ddrawer.cpp
View file

@ -40,7 +40,7 @@ IMPLEMENT_CLASS(DShape2D, false, false)
DEFINE_ACTION_FUNCTION(DShape2D, Clear)
{
PARAM_SELF_PROLOGUE(DShape2D);
PARAM_INT_DEF(which);
PARAM_INT(which);
if ( which&C_Verts ) self->mVertices.Clear();
if ( which&C_Coords ) self->mCoords.Clear();
if ( which&C_Indices ) self->mIndices.Clear();

10
src/v_draw.cpp
View file

@ -993,8 +993,8 @@ DEFINE_ACTION_FUNCTION(_Screen, VirtualToRealCoords)
PARAM_FLOAT(h);
PARAM_FLOAT(vw);
PARAM_FLOAT(vh);
PARAM_BOOL_DEF(vbottom);
PARAM_BOOL_DEF(handleaspect);
PARAM_BOOL(vbottom);
PARAM_BOOL(handleaspect);
screen->VirtualToRealCoords(x, y, w, h, vw, vh, vbottom, handleaspect);
if (numret >= 1) ret[0].SetVector2(DVector2(x, y));
if (numret >= 2) ret[1].SetVector2(DVector2(w, h));
@ -1088,7 +1088,7 @@ DEFINE_ACTION_FUNCTION(_Screen, DrawLine)
PARAM_INT(x1);
PARAM_INT(y1);
PARAM_INT(color);
PARAM_INT_DEF(alpha);
PARAM_INT(alpha);
if (!screen->HasBegun2D()) ThrowAbortException(X_OTHER, "Attempt to draw to screen outside a draw function");
screen->DrawLine(x0, y0, x1, y1, -1, color, alpha);
return 0;
@ -1107,7 +1107,7 @@ DEFINE_ACTION_FUNCTION(_Screen, DrawThickLine)
PARAM_INT(y1);
PARAM_FLOAT(thickness);
PARAM_INT(color);
PARAM_INT_DEF(alpha);
PARAM_INT(alpha);
if (!screen->HasBegun2D()) ThrowAbortException(X_OTHER, "Attempt to draw to screen outside a draw function");
screen->DrawThickLine(x0, y0, x1, y1, thickness, color, alpha);
return 0;
@ -1172,7 +1172,7 @@ DEFINE_ACTION_FUNCTION(_Screen, Clear)
PARAM_INT(x2);
PARAM_INT(y2);
PARAM_INT(color);
PARAM_INT_DEF(palcol);
PARAM_INT(palcol);
if (!screen->HasBegun2D()) ThrowAbortException(X_OTHER, "Attempt to draw to screen outside a draw function");
screen->Clear(x1, y1, x2, y2, palcol, color);
return 0;

8
src/w_wad.cpp
View file

@ -471,8 +471,8 @@ DEFINE_ACTION_FUNCTION(_Wads, CheckNumForName)
PARAM_PROLOGUE;
PARAM_STRING(name);
PARAM_INT(ns);
PARAM_INT_DEF(wadnum);
PARAM_BOOL_DEF(exact);
PARAM_INT(wadnum);
PARAM_BOOL(exact);
ACTION_RETURN_INT(Wads.CheckNumForName(name, ns, wadnum, exact));
}
//==========================================================================
@ -1081,8 +1081,8 @@ DEFINE_ACTION_FUNCTION(_Wads, FindLump)
{
PARAM_PROLOGUE;
PARAM_STRING(name);
PARAM_INT_DEF(startlump);
PARAM_INT_DEF(ns);
PARAM_INT(startlump);
PARAM_INT(ns);
const bool isLumpValid = startlump >= 0 && startlump < Wads.GetNumLumps();
ACTION_RETURN_INT(isLumpValid ? Wads.FindLump(name, &startlump, 0 != ns) : -1);
}