diff --git a/src/c_console.cpp b/src/c_console.cpp
index eb078033e..115d2bc43 100644
--- a/src/c_console.cpp
+++ b/src/c_console.cpp
@@ -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);
diff --git a/src/c_cvars.cpp b/src/c_cvars.cpp
index 5be8a28a7..ba6a5e53e 100644
--- a/src/c_cvars.cpp
+++ b/src/c_cvars.cpp
@@ -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));
 }
 
diff --git a/src/dsectoreffect.cpp b/src/dsectoreffect.cpp
index 3c33268e8..cee696dfb 100644
--- a/src/dsectoreffect.cpp
+++ b/src/dsectoreffect.cpp
@@ -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));
 }
 
diff --git a/src/dthinker.cpp b/src/dthinker.cpp
index 5605e6c53..eb7a61dcc 100644
--- a/src/dthinker.cpp
+++ b/src/dthinker.cpp
@@ -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));
 }
 
diff --git a/src/events.cpp b/src/events.cpp
index 15ab919ea..8dd9baa96 100755
--- a/src/events.cpp
+++ b/src/events.cpp
@@ -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));
diff --git a/src/g_game.cpp b/src/g_game.cpp
index ffc5b40b5..54ca664cf 100644
--- a/src/g_game.cpp
+++ b/src/g_game.cpp
@@ -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;
 }
diff --git a/src/g_inventory/a_keys.cpp b/src/g_inventory/a_keys.cpp
index c3edfd60f..c41e2ef0a 100644
--- a/src/g_inventory/a_keys.cpp
+++ b/src/g_inventory/a_keys.cpp
@@ -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));
 }
 
diff --git a/src/g_inventory/a_weapons.cpp b/src/g_inventory/a_weapons.cpp
index 25c3918c4..c026eda04 100644
--- a/src/g_inventory/a_weapons.cpp
+++ b/src/g_inventory/a_weapons.cpp
@@ -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));
 }
 
diff --git a/src/g_level.cpp b/src/g_level.cpp
index c51508f04..b1a7cb3ad 100644
--- a/src/g_level.cpp
+++ b/src/g_level.cpp
@@ -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));
diff --git a/src/g_shared/a_action.cpp b/src/g_shared/a_action.cpp
index f48830b35..83b2f3968 100644
--- a/src/g_shared/a_action.cpp
+++ b/src/g_shared/a_action.cpp
@@ -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;
 }
diff --git a/src/g_shared/a_morph.cpp b/src/g_shared/a_morph.cpp
index d8b5a6ecd..95b85349c 100644
--- a/src/g_shared/a_morph.cpp
+++ b/src/g_shared/a_morph.cpp
@@ -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)
 	{
diff --git a/src/g_shared/a_specialspot.cpp b/src/g_shared/a_specialspot.cpp
index 25cb0cd8a..77292a7dc 100644
--- a/src/g_shared/a_specialspot.cpp
+++ b/src/g_shared/a_specialspot.cpp
@@ -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();
diff --git a/src/g_statusbar/shared_sbar.cpp b/src/g_statusbar/shared_sbar.cpp
index 1aaa6a18d..e3430f2cf 100644
--- a/src/g_statusbar/shared_sbar.cpp
+++ b/src/g_statusbar/shared_sbar.cpp
@@ -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);
 }
diff --git a/src/hwrenderer/postprocessing/hw_postprocessshader.cpp b/src/hwrenderer/postprocessing/hw_postprocessshader.cpp
index 2166af154..95205dac6 100644
--- a/src/hwrenderer/postprocessing/hw_postprocessshader.cpp
+++ b/src/hwrenderer/postprocessing/hw_postprocessshader.cpp
@@ -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))
 	{
diff --git a/src/menu/menu.cpp b/src/menu/menu.cpp
index 477ceda96..a09186dcc 100644
--- a/src/menu/menu.cpp
+++ b/src/menu/menu.cpp
@@ -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;
 }
diff --git a/src/menu/messagebox.cpp b/src/menu/messagebox.cpp
index f2a2453ea..e20553673 100644
--- a/src/menu/messagebox.cpp
+++ b/src/menu/messagebox.cpp
@@ -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;
 }
diff --git a/src/p_actionfunctions.cpp b/src/p_actionfunctions.cpp
index aa722ba7a..5973f90b4 100644
--- a/src/p_actionfunctions.cpp
+++ b/src/p_actionfunctions.cpp
@@ -268,8 +268,8 @@ DEFINE_ACTION_FUNCTION(AActor, CheckClass)
 		assert(ret != NULL);
 		PARAM_SELF_PROLOGUE(AActor);
 		PARAM_CLASS		(checktype, AActor);
-		PARAM_INT_DEF	(pick_pointer);
-		PARAM_BOOL_DEF	(match_superclass);
+		PARAM_INT	(pick_pointer);
+		PARAM_BOOL	(match_superclass);
 
 		self = COPY_AAPTR(self, pick_pointer);
 		if (self == nullptr || checktype == nullptr)
@@ -305,7 +305,7 @@ DEFINE_ACTION_FUNCTION(AActor, GetMissileDamage)
 		PARAM_SELF_PROLOGUE(AActor);
 		PARAM_INT(mask);
 		PARAM_INT(add);
-		PARAM_INT_DEF(pick_pointer);
+		PARAM_INT(pick_pointer);
 
 		self = COPY_AAPTR(self, pick_pointer);
 		if (self == NULL)
@@ -336,7 +336,7 @@ DEFINE_ACTION_FUNCTION(AActor, CountInv)
 		assert(ret != NULL);
 		PARAM_SELF_PROLOGUE(AActor);
 		PARAM_CLASS(itemtype, AInventory);
-		PARAM_INT_DEF(pick_pointer);
+		PARAM_INT(pick_pointer);
 
 		self = COPY_AAPTR(self, pick_pointer);
 		if (self == NULL || itemtype == NULL)
@@ -367,7 +367,7 @@ DEFINE_ACTION_FUNCTION(AActor, GetDistance)
 		assert(ret != NULL);
 		PARAM_SELF_PROLOGUE(AActor);
 		PARAM_BOOL(checkz);
-		PARAM_INT_DEF(ptr);
+		PARAM_INT(ptr);
 
 		AActor *target = COPY_AAPTR(self, ptr);
 
@@ -410,7 +410,7 @@ DEFINE_ACTION_FUNCTION(AActor, GetAngle)
 		assert(ret != NULL);
 		PARAM_SELF_PROLOGUE(AActor);
 		PARAM_INT(flags);
-		PARAM_INT_DEF(ptr)
+		PARAM_INT(ptr)
 
 		AActor *target = COPY_AAPTR(self, ptr);
 
@@ -459,7 +459,7 @@ DEFINE_ACTION_FUNCTION(AActor, GetSpriteAngle)
 	{
 		assert(ret != NULL);
 		PARAM_SELF_PROLOGUE(AActor);
-		PARAM_INT_DEF(ptr);
+		PARAM_INT(ptr);
 
 		AActor *target = COPY_AAPTR(self, ptr);
 		if (target == nullptr)
@@ -488,7 +488,7 @@ DEFINE_ACTION_FUNCTION(AActor, GetSpriteRotation)
 	{
 		assert(ret != NULL);
 		PARAM_SELF_PROLOGUE(AActor);
-		PARAM_INT_DEF(ptr);
+		PARAM_INT(ptr);
 
 		AActor *target = COPY_AAPTR(self, ptr);
 		if (target == nullptr)
@@ -528,11 +528,11 @@ DEFINE_ACTION_FUNCTION(AActor, GetZAt)
 	{
 		assert(ret != NULL);
 		PARAM_SELF_PROLOGUE(AActor);
-		PARAM_FLOAT_DEF(px);
-		PARAM_FLOAT_DEF(py);
-		PARAM_ANGLE_DEF(angle);
-		PARAM_INT_DEF(flags);
-		PARAM_INT_DEF(pick_pointer);
+		PARAM_FLOAT(px);
+		PARAM_FLOAT(py);
+		PARAM_ANGLE(angle);
+		PARAM_INT(flags);
+		PARAM_INT(pick_pointer);
 
 		AActor *mobj = COPY_AAPTR(self, pick_pointer);
 		if (mobj == nullptr)
@@ -616,7 +616,7 @@ DEFINE_ACTION_FUNCTION(AActor, GetCrouchFactor)
 	{
 		assert(ret != NULL);
 		PARAM_SELF_PROLOGUE(AActor);
-		PARAM_INT_DEF(ptr);
+		PARAM_INT(ptr);
 		AActor *mobj = COPY_AAPTR(self, ptr);
 
 		if (!mobj || !mobj->player)
@@ -707,7 +707,7 @@ DEFINE_ACTION_FUNCTION(AActor, GetPlayerInput)
 		assert(ret != nullptr);
 		PARAM_SELF_PROLOGUE(AActor);
 		PARAM_INT		(inputnum);
-		PARAM_INT_DEF(ptr);
+		PARAM_INT(ptr);
 
 		AActor *mobj = COPY_AAPTR(self, ptr);
 
@@ -740,8 +740,8 @@ DEFINE_ACTION_FUNCTION(AActor, CountProximity)
 		PARAM_SELF_PROLOGUE(AActor);
 		PARAM_CLASS(classname, AActor);
 		PARAM_FLOAT(distance);
-		PARAM_INT_DEF(flags);
-		PARAM_INT_DEF(ptr);
+		PARAM_INT(flags);
+		PARAM_INT(ptr);
 
 		AActor *mobj = COPY_AAPTR(self, ptr);
 		if (mobj == nullptr)
@@ -809,9 +809,9 @@ DEFINE_ACTION_FUNCTION(AActor, A_RearrangePointers)
 {
 	PARAM_SELF_PROLOGUE(AActor);
 	PARAM_INT		(ptr_target);
-	PARAM_INT_DEF	(ptr_master);
-	PARAM_INT_DEF	(ptr_tracer);
-	PARAM_INT_DEF	(flags);
+	PARAM_INT	(ptr_master);
+	PARAM_INT	(ptr_tracer);
+	PARAM_INT	(flags);
 
 	// Rearrange pointers internally
 
@@ -891,8 +891,8 @@ DEFINE_ACTION_FUNCTION(AActor, A_TransferPointer)
 	PARAM_INT		(ptr_source);
 	PARAM_INT		(ptr_recipient);
 	PARAM_INT		(ptr_sourcefield);
-	PARAM_INT_DEF	(ptr_recipientfield);
-	PARAM_INT_DEF	(flags);
+	PARAM_INT	(ptr_recipientfield);
+	PARAM_INT	(flags);
 
 	AActor *source, *recipient;
 
@@ -931,7 +931,7 @@ DEFINE_ACTION_FUNCTION(AActor, A_TransferPointer)
 DEFINE_ACTION_FUNCTION(AActor, A_CopyFriendliness)
 {
 	PARAM_SELF_PROLOGUE(AActor);
-	PARAM_INT_DEF	(ptr_source);
+	PARAM_INT	(ptr_source);
 	
 	if (self->player != NULL)
 	{
@@ -955,12 +955,12 @@ DEFINE_ACTION_FUNCTION(AActor, A_CopyFriendliness)
 DEFINE_ACTION_FUNCTION(AActor, A_PlaySound)
 {
 	PARAM_SELF_PROLOGUE(AActor);
-	PARAM_SOUND_DEF	(soundid);
-	PARAM_INT_DEF	(channel);
-	PARAM_FLOAT_DEF	(volume);
-	PARAM_BOOL_DEF	(looping);
-	PARAM_FLOAT_DEF	(attenuation);
-	PARAM_BOOL_DEF	(local);
+	PARAM_SOUND	(soundid);
+	PARAM_INT	(channel);
+	PARAM_FLOAT	(volume);
+	PARAM_BOOL	(looping);
+	PARAM_FLOAT	(attenuation);
+	PARAM_BOOL	(local);
 
 	if (!looping)
 	{
@@ -982,7 +982,7 @@ DEFINE_ACTION_FUNCTION(AActor, A_PlaySound)
 DEFINE_ACTION_FUNCTION(AActor, A_StopSound)
 {
 	PARAM_SELF_PROLOGUE(AActor);
-	PARAM_INT_DEF(slot);
+	PARAM_INT(slot);
 
 	S_StopSound(self, slot);
 	return 0;
@@ -1012,8 +1012,8 @@ DEFINE_ACTION_FUNCTION(AActor, A_PlaySoundEx)
 	PARAM_SELF_PROLOGUE(AActor);
 	PARAM_SOUND		(soundid);
 	PARAM_NAME		(channel);
-	PARAM_BOOL_DEF	(looping);
-	PARAM_INT_DEF	(attenuation_raw);
+	PARAM_BOOL	(looping);
+	PARAM_INT	(attenuation_raw);
 
 	float attenuation;
 	switch (attenuation_raw)
@@ -1073,9 +1073,9 @@ DEFINE_ACTION_FUNCTION(AActor, A_SeekerMissile)
 	PARAM_SELF_PROLOGUE(AActor);
 	PARAM_INT(ang1);
 	PARAM_INT(ang2);
-	PARAM_INT_DEF(flags);
-	PARAM_INT_DEF(chance);
-	PARAM_INT_DEF(distance);
+	PARAM_INT(flags);
+	PARAM_INT(chance);
+	PARAM_INT(distance);
 
 	if ((flags & SMF_LOOK) && (self->tracer == nullptr) && (pr_seekermissile()<chance))
 	{
@@ -1152,7 +1152,7 @@ DEFINE_ACTION_FUNCTION(AActor, CheckInventory)
 	PARAM_SELF_PROLOGUE(AActor);
 	PARAM_CLASS		(itemtype, AInventory);
 	PARAM_INT		(itemamount);
-	PARAM_INT_DEF	(setowner);
+	PARAM_INT	(setowner);
 
 	if (itemtype == nullptr)
 	{
@@ -1201,15 +1201,15 @@ enum
 DEFINE_ACTION_FUNCTION(AActor, A_Explode)
 {
 	PARAM_SELF_PROLOGUE(AActor);
-	PARAM_INT_DEF	(damage);
-	PARAM_INT_DEF	(distance);
-	PARAM_INT_DEF	(flags);
-	PARAM_BOOL_DEF	(alert);
-	PARAM_INT_DEF	(fulldmgdistance);
-	PARAM_INT_DEF	(nails);
-	PARAM_INT_DEF	(naildamage);
-	PARAM_CLASS_DEF	(pufftype, AActor);
-	PARAM_NAME_DEF	(damagetype);
+	PARAM_INT	(damage);
+	PARAM_INT	(distance);
+	PARAM_INT	(flags);
+	PARAM_BOOL	(alert);
+	PARAM_INT	(fulldmgdistance);
+	PARAM_INT	(nails);
+	PARAM_INT	(naildamage);
+	PARAM_CLASS	(pufftype, AActor);
+	PARAM_NAME	(damagetype);
 
 	if (damage < 0)	// get parameters from metadata
 	{
@@ -1270,10 +1270,10 @@ enum
 DEFINE_ACTION_FUNCTION(AActor, A_RadiusThrust)
 {
 	PARAM_SELF_PROLOGUE(AActor);
-	PARAM_INT_DEF	(force);
-	PARAM_INT_DEF	(distance);
-	PARAM_INT_DEF	(flags);
-	PARAM_INT_DEF	(fullthrustdistance);
+	PARAM_INT	(force);
+	PARAM_INT	(distance);
+	PARAM_INT	(flags);
+	PARAM_INT	(fullthrustdistance);
 
 	bool sourcenothrust = false;
 
@@ -1310,10 +1310,10 @@ enum
 DEFINE_ACTION_FUNCTION(AActor, A_RadiusDamageSelf)
 {
 	PARAM_SELF_PROLOGUE(AActor);
-	PARAM_INT_DEF(damage);
-	PARAM_FLOAT_DEF(distance);
-	PARAM_INT_DEF(flags);
-	PARAM_CLASS_DEF(flashtype, AActor);
+	PARAM_INT(damage);
+	PARAM_FLOAT(distance);
+	PARAM_INT(flags);
+	PARAM_CLASS(flashtype, AActor);
 
 	int 				i;
 	int 				damageSteps;
@@ -1386,12 +1386,12 @@ DEFINE_ACTION_FUNCTION(AActor, A_SpawnProjectile)
 {
 	PARAM_SELF_PROLOGUE(AActor);
 	PARAM_CLASS		(ti, AActor);
-	PARAM_FLOAT_DEF	(Spawnheight);
-	PARAM_FLOAT_DEF	(Spawnofs_xy);
-	PARAM_ANGLE_DEF	(Angle);
-	PARAM_INT_DEF	(flags);
-	PARAM_ANGLE_DEF	(Pitch);
-	PARAM_INT_DEF	(ptr);
+	PARAM_FLOAT	(Spawnheight);
+	PARAM_FLOAT	(Spawnofs_xy);
+	PARAM_ANGLE	(Angle);
+	PARAM_INT	(flags);
+	PARAM_ANGLE	(Pitch);
+	PARAM_INT	(ptr);
 
 	AActor *ref = COPY_AAPTR(self, ptr);
 
@@ -1539,13 +1539,13 @@ DEFINE_ACTION_FUNCTION(AActor, A_CustomBulletAttack)
 	PARAM_ANGLE		(spread_z);
 	PARAM_INT		(numbullets);
 	PARAM_INT		(damageperbullet);
-	PARAM_CLASS_DEF	(pufftype, AActor);
-	PARAM_FLOAT_DEF	(range);
-	PARAM_INT_DEF	(flags);
-	PARAM_INT_DEF	(ptr);
-	PARAM_CLASS_DEF (missile, AActor);
-	PARAM_FLOAT_DEF (Spawnheight);
-	PARAM_FLOAT_DEF (Spawnofs_xy);
+	PARAM_CLASS	(pufftype, AActor);
+	PARAM_FLOAT	(range);
+	PARAM_INT	(flags);
+	PARAM_INT	(ptr);
+	PARAM_CLASS (missile, AActor);
+	PARAM_FLOAT (Spawnheight);
+	PARAM_FLOAT (Spawnofs_xy);
 
 	AActor *ref = COPY_AAPTR(self, ptr);
 
@@ -1627,11 +1627,11 @@ DEFINE_ACTION_FUNCTION(AActor, A_CustomBulletAttack)
 DEFINE_ACTION_FUNCTION(AActor, A_CustomMeleeAttack)
 {
 	PARAM_SELF_PROLOGUE(AActor);
-	PARAM_INT_DEF	(damage);
-	PARAM_SOUND_DEF	(meleesound);
-	PARAM_SOUND_DEF	(misssound);
-	PARAM_NAME_DEF	(damagetype);
-	PARAM_BOOL_DEF	(bleed);
+	PARAM_INT	(damage);
+	PARAM_SOUND	(meleesound);
+	PARAM_SOUND	(misssound);
+	PARAM_NAME	(damagetype);
+	PARAM_BOOL	(bleed);
 
 	if (damagetype == NAME_None)
 		damagetype = NAME_Melee;	// Melee is the default type
@@ -1667,9 +1667,9 @@ DEFINE_ACTION_FUNCTION(AActor, A_CustomComboAttack)
 	PARAM_CLASS		(ti, AActor);
 	PARAM_FLOAT		(spawnheight);
 	PARAM_INT		(damage);
-	PARAM_SOUND_DEF	(meleesound);
-	PARAM_NAME_DEF	(damagetype);
-	PARAM_BOOL_DEF	(bleed);
+	PARAM_SOUND	(meleesound);
+	PARAM_NAME	(damagetype);
+	PARAM_BOOL	(bleed);
 
 	if (!self->target)
 		return 0;
@@ -1789,12 +1789,12 @@ DEFINE_ACTION_FUNCTION(AStateProvider, A_FireBullets)
 	PARAM_ANGLE		(spread_z);
 	PARAM_INT		(numbullets);
 	PARAM_INT		(damageperbullet);
-	PARAM_CLASS_DEF	(pufftype, AActor);
-	PARAM_INT_DEF	(flags);
-	PARAM_FLOAT_DEF	(range);
-	PARAM_CLASS_DEF (missile, AActor);
-	PARAM_FLOAT_DEF (Spawnheight);
-	PARAM_FLOAT_DEF (Spawnofs_xy);
+	PARAM_CLASS	(pufftype, AActor);
+	PARAM_INT	(flags);
+	PARAM_FLOAT	(range);
+	PARAM_CLASS (missile, AActor);
+	PARAM_FLOAT (Spawnheight);
+	PARAM_FLOAT (Spawnofs_xy);
 
 	if (!self->player) return 0;
 
@@ -1916,12 +1916,12 @@ DEFINE_ACTION_FUNCTION(AStateProvider, A_FireProjectile)
 {
 	PARAM_ACTION_PROLOGUE(AStateProvider);
 	PARAM_CLASS		(ti, AActor);
-	PARAM_ANGLE_DEF	(angle);
-	PARAM_BOOL_DEF	(useammo);
-	PARAM_FLOAT_DEF	(spawnofs_xy);
-	PARAM_FLOAT_DEF	(spawnheight);
-	PARAM_INT_DEF	(flags);
-	PARAM_ANGLE_DEF	(pitch);
+	PARAM_ANGLE	(angle);
+	PARAM_BOOL	(useammo);
+	PARAM_FLOAT	(spawnofs_xy);
+	PARAM_FLOAT	(spawnheight);
+	PARAM_INT	(flags);
+	PARAM_ANGLE	(pitch);
 
 	if (!self->player)
 		ACTION_RETURN_OBJECT(nullptr);
@@ -1994,15 +1994,15 @@ DEFINE_ACTION_FUNCTION(AStateProvider, A_CustomPunch)
 {
 	PARAM_ACTION_PROLOGUE(AStateProvider);
 	PARAM_INT		(damage);
-	PARAM_BOOL_DEF	(norandom);
-	PARAM_INT_DEF	(flags);
-	PARAM_CLASS_DEF	(pufftype, AActor);
-	PARAM_FLOAT_DEF	(range);
-	PARAM_FLOAT_DEF	(lifesteal);
-	PARAM_INT_DEF	(lifestealmax);
-	PARAM_CLASS_DEF	(armorbonustype, AActor);
-	PARAM_SOUND_DEF	(MeleeSound);
-	PARAM_SOUND_DEF	(MissSound);
+	PARAM_BOOL	(norandom);
+	PARAM_INT	(flags);
+	PARAM_CLASS	(pufftype, AActor);
+	PARAM_FLOAT	(range);
+	PARAM_FLOAT	(lifesteal);
+	PARAM_INT	(lifestealmax);
+	PARAM_CLASS	(armorbonustype, AActor);
+	PARAM_SOUND	(MeleeSound);
+	PARAM_SOUND	(MissSound);
 
 	if (!self->player)
 		return 0;
@@ -2097,23 +2097,23 @@ DEFINE_ACTION_FUNCTION(AStateProvider, A_RailAttack)
 {
 	PARAM_ACTION_PROLOGUE(AStateProvider);
 	PARAM_INT		(damage);
-	PARAM_INT_DEF	(spawnofs_xy);
-	PARAM_BOOL_DEF	(useammo);
-	PARAM_COLOR_DEF	(color1);
-	PARAM_COLOR_DEF	(color2);
-	PARAM_INT_DEF	(flags);
-	PARAM_FLOAT_DEF	(maxdiff);
-	PARAM_CLASS_DEF	(pufftype, AActor);
-	PARAM_ANGLE_DEF	(spread_xy);
-	PARAM_ANGLE_DEF	(spread_z);
-	PARAM_FLOAT_DEF	(range)	;
-	PARAM_INT_DEF	(duration);
-	PARAM_FLOAT_DEF	(sparsity);
-	PARAM_FLOAT_DEF	(driftspeed);
-	PARAM_CLASS_DEF	(spawnclass, AActor);
-	PARAM_FLOAT_DEF	(spawnofs_z);
-	PARAM_INT_DEF	(SpiralOffset);
-	PARAM_INT_DEF	(limit);
+	PARAM_INT	(spawnofs_xy);
+	PARAM_BOOL	(useammo);
+	PARAM_COLOR	(color1);
+	PARAM_COLOR	(color2);
+	PARAM_INT	(flags);
+	PARAM_FLOAT	(maxdiff);
+	PARAM_CLASS	(pufftype, AActor);
+	PARAM_ANGLE	(spread_xy);
+	PARAM_ANGLE	(spread_z);
+	PARAM_FLOAT	(range)	;
+	PARAM_INT	(duration);
+	PARAM_FLOAT	(sparsity);
+	PARAM_FLOAT	(driftspeed);
+	PARAM_CLASS	(spawnclass, AActor);
+	PARAM_FLOAT	(spawnofs_z);
+	PARAM_INT	(SpiralOffset);
+	PARAM_INT	(limit);
 	
 	if (range == 0) range = 8192;
 	if (sparsity == 0) sparsity=1.0;
@@ -2176,24 +2176,24 @@ DEFINE_ACTION_FUNCTION(AActor, A_CustomRailgun)
 {
 	PARAM_SELF_PROLOGUE(AActor);
 	PARAM_INT		(damage);
-	PARAM_INT_DEF	(spawnofs_xy)		
-	PARAM_COLOR_DEF	(color1)			
-	PARAM_COLOR_DEF	(color2)			
-	PARAM_INT_DEF	(flags)				
-	PARAM_INT_DEF	(aim)				
-	PARAM_FLOAT_DEF	(maxdiff)			
-	PARAM_CLASS_DEF	(pufftype, AActor)	
-	PARAM_ANGLE_DEF	(spread_xy)			
-	PARAM_ANGLE_DEF	(spread_z)			
-	PARAM_FLOAT_DEF	(range)				
-	PARAM_INT_DEF	(duration)			
-	PARAM_FLOAT_DEF	(sparsity)			
-	PARAM_FLOAT_DEF	(driftspeed)		
-	PARAM_CLASS_DEF	(spawnclass, AActor)
-	PARAM_FLOAT_DEF	(spawnofs_z)		
-	PARAM_INT_DEF	(SpiralOffset)		
-	PARAM_INT_DEF	(limit)				
-	PARAM_FLOAT_DEF	(veleffect)
+	PARAM_INT	(spawnofs_xy)		
+	PARAM_COLOR	(color1)			
+	PARAM_COLOR	(color2)			
+	PARAM_INT	(flags)				
+	PARAM_INT	(aim)				
+	PARAM_FLOAT	(maxdiff)			
+	PARAM_CLASS	(pufftype, AActor)	
+	PARAM_ANGLE	(spread_xy)			
+	PARAM_ANGLE	(spread_z)			
+	PARAM_FLOAT	(range)				
+	PARAM_INT	(duration)			
+	PARAM_FLOAT	(sparsity)			
+	PARAM_FLOAT	(driftspeed)		
+	PARAM_CLASS	(spawnclass, AActor)
+	PARAM_FLOAT	(spawnofs_z)		
+	PARAM_INT	(SpiralOffset)		
+	PARAM_INT	(limit)				
+	PARAM_FLOAT	(veleffect)
 
 	if (range == 0) range = 8192.;
 	if (sparsity == 0) sparsity = 1;
@@ -2295,11 +2295,11 @@ static bool DoGiveInventory(AActor *receiver, bool orresult, VM_ARGS)
 {
 	int paramnum = 0;
 	PARAM_CLASS		(mi, AInventory);
-	PARAM_INT_DEF	(amount)
+	PARAM_INT	(amount)
 
 	if (!orresult)
 	{
-		PARAM_INT_DEF(setreceiver)
+		PARAM_INT(setreceiver)
 		receiver = COPY_AAPTR(receiver, setreceiver);
 	}
 	if (receiver == NULL)
@@ -2408,8 +2408,8 @@ DEFINE_ACTION_FUNCTION(AActor, A_SetInventory)
 	PARAM_SELF_PROLOGUE(AActor);
 	PARAM_CLASS(itemtype, AInventory);
 	PARAM_INT(amount);
-	PARAM_INT_DEF(ptr);
-	PARAM_BOOL_DEF(beyondMax);
+	PARAM_INT(ptr);
+	PARAM_BOOL(beyondMax);
 
 	bool res = false;
 
@@ -2448,8 +2448,8 @@ bool DoTakeInventory(AActor *receiver, bool orresult, VM_ARGS)
 {
 	int paramnum = 0;
 	PARAM_CLASS		(itemtype, AInventory);
-	PARAM_INT_DEF	(amount);
-	PARAM_INT_DEF	(flags);
+	PARAM_INT	(amount);
+	PARAM_INT	(flags);
 	
 	if (itemtype == NULL)
 	{
@@ -2457,7 +2457,7 @@ bool DoTakeInventory(AActor *receiver, bool orresult, VM_ARGS)
 	}
 	if (!orresult)
 	{
-		PARAM_INT_DEF(setreceiver);
+		PARAM_INT(setreceiver);
 		receiver = COPY_AAPTR(receiver, setreceiver);
 	}
 	if (receiver == NULL)
@@ -2735,11 +2735,11 @@ static bool InitSpawnedItem(AActor *self, AActor *mo, int flags)
 DEFINE_ACTION_FUNCTION(AActor, A_SpawnItem)
 {
 	PARAM_ACTION_PROLOGUE(AActor);
-	PARAM_CLASS_DEF	(missile, AActor)		
-	PARAM_FLOAT_DEF	(distance)				
-	PARAM_FLOAT_DEF	(zheight)				
-	PARAM_BOOL_DEF	(useammo)				
-	PARAM_BOOL_DEF	(transfer_translation);
+	PARAM_CLASS	(missile, AActor)		
+	PARAM_FLOAT	(distance)				
+	PARAM_FLOAT	(zheight)				
+	PARAM_BOOL	(useammo)				
+	PARAM_BOOL	(transfer_translation);
 		
 	if (numret > 1) ret[1].SetObject(nullptr);
 
@@ -2794,16 +2794,16 @@ DEFINE_ACTION_FUNCTION(AActor, A_SpawnItemEx)
 {
 	PARAM_SELF_PROLOGUE(AActor);
 	PARAM_CLASS		(missile, AActor);
-	PARAM_FLOAT_DEF	(xofs)		
-	PARAM_FLOAT_DEF	(yofs)		
-	PARAM_FLOAT_DEF	(zofs)		
-	PARAM_FLOAT_DEF	(xvel)		
-	PARAM_FLOAT_DEF	(yvel)		
-	PARAM_FLOAT_DEF	(zvel)		
-	PARAM_ANGLE_DEF	(angle)		
-	PARAM_INT_DEF	(flags)		
-	PARAM_INT_DEF	(chance)	
-	PARAM_INT_DEF	(tid)		
+	PARAM_FLOAT	(xofs)		
+	PARAM_FLOAT	(yofs)		
+	PARAM_FLOAT	(zofs)		
+	PARAM_FLOAT	(xvel)		
+	PARAM_FLOAT	(yvel)		
+	PARAM_FLOAT	(zvel)		
+	PARAM_ANGLE	(angle)		
+	PARAM_INT	(flags)		
+	PARAM_INT	(chance)	
+	PARAM_INT	(tid)		
 
 	if (numret > 1) ret[1].SetObject(nullptr);
 
@@ -2885,10 +2885,10 @@ DEFINE_ACTION_FUNCTION(AActor, A_ThrowGrenade)
 {
 		PARAM_ACTION_PROLOGUE(AActor);
 	PARAM_CLASS		(missile, AActor);
-		PARAM_FLOAT_DEF	(zheight)	
-		PARAM_FLOAT_DEF	(xyvel)		
-		PARAM_FLOAT_DEF	(zvel)		
-		PARAM_BOOL_DEF	(useammo)	
+		PARAM_FLOAT	(zheight)	
+		PARAM_FLOAT	(xyvel)		
+		PARAM_FLOAT	(zvel)		
+		PARAM_BOOL	(useammo)	
 
 	if (numret > 1) ret[1].SetObject(nullptr);
 
@@ -2991,7 +2991,7 @@ DEFINE_ACTION_FUNCTION(AActor, A_SelectWeapon)
 {
 	PARAM_SELF_PROLOGUE(AActor);
 	PARAM_CLASS(cls, AWeapon);
-	PARAM_INT_DEF(flags);
+	PARAM_INT(flags);
 
 	bool selectPriority = !!(flags & SWF_SELECTPRIORITY);
 
@@ -3036,8 +3036,8 @@ DEFINE_ACTION_FUNCTION(AActor, A_Print)
 {
 	PARAM_SELF_PROLOGUE(AActor);
 	PARAM_STRING	(text);
-	PARAM_FLOAT_DEF	(time);
-	PARAM_NAME_DEF	(fontname);
+	PARAM_FLOAT	(time);
+	PARAM_NAME	(fontname);
 
 	if (text[0] == '$') text = GStrings(&text[1]);
 	if (self->CheckLocalView (consoleplayer) ||
@@ -3071,8 +3071,8 @@ DEFINE_ACTION_FUNCTION(AActor, A_PrintBold)
 {
 	PARAM_SELF_PROLOGUE(AActor);
 	PARAM_STRING	(text);
-	PARAM_FLOAT_DEF	(time);
-	PARAM_NAME_DEF	(fontname);
+	PARAM_FLOAT	(time);
+	PARAM_NAME	(fontname);
 
 	float saved = con_midtime;
 	FFont *font = NULL;
@@ -3102,7 +3102,7 @@ DEFINE_ACTION_FUNCTION(AActor, A_Log)
 {
 	PARAM_SELF_PROLOGUE(AActor);
 	PARAM_STRING(text);
-	PARAM_BOOL_DEF(local);
+	PARAM_BOOL(local);
 
 	if (local && !self->CheckLocalView(consoleplayer)) return 0;
 
@@ -3122,7 +3122,7 @@ DEFINE_ACTION_FUNCTION(AActor, A_LogInt)
 {
 	PARAM_SELF_PROLOGUE(AActor);
 	PARAM_INT(num);
-	PARAM_BOOL_DEF(local);
+	PARAM_BOOL(local);
 
 	if (local && !self->CheckLocalView(consoleplayer)) return 0;
 	Printf("%d\n", num);
@@ -3139,7 +3139,7 @@ DEFINE_ACTION_FUNCTION(AActor, A_LogFloat)
 {
 	PARAM_SELF_PROLOGUE(AActor);
 	PARAM_FLOAT(num);
-	PARAM_BOOL_DEF(local);
+	PARAM_BOOL(local);
 
 	if (local && !self->CheckLocalView(consoleplayer)) return 0;
 	IGNORE_FORMAT_PRE
@@ -3157,7 +3157,7 @@ DEFINE_ACTION_FUNCTION(AActor, A_SetTranslucent)
 {
 	PARAM_SELF_PROLOGUE(AActor);
 	PARAM_FLOAT		(alpha);
-	PARAM_INT_DEF	(mode);
+	PARAM_INT	(mode);
 
 	mode = mode == 0 ? STYLE_Translucent : mode == 2 ? STYLE_Fuzzy : STYLE_Add;
 
@@ -3176,7 +3176,7 @@ DEFINE_ACTION_FUNCTION(AActor, A_SetRenderStyle)
 {
 	PARAM_SELF_PROLOGUE(AActor);
 	PARAM_FLOAT(alpha);
-	PARAM_INT_DEF(mode);
+	PARAM_INT(mode);
 
 	self->Alpha = clamp(alpha, 0., 1.);
 	self->RenderStyle = ERenderStyle(mode);
@@ -3200,8 +3200,8 @@ enum FadeFlags
 DEFINE_ACTION_FUNCTION(AActor, A_FadeIn)
 {
 	PARAM_SELF_PROLOGUE(AActor);
-	PARAM_FLOAT_DEF(reduce);
-	PARAM_INT_DEF(flags);
+	PARAM_FLOAT(reduce);
+	PARAM_INT(flags);
 
 
 	if (reduce == 0)
@@ -3235,8 +3235,8 @@ DEFINE_ACTION_FUNCTION(AActor, A_FadeIn)
 DEFINE_ACTION_FUNCTION(AActor, A_FadeOut)
 {
 	PARAM_SELF_PROLOGUE(AActor);
-	PARAM_FLOAT_DEF(reduce);
-	PARAM_INT_DEF(flags);
+	PARAM_FLOAT(reduce);
+	PARAM_INT(flags);
 
 	if (reduce == 0)
 	{
@@ -3270,8 +3270,8 @@ DEFINE_ACTION_FUNCTION(AActor, A_FadeTo)
 {
 	PARAM_SELF_PROLOGUE(AActor);
 	PARAM_FLOAT		(target);
-	PARAM_FLOAT_DEF	(amount);
-	PARAM_INT_DEF	(flags);
+	PARAM_FLOAT	(amount);
+	PARAM_INT	(flags);
 
 	self->RenderStyle.Flags &= ~STYLEF_Alpha1;
 
@@ -3313,9 +3313,9 @@ DEFINE_ACTION_FUNCTION(AActor, A_SpawnDebris)
 {
 	PARAM_SELF_PROLOGUE(AActor);
 	PARAM_CLASS		(debris, AActor);
-	PARAM_BOOL_DEF	(transfer_translation)
-	PARAM_FLOAT_DEF	(mult_h)				
-	PARAM_FLOAT_DEF	(mult_v)				
+	PARAM_BOOL	(transfer_translation)
+	PARAM_FLOAT	(mult_h)				
+	PARAM_FLOAT	(mult_v)				
 	int i;
 	AActor *mo;
 
@@ -3369,22 +3369,22 @@ DEFINE_ACTION_FUNCTION(AActor, A_SpawnParticle)
 {
 	PARAM_SELF_PROLOGUE(AActor);
 	PARAM_COLOR		(color);
-	PARAM_INT_DEF	(flags)		
-	PARAM_INT_DEF	(lifetime)	
-	PARAM_FLOAT_DEF	(size)		
-	PARAM_ANGLE_DEF	(angle)		
-	PARAM_FLOAT_DEF	(xoff)		
-	PARAM_FLOAT_DEF	(yoff)		
-	PARAM_FLOAT_DEF	(zoff)		
-	PARAM_FLOAT_DEF	(xvel)		
-	PARAM_FLOAT_DEF	(yvel)		
-	PARAM_FLOAT_DEF	(zvel)		
-	PARAM_FLOAT_DEF	(accelx)	
-	PARAM_FLOAT_DEF	(accely)	
-	PARAM_FLOAT_DEF	(accelz)	
-	PARAM_FLOAT_DEF	(startalpha)
-	PARAM_FLOAT_DEF	(fadestep)	
-	PARAM_FLOAT_DEF (sizestep)	
+	PARAM_INT	(flags)		
+	PARAM_INT	(lifetime)	
+	PARAM_FLOAT	(size)		
+	PARAM_ANGLE	(angle)		
+	PARAM_FLOAT	(xoff)		
+	PARAM_FLOAT	(yoff)		
+	PARAM_FLOAT	(zoff)		
+	PARAM_FLOAT	(xvel)		
+	PARAM_FLOAT	(yvel)		
+	PARAM_FLOAT	(zvel)		
+	PARAM_FLOAT	(accelx)	
+	PARAM_FLOAT	(accely)	
+	PARAM_FLOAT	(accelz)	
+	PARAM_FLOAT	(startalpha)
+	PARAM_FLOAT	(fadestep)	
+	PARAM_FLOAT (sizestep)	
 
 	startalpha = clamp(startalpha, 0., 1.);
 	if (fadestep > 0) fadestep = clamp(fadestep, 0., 1.);
@@ -3498,7 +3498,7 @@ DEFINE_ACTION_FUNCTION(AActor, CheckSightOrRange)
 {
 	PARAM_SELF_PROLOGUE(AActor);
 	PARAM_FLOAT(range);
-	PARAM_BOOL_DEF(twodi);
+	PARAM_BOOL(twodi);
 
 	range *= range;
 	for (int i = 0; i < MAXPLAYERS; ++i)
@@ -3526,7 +3526,7 @@ DEFINE_ACTION_FUNCTION(AActor, CheckRange)
 {
 	PARAM_SELF_PROLOGUE(AActor);
 	PARAM_FLOAT(range);
-	PARAM_BOOL_DEF(twodi);
+	PARAM_BOOL(twodi);
 
 	range *= range;
 	for (int i = 0; i < MAXPLAYERS; ++i)
@@ -3559,7 +3559,7 @@ DEFINE_ACTION_FUNCTION(AActor, A_DropInventory)
 {
 	PARAM_SELF_PROLOGUE(AActor);
 	PARAM_CLASS(drop, AInventory);
-	PARAM_INT_DEF(amount);
+	PARAM_INT(amount);
 
 	if (drop)
 	{
@@ -3584,8 +3584,8 @@ DEFINE_ACTION_FUNCTION(AActor, A_SetBlend)
 	PARAM_COLOR		(color);
 	PARAM_FLOAT		(alpha);
 	PARAM_INT		(tics);
-	PARAM_COLOR_DEF	(color2);
-	PARAM_FLOAT_DEF	(alpha2);
+	PARAM_COLOR	(color2);
+	PARAM_FLOAT	(alpha2);
 
 	if (color == MAKEARGB(255,255,255,255))
 		color = 0;
@@ -3611,7 +3611,7 @@ DEFINE_ACTION_FUNCTION(AActor, A_CountdownArg)
 {
 	PARAM_SELF_PROLOGUE(AActor);
 	PARAM_INT(cnt);
-	PARAM_STATE_DEF(state)
+	PARAM_STATE(state)
 
 	if (cnt<0 || cnt >= 5) return 0;
 	if (!self->args[cnt]--)
@@ -3736,7 +3736,7 @@ enum RS_Flags
 DEFINE_ACTION_FUNCTION(AActor, A_Respawn)
 {
 	PARAM_SELF_PROLOGUE(AActor);
-	PARAM_INT_DEF(flags);
+	PARAM_INT(flags);
 
 	bool oktorespawn = false;
 	DVector3 pos = self->Pos();
@@ -3964,15 +3964,15 @@ DEFINE_ACTION_FUNCTION(AActor, CheckLOF)
 	DVector3 vel;
 
 	PARAM_SELF_PROLOGUE(AActor);
-	PARAM_INT_DEF	(flags)			
-	PARAM_FLOAT_DEF	(range)			
-	PARAM_FLOAT_DEF	(minrange)		
-	PARAM_ANGLE_DEF	(angle)			
-	PARAM_ANGLE_DEF	(pitch)			
-	PARAM_FLOAT_DEF	(offsetheight)	
-	PARAM_FLOAT_DEF	(offsetwidth)	
-	PARAM_INT_DEF	(ptr_target)	
-	PARAM_FLOAT_DEF	(offsetforward)	
+	PARAM_INT	(flags)			
+	PARAM_FLOAT	(range)			
+	PARAM_FLOAT	(minrange)		
+	PARAM_ANGLE	(angle)			
+	PARAM_ANGLE	(pitch)			
+	PARAM_FLOAT	(offsetheight)	
+	PARAM_FLOAT	(offsetwidth)	
+	PARAM_INT	(ptr_target)	
+	PARAM_FLOAT	(offsetforward)	
 
 	DAngle ang;
 
@@ -4155,10 +4155,10 @@ enum JLOS_flags
 DEFINE_ACTION_FUNCTION(AActor, CheckIfTargetInLOS)
 {
 	PARAM_SELF_PROLOGUE(AActor);
-	PARAM_ANGLE_DEF	(fov)		
-	PARAM_INT_DEF	(flags)		
-	PARAM_FLOAT_DEF	(dist_max)	
-	PARAM_FLOAT_DEF	(dist_close)
+	PARAM_ANGLE	(fov)		
+	PARAM_INT	(flags)		
+	PARAM_FLOAT	(dist_max)	
+	PARAM_FLOAT	(dist_close)
 
 	AActor *target, *viewport;
 	FTranslatedLineTarget t;
@@ -4292,10 +4292,10 @@ DEFINE_ACTION_FUNCTION(AActor, CheckIfTargetInLOS)
 DEFINE_ACTION_FUNCTION(AActor, CheckIfInTargetLOS)
 {
 	PARAM_SELF_PROLOGUE(AActor);
-	PARAM_ANGLE_DEF	(fov)		
-	PARAM_INT_DEF	(flags)		
-	PARAM_FLOAT_DEF	(dist_max)	
-	PARAM_FLOAT_DEF	(dist_close)
+	PARAM_ANGLE	(fov)		
+	PARAM_INT	(flags)		
+	PARAM_FLOAT	(dist_max)	
+	PARAM_FLOAT	(dist_close)
 
 	AActor *target;
 
@@ -4379,7 +4379,7 @@ DEFINE_ACTION_FUNCTION(AStateProvider, A_CheckForReload)
 	}
 	PARAM_INT		(count);
 	PARAM_STATE_ACTION	(jump);
-	PARAM_BOOL_DEF	(dontincrement);
+	PARAM_BOOL	(dontincrement);
 
 	if (numret > 0)
 	{
@@ -4459,7 +4459,7 @@ DEFINE_ACTION_FUNCTION(AActor, CheckFlag)
 {
 	PARAM_SELF_PROLOGUE(AActor);
 	PARAM_STRING	(flagname);
-	PARAM_INT_DEF	(checkpointer);
+	PARAM_INT	(checkpointer);
 
 	AActor *owner = COPY_AAPTR(self, checkpointer);
 	ACTION_RETURN_BOOL(owner != nullptr && CheckActorFlag(owner, flagname));
@@ -4469,9 +4469,9 @@ DEFINE_ACTION_FUNCTION(AActor, CheckFlag)
 DEFINE_ACTION_FUNCTION(AActor, A_ChangeCountFlags)
 {
 	PARAM_SELF_PROLOGUE(AActor);
-	PARAM_INT_DEF(kill);
-	PARAM_INT_DEF(item);
-	PARAM_INT_DEF(secret);
+	PARAM_INT(kill);
+	PARAM_INT(item);
+	PARAM_INT(secret);
 
 	if (self->CountsAsKill() && self->health > 0) --level.total_monsters;
 	if (self->flags & MF_COUNTITEM) --level.total_items;
@@ -4515,7 +4515,7 @@ enum ERaise
 DEFINE_ACTION_FUNCTION(AActor, A_RaiseMaster)
 {
 	PARAM_SELF_PROLOGUE(AActor);
-	PARAM_INT_DEF(flags);
+	PARAM_INT(flags);
 
 	bool copy = !!(flags & RF_TRANSFERFRIENDLINESS);
 	if (self->master != NULL)
@@ -4533,7 +4533,7 @@ DEFINE_ACTION_FUNCTION(AActor, A_RaiseMaster)
 DEFINE_ACTION_FUNCTION(AActor, A_RaiseChildren)
 {
 	PARAM_SELF_PROLOGUE(AActor);
-	PARAM_INT_DEF(flags);
+	PARAM_INT(flags);
 
 	TThinkerIterator<AActor> it;
 	AActor *mo;
@@ -4557,7 +4557,7 @@ DEFINE_ACTION_FUNCTION(AActor, A_RaiseChildren)
 DEFINE_ACTION_FUNCTION(AActor, A_RaiseSiblings)
 {
 	PARAM_SELF_PROLOGUE(AActor);
-	PARAM_INT_DEF(flags);
+	PARAM_INT(flags);
 
 	TThinkerIterator<AActor> it;
 	AActor *mo;
@@ -4584,7 +4584,7 @@ DEFINE_ACTION_FUNCTION(AActor, A_RaiseSiblings)
 DEFINE_ACTION_FUNCTION(AActor, A_RaiseSelf)
 {
 	PARAM_SELF_PROLOGUE(AActor);
-	PARAM_INT_DEF(flags);
+	PARAM_INT(flags);
 	ACTION_RETURN_BOOL(P_Thing_Raise(self, NULL, (flags & RF_NOCHECKPOSITION)));
 }
 
@@ -4598,7 +4598,7 @@ DEFINE_ACTION_FUNCTION(AActor, RaiseActor)
 {
 	PARAM_SELF_PROLOGUE(AActor);
 	PARAM_OBJECT(other, AActor);
-	PARAM_INT_DEF(flags);
+	PARAM_INT(flags);
 	ACTION_RETURN_BOOL(P_Thing_Raise(other, self, (flags & RF_NOCHECKPOSITION)));
 }
 
@@ -4659,9 +4659,9 @@ enum
 DEFINE_ACTION_FUNCTION(AActor, A_SetAngle)
 {
 	PARAM_SELF_PROLOGUE(AActor);
-	PARAM_FLOAT_DEF(angle);
-	PARAM_INT_DEF(flags);
-	PARAM_INT_DEF(ptr);
+	PARAM_FLOAT(angle);
+	PARAM_INT(flags);
+	PARAM_INT(ptr);
 
 	AActor *ref = COPY_AAPTR(self, ptr);
 	if (ref != NULL)
@@ -4683,8 +4683,8 @@ DEFINE_ACTION_FUNCTION(AActor, A_SetPitch)
 {
 	PARAM_SELF_PROLOGUE(AActor);
 	PARAM_FLOAT(pitch);
-	PARAM_INT_DEF(flags);
-	PARAM_INT_DEF(ptr);
+	PARAM_INT(flags);
+	PARAM_INT(ptr);
 
 	AActor *ref = COPY_AAPTR(self, ptr);
 
@@ -4707,8 +4707,8 @@ DEFINE_ACTION_FUNCTION(AActor, A_SetRoll)
 {
 	PARAM_SELF_PROLOGUE(AActor);
 	PARAM_FLOAT		(roll);
-	PARAM_INT_DEF	(flags);
-	PARAM_INT_DEF	(ptr)	;
+	PARAM_INT	(flags);
+	PARAM_INT	(ptr)	;
 	AActor *ref = COPY_AAPTR(self, ptr);
 
 	if (ref != NULL)
@@ -4730,7 +4730,7 @@ DEFINE_ACTION_FUNCTION(AActor, A_ScaleVelocity)
 {
 	PARAM_SELF_PROLOGUE(AActor);
 	PARAM_FLOAT(scale);
-	PARAM_INT_DEF(ptr);
+	PARAM_INT(ptr);
 
 	AActor *ref = COPY_AAPTR(self, ptr);
 
@@ -4761,11 +4761,11 @@ DEFINE_ACTION_FUNCTION(AActor, A_ScaleVelocity)
 DEFINE_ACTION_FUNCTION(AActor, A_ChangeVelocity)
 {
 	PARAM_SELF_PROLOGUE(AActor);
-	PARAM_FLOAT_DEF	(x)		
-	PARAM_FLOAT_DEF	(y)		
-	PARAM_FLOAT_DEF	(z)		
-	PARAM_INT_DEF	(flags)	
-	PARAM_INT_DEF	(ptr)	
+	PARAM_FLOAT	(x)		
+	PARAM_FLOAT	(y)		
+	PARAM_FLOAT	(z)		
+	PARAM_INT	(flags)	
+	PARAM_INT	(ptr)	
 
 	AActor *ref = COPY_AAPTR(self, ptr);
 
@@ -4940,13 +4940,13 @@ enum T_Flags
 DEFINE_ACTION_FUNCTION(AActor, A_Teleport)
 {
 	PARAM_ACTION_PROLOGUE(AActor);
-	PARAM_STATE_ACTION_DEF	(teleport_state)			
-	PARAM_CLASS_DEF		(target_type, ASpecialSpot)	
-	PARAM_CLASS_DEF		(fog_type, AActor)			
-	PARAM_INT_DEF		(flags)						
-	PARAM_FLOAT_DEF		(mindist)					
-	PARAM_FLOAT_DEF		(maxdist)					
-	PARAM_INT_DEF		(ptr)						
+	PARAM_STATE_ACTION	(teleport_state)			
+	PARAM_CLASS		(target_type, ASpecialSpot)	
+	PARAM_CLASS		(fog_type, AActor)			
+	PARAM_INT		(flags)						
+	PARAM_FLOAT		(mindist)					
+	PARAM_FLOAT		(maxdist)					
+	PARAM_INT		(ptr)						
 
 	AActor *ref = COPY_AAPTR(self, ptr);
 
@@ -5120,7 +5120,7 @@ DEFINE_ACTION_FUNCTION(AActor, A_Quake)
 	PARAM_INT		(duration);
 	PARAM_INT		(damrad);
 	PARAM_INT		(tremrad);
-	PARAM_SOUND_DEF	(sound);
+	PARAM_SOUND	(sound);
 
 	P_StartQuake(self, 0, intensity, duration, damrad, tremrad, sound);
 	return 0;
@@ -5143,15 +5143,15 @@ DEFINE_ACTION_FUNCTION(AActor, A_QuakeEx)
 	PARAM_INT(duration);
 	PARAM_INT(damrad);
 	PARAM_INT(tremrad);
-	PARAM_SOUND_DEF(sound);
-	PARAM_INT_DEF(flags);
-	PARAM_FLOAT_DEF(mulWaveX);
-	PARAM_FLOAT_DEF(mulWaveY);
-	PARAM_FLOAT_DEF(mulWaveZ);
-	PARAM_INT_DEF(falloff);
-	PARAM_INT_DEF(highpoint);
-	PARAM_FLOAT_DEF(rollIntensity);
-	PARAM_FLOAT_DEF(rollWave);
+	PARAM_SOUND(sound);
+	PARAM_INT(flags);
+	PARAM_FLOAT(mulWaveX);
+	PARAM_FLOAT(mulWaveY);
+	PARAM_FLOAT(mulWaveZ);
+	PARAM_INT(falloff);
+	PARAM_INT(highpoint);
+	PARAM_FLOAT(rollIntensity);
+	PARAM_FLOAT(rollWave);
 	P_StartQuakeXYZ(self, 0, intensityX, intensityY, intensityZ, duration, damrad, tremrad, sound, flags, mulWaveX, mulWaveY, mulWaveZ, falloff, highpoint, 
 		rollIntensity, rollWave);
 	return 0;
@@ -5231,8 +5231,8 @@ DEFINE_ACTION_FUNCTION(AActor, A_Weave)
 DEFINE_ACTION_FUNCTION(AActor, A_LineEffect)
 {
 	PARAM_SELF_PROLOGUE(AActor);
-	PARAM_INT_DEF(special);
-	PARAM_INT_DEF(tag);
+	PARAM_INT(special);
+	PARAM_INT(tag);
 
 	line_t junk;
 	maplinedef_t oldjunk;
@@ -5266,15 +5266,15 @@ enum WolfAttackFlags
 DEFINE_ACTION_FUNCTION(AActor, A_WolfAttack)
 {
 	PARAM_SELF_PROLOGUE(AActor);
-	PARAM_INT_DEF	(flags)				
-	PARAM_SOUND_DEF	(sound)				
-	PARAM_FLOAT_DEF	(snipe)				
-	PARAM_INT_DEF	(maxdamage)			
-	PARAM_INT_DEF	(blocksize)			
-	PARAM_INT_DEF	(pointblank)		
-	PARAM_INT_DEF	(longrange)			
-	PARAM_FLOAT_DEF	(runspeed)			
-	PARAM_CLASS_DEF	(pufftype, AActor)	
+	PARAM_INT	(flags)				
+	PARAM_SOUND	(sound)				
+	PARAM_FLOAT	(snipe)				
+	PARAM_INT	(maxdamage)			
+	PARAM_INT	(blocksize)			
+	PARAM_INT	(pointblank)		
+	PARAM_INT	(longrange)			
+	PARAM_FLOAT	(runspeed)			
+	PARAM_CLASS	(pufftype, AActor)	
 
 	if (!self->target)
 		return 0;
@@ -5372,15 +5372,15 @@ DEFINE_ACTION_FUNCTION(AActor, A_Warp)
 {
 	PARAM_ACTION_PROLOGUE(AActor);
 	PARAM_INT(destination_selector);
-	PARAM_FLOAT_DEF(xofs)				
-	PARAM_FLOAT_DEF(yofs)				
-	PARAM_FLOAT_DEF(zofs)				
-	PARAM_ANGLE_DEF(angle)				
-	PARAM_INT_DEF(flags)				
-	PARAM_STATE_ACTION_DEF(success_state)		
-	PARAM_FLOAT_DEF(heightoffset)		
-	PARAM_FLOAT_DEF(radiusoffset)		
-	PARAM_ANGLE_DEF(pitch)				
+	PARAM_FLOAT(xofs)				
+	PARAM_FLOAT(yofs)				
+	PARAM_FLOAT(zofs)				
+	PARAM_ANGLE(angle)				
+	PARAM_INT(flags)				
+	PARAM_STATE_ACTION(success_state)		
+	PARAM_FLOAT(heightoffset)		
+	PARAM_FLOAT(radiusoffset)		
+	PARAM_ANGLE(pitch)				
 	
 	AActor *reference;
 
@@ -5626,11 +5626,11 @@ DEFINE_ACTION_FUNCTION(AActor, A_RadiusGive)
 	PARAM_CLASS		(item, AInventory);
 	PARAM_FLOAT		(distance);
 	PARAM_INT		(flags);
-	PARAM_INT_DEF	(amount);
-	PARAM_CLASS_DEF	(filter, AActor);
-	PARAM_NAME_DEF	(species);
-	PARAM_FLOAT_DEF	(mindist);
-	PARAM_INT_DEF	(limit);
+	PARAM_INT	(amount);
+	PARAM_CLASS	(filter, AActor);
+	PARAM_NAME	(species);
+	PARAM_FLOAT	(mindist);
+	PARAM_INT	(limit);
 
 	// We need a valid item, valid targets, and a valid range
 	if (item == nullptr || (flags & RGF_MASK) == 0 || !flags || distance <= 0 || mindist >= distance)
@@ -5706,8 +5706,8 @@ DEFINE_ACTION_FUNCTION(AActor, A_DropItem)
 {
 	PARAM_SELF_PROLOGUE(AActor);
 	PARAM_CLASS   (spawntype, AActor);
-	PARAM_INT_DEF(amount);
-	PARAM_INT_DEF(chance);
+	PARAM_INT(amount);
+	PARAM_INT(chance);
 
 	P_DropItem(self, spawntype, amount, chance);
 	return 0;
@@ -5787,12 +5787,12 @@ DEFINE_ACTION_FUNCTION(AActor, A_DamageSelf)
 {
 	PARAM_SELF_PROLOGUE(AActor);
 	PARAM_INT		(amount);
-	PARAM_NAME_DEF	(damagetype)	
-	PARAM_INT_DEF	(flags)			
-	PARAM_CLASS_DEF	(filter, AActor)
-	PARAM_NAME_DEF	(species)		
-	PARAM_INT_DEF	(src)			
-	PARAM_INT_DEF	(inflict)		
+	PARAM_NAME	(damagetype)	
+	PARAM_INT	(flags)			
+	PARAM_CLASS	(filter, AActor)
+	PARAM_NAME	(species)		
+	PARAM_INT	(src)			
+	PARAM_INT	(inflict)		
 
 	AActor *source = COPY_AAPTR(self, src);
 	AActor *inflictor = COPY_AAPTR(self, inflict);
@@ -5810,12 +5810,12 @@ DEFINE_ACTION_FUNCTION(AActor, A_DamageTarget)
 {
 	PARAM_SELF_PROLOGUE(AActor);
 	PARAM_INT		(amount);
-	PARAM_NAME_DEF	(damagetype)	
-	PARAM_INT_DEF	(flags)			
-	PARAM_CLASS_DEF	(filter, AActor)
-	PARAM_NAME_DEF	(species)		
-	PARAM_INT_DEF	(src)			
-	PARAM_INT_DEF	(inflict)		
+	PARAM_NAME	(damagetype)	
+	PARAM_INT	(flags)			
+	PARAM_CLASS	(filter, AActor)
+	PARAM_NAME	(species)		
+	PARAM_INT	(src)			
+	PARAM_INT	(inflict)		
 
 	AActor *source = COPY_AAPTR(self, src);
 	AActor *inflictor = COPY_AAPTR(self, inflict);
@@ -5834,12 +5834,12 @@ DEFINE_ACTION_FUNCTION(AActor, A_DamageTracer)
 {
 	PARAM_SELF_PROLOGUE(AActor);
 	PARAM_INT		(amount);
-	PARAM_NAME_DEF	(damagetype)	
-	PARAM_INT_DEF	(flags)			
-	PARAM_CLASS_DEF	(filter, AActor)
-	PARAM_NAME_DEF	(species)		
-	PARAM_INT_DEF	(src)			
-	PARAM_INT_DEF	(inflict)		
+	PARAM_NAME	(damagetype)	
+	PARAM_INT	(flags)			
+	PARAM_CLASS	(filter, AActor)
+	PARAM_NAME	(species)		
+	PARAM_INT	(src)			
+	PARAM_INT	(inflict)		
 
 	AActor *source = COPY_AAPTR(self, src);
 	AActor *inflictor = COPY_AAPTR(self, inflict);
@@ -5858,12 +5858,12 @@ DEFINE_ACTION_FUNCTION(AActor, A_DamageMaster)
 {
 	PARAM_SELF_PROLOGUE(AActor);
 	PARAM_INT		(amount);
-	PARAM_NAME_DEF	(damagetype)	
-	PARAM_INT_DEF	(flags)			
-	PARAM_CLASS_DEF	(filter, AActor)
-	PARAM_NAME_DEF	(species)		
-	PARAM_INT_DEF	(src)			
-	PARAM_INT_DEF	(inflict)		
+	PARAM_NAME	(damagetype)	
+	PARAM_INT	(flags)			
+	PARAM_CLASS	(filter, AActor)
+	PARAM_NAME	(species)		
+	PARAM_INT	(src)			
+	PARAM_INT	(inflict)		
 
 	AActor *source = COPY_AAPTR(self, src);
 	AActor *inflictor = COPY_AAPTR(self, inflict);
@@ -5882,12 +5882,12 @@ DEFINE_ACTION_FUNCTION(AActor, A_DamageChildren)
 {
 	PARAM_SELF_PROLOGUE(AActor);
 	PARAM_INT		(amount);
-	PARAM_NAME_DEF	(damagetype)	
-	PARAM_INT_DEF	(flags)			
-	PARAM_CLASS_DEF	(filter, AActor)
-	PARAM_NAME_DEF	(species)		
-	PARAM_INT_DEF	(src)			
-	PARAM_INT_DEF	(inflict)		
+	PARAM_NAME	(damagetype)	
+	PARAM_INT	(flags)			
+	PARAM_CLASS	(filter, AActor)
+	PARAM_NAME	(species)		
+	PARAM_INT	(src)			
+	PARAM_INT	(inflict)		
 
 	AActor *source = COPY_AAPTR(self, src);
 	AActor *inflictor = COPY_AAPTR(self, inflict);
@@ -5912,12 +5912,12 @@ DEFINE_ACTION_FUNCTION(AActor, A_DamageSiblings)
 {
 	PARAM_SELF_PROLOGUE(AActor);
 	PARAM_INT		(amount);
-	PARAM_NAME_DEF	(damagetype)	
-	PARAM_INT_DEF	(flags)			
-	PARAM_CLASS_DEF	(filter, AActor)
-	PARAM_NAME_DEF	(species)		
-	PARAM_INT_DEF	(src)			
-	PARAM_INT_DEF	(inflict)		
+	PARAM_NAME	(damagetype)	
+	PARAM_INT	(flags)			
+	PARAM_CLASS	(filter, AActor)
+	PARAM_NAME	(species)		
+	PARAM_INT	(src)			
+	PARAM_INT	(inflict)		
 
 	AActor *source = COPY_AAPTR(self, src);
 	AActor *inflictor = COPY_AAPTR(self, inflict);
@@ -5994,12 +5994,12 @@ static void DoKill(AActor *killtarget, AActor *inflictor, AActor *source, FName
 DEFINE_ACTION_FUNCTION(AActor, A_KillTarget)
 {
 	PARAM_SELF_PROLOGUE(AActor);
-	PARAM_NAME_DEF	(damagetype)	
-	PARAM_INT_DEF	(flags)			
-	PARAM_CLASS_DEF	(filter, AActor)
-	PARAM_NAME_DEF	(species)		
-	PARAM_INT_DEF	(src)			
-	PARAM_INT_DEF	(inflict)		
+	PARAM_NAME	(damagetype)	
+	PARAM_INT	(flags)			
+	PARAM_CLASS	(filter, AActor)
+	PARAM_NAME	(species)		
+	PARAM_INT	(src)			
+	PARAM_INT	(inflict)		
 
 	AActor *source = COPY_AAPTR(self, src);
 	AActor *inflictor = COPY_AAPTR(self, inflict);
@@ -6017,12 +6017,12 @@ DEFINE_ACTION_FUNCTION(AActor, A_KillTarget)
 DEFINE_ACTION_FUNCTION(AActor, A_KillTracer)
 {
 	PARAM_SELF_PROLOGUE(AActor);
-	PARAM_NAME_DEF	(damagetype)	
-	PARAM_INT_DEF	(flags)			
-	PARAM_CLASS_DEF	(filter, AActor)
-	PARAM_NAME_DEF	(species)		
-	PARAM_INT_DEF	(src)			
-	PARAM_INT_DEF	(inflict)		
+	PARAM_NAME	(damagetype)	
+	PARAM_INT	(flags)			
+	PARAM_CLASS	(filter, AActor)
+	PARAM_NAME	(species)		
+	PARAM_INT	(src)			
+	PARAM_INT	(inflict)		
 
 	AActor *source = COPY_AAPTR(self, src);
 	AActor *inflictor = COPY_AAPTR(self, inflict);
@@ -6040,12 +6040,12 @@ DEFINE_ACTION_FUNCTION(AActor, A_KillTracer)
 DEFINE_ACTION_FUNCTION(AActor, A_KillMaster)
 {
 	PARAM_SELF_PROLOGUE(AActor);
-	PARAM_NAME_DEF	(damagetype)	
-	PARAM_INT_DEF	(flags)			
-	PARAM_CLASS_DEF	(filter, AActor)
-	PARAM_NAME_DEF	(species)		
-	PARAM_INT_DEF	(src)			
-	PARAM_INT_DEF	(inflict)		
+	PARAM_NAME	(damagetype)	
+	PARAM_INT	(flags)			
+	PARAM_CLASS	(filter, AActor)
+	PARAM_NAME	(species)		
+	PARAM_INT	(src)			
+	PARAM_INT	(inflict)		
 
 	AActor *source = COPY_AAPTR(self, src); 
 	AActor *inflictor = COPY_AAPTR(self, inflict);
@@ -6063,12 +6063,12 @@ DEFINE_ACTION_FUNCTION(AActor, A_KillMaster)
 DEFINE_ACTION_FUNCTION(AActor, A_KillChildren)
 {
 	PARAM_SELF_PROLOGUE(AActor);
-	PARAM_NAME_DEF	(damagetype)	
-	PARAM_INT_DEF	(flags)			
-	PARAM_CLASS_DEF	(filter, AActor)
-	PARAM_NAME_DEF	(species)		
-	PARAM_INT_DEF	(src)			
-	PARAM_INT_DEF	(inflict)		
+	PARAM_NAME	(damagetype)	
+	PARAM_INT	(flags)			
+	PARAM_CLASS	(filter, AActor)
+	PARAM_NAME	(species)		
+	PARAM_INT	(src)			
+	PARAM_INT	(inflict)		
 
 	AActor *source = COPY_AAPTR(self, src);
 	AActor *inflictor = COPY_AAPTR(self, inflict);
@@ -6094,12 +6094,12 @@ DEFINE_ACTION_FUNCTION(AActor, A_KillChildren)
 DEFINE_ACTION_FUNCTION(AActor, A_KillSiblings)
 {
 	PARAM_SELF_PROLOGUE(AActor);
-	PARAM_NAME_DEF	(damagetype)	
-	PARAM_INT_DEF	(flags)			
-	PARAM_CLASS_DEF	(filter, AActor)
-	PARAM_NAME_DEF	(species)		
-	PARAM_INT_DEF	(src)			
-	PARAM_INT_DEF	(inflict)		
+	PARAM_NAME	(damagetype)	
+	PARAM_INT	(flags)			
+	PARAM_CLASS	(filter, AActor)
+	PARAM_NAME	(species)		
+	PARAM_INT	(src)			
+	PARAM_INT	(inflict)		
 
 	AActor *source = COPY_AAPTR(self, src);
 	AActor *inflictor = COPY_AAPTR(self, inflict);
@@ -6170,9 +6170,9 @@ static void DoRemove(AActor *removetarget, int flags, PClassActor *filter, FName
 DEFINE_ACTION_FUNCTION(AActor, A_RemoveTarget)
 {
 	PARAM_SELF_PROLOGUE(AActor);
-	PARAM_INT_DEF(flags);
-	PARAM_CLASS_DEF(filter, AActor);
-	PARAM_NAME_DEF(species);
+	PARAM_INT(flags);
+	PARAM_CLASS(filter, AActor);
+	PARAM_NAME(species);
 
 	if (self->target != NULL)
 	{
@@ -6189,9 +6189,9 @@ DEFINE_ACTION_FUNCTION(AActor, A_RemoveTarget)
 DEFINE_ACTION_FUNCTION(AActor, A_RemoveTracer)
 {
 	PARAM_SELF_PROLOGUE(AActor);
-	PARAM_INT_DEF(flags);
-	PARAM_CLASS_DEF(filter, AActor);
-	PARAM_NAME_DEF(species);
+	PARAM_INT(flags);
+	PARAM_CLASS(filter, AActor);
+	PARAM_NAME(species);
 
 	if (self->tracer != NULL)
 	{
@@ -6208,9 +6208,9 @@ DEFINE_ACTION_FUNCTION(AActor, A_RemoveTracer)
 DEFINE_ACTION_FUNCTION(AActor, A_RemoveMaster)
 {
 	PARAM_SELF_PROLOGUE(AActor);
-	PARAM_INT_DEF(flags);
-	PARAM_CLASS_DEF(filter, AActor);
-	PARAM_NAME_DEF(species);
+	PARAM_INT(flags);
+	PARAM_CLASS(filter, AActor);
+	PARAM_NAME(species);
 
 	if (self->master != NULL)
 	{
@@ -6227,10 +6227,10 @@ DEFINE_ACTION_FUNCTION(AActor, A_RemoveMaster)
 DEFINE_ACTION_FUNCTION(AActor, A_RemoveChildren)
 {
 	PARAM_SELF_PROLOGUE(AActor);
-	PARAM_BOOL_DEF(removeall);
-	PARAM_INT_DEF(flags);
-	PARAM_CLASS_DEF(filter, AActor);
-	PARAM_NAME_DEF(species);
+	PARAM_BOOL(removeall);
+	PARAM_INT(flags);
+	PARAM_CLASS(filter, AActor);
+	PARAM_NAME(species);
 
 	TThinkerIterator<AActor> it;
 	AActor *mo;
@@ -6253,10 +6253,10 @@ DEFINE_ACTION_FUNCTION(AActor, A_RemoveChildren)
 DEFINE_ACTION_FUNCTION(AActor, A_RemoveSiblings)
 {
 	PARAM_SELF_PROLOGUE(AActor);
-	PARAM_BOOL_DEF(removeall);
-	PARAM_INT_DEF(flags);
-	PARAM_CLASS_DEF(filter, AActor);
-	PARAM_NAME_DEF(species);
+	PARAM_BOOL(removeall);
+	PARAM_INT(flags);
+	PARAM_CLASS(filter, AActor);
+	PARAM_NAME(species);
 
 	TThinkerIterator<AActor> it;
 	AActor *mo;
@@ -6283,9 +6283,9 @@ DEFINE_ACTION_FUNCTION(AActor, A_Remove)
 {
 	PARAM_SELF_PROLOGUE(AActor);
 	PARAM_INT(removee);
-	PARAM_INT_DEF(flags);
-	PARAM_CLASS_DEF(filter, AActor);
-	PARAM_NAME_DEF(species);
+	PARAM_INT(flags);
+	PARAM_CLASS(filter, AActor);
+	PARAM_NAME(species);
 
 	AActor *reference = COPY_AAPTR(self, removee);
 	if (reference != NULL)
@@ -6352,7 +6352,7 @@ DEFINE_ACTION_FUNCTION(AActor, A_SetHealth)
 {
 	PARAM_SELF_PROLOGUE(AActor);
 	PARAM_INT		(health);
-	PARAM_INT_DEF	(ptr);
+	PARAM_INT	(ptr);
 
 	AActor *mobj = COPY_AAPTR(self, ptr);
 
@@ -6389,7 +6389,7 @@ DEFINE_ACTION_FUNCTION(AActor, A_SetHealth)
 DEFINE_ACTION_FUNCTION(AActor, A_ResetHealth)
 {
 	PARAM_SELF_PROLOGUE(AActor);
-	PARAM_INT_DEF(ptr);
+	PARAM_INT(ptr);
 
 	AActor *mobj = COPY_AAPTR(self, ptr);
 
@@ -6419,7 +6419,7 @@ DEFINE_ACTION_FUNCTION(AActor, A_SetSpecies)
 {
 	PARAM_SELF_PROLOGUE(AActor);
 	PARAM_NAME(species);
-	PARAM_INT_DEF(ptr);
+	PARAM_INT(ptr);
 
 	AActor *mobj = COPY_AAPTR(self, ptr);
 	if (!mobj)
@@ -6443,8 +6443,8 @@ DEFINE_ACTION_FUNCTION(AActor, A_SetChaseThreshold)
 {
 	PARAM_SELF_PROLOGUE(AActor);
 	PARAM_INT(threshold);
-	PARAM_BOOL_DEF(def);
-	PARAM_INT_DEF(ptr);
+	PARAM_BOOL(def);
+	PARAM_INT(ptr);
 
 
 	AActor *mobj = COPY_AAPTR(self, ptr);
@@ -6471,9 +6471,9 @@ DEFINE_ACTION_FUNCTION(AActor, CheckProximity)
 	PARAM_SELF_PROLOGUE(AActor);
 	PARAM_CLASS(classname, AActor);
 	PARAM_FLOAT(distance);
-	PARAM_INT_DEF(count);
-	PARAM_INT_DEF(flags);
-	PARAM_INT_DEF(ptr);
+	PARAM_INT(count);
+	PARAM_INT(flags);
+	PARAM_INT(ptr);
 
 	ACTION_RETURN_BOOL(!!P_Thing_CheckProximity(self, classname, distance, count, flags, ptr));
 }
@@ -6502,12 +6502,12 @@ enum CBF
 DEFINE_ACTION_FUNCTION(AActor, CheckBlock)
 {
 	PARAM_SELF_PROLOGUE(AActor);
-	PARAM_INT_DEF(flags)	
-	PARAM_INT_DEF(ptr)		
-	PARAM_FLOAT_DEF(xofs)	
-	PARAM_FLOAT_DEF(yofs)	
-	PARAM_FLOAT_DEF(zofs)	
-	PARAM_ANGLE_DEF(angle)	
+	PARAM_INT(flags)	
+	PARAM_INT(ptr)		
+	PARAM_FLOAT(xofs)	
+	PARAM_FLOAT(yofs)	
+	PARAM_FLOAT(zofs)	
+	PARAM_ANGLE(angle)	
 
 	AActor *mobj = COPY_AAPTR(self, ptr);
 
@@ -6601,11 +6601,11 @@ enum FMDFlags
 DEFINE_ACTION_FUNCTION(AActor, A_FaceMovementDirection)
 {
 	PARAM_SELF_PROLOGUE(AActor);
-	PARAM_ANGLE_DEF(offset)		
-	PARAM_ANGLE_DEF(anglelimit)	
-	PARAM_ANGLE_DEF(pitchlimit)	
-	PARAM_INT_DEF(flags)		
-	PARAM_INT_DEF(ptr)			
+	PARAM_ANGLE(offset)		
+	PARAM_ANGLE(anglelimit)	
+	PARAM_ANGLE(pitchlimit)	
+	PARAM_INT(flags)		
+	PARAM_INT(ptr)			
 
 	AActor *mobj = COPY_AAPTR(self, ptr);
 
@@ -6697,7 +6697,7 @@ DEFINE_ACTION_FUNCTION(AActor, A_CopySpriteFrame)
 	PARAM_SELF_PROLOGUE(AActor);
 	PARAM_INT(from);
 	PARAM_INT(to);
-	PARAM_INT_DEF(flags);
+	PARAM_INT(flags);
 
 	AActor *copyfrom = COPY_AAPTR(self, from);
 	AActor *copyto = COPY_AAPTR(self, to);
@@ -6730,12 +6730,12 @@ enum VRFFlags
 DEFINE_ACTION_FUNCTION(AActor, A_SetVisibleRotation)
 {
 	PARAM_SELF_PROLOGUE(AActor);
-	PARAM_ANGLE_DEF(anglestart)
-	PARAM_ANGLE_DEF(angleend)	
-	PARAM_ANGLE_DEF(pitchstart)
-	PARAM_ANGLE_DEF(pitchend)	
-	PARAM_INT_DEF(flags)		
-	PARAM_INT_DEF(ptr)			
+	PARAM_ANGLE(anglestart)
+	PARAM_ANGLE(angleend)	
+	PARAM_ANGLE(pitchstart)
+	PARAM_ANGLE(pitchend)	
+	PARAM_INT(flags)		
+	PARAM_INT(ptr)			
 
 	AActor *mobj = COPY_AAPTR(self, ptr);
 
@@ -6811,9 +6811,9 @@ DEFINE_ACTION_FUNCTION(AActor, A_CheckTerrain)
 DEFINE_ACTION_FUNCTION(AActor, A_SetSize)
 {
 	PARAM_SELF_PROLOGUE(AActor);
-	PARAM_FLOAT_DEF(newradius);
-	PARAM_FLOAT_DEF(newheight);
-	PARAM_BOOL_DEF(testpos);
+	PARAM_FLOAT(newradius);
+	PARAM_FLOAT(newheight);
+	PARAM_BOOL(testpos);
 
 	if (newradius < 0.)		newradius = self->radius;
 	if (newheight < 0.)		newheight = self->Height;
@@ -6847,7 +6847,7 @@ DEFINE_ACTION_FUNCTION(AActor, SetCamera)
 {
 	PARAM_ACTION_PROLOGUE(AActor);
 	PARAM_OBJECT(cam, AActor);
-	PARAM_BOOL_DEF(revert);
+	PARAM_BOOL(revert);
 
 	if (self->player == nullptr || self->player->mo != self) return 0;
 
@@ -6871,7 +6871,7 @@ DEFINE_ACTION_FUNCTION(AActor, A_SprayDecal)
 {
 	PARAM_SELF_PROLOGUE(AActor);
 	PARAM_STRING(name);
-	PARAM_FLOAT_DEF(dist);
+	PARAM_FLOAT(dist);
 	SprayDecal(self, name, dist);
 	return 0;
 }
diff --git a/src/p_ceiling.cpp b/src/p_ceiling.cpp
index 0f37e3379..02448f07c 100644
--- a/src/p_ceiling.cpp
+++ b/src/p_ceiling.cpp
@@ -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));
 }
 
diff --git a/src/p_enemy.cpp b/src/p_enemy.cpp
index 14715608b..b99d60798 100644
--- a/src/p_enemy.cpp
+++ b/src/p_enemy.cpp
@@ -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;
diff --git a/src/p_floor.cpp b/src/p_floor.cpp
index 7141a842e..f9d72c57a 100644
--- a/src/p_floor.cpp
+++ b/src/p_floor.cpp
@@ -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));
 }
 
diff --git a/src/p_interaction.cpp b/src/p_interaction.cpp
index d5404a19a..f40d01034 100644
--- a/src/p_interaction.cpp
+++ b/src/p_interaction.cpp
@@ -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;
diff --git a/src/p_lnspec.cpp b/src/p_lnspec.cpp
index 2422dfe19..2d48937e8 100644
--- a/src/p_lnspec.cpp
+++ b/src/p_lnspec.cpp
@@ -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);
 
diff --git a/src/p_map.cpp b/src/p_map.cpp
index e0b16ca2e..d1670dc37 100644
--- a/src/p_map.cpp
+++ b/src/p_map.cpp
@@ -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)
 	{
diff --git a/src/p_maputl.cpp b/src/p_maputl.cpp
index 48396b7cf..16aca4d86 100644
--- a/src/p_maputl.cpp
+++ b/src/p_maputl.cpp
@@ -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));
 }
 
diff --git a/src/p_mobj.cpp b/src/p_mobj.cpp
index 74fcffa88..1e4d412a2 100644
--- a/src/p_mobj.cpp
+++ b/src/p_mobj.cpp
@@ -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));
 }
 
diff --git a/src/p_pspr.cpp b/src/p_pspr.cpp
index 2c0e418b3..948cdf8a0 100644
--- a/src/p_pspr.cpp
+++ b/src/p_pspr.cpp
@@ -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);
 }
 
diff --git a/src/p_sectors.cpp b/src/p_sectors.cpp
index 14cd4a4d1..1a95f051d 100644
--- a/src/p_sectors.cpp
+++ b/src/p_sectors.cpp
@@ -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;
  }
diff --git a/src/p_sight.cpp b/src/p_sight.cpp
index 9716ad50e..cb6dbb011 100644
--- a/src/p_sight.cpp
+++ b/src/p_sight.cpp
@@ -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));
 }
 
diff --git a/src/p_spec.cpp b/src/p_spec.cpp
index e8dbe8d2f..d6911c596 100644
--- a/src/p_spec.cpp
+++ b/src/p_spec.cpp
@@ -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;
 }
diff --git a/src/p_states.cpp b/src/p_states.cpp
index addf8ad1d..50adf53c6 100644
--- a/src/p_states.cpp
+++ b/src/p_states.cpp
@@ -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));
 }
 
diff --git a/src/p_tags.cpp b/src/p_tags.cpp
index 74bcafbd7..458a456fc 100644
--- a/src/p_tags.cpp
+++ b/src/p_tags.cpp
@@ -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));
 }
 
diff --git a/src/p_things.cpp b/src/p_things.cpp
index e7de17aab..1cd3970f4 100644
--- a/src/p_things.cpp
+++ b/src/p_things.cpp
@@ -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));
 }
diff --git a/src/p_user.cpp b/src/p_user.cpp
index e910eac97..a601f1db2 100644
--- a/src/p_user.cpp
+++ b/src/p_user.cpp
@@ -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;
diff --git a/src/s_sndseq.cpp b/src/s_sndseq.cpp
index a3937a01e..9887328e6 100644
--- a/src/s_sndseq.cpp
+++ b/src/s_sndseq.cpp
@@ -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));
 }
 
diff --git a/src/s_sound.cpp b/src/s_sound.cpp
index be12d3693..4ba1d476e 100644
--- a/src/s_sound.cpp
+++ b/src/s_sound.cpp
@@ -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));
 }
 
diff --git a/src/scripting/backend/codegen.cpp b/src/scripting/backend/codegen.cpp
index bf2ab371a..50ecd1040 100644
--- a/src/scripting/backend/codegen.cpp
+++ b/src/scripting/backend/codegen.cpp
@@ -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);
diff --git a/src/scripting/backend/dynarrays.cpp b/src/scripting/backend/dynarrays.cpp
index 49c916a88..de09ec79b 100644
--- a/src/scripting/backend/dynarrays.cpp
+++ b/src/scripting/backend/dynarrays.cpp
@@ -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;
 }
diff --git a/src/scripting/thingdef_data.cpp b/src/scripting/thingdef_data.cpp
index 60200e765..6d62e7081 100644
--- a/src/scripting/thingdef_data.cpp
+++ b/src/scripting/thingdef_data.cpp
@@ -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;
 }
diff --git a/src/scripting/vm/vm.h b/src/scripting/vm/vm.h
index e498d4c14..ab1fdad71 100644
--- a/src/scripting/vm/vm.h
+++ b/src/scripting/vm/vm.h
@@ -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
 {
diff --git a/src/scripting/vm/vmexec.h b/src/scripting/vm/vmexec.h
index 0a6392724..1e8e0c5c3 100644
--- a/src/scripting/vm/vmexec.h
+++ b/src/scripting/vm/vmexec.h
@@ -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;
 				}
diff --git a/src/scripting/vm/vmframe.cpp b/src/scripting/vm/vmframe.cpp
index 72046d0a2..0a69c8c2b 100644
--- a/src/scripting/vm/vmframe.cpp
+++ b/src/scripting/vm/vmframe.cpp
@@ -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;
 }
diff --git a/src/textures/texturemanager.cpp b/src/textures/texturemanager.cpp
index b29a9d97f..76e1febbf 100644
--- a/src/textures/texturemanager.cpp
+++ b/src/textures/texturemanager.cpp
@@ -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());
 }
 
diff --git a/src/v_2ddrawer.cpp b/src/v_2ddrawer.cpp
index 8fc487ef9..6b4305de9 100644
--- a/src/v_2ddrawer.cpp
+++ b/src/v_2ddrawer.cpp
@@ -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();
diff --git a/src/v_draw.cpp b/src/v_draw.cpp
index 252d9bf4e..ca9ff6640 100644
--- a/src/v_draw.cpp
+++ b/src/v_draw.cpp
@@ -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;
diff --git a/src/w_wad.cpp b/src/w_wad.cpp
index 9c0dd3760..9564bb5ac 100644
--- a/src/w_wad.cpp
+++ b/src/w_wad.cpp
@@ -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);
 }