Update for 37-13

Update for NWNEE 37-13.  Updated NWNxEE.  Full compile.

_module/nss/nwnx_admin.nss

@@ -2,7 +2,6 @@
 /// @brief Various admin related functions
 /// @{
 /// @file nwnx_admin.nss
-#include "nwnx"
 
 const string NWNX_Administration = "NWNX_Administration"; ///< @private
 
@@ -179,213 +178,161 @@ void NWNX_Administration_SetMaxLevel(int nLevel);
 
 string NWNX_Administration_GetPlayerPassword()
 {
-    string sFunc = "GetPlayerPassword";
-
-    NWNX_CallFunction(NWNX_Administration, sFunc);
-    return NWNX_GetReturnValueString();
+    NWNXCall(NWNX_Administration, "GetPlayerPassword");
+    return NWNXPopString();
 }
 
 void NWNX_Administration_SetPlayerPassword(string password)
 {
-    string sFunc = "SetPlayerPassword";
-
-    NWNX_PushArgumentString(password);
-    NWNX_CallFunction(NWNX_Administration, sFunc);
+    NWNXPushString(password);
+    NWNXCall(NWNX_Administration, "SetPlayerPassword");
 }
 
 void NWNX_Administration_ClearPlayerPassword()
 {
-    string sFunc = "ClearPlayerPassword";
-
-    NWNX_CallFunction(NWNX_Administration, sFunc);
+    NWNXCall(NWNX_Administration, "ClearPlayerPassword");
 }
 
 string NWNX_Administration_GetDMPassword()
 {
-    string sFunc = "GetDMPassword";
-
-    NWNX_CallFunction(NWNX_Administration, sFunc);
-    return NWNX_GetReturnValueString();
+    NWNXCall(NWNX_Administration, "GetDMPassword");
+    return NWNXPopString();
 }
 
 void NWNX_Administration_SetDMPassword(string password)
 {
-    string sFunc = "SetDMPassword";
-
-    NWNX_PushArgumentString(password);
-    NWNX_CallFunction(NWNX_Administration, sFunc);
+    NWNXPushString(password);
+    NWNXCall(NWNX_Administration, "SetDMPassword");
 }
 
 void NWNX_Administration_ShutdownServer()
 {
-    string sFunc = "ShutdownServer";
-
-    NWNX_CallFunction(NWNX_Administration, sFunc);
+    NWNXCall(NWNX_Administration, "ShutdownServer");
 }
 
 void NWNX_Administration_DeletePlayerCharacter(object oPC, int bPreserveBackup = TRUE, string sKickMessage = "")
 {
-    string sFunc = "DeletePlayerCharacter";
-
-    NWNX_PushArgumentString(sKickMessage);
-    NWNX_PushArgumentInt(bPreserveBackup);
-    NWNX_PushArgumentObject(oPC);
-    NWNX_CallFunction(NWNX_Administration, sFunc);
+    NWNXPushString(sKickMessage);
+    NWNXPushInt(bPreserveBackup);
+    NWNXPushObject(oPC);
+    NWNXCall(NWNX_Administration, "DeletePlayerCharacter");
 }
 
 void NWNX_Administration_AddBannedIP(string ip)
 {
-    string sFunc = "AddBannedIP";
-
-    NWNX_PushArgumentString(ip);
-    NWNX_CallFunction(NWNX_Administration, sFunc);
+    NWNXPushString(ip);
+    NWNXCall(NWNX_Administration, "AddBannedIP");
 }
 void NWNX_Administration_RemoveBannedIP(string ip)
 {
-    string sFunc = "RemoveBannedIP";
-
-    NWNX_PushArgumentString(ip);
-    NWNX_CallFunction(NWNX_Administration, sFunc);
+    NWNXPushString(ip);
+    NWNXCall(NWNX_Administration, "RemoveBannedIP");
 }
 void NWNX_Administration_AddBannedCDKey(string key)
 {
-    string sFunc = "AddBannedCDKey";
-
-    NWNX_PushArgumentString(key);
-    NWNX_CallFunction(NWNX_Administration, sFunc);
+    NWNXPushString(key);
+    NWNXCall(NWNX_Administration, "AddBannedCDKey");
 }
 void NWNX_Administration_RemoveBannedCDKey(string key)
 {
-    string sFunc = "RemoveBannedCDKey";
-
-    NWNX_PushArgumentString(key);
-    NWNX_CallFunction(NWNX_Administration, sFunc);
+    NWNXPushString(key);
+    NWNXCall(NWNX_Administration, "RemoveBannedCDKey");
 }
 void NWNX_Administration_AddBannedPlayerName(string playerName)
 {
-    string sFunc = "AddBannedPlayerName";
-
-    NWNX_PushArgumentString(playerName);
-    NWNX_CallFunction(NWNX_Administration, sFunc);
+    NWNXPushString(playerName);
+    NWNXCall(NWNX_Administration, "AddBannedPlayerName");
 }
 void NWNX_Administration_RemoveBannedPlayerName(string playerName)
 {
-    string sFunc = "RemoveBannedPlayerName";
-
-    NWNX_PushArgumentString(playerName);
-    NWNX_CallFunction(NWNX_Administration, sFunc);
+    NWNXPushString(playerName);
+    NWNXCall(NWNX_Administration, "RemoveBannedPlayerName");
 }
 string NWNX_Administration_GetBannedList()
 {
-    string sFunc = "GetBannedList";
-
-    NWNX_CallFunction(NWNX_Administration, sFunc);
-    return NWNX_GetReturnValueString();
+    NWNXCall(NWNX_Administration, "GetBannedList");
+    return NWNXPopString();
 }
 
 void NWNX_Administration_SetModuleName(string name)
 {
-    string sFunc = "SetModuleName";
-
-    NWNX_PushArgumentString(name);
-    NWNX_CallFunction(NWNX_Administration, sFunc);
+    NWNXPushString(name);
+    NWNXCall(NWNX_Administration, "SetModuleName");
 }
 
 void NWNX_Administration_SetServerName(string name)
 {
-    string sFunc = "SetServerName";
-
-    NWNX_PushArgumentString(name);
-    NWNX_CallFunction(NWNX_Administration, sFunc);
+    NWNXPushString(name);
+    NWNXCall(NWNX_Administration, "SetServerName");
 }
 
 string NWNX_Administration_GetServerName()
 {
-    string sFunc = "GetServerName";
-    NWNX_CallFunction(NWNX_Administration, sFunc);
-    return NWNX_GetReturnValueString();
+    NWNXCall(NWNX_Administration, "GetServerName");
+    return NWNXPopString();
 }
 
 int NWNX_Administration_GetPlayOption(int option)
 {
-    string sFunc = "GetPlayOption";
-
-    NWNX_PushArgumentInt(option);
-    NWNX_CallFunction(NWNX_Administration, sFunc);
-
-    return NWNX_GetReturnValueInt();
+    NWNXPushInt(option);
+    NWNXCall(NWNX_Administration, "GetPlayOption");
+    return NWNXPopInt();
 }
 
 void NWNX_Administration_SetPlayOption(int option, int value)
 {
-    string sFunc = "SetPlayOption";
-
-    NWNX_PushArgumentInt(value);
-    NWNX_PushArgumentInt(option);
-    NWNX_CallFunction(NWNX_Administration, sFunc);
+    NWNXPushInt(value);
+    NWNXPushInt(option);
+    NWNXCall(NWNX_Administration, "SetPlayOption");
 }
 
 int NWNX_Administration_DeleteTURD(string playerName, string characterName)
 {
-    string sFunc = "DeleteTURD";
-
-    NWNX_PushArgumentString(characterName);
-    NWNX_PushArgumentString(playerName);
-    NWNX_CallFunction(NWNX_Administration, sFunc);
-
-    return NWNX_GetReturnValueInt();
+    NWNXPushString(characterName);
+    NWNXPushString(playerName);
+    NWNXCall(NWNX_Administration, "DeleteTURD");
+    return NWNXPopInt();
 }
 
 int NWNX_Administration_GetDebugValue(int type)
 {
-    string sFunc = "GetDebugValue";
-
-    NWNX_PushArgumentInt(type);
-    NWNX_CallFunction(NWNX_Administration, sFunc);
-
-    return NWNX_GetReturnValueInt();
+    NWNXPushInt(type);
+    NWNXCall(NWNX_Administration, "GetDebugValue");
+    return NWNXPopInt();
 }
 
 void NWNX_Administration_SetDebugValue(int type, int state)
 {
-    string sFunc = "SetDebugValue";
-
-    NWNX_PushArgumentInt(state);
-    NWNX_PushArgumentInt(type);
-    NWNX_CallFunction(NWNX_Administration, sFunc);
+    NWNXPushInt(state);
+    NWNXPushInt(type);
+    NWNXCall(NWNX_Administration, "SetDebugValue");
 }
 
 void NWNX_Administration_ReloadRules()
 {
-    string sFunc = "ReloadRules";
-
-    NWNX_CallFunction(NWNX_Administration, sFunc);
+    NWNXCall(NWNX_Administration, "ReloadRules");
 }
 
 int NWNX_Administration_GetMinLevel()
 {
-    string sFunc = "GetMinLevel";
-    NWNX_CallFunction(NWNX_Administration, sFunc);
-    return NWNX_GetReturnValueInt();
+    NWNXCall(NWNX_Administration, "GetMinLevel");
+    return NWNXPopInt();
 }
 
 void NWNX_Administration_SetMinLevel(int nLevel)
 {
-    string sFunc = "SetMinLevel";
-    NWNX_PushArgumentInt(nLevel);
-    NWNX_CallFunction(NWNX_Administration, sFunc);
+    NWNXPushInt(nLevel);
+    NWNXCall(NWNX_Administration, "SetMinLevel");
 }
 
 int NWNX_Administration_GetMaxLevel()
 {
-    string sFunc = "GetMaxLevel";
-    NWNX_CallFunction(NWNX_Administration, sFunc);
-    return NWNX_GetReturnValueInt();
+    NWNXCall(NWNX_Administration, "GetMaxLevel");
+    return NWNXPopInt();
 }
 
 void NWNX_Administration_SetMaxLevel(int nLevel)
 {
-    string sFunc = "SetMaxLevel";
-    NWNX_PushArgumentInt(nLevel);
-    NWNX_CallFunction(NWNX_Administration, sFunc);
+    NWNXPushInt(nLevel);
+    NWNXCall(NWNX_Administration, "SetMaxLevel");
 }

_module/nss/nwnx_appearance.nss

@@ -2,7 +2,6 @@
 /// @brief Allows the appearance and some other things of creatures to be overridden per player.
 /// @{
 /// @file nwnx_appearance.nss
-#include "nwnx"
 
 const string NWNX_Appearance = "NWNX_Appearance"; ///< @private
 
@@ -49,25 +48,18 @@ int NWNX_Appearance_GetOverride(object oPlayer, object oCreature, int nType);
 
 void NWNX_Appearance_SetOverride(object oPlayer, object oCreature, int nType, int nValue)
 {
-    string sFunc = "SetOverride";
-
-    NWNX_PushArgumentInt(nValue);
-    NWNX_PushArgumentInt(nType);
-    NWNX_PushArgumentObject(oCreature);
-    NWNX_PushArgumentObject(oPlayer);
-
-    NWNX_CallFunction(NWNX_Appearance, sFunc);
+    NWNXPushInt(nValue);
+    NWNXPushInt(nType);
+    NWNXPushObject(oCreature);
+    NWNXPushObject(oPlayer);
+    NWNXCall(NWNX_Appearance, "SetOverride");
 }
 
 int NWNX_Appearance_GetOverride(object oPlayer, object oCreature, int nType)
 {
-    string sFunc = "GetOverride";
-
-    NWNX_PushArgumentInt(nType);
-    NWNX_PushArgumentObject(oCreature);
-    NWNX_PushArgumentObject(oPlayer);
-
-    NWNX_CallFunction(NWNX_Appearance, sFunc);
-
-    return NWNX_GetReturnValueInt();
+    NWNXPushInt(nType);
+    NWNXPushObject(oCreature);
+    NWNXPushObject(oPlayer);
+    NWNXCall(NWNX_Appearance, "GetOverride");
+    return NWNXPopInt();
 }

_module/nss/nwnx_area.nss

@@ -2,7 +2,6 @@
 /// @brief Functions exposing additional area properties as well as creating transitions.
 /// @{
 /// @file nwnx_area.nss
-#include "nwnx"
 
 const string NWNX_Area = "NWNX_Area"; ///< @private
 
@@ -353,536 +352,396 @@ void NWNX_Area_SetDefaultObjectUiDiscoveryMask(object oArea, int nObjectTypes, i
 
 int NWNX_Area_GetNumberOfPlayersInArea(object area)
 {
-    string sFunc = "GetNumberOfPlayersInArea";
-
-    NWNX_PushArgumentObject(area);
-    NWNX_CallFunction(NWNX_Area, sFunc);
-
-    return NWNX_GetReturnValueInt();
+    NWNXPushObject(area);
+    NWNXCall(NWNX_Area, "GetNumberOfPlayersInArea");
+    return NWNXPopInt();
 }
 
 object NWNX_Area_GetLastEntered(object area)
 {
-    string sFunc = "GetLastEntered";
-
-    NWNX_PushArgumentObject(area);
-    NWNX_CallFunction(NWNX_Area, sFunc);
-
-    return NWNX_GetReturnValueObject();
+    NWNXPushObject(area);
+    NWNXCall(NWNX_Area, "GetLastEntered");
+    return NWNXPopObject();
 }
 
 object NWNX_Area_GetLastLeft(object area)
 {
-    string sFunc = "GetLastLeft";
-
-    NWNX_PushArgumentObject(area);
-    NWNX_CallFunction(NWNX_Area, sFunc);
-
-    return NWNX_GetReturnValueObject();
+    NWNXPushObject(area);
+    NWNXCall(NWNX_Area, "GetLastLeft");
+    return NWNXPopObject();
 }
 
 int NWNX_Area_GetPVPSetting(object area)
 {
-    string sFunc = "GetPVPSetting";
-
-    NWNX_PushArgumentObject(area);
-    NWNX_CallFunction(NWNX_Area, sFunc);
-
-    return NWNX_GetReturnValueInt();
+    NWNXPushObject(area);
+    NWNXCall(NWNX_Area, "GetPVPSetting");
+    return NWNXPopInt();
 }
 
 void NWNX_Area_SetPVPSetting(object area, int pvpSetting)
 {
-    string sFunc = "SetPVPSetting";
-
-    NWNX_PushArgumentInt(pvpSetting);
-    NWNX_PushArgumentObject(area);
-    NWNX_CallFunction(NWNX_Area, sFunc);
+    NWNXPushInt(pvpSetting);
+    NWNXPushObject(area);
+    NWNXCall(NWNX_Area, "SetPVPSetting");
 }
 
 int NWNX_Area_GetAreaSpotModifier(object area)
 {
-    string sFunc = "GetAreaSpotModifier";
-
-    NWNX_PushArgumentObject(area);
-    NWNX_CallFunction(NWNX_Area, sFunc);
-
-    return NWNX_GetReturnValueInt();
+    NWNXPushObject(area);
+    NWNXCall(NWNX_Area, "GetAreaSpotModifier");
+    return NWNXPopInt();
 }
 
 void NWNX_Area_SetAreaSpotModifier(object area, int spotModifier)
 {
-    string sFunc = "SetAreaSpotModifier";
-
-    NWNX_PushArgumentInt(spotModifier);
-    NWNX_PushArgumentObject(area);
-    NWNX_CallFunction(NWNX_Area, sFunc);
+    NWNXPushInt(spotModifier);
+    NWNXPushObject(area);
+    NWNXCall(NWNX_Area, "SetAreaSpotModifier");
 }
 
 int NWNX_Area_GetAreaListenModifier(object area)
 {
-    string sFunc = "GetAreaListenModifier";
-
-    NWNX_PushArgumentObject(area);
-    NWNX_CallFunction(NWNX_Area, sFunc);
-
-    return NWNX_GetReturnValueInt();
+    NWNXPushObject(area);
+    NWNXCall(NWNX_Area, "GetAreaListenModifier");
+    return NWNXPopInt();
 }
 
 void NWNX_Area_SetAreaListenModifier(object area, int listenModifier)
 {
-    string sFunc = "SetAreaListenModifier";
-
-    NWNX_PushArgumentInt(listenModifier);
-    NWNX_PushArgumentObject(area);
-    NWNX_CallFunction(NWNX_Area, sFunc);
+    NWNXPushInt(listenModifier);
+    NWNXPushObject(area);
+    NWNXCall(NWNX_Area, "SetAreaListenModifier");
 }
 
 int NWNX_Area_GetNoRestingAllowed(object area)
 {
-    string sFunc = "GetNoRestingAllowed";
-
-    NWNX_PushArgumentObject(area);
-    NWNX_CallFunction(NWNX_Area, sFunc);
-
-    return NWNX_GetReturnValueInt();
+    NWNXPushObject(area);
+    NWNXCall(NWNX_Area, "GetNoRestingAllowed");
+    return NWNXPopInt();
 }
 
 void NWNX_Area_SetNoRestingAllowed(object area, int bNoRestingAllowed)
 {
-    string sFunc = "SetNoRestingAllowed";
-
-    NWNX_PushArgumentInt(bNoRestingAllowed);
-    NWNX_PushArgumentObject(area);
-    NWNX_CallFunction(NWNX_Area, sFunc);
+    NWNXPushInt(bNoRestingAllowed);
+    NWNXPushObject(area);
+    NWNXCall(NWNX_Area, "SetNoRestingAllowed");
 }
 
 int NWNX_Area_GetWindPower(object area)
 {
-    string sFunc = "GetWindPower";
-
-    NWNX_PushArgumentObject(area);
-    NWNX_CallFunction(NWNX_Area, sFunc);
-
-    return NWNX_GetReturnValueInt();
+    NWNXPushObject(area);
+    NWNXCall(NWNX_Area, "GetWindPower");
+    return NWNXPopInt();
 }
 
 void NWNX_Area_SetWindPower(object area, int windPower)
 {
-    string sFunc = "SetWindPower";
-
-    NWNX_PushArgumentInt(windPower);
-    NWNX_PushArgumentObject(area);
-    NWNX_CallFunction(NWNX_Area, sFunc);
+    NWNXPushInt(windPower);
+    NWNXPushObject(area);
+    NWNXCall(NWNX_Area, "SetWindPower");
 }
 
 int NWNX_Area_GetWeatherChance(object area, int type)
 {
-    string sFunc = "GetWeatherChance";
-
-    NWNX_PushArgumentInt(type);
-    NWNX_PushArgumentObject(area);
-    NWNX_CallFunction(NWNX_Area, sFunc);
-
-    return NWNX_GetReturnValueInt();
+    NWNXPushInt(type);
+    NWNXPushObject(area);
+    NWNXCall(NWNX_Area, "GetWeatherChance");
+    return NWNXPopInt();
 }
 
 void NWNX_Area_SetWeatherChance(object area, int type, int chance)
 {
-    string sFunc = "SetWeatherChance";
-
-    NWNX_PushArgumentInt(chance);
-    NWNX_PushArgumentInt(type);
-    NWNX_PushArgumentObject(area);
-    NWNX_CallFunction(NWNX_Area, sFunc);
+    NWNXPushInt(chance);
+    NWNXPushInt(type);
+    NWNXPushObject(area);
+    NWNXCall(NWNX_Area, "SetWeatherChance");
 }
 
 float NWNX_Area_GetFogClipDistance(object area)
 {
-    string sFunc = "GetFogClipDistance";
-
-    NWNX_PushArgumentObject(area);
-    NWNX_CallFunction(NWNX_Area, sFunc);
-
-    return NWNX_GetReturnValueFloat();
+    NWNXPushObject(area);
+    NWNXCall(NWNX_Area, "GetFogClipDistance");
+    return NWNXPopFloat();
 }
 
 void NWNX_Area_SetFogClipDistance(object area, float distance)
 {
-    string sFunc = "SetFogClipDistance";
-
-    NWNX_PushArgumentFloat(distance);
-    NWNX_PushArgumentObject(area);
-    NWNX_CallFunction(NWNX_Area, sFunc);
+    NWNXPushFloat(distance);
+    NWNXPushObject(area);
+    NWNXCall(NWNX_Area, "SetFogClipDistance");
 }
 
 int NWNX_Area_GetShadowOpacity(object area)
 {
-    string sFunc = "GetShadowOpacity";
-
-    NWNX_PushArgumentObject(area);
-    NWNX_CallFunction(NWNX_Area, sFunc);
-
-    return NWNX_GetReturnValueInt();
+    NWNXPushObject(area);
+    NWNXCall(NWNX_Area, "GetShadowOpacity");
+    return NWNXPopInt();
 }
 
 void NWNX_Area_SetShadowOpacity(object area, int shadowOpacity)
 {
-    string sFunc = "SetShadowOpacity";
-
-    NWNX_PushArgumentInt(shadowOpacity);
-    NWNX_PushArgumentObject(area);
-    NWNX_CallFunction(NWNX_Area, sFunc);
+    NWNXPushInt(shadowOpacity);
+    NWNXPushObject(area);
+    NWNXCall(NWNX_Area, "SetShadowOpacity");
 }
 
 
 int NWNX_Area_GetDayNightCycle(object area)
 {
-    string sFunc = "GetDayNightCycle";
-
-    NWNX_PushArgumentObject(area);
-    NWNX_CallFunction(NWNX_Area, sFunc);
-
-    return NWNX_GetReturnValueInt();
+    NWNXPushObject(area);
+    NWNXCall(NWNX_Area, "GetDayNightCycle");
+    return NWNXPopInt();
 }
 
 void NWNX_Area_SetDayNightCycle(object area, int type)
 {
-    string sFunc = "SetDayNightCycle";
-
-    NWNX_PushArgumentInt(type);
-    NWNX_PushArgumentObject(area);
-    NWNX_CallFunction(NWNX_Area, sFunc);
+    NWNXPushInt(type);
+    NWNXPushObject(area);
+    NWNXCall(NWNX_Area, "SetDayNightCycle");
 }
 
 int NWNX_Area_GetSunMoonColors(object area, int type)
 {
-    string sFunc = "GetSunMoonColors";
-
-    NWNX_PushArgumentInt(type);
-    NWNX_PushArgumentObject(area);
-    NWNX_CallFunction(NWNX_Area, sFunc);
-
-    return NWNX_GetReturnValueInt();
+    NWNXPushInt(type);
+    NWNXPushObject(area);
+    NWNXCall(NWNX_Area, "GetSunMoonColors");
+    return NWNXPopInt();
 }
 
 void NWNX_Area_SetSunMoonColors(object area, int type, int color)
 {
-    string sFunc = "SetSunMoonColors";
-
-    NWNX_PushArgumentInt(color);
-    NWNX_PushArgumentInt(type);
-    NWNX_PushArgumentObject(area);
-    NWNX_CallFunction(NWNX_Area, sFunc);
+    NWNXPushInt(color);
+    NWNXPushInt(type);
+    NWNXPushObject(area);
+    NWNXCall(NWNX_Area, "SetSunMoonColors");
 }
 
 object NWNX_Area_CreateTransition(object area, object target, float x, float y, float z, float size = 2.0f, string tag="")
 {
-    string sFunc = "CreateTransition";
-
-    NWNX_PushArgumentString(tag);
-    NWNX_PushArgumentFloat(size);
-    NWNX_PushArgumentFloat(z);
-    NWNX_PushArgumentFloat(y);
-    NWNX_PushArgumentFloat(x);
-    NWNX_PushArgumentObject(target);
-    NWNX_PushArgumentObject(area);
-    NWNX_CallFunction(NWNX_Area, sFunc);
-
-    return NWNX_GetReturnValueObject();
+    NWNXPushString(tag);
+    NWNXPushFloat(size);
+    NWNXPushFloat(z);
+    NWNXPushFloat(y);
+    NWNXPushFloat(x);
+    NWNXPushObject(target);
+    NWNXPushObject(area);
+    NWNXCall(NWNX_Area, "CreateTransition");
+    return NWNXPopObject();
 }
 
 int NWNX_Area_GetTileAnimationLoop(object oArea, float fTileX, float fTileY, int nAnimLoop)
 {
-    string sFunc = "GetTileAnimationLoop";
+    NWNXPushInt(nAnimLoop);
+    NWNXPushFloat(fTileY);
+    NWNXPushFloat(fTileX);
+    NWNXPushObject(oArea);
 
-    NWNX_PushArgumentInt(nAnimLoop);
-    NWNX_PushArgumentFloat(fTileY);
-    NWNX_PushArgumentFloat(fTileX);
-    NWNX_PushArgumentObject(oArea);
-
-    NWNX_CallFunction(NWNX_Area, sFunc);
-
-    return NWNX_GetReturnValueInt();
+    NWNXCall(NWNX_Area, "GetTileAnimationLoop");
+    return NWNXPopInt();
 }
 
 void NWNX_Area_SetTileAnimationLoop(object oArea, float fTileX, float fTileY, int nAnimLoop, int bEnabled)
 {
-    string sFunc = "SetTileAnimationLoop";
-
-    NWNX_PushArgumentInt(bEnabled);
-    NWNX_PushArgumentInt(nAnimLoop);
-    NWNX_PushArgumentFloat(fTileY);
-    NWNX_PushArgumentFloat(fTileX);
-    NWNX_PushArgumentObject(oArea);
-
-    NWNX_CallFunction(NWNX_Area, sFunc);
+    NWNXPushInt(bEnabled);
+    NWNXPushInt(nAnimLoop);
+    NWNXPushFloat(fTileY);
+    NWNXPushFloat(fTileX);
+    NWNXPushObject(oArea);
+    NWNXCall(NWNX_Area, "SetTileAnimationLoop");
 }
 
 string NWNX_Area_GetTileModelResRef(object oArea, float fTileX, float fTileY)
 {
-    string sFunc = "GetTileModelResRef";
-    NWNX_PushArgumentFloat(fTileY);
-    NWNX_PushArgumentFloat(fTileX);
-    NWNX_PushArgumentObject(oArea);
-
-    NWNX_CallFunction(NWNX_Area, sFunc);
-
-    return NWNX_GetReturnValueString();
+    NWNXPushFloat(fTileY);
+    NWNXPushFloat(fTileX);
+    NWNXPushObject(oArea);
+    NWNXCall(NWNX_Area, "GetTileModelResRef");
+    return NWNXPopString();
 }
 
 int NWNX_Area_TestDirectLine(object oArea, float fStartX, float fStartY, float fEndX, float fEndY, float fPerSpace, float fHeight, int bIgnoreDoors=FALSE)
 {
-    string sFunc = "TestDirectLine";
-
-    NWNX_PushArgumentInt(bIgnoreDoors);
-    NWNX_PushArgumentFloat(fHeight);
-    NWNX_PushArgumentFloat(fPerSpace);
-    NWNX_PushArgumentFloat(fEndY);
-    NWNX_PushArgumentFloat(fEndX);
-    NWNX_PushArgumentFloat(fStartY);
-    NWNX_PushArgumentFloat(fStartX);
-    NWNX_PushArgumentObject(oArea);
-
-    NWNX_CallFunction(NWNX_Area, sFunc);
-
-    return NWNX_GetReturnValueInt();
+    NWNXPushInt(bIgnoreDoors);
+    NWNXPushFloat(fHeight);
+    NWNXPushFloat(fPerSpace);
+    NWNXPushFloat(fEndY);
+    NWNXPushFloat(fEndX);
+    NWNXPushFloat(fStartY);
+    NWNXPushFloat(fStartX);
+    NWNXPushObject(oArea);
+    NWNXCall(NWNX_Area, "TestDirectLine");
+    return NWNXPopInt();
 }
 
 int NWNX_Area_GetMusicIsPlaying(object oArea, int bBattleMusic = FALSE)
 {
-    string sFunc = "GetMusicIsPlaying";
-
-    NWNX_PushArgumentInt(bBattleMusic);
-    NWNX_PushArgumentObject(oArea);
-    NWNX_CallFunction(NWNX_Area, sFunc);
-
-    return NWNX_GetReturnValueInt();
+    NWNXPushInt(bBattleMusic);
+    NWNXPushObject(oArea);
+    NWNXCall(NWNX_Area, "GetMusicIsPlaying");
+    return NWNXPopInt();
 }
 
 object NWNX_Area_CreateGenericTrigger(object oArea, float fX, float fY, float fZ, string sTag = "", float fSize = 1.0f)
 {
-    string sFunc = "CreateGenericTrigger";
-
-    NWNX_PushArgumentFloat(fSize);
-    NWNX_PushArgumentString(sTag);
-    NWNX_PushArgumentFloat(fZ);
-    NWNX_PushArgumentFloat(fY);
-    NWNX_PushArgumentFloat(fX);
-    NWNX_PushArgumentObject(oArea);
-    NWNX_CallFunction(NWNX_Area, sFunc);
-
-    return NWNX_GetReturnValueObject();
+    NWNXPushFloat(fSize);
+    NWNXPushString(sTag);
+    NWNXPushFloat(fZ);
+    NWNXPushFloat(fY);
+    NWNXPushFloat(fX);
+    NWNXPushObject(oArea);
+    NWNXCall(NWNX_Area, "CreateGenericTrigger");
+    return NWNXPopObject();
 }
 
 void NWNX_Area_AddObjectToExclusionList(object oObject)
 {
-    string sFunc = "AddObjectToExclusionList";
-
-    NWNX_PushArgumentObject(oObject);
-    NWNX_CallFunction(NWNX_Area, sFunc);
+    NWNXPushObject(oObject);
+    NWNXCall(NWNX_Area, "AddObjectToExclusionList");
 }
 
 void NWNX_Area_RemoveObjectFromExclusionList(object oObject)
 {
-    string sFunc = "RemoveObjectFromExclusionList";
-
-    NWNX_PushArgumentObject(oObject);
-    NWNX_CallFunction(NWNX_Area, sFunc);
+    NWNXPushObject(oObject);
+    NWNXCall(NWNX_Area, "RemoveObjectFromExclusionList");
 }
 
 int NWNX_Area_ExportGIT(object oArea, string sFileName = "", int bExportVarTable = TRUE, int bExportUUID = TRUE, int nObjectFilter = 0, string sAlias = "NWNX")
 {
-    string sFunc = "ExportGIT";
-
-    NWNX_PushArgumentString(sAlias);
-    NWNX_PushArgumentInt(nObjectFilter);
-    NWNX_PushArgumentInt(bExportUUID);
-    NWNX_PushArgumentInt(bExportVarTable);
-    NWNX_PushArgumentString(sFileName);
-    NWNX_PushArgumentObject(oArea);
-    NWNX_CallFunction(NWNX_Area, sFunc);
-
-    return NWNX_GetReturnValueInt();
+    NWNXPushString(sAlias);
+    NWNXPushInt(nObjectFilter);
+    NWNXPushInt(bExportUUID);
+    NWNXPushInt(bExportVarTable);
+    NWNXPushString(sFileName);
+    NWNXPushObject(oArea);
+    NWNXCall(NWNX_Area, "ExportGIT");
+    return NWNXPopInt();
 }
 
 struct NWNX_Area_TileInfo NWNX_Area_GetTileInfo(object oArea, float fTileX, float fTileY)
 {
-    string sFunc = "GetTileInfo";
-
-    NWNX_PushArgumentFloat(fTileY);
-    NWNX_PushArgumentFloat(fTileX);
-    NWNX_PushArgumentObject(oArea);
-    NWNX_CallFunction(NWNX_Area, sFunc);
-
+    NWNXPushFloat(fTileY);
+    NWNXPushFloat(fTileX);
+    NWNXPushObject(oArea);
+    NWNXCall(NWNX_Area, "GetTileInfo");
     struct NWNX_Area_TileInfo str;
-
-    str.nGridY = NWNX_GetReturnValueInt();
-    str.nGridX = NWNX_GetReturnValueInt();
-    str.nOrientation = NWNX_GetReturnValueInt();
-    str.nHeight = NWNX_GetReturnValueInt();
-    str.nID = NWNX_GetReturnValueInt();
-
+    str.nGridY = NWNXPopInt();
+    str.nGridX = NWNXPopInt();
+    str.nOrientation = NWNXPopInt();
+    str.nHeight = NWNXPopInt();
+    str.nID = NWNXPopInt();
     return str;
 }
 
 int NWNX_Area_ExportARE(object oArea, string sFileName, string sNewName = "", string sNewTag = "", string sAlias = "NWNX")
 {
-    string sFunc = "ExportARE";
-
-    NWNX_PushArgumentString(sAlias);
-    NWNX_PushArgumentString(sNewTag);
-    NWNX_PushArgumentString(sNewName);
-    NWNX_PushArgumentString(sFileName);
-    NWNX_PushArgumentObject(oArea);
-    NWNX_CallFunction(NWNX_Area, sFunc);
-
-    return NWNX_GetReturnValueInt();
+    NWNXPushString(sAlias);
+    NWNXPushString(sNewTag);
+    NWNXPushString(sNewName);
+    NWNXPushString(sFileName);
+    NWNXPushObject(oArea);
+    NWNXCall(NWNX_Area, "ExportARE");
+    return NWNXPopInt();
 }
 
 int NWNX_Area_GetAmbientSoundDay(object oArea)
 {
-    string sFunc = "GetAmbientSoundDay";
-
-    NWNX_PushArgumentObject(oArea);
-    NWNX_CallFunction(NWNX_Area, sFunc);
-
-    return NWNX_GetReturnValueInt();
+    NWNXPushObject(oArea);
+    NWNXCall(NWNX_Area, "GetAmbientSoundDay");
+    return NWNXPopInt();
 }
 
 int NWNX_Area_GetAmbientSoundNight(object oArea)
 {
-    string sFunc = "GetAmbientSoundNight";
-
-    NWNX_PushArgumentObject(oArea);
-    NWNX_CallFunction(NWNX_Area, sFunc);
-
-    return NWNX_GetReturnValueInt();
+    NWNXPushObject(oArea);
+    NWNXCall(NWNX_Area, "GetAmbientSoundNight");
+    return NWNXPopInt();
 }
 
 int NWNX_Area_GetAmbientSoundDayVolume(object oArea)
 {
-    string sFunc = "GetAmbientSoundDayVolume";
-
-    NWNX_PushArgumentObject(oArea);
-    NWNX_CallFunction(NWNX_Area, sFunc);
-
-    return NWNX_GetReturnValueInt();
+    NWNXPushObject(oArea);
+    NWNXCall(NWNX_Area, "GetAmbientSoundDayVolume");
+    return NWNXPopInt();
 }
 
 int NWNX_Area_GetAmbientSoundNightVolume(object oArea)
 {
-    string sFunc = "GetAmbientSoundNightVolume";
-
-    NWNX_PushArgumentObject(oArea);
-    NWNX_CallFunction(NWNX_Area, sFunc);
-
-    return NWNX_GetReturnValueInt();
+    NWNXPushObject(oArea);
+    NWNXCall(NWNX_Area, "GetAmbientSoundNightVolume");
+    return NWNXPopInt();
 }
 
 object NWNX_Area_CreateSoundObject(object oArea, vector vPosition, string sResRef)
 {
-    string sFunc = "CreateSoundObject";
-
-    NWNX_PushArgumentString(sResRef);
-    NWNX_PushArgumentFloat(vPosition.z);
-    NWNX_PushArgumentFloat(vPosition.y);
-    NWNX_PushArgumentFloat(vPosition.x);
-    NWNX_PushArgumentObject(oArea);
-
-    NWNX_CallFunction(NWNX_Area, sFunc);
-
-    return NWNX_GetReturnValueObject();
+    NWNXPushString(sResRef);
+    NWNXPushVector(vPosition);
+    NWNXPushObject(oArea);
+    NWNXCall(NWNX_Area, "CreateSoundObject");
+    return NWNXPopObject();
 }
 
 void NWNX_Area_RotateArea(object oArea, int nRotation)
 {
-    string sFunc = "RotateArea";
-
-    NWNX_PushArgumentInt(nRotation);
-    NWNX_PushArgumentObject(oArea);
-
-    NWNX_CallFunction(NWNX_Area, sFunc);
+    NWNXPushInt(nRotation);
+    NWNXPushObject(oArea);
+    NWNXCall(NWNX_Area, "RotateArea");
 }
 
 struct NWNX_Area_TileInfo NWNX_Area_GetTileInfoByTileIndex(object oArea, int nIndex)
 {
-    string sFunc = "GetTileInfoByTileIndex";
-
-    NWNX_PushArgumentInt(nIndex);
-    NWNX_PushArgumentObject(oArea);
-    NWNX_CallFunction(NWNX_Area, sFunc);
-
+    NWNXPushInt(nIndex);
+    NWNXPushObject(oArea);
+    NWNXCall(NWNX_Area, "GetTileInfoByTileIndex");
     struct NWNX_Area_TileInfo str;
-
-    str.nGridY = NWNX_GetReturnValueInt();
-    str.nGridX = NWNX_GetReturnValueInt();
-    str.nOrientation = NWNX_GetReturnValueInt();
-    str.nHeight = NWNX_GetReturnValueInt();
-    str.nID = NWNX_GetReturnValueInt();
-
+    str.nGridY = NWNXPopInt();
+    str.nGridX = NWNXPopInt();
+    str.nOrientation = NWNXPopInt();
+    str.nHeight = NWNXPopInt();
+    str.nID = NWNXPopInt();
     return str;
 }
 
 int NWNX_Area_GetPathExists(object oArea, vector vStartPosition, vector vEndPosition, int nMaxDepth)
 {
-    string sFunc = "GetPathExists";
-
-    NWNX_PushArgumentInt(nMaxDepth);
-    NWNX_PushArgumentFloat(vEndPosition.y);
-    NWNX_PushArgumentFloat(vEndPosition.x);
-    NWNX_PushArgumentFloat(vStartPosition.y);
-    NWNX_PushArgumentFloat(vStartPosition.x);
-    NWNX_PushArgumentObject(oArea);
-    NWNX_CallFunction(NWNX_Area, sFunc);
-
-    return NWNX_GetReturnValueInt();
+    NWNXPushInt(nMaxDepth);
+    NWNXPushVector(vEndPosition);
+    NWNXPushVector(vStartPosition);
+    NWNXPushObject(oArea);
+    NWNXCall(NWNX_Area, "GetPathExists");
+    return NWNXPopInt();
 }
 
 int NWNX_Area_GetAreaFlags(object oArea)
 {
-    string sFunc = "GetAreaFlags";
-
-    NWNX_PushArgumentObject(oArea);
-    NWNX_CallFunction(NWNX_Area, sFunc);
-
-    return NWNX_GetReturnValueInt();
+    NWNXPushObject(oArea);
+    NWNXCall(NWNX_Area, "GetAreaFlags");
+    return NWNXPopInt();
 }
 
 void NWNX_Area_SetAreaFlags(object oArea, int nFlags)
 {
-    string sFunc = "SetAreaFlags";
-
-    NWNX_PushArgumentInt(nFlags);
-    NWNX_PushArgumentObject(oArea);
-    NWNX_CallFunction(NWNX_Area, sFunc);
+    NWNXPushInt(nFlags);
+    NWNXPushObject(oArea);
+    NWNXCall(NWNX_Area, "SetAreaFlags");
 }
 
 struct NWNX_Area_AreaWind NWNX_Area_GetAreaWind(object oArea)
 {
-    string sFunc = "GetAreaWind";
     struct NWNX_Area_AreaWind data;
-
-    NWNX_PushArgumentObject(oArea);
-    NWNX_CallFunction(NWNX_Area, sFunc);
-
-    data.fPitch = NWNX_GetReturnValueFloat();
-    data.fYaw = NWNX_GetReturnValueFloat();
-    data.fMagnitude = NWNX_GetReturnValueFloat();
-    data.vDirection.x = NWNX_GetReturnValueFloat();
-    data.vDirection.y = NWNX_GetReturnValueFloat();
-    data.vDirection.z = NWNX_GetReturnValueFloat();
-
+    NWNXPushObject(oArea);
+    NWNXCall(NWNX_Area, "GetAreaWind");
+    data.fPitch = NWNXPopFloat();
+    data.fYaw = NWNXPopFloat();
+    data.fMagnitude = NWNXPopFloat();
+    data.vDirection = NWNXPopVector();
     return data;
 }
 
 void NWNX_Area_SetDefaultObjectUiDiscoveryMask(object oArea, int nObjectTypes, int nMask, int bForceUpdate = FALSE)
 {
-    string sFunc = "SetDefaultObjectUiDiscoveryMask";
-
-    NWNX_PushArgumentInt(bForceUpdate);
-    NWNX_PushArgumentInt(nMask);
-    NWNX_PushArgumentInt(nObjectTypes);
-    NWNX_PushArgumentObject(oArea);
-    NWNX_CallFunction(NWNX_Area, sFunc);
+    NWNXPushInt(bForceUpdate);
+    NWNXPushInt(nMask);
+    NWNXPushInt(nObjectTypes);
+    NWNXPushObject(oArea);
+    NWNXCall(NWNX_Area, "SetDefaultObjectUiDiscoveryMask");
 }

_module/nss/nwnx_chat.nss

@@ -2,7 +2,6 @@
 /// @brief Functions related to chat.
 /// @{
 /// @file nwnx_chat.nss
-#include "nwnx"
 
 const string NWNX_Chat = "NWNX_Chat"; ///< @private
 
@@ -80,79 +79,61 @@ float NWNX_Chat_GetChatHearingDistance(object listener = OBJECT_INVALID, int cha
 
 int NWNX_Chat_SendMessage(int channel, string message, object sender = OBJECT_SELF, object target = OBJECT_INVALID)
 {
-    string sFunc = "SendMessage";
-
-    NWNX_PushArgumentObject(target);
-    NWNX_PushArgumentObject(sender);
-    NWNX_PushArgumentString(message);
-    NWNX_PushArgumentInt(channel);
-    NWNX_CallFunction(NWNX_Chat, sFunc);
-    return NWNX_GetReturnValueInt();
+    NWNXPushObject(target);
+    NWNXPushObject(sender);
+    NWNXPushString(message);
+    NWNXPushInt(channel);
+    NWNXCall(NWNX_Chat, "SendMessage");
+    return NWNXPopInt();
 }
 
 void NWNX_Chat_RegisterChatScript(string script)
 {
-    string sFunc = "RegisterChatScript";
-
-    NWNX_PushArgumentString(script);
-    NWNX_CallFunction(NWNX_Chat, sFunc);
+    NWNXPushString(script);
+    NWNXCall(NWNX_Chat, "RegisterChatScript");
 }
 
 void NWNX_Chat_SkipMessage()
 {
-    string sFunc = "SkipMessage";
-
-    NWNX_CallFunction(NWNX_Chat, sFunc);
+    NWNXCall(NWNX_Chat, "SkipMessage");
 }
 
 int NWNX_Chat_GetChannel()
 {
-    string sFunc = "GetChannel";
-
-    NWNX_CallFunction(NWNX_Chat, sFunc);
-    return NWNX_GetReturnValueInt();
+    NWNXCall(NWNX_Chat, "GetChannel");
+    return NWNXPopInt();
 }
 
 string NWNX_Chat_GetMessage()
 {
-    string sFunc = "GetMessage";
-
-    NWNX_CallFunction(NWNX_Chat, sFunc);
-    return NWNX_GetReturnValueString();
+    NWNXCall(NWNX_Chat, "GetMessage");
+    return NWNXPopString();
 }
 
 object NWNX_Chat_GetSender()
 {
-    string sFunc = "GetSender";
-
-    NWNX_CallFunction(NWNX_Chat, sFunc);
-    return NWNX_GetReturnValueObject();
+    NWNXCall(NWNX_Chat, "GetSender");
+    return NWNXPopObject();
 }
 
 object NWNX_Chat_GetTarget()
 {
-    string sFunc = "GetTarget";
-
-    NWNX_CallFunction(NWNX_Chat, sFunc);
-    return NWNX_GetReturnValueObject();
+    NWNXCall(NWNX_Chat, "GetTarget");
+    return NWNXPopObject();
 }
 
 void NWNX_Chat_SetChatHearingDistance(float distance, object listener = OBJECT_INVALID, int channel = NWNX_CHAT_CHANNEL_PLAYER_TALK)
 {
-    string sFunc = "SetChatHearingDistance";
-
-    NWNX_PushArgumentInt(channel);
-    NWNX_PushArgumentObject(listener);
-    NWNX_PushArgumentFloat(distance);
-    NWNX_CallFunction(NWNX_Chat, sFunc);
+    NWNXPushInt(channel);
+    NWNXPushObject(listener);
+    NWNXPushFloat(distance);
+    NWNXCall(NWNX_Chat, "SetChatHearingDistance");
 }
 
 float NWNX_Chat_GetChatHearingDistance(object listener = OBJECT_INVALID, int channel = NWNX_CHAT_CHANNEL_PLAYER_TALK)
 {
-    string sFunc = "GetChatHearingDistance";
-
-    NWNX_PushArgumentInt(channel);
-    NWNX_PushArgumentObject(listener);
-    NWNX_CallFunction(NWNX_Chat, sFunc);
-    return NWNX_GetReturnValueFloat();
+    NWNXPushInt(channel);
+    NWNXPushObject(listener);
+    NWNXCall(NWNX_Chat, "GetChatHearingDistance");
+    return NWNXPopFloat();
 }

_module/nss/nwnx_core.nss

@@ -0,0 +1,21 @@
+/// @addtogroup nwnx NWNX
+/// @brief Core NWNX Functions.
+/// @{
+/// @file nwnx_core.nss
+
+const string NWNX_Core = "NWNX_Core"; ///< @private
+
+/// @brief Determines if the given plugin exists and is enabled.
+/// @param sPlugin The name of the plugin to check. This is the case sensitive plugin name as used by NWNXCall
+/// @note Example usage: NWNX_PluginExists("NWNX_Creature");
+/// @return TRUE if the plugin exists and is enabled, otherwise FALSE.
+int NWNX_Core_PluginExists(string sPlugin);
+
+/// @}
+
+int NWNX_Core_PluginExists(string sPlugin)
+{
+    NWNXPushString(sPlugin);
+    NWNXCall(NWNX_Core, "PluginExists");
+    return NWNXPopInt();
+}

_module/nss/nwnx_damage.nss

@@ -2,7 +2,6 @@
 /// @brief Run a script before damage and attack events allowing for modification. Includes function to arbitrarily apply damage.
 /// @{
 /// @file nwnx_damage.nss
-#include "nwnx"
 
 const string NWNX_Damage = "NWNX_Damage"; ///< @private
 
@@ -174,245 +173,223 @@ void NWNX_Damage_DealDamage(struct NWNX_Damage_DamageData data, object oTarget,
 
 void NWNX_Damage_SetDamageEventScript(string sScript, object oOwner=OBJECT_INVALID)
 {
-    string sFunc = "SetEventScript";
-
-    NWNX_PushArgumentObject(oOwner);
-    NWNX_PushArgumentString(sScript);
-    NWNX_PushArgumentString("DAMAGE");
-
-    NWNX_CallFunction(NWNX_Damage, sFunc);
+    NWNXPushObject(oOwner);
+    NWNXPushString(sScript);
+    NWNXPushString("DAMAGE");
+    NWNXCall(NWNX_Damage, "SetEventScript");
 }
 
 struct NWNX_Damage_DamageEventData NWNX_Damage_GetDamageEventData()
 {
-    string sFunc = "GetDamageEventData";
     struct NWNX_Damage_DamageEventData data;
-
-    NWNX_CallFunction(NWNX_Damage, sFunc);
-
-    data.oDamager     = NWNX_GetReturnValueObject();
-    data.iBludgeoning = NWNX_GetReturnValueInt();
-    data.iPierce      = NWNX_GetReturnValueInt();
-    data.iSlash       = NWNX_GetReturnValueInt();
-    data.iMagical     = NWNX_GetReturnValueInt();
-    data.iAcid        = NWNX_GetReturnValueInt();
-    data.iCold        = NWNX_GetReturnValueInt();
-    data.iDivine      = NWNX_GetReturnValueInt();
-    data.iElectrical  = NWNX_GetReturnValueInt();
-    data.iFire        = NWNX_GetReturnValueInt();
-    data.iNegative    = NWNX_GetReturnValueInt();
-    data.iPositive    = NWNX_GetReturnValueInt();
-    data.iSonic       = NWNX_GetReturnValueInt();
-    data.iBase        = NWNX_GetReturnValueInt();
-    data.iCustom1     = NWNX_GetReturnValueInt();
-    data.iCustom2     = NWNX_GetReturnValueInt();
-    data.iCustom3     = NWNX_GetReturnValueInt();
-    data.iCustom4     = NWNX_GetReturnValueInt();
-    data.iCustom5     = NWNX_GetReturnValueInt();
-    data.iCustom6     = NWNX_GetReturnValueInt();
-    data.iCustom7     = NWNX_GetReturnValueInt();
-    data.iCustom8     = NWNX_GetReturnValueInt();
-    data.iCustom9     = NWNX_GetReturnValueInt();
-    data.iCustom10    = NWNX_GetReturnValueInt();
-    data.iCustom11    = NWNX_GetReturnValueInt();
-    data.iCustom12    = NWNX_GetReturnValueInt();
-    data.iCustom13    = NWNX_GetReturnValueInt();
-    data.iCustom14    = NWNX_GetReturnValueInt();
-    data.iCustom15    = NWNX_GetReturnValueInt();
-    data.iCustom16    = NWNX_GetReturnValueInt();
-    data.iCustom17    = NWNX_GetReturnValueInt();
-    data.iCustom18    = NWNX_GetReturnValueInt();
-    data.iCustom19    = NWNX_GetReturnValueInt();
-    data.iSpellId     = NWNX_GetReturnValueInt();
-
+    NWNXCall(NWNX_Damage, "GetDamageEventData");
+    data.oDamager     = NWNXPopObject();
+    data.iBludgeoning = NWNXPopInt();
+    data.iPierce      = NWNXPopInt();
+    data.iSlash       = NWNXPopInt();
+    data.iMagical     = NWNXPopInt();
+    data.iAcid        = NWNXPopInt();
+    data.iCold        = NWNXPopInt();
+    data.iDivine      = NWNXPopInt();
+    data.iElectrical  = NWNXPopInt();
+    data.iFire        = NWNXPopInt();
+    data.iNegative    = NWNXPopInt();
+    data.iPositive    = NWNXPopInt();
+    data.iSonic       = NWNXPopInt();
+    data.iBase        = NWNXPopInt();
+    data.iCustom1     = NWNXPopInt();
+    data.iCustom2     = NWNXPopInt();
+    data.iCustom3     = NWNXPopInt();
+    data.iCustom4     = NWNXPopInt();
+    data.iCustom5     = NWNXPopInt();
+    data.iCustom6     = NWNXPopInt();
+    data.iCustom7     = NWNXPopInt();
+    data.iCustom8     = NWNXPopInt();
+    data.iCustom9     = NWNXPopInt();
+    data.iCustom10    = NWNXPopInt();
+    data.iCustom11    = NWNXPopInt();
+    data.iCustom12    = NWNXPopInt();
+    data.iCustom13    = NWNXPopInt();
+    data.iCustom14    = NWNXPopInt();
+    data.iCustom15    = NWNXPopInt();
+    data.iCustom16    = NWNXPopInt();
+    data.iCustom17    = NWNXPopInt();
+    data.iCustom18    = NWNXPopInt();
+    data.iCustom19    = NWNXPopInt();
+    data.iSpellId     = NWNXPopInt();
     return data;
 }
 
 void NWNX_Damage_SetDamageEventData(struct NWNX_Damage_DamageEventData data)
 {
-    string sFunc = "SetDamageEventData";
+    NWNXPushInt(data.iCustom19);
+    NWNXPushInt(data.iCustom18);
+    NWNXPushInt(data.iCustom17);
+    NWNXPushInt(data.iCustom16);
+    NWNXPushInt(data.iCustom15);
+    NWNXPushInt(data.iCustom14);
+    NWNXPushInt(data.iCustom13);
+    NWNXPushInt(data.iCustom12);
+    NWNXPushInt(data.iCustom11);
+    NWNXPushInt(data.iCustom10);
+    NWNXPushInt(data.iCustom9);
+    NWNXPushInt(data.iCustom8);
+    NWNXPushInt(data.iCustom7);
+    NWNXPushInt(data.iCustom6);
+    NWNXPushInt(data.iCustom5);
+    NWNXPushInt(data.iCustom4);
+    NWNXPushInt(data.iCustom3);
+    NWNXPushInt(data.iCustom2);
+    NWNXPushInt(data.iCustom1);
+    NWNXPushInt(data.iBase);
+    NWNXPushInt(data.iSonic);
+    NWNXPushInt(data.iPositive);
+    NWNXPushInt(data.iNegative);
+    NWNXPushInt(data.iFire);
+    NWNXPushInt(data.iElectrical);
+    NWNXPushInt(data.iDivine);
+    NWNXPushInt(data.iCold);
+    NWNXPushInt(data.iAcid);
+    NWNXPushInt(data.iMagical);
+    NWNXPushInt(data.iSlash);
+    NWNXPushInt(data.iPierce);
+    NWNXPushInt(data.iBludgeoning);
 
-    NWNX_PushArgumentInt(data.iCustom19);
-    NWNX_PushArgumentInt(data.iCustom18);
-    NWNX_PushArgumentInt(data.iCustom17);
-    NWNX_PushArgumentInt(data.iCustom16);
-    NWNX_PushArgumentInt(data.iCustom15);
-    NWNX_PushArgumentInt(data.iCustom14);
-    NWNX_PushArgumentInt(data.iCustom13);
-    NWNX_PushArgumentInt(data.iCustom12);
-    NWNX_PushArgumentInt(data.iCustom11);
-    NWNX_PushArgumentInt(data.iCustom10);
-    NWNX_PushArgumentInt(data.iCustom9);
-    NWNX_PushArgumentInt(data.iCustom8);
-    NWNX_PushArgumentInt(data.iCustom7);
-    NWNX_PushArgumentInt(data.iCustom6);
-    NWNX_PushArgumentInt(data.iCustom5);
-    NWNX_PushArgumentInt(data.iCustom4);
-    NWNX_PushArgumentInt(data.iCustom3);
-    NWNX_PushArgumentInt(data.iCustom2);
-    NWNX_PushArgumentInt(data.iCustom1);
-    NWNX_PushArgumentInt(data.iBase);
-    NWNX_PushArgumentInt(data.iSonic);
-    NWNX_PushArgumentInt(data.iPositive);
-    NWNX_PushArgumentInt(data.iNegative);
-    NWNX_PushArgumentInt(data.iFire);
-    NWNX_PushArgumentInt(data.iElectrical);
-    NWNX_PushArgumentInt(data.iDivine);
-    NWNX_PushArgumentInt(data.iCold);
-    NWNX_PushArgumentInt(data.iAcid);
-    NWNX_PushArgumentInt(data.iMagical);
-    NWNX_PushArgumentInt(data.iSlash);
-    NWNX_PushArgumentInt(data.iPierce);
-    NWNX_PushArgumentInt(data.iBludgeoning);
-
-    NWNX_CallFunction(NWNX_Damage, sFunc);
+    NWNXCall(NWNX_Damage, "SetDamageEventData");
 }
 
 void NWNX_Damage_SetAttackEventScript(string sScript, object oOwner=OBJECT_INVALID)
 {
-    string sFunc = "SetEventScript";
-
-    NWNX_PushArgumentObject(oOwner);
-    NWNX_PushArgumentString(sScript);
-    NWNX_PushArgumentString("ATTACK");
-
-    NWNX_CallFunction(NWNX_Damage, sFunc);
+    NWNXPushObject(oOwner);
+    NWNXPushString(sScript);
+    NWNXPushString("ATTACK");
+    NWNXCall(NWNX_Damage, "SetEventScript");
 }
 
 struct NWNX_Damage_AttackEventData NWNX_Damage_GetAttackEventData()
 {
-    string sFunc = "GetAttackEventData";
     struct NWNX_Damage_AttackEventData data;
-
-    NWNX_CallFunction(NWNX_Damage, sFunc);
-
-    data.oTarget           = NWNX_GetReturnValueObject();
-    data.iBludgeoning      = NWNX_GetReturnValueInt();
-    data.iPierce           = NWNX_GetReturnValueInt();
-    data.iSlash            = NWNX_GetReturnValueInt();
-    data.iMagical          = NWNX_GetReturnValueInt();
-    data.iAcid             = NWNX_GetReturnValueInt();
-    data.iCold             = NWNX_GetReturnValueInt();
-    data.iDivine           = NWNX_GetReturnValueInt();
-    data.iElectrical       = NWNX_GetReturnValueInt();
-    data.iFire             = NWNX_GetReturnValueInt();
-    data.iNegative         = NWNX_GetReturnValueInt();
-    data.iPositive         = NWNX_GetReturnValueInt();
-    data.iSonic            = NWNX_GetReturnValueInt();
-    data.iBase             = NWNX_GetReturnValueInt();
-    data.iCustom1          = NWNX_GetReturnValueInt();
-    data.iCustom2          = NWNX_GetReturnValueInt();
-    data.iCustom3          = NWNX_GetReturnValueInt();
-    data.iCustom4          = NWNX_GetReturnValueInt();
-    data.iCustom5          = NWNX_GetReturnValueInt();
-    data.iCustom6          = NWNX_GetReturnValueInt();
-    data.iCustom7          = NWNX_GetReturnValueInt();
-    data.iCustom8          = NWNX_GetReturnValueInt();
-    data.iCustom9          = NWNX_GetReturnValueInt();
-    data.iCustom10         = NWNX_GetReturnValueInt();
-    data.iCustom11         = NWNX_GetReturnValueInt();
-    data.iCustom12         = NWNX_GetReturnValueInt();
-    data.iCustom13         = NWNX_GetReturnValueInt();
-    data.iCustom14         = NWNX_GetReturnValueInt();
-    data.iCustom15         = NWNX_GetReturnValueInt();
-    data.iCustom16         = NWNX_GetReturnValueInt();
-    data.iCustom17         = NWNX_GetReturnValueInt();
-    data.iCustom18         = NWNX_GetReturnValueInt();
-    data.iCustom19         = NWNX_GetReturnValueInt();
-    data.iAttackNumber     = NWNX_GetReturnValueInt();
-    data.iAttackResult     = NWNX_GetReturnValueInt();
-    data.iWeaponAttackType = NWNX_GetReturnValueInt();
-    data.iSneakAttack      = NWNX_GetReturnValueInt();
-    data.bKillingBlow      = NWNX_GetReturnValueInt();
-    data.iAttackType       = NWNX_GetReturnValueInt();
-    data.iToHitRoll        = NWNX_GetReturnValueInt();
-    data.iToHitModifier    = NWNX_GetReturnValueInt();
-
+    NWNXCall(NWNX_Damage, "GetAttackEventData");
+    data.oTarget           = NWNXPopObject();
+    data.iBludgeoning      = NWNXPopInt();
+    data.iPierce           = NWNXPopInt();
+    data.iSlash            = NWNXPopInt();
+    data.iMagical          = NWNXPopInt();
+    data.iAcid             = NWNXPopInt();
+    data.iCold             = NWNXPopInt();
+    data.iDivine           = NWNXPopInt();
+    data.iElectrical       = NWNXPopInt();
+    data.iFire             = NWNXPopInt();
+    data.iNegative         = NWNXPopInt();
+    data.iPositive         = NWNXPopInt();
+    data.iSonic            = NWNXPopInt();
+    data.iBase             = NWNXPopInt();
+    data.iCustom1          = NWNXPopInt();
+    data.iCustom2          = NWNXPopInt();
+    data.iCustom3          = NWNXPopInt();
+    data.iCustom4          = NWNXPopInt();
+    data.iCustom5          = NWNXPopInt();
+    data.iCustom6          = NWNXPopInt();
+    data.iCustom7          = NWNXPopInt();
+    data.iCustom8          = NWNXPopInt();
+    data.iCustom9          = NWNXPopInt();
+    data.iCustom10         = NWNXPopInt();
+    data.iCustom11         = NWNXPopInt();
+    data.iCustom12         = NWNXPopInt();
+    data.iCustom13         = NWNXPopInt();
+    data.iCustom14         = NWNXPopInt();
+    data.iCustom15         = NWNXPopInt();
+    data.iCustom16         = NWNXPopInt();
+    data.iCustom17         = NWNXPopInt();
+    data.iCustom18         = NWNXPopInt();
+    data.iCustom19         = NWNXPopInt();
+    data.iAttackNumber     = NWNXPopInt();
+    data.iAttackResult     = NWNXPopInt();
+    data.iWeaponAttackType = NWNXPopInt();
+    data.iSneakAttack      = NWNXPopInt();
+    data.bKillingBlow      = NWNXPopInt();
+    data.iAttackType       = NWNXPopInt();
+    data.iToHitRoll        = NWNXPopInt();
+    data.iToHitModifier    = NWNXPopInt();
     return data;
 }
 
 void NWNX_Damage_SetAttackEventData(struct NWNX_Damage_AttackEventData data)
 {
-    string sFunc = "SetAttackEventData";
-
-    NWNX_PushArgumentInt(data.iSneakAttack);
-    NWNX_PushArgumentInt(data.iAttackResult);
-    NWNX_PushArgumentInt(data.iCustom19);
-    NWNX_PushArgumentInt(data.iCustom18);
-    NWNX_PushArgumentInt(data.iCustom17);
-    NWNX_PushArgumentInt(data.iCustom16);
-    NWNX_PushArgumentInt(data.iCustom15);
-    NWNX_PushArgumentInt(data.iCustom14);
-    NWNX_PushArgumentInt(data.iCustom13);
-    NWNX_PushArgumentInt(data.iCustom12);
-    NWNX_PushArgumentInt(data.iCustom11);
-    NWNX_PushArgumentInt(data.iCustom10);
-    NWNX_PushArgumentInt(data.iCustom9);
-    NWNX_PushArgumentInt(data.iCustom8);
-    NWNX_PushArgumentInt(data.iCustom7);
-    NWNX_PushArgumentInt(data.iCustom6);
-    NWNX_PushArgumentInt(data.iCustom5);
-    NWNX_PushArgumentInt(data.iCustom4);
-    NWNX_PushArgumentInt(data.iCustom3);
-    NWNX_PushArgumentInt(data.iCustom2);
-    NWNX_PushArgumentInt(data.iCustom1);
-    NWNX_PushArgumentInt(data.iBase);
-    NWNX_PushArgumentInt(data.iSonic);
-    NWNX_PushArgumentInt(data.iPositive);
-    NWNX_PushArgumentInt(data.iNegative);
-    NWNX_PushArgumentInt(data.iFire);
-    NWNX_PushArgumentInt(data.iElectrical);
-    NWNX_PushArgumentInt(data.iDivine);
-    NWNX_PushArgumentInt(data.iCold);
-    NWNX_PushArgumentInt(data.iAcid);
-    NWNX_PushArgumentInt(data.iMagical);
-    NWNX_PushArgumentInt(data.iSlash);
-    NWNX_PushArgumentInt(data.iPierce);
-    NWNX_PushArgumentInt(data.iBludgeoning);
-
-    NWNX_CallFunction(NWNX_Damage, sFunc);
+    NWNXPushInt(data.iSneakAttack);
+    NWNXPushInt(data.iAttackResult);
+    NWNXPushInt(data.iCustom19);
+    NWNXPushInt(data.iCustom18);
+    NWNXPushInt(data.iCustom17);
+    NWNXPushInt(data.iCustom16);
+    NWNXPushInt(data.iCustom15);
+    NWNXPushInt(data.iCustom14);
+    NWNXPushInt(data.iCustom13);
+    NWNXPushInt(data.iCustom12);
+    NWNXPushInt(data.iCustom11);
+    NWNXPushInt(data.iCustom10);
+    NWNXPushInt(data.iCustom9);
+    NWNXPushInt(data.iCustom8);
+    NWNXPushInt(data.iCustom7);
+    NWNXPushInt(data.iCustom6);
+    NWNXPushInt(data.iCustom5);
+    NWNXPushInt(data.iCustom4);
+    NWNXPushInt(data.iCustom3);
+    NWNXPushInt(data.iCustom2);
+    NWNXPushInt(data.iCustom1);
+    NWNXPushInt(data.iBase);
+    NWNXPushInt(data.iSonic);
+    NWNXPushInt(data.iPositive);
+    NWNXPushInt(data.iNegative);
+    NWNXPushInt(data.iFire);
+    NWNXPushInt(data.iElectrical);
+    NWNXPushInt(data.iDivine);
+    NWNXPushInt(data.iCold);
+    NWNXPushInt(data.iAcid);
+    NWNXPushInt(data.iMagical);
+    NWNXPushInt(data.iSlash);
+    NWNXPushInt(data.iPierce);
+    NWNXPushInt(data.iBludgeoning);
+    NWNXCall(NWNX_Damage, "SetAttackEventData");
 }
 
 void NWNX_Damage_DealDamage(struct NWNX_Damage_DamageData data, object oTarget, object oSource, int iRanged = FALSE)
 {
-    string sFunc = "DealDamage";
-
-    NWNX_PushArgumentInt(iRanged);
-    NWNX_PushArgumentInt(data.iPower);
-    NWNX_PushArgumentInt(data.iCustom19);
-    NWNX_PushArgumentInt(data.iCustom18);
-    NWNX_PushArgumentInt(data.iCustom17);
-    NWNX_PushArgumentInt(data.iCustom16);
-    NWNX_PushArgumentInt(data.iCustom15);
-    NWNX_PushArgumentInt(data.iCustom14);
-    NWNX_PushArgumentInt(data.iCustom13);
-    NWNX_PushArgumentInt(data.iCustom12);
-    NWNX_PushArgumentInt(data.iCustom11);
-    NWNX_PushArgumentInt(data.iCustom10);
-    NWNX_PushArgumentInt(data.iCustom9);
-    NWNX_PushArgumentInt(data.iCustom8);
-    NWNX_PushArgumentInt(data.iCustom7);
-    NWNX_PushArgumentInt(data.iCustom6);
-    NWNX_PushArgumentInt(data.iCustom5);
-    NWNX_PushArgumentInt(data.iCustom4);
-    NWNX_PushArgumentInt(data.iCustom3);
-    NWNX_PushArgumentInt(data.iCustom2);
-    NWNX_PushArgumentInt(data.iCustom1);
-    NWNX_PushArgumentInt(0);// Padding for Base Damage
-    NWNX_PushArgumentInt(data.iSonic);
-    NWNX_PushArgumentInt(data.iPositive);
-    NWNX_PushArgumentInt(data.iNegative);
-    NWNX_PushArgumentInt(data.iFire);
-    NWNX_PushArgumentInt(data.iElectrical);
-    NWNX_PushArgumentInt(data.iDivine);
-    NWNX_PushArgumentInt(data.iCold);
-    NWNX_PushArgumentInt(data.iAcid);
-    NWNX_PushArgumentInt(data.iMagical);
-    NWNX_PushArgumentInt(data.iSlash);
-    NWNX_PushArgumentInt(data.iPierce);
-    NWNX_PushArgumentInt(data.iBludgeoning);
-    NWNX_PushArgumentObject(oTarget);
-    NWNX_PushArgumentObject(oSource);
-
-    NWNX_CallFunction(NWNX_Damage, sFunc);
+    NWNXPushInt(iRanged);
+    NWNXPushInt(data.iPower);
+    NWNXPushInt(data.iCustom19);
+    NWNXPushInt(data.iCustom18);
+    NWNXPushInt(data.iCustom17);
+    NWNXPushInt(data.iCustom16);
+    NWNXPushInt(data.iCustom15);
+    NWNXPushInt(data.iCustom14);
+    NWNXPushInt(data.iCustom13);
+    NWNXPushInt(data.iCustom12);
+    NWNXPushInt(data.iCustom11);
+    NWNXPushInt(data.iCustom10);
+    NWNXPushInt(data.iCustom9);
+    NWNXPushInt(data.iCustom8);
+    NWNXPushInt(data.iCustom7);
+    NWNXPushInt(data.iCustom6);
+    NWNXPushInt(data.iCustom5);
+    NWNXPushInt(data.iCustom4);
+    NWNXPushInt(data.iCustom3);
+    NWNXPushInt(data.iCustom2);
+    NWNXPushInt(data.iCustom1);
+    NWNXPushInt(0);// Padding for Base Damage
+    NWNXPushInt(data.iSonic);
+    NWNXPushInt(data.iPositive);
+    NWNXPushInt(data.iNegative);
+    NWNXPushInt(data.iFire);
+    NWNXPushInt(data.iElectrical);
+    NWNXPushInt(data.iDivine);
+    NWNXPushInt(data.iCold);
+    NWNXPushInt(data.iAcid);
+    NWNXPushInt(data.iMagical);
+    NWNXPushInt(data.iSlash);
+    NWNXPushInt(data.iPierce);
+    NWNXPushInt(data.iBludgeoning);
+    NWNXPushObject(oTarget);
+    NWNXPushObject(oSource);
+    NWNXCall(NWNX_Damage, "DealDamage");
 }

_module/nss/nwnx_dialog.nss

@@ -3,8 +3,6 @@
 /// @{
 /// @file nwnx_dialog.nss
 
-#include "nwnx"
-
 const string NWNX_Dialog = "NWNX_Dialog"; ///< @private
 
 /// @name Dialog Node Types
@@ -80,60 +78,46 @@ void NWNX_Dialog_End(object oObject);
 
 int NWNX_Dialog_GetCurrentNodeType()
 {
-    string sFunc = "GetCurrentNodeType";
-
-    NWNX_CallFunction(NWNX_Dialog, sFunc);
-    return NWNX_GetReturnValueInt();
+    NWNXCall(NWNX_Dialog, "GetCurrentNodeType");
+    return NWNXPopInt();
 }
 
 int NWNX_Dialog_GetCurrentScriptType()
 {
-    string sFunc = "GetCurrentScriptType";
-
-    NWNX_CallFunction(NWNX_Dialog, sFunc);
-    return NWNX_GetReturnValueInt();
+    NWNXCall(NWNX_Dialog, "GetCurrentScriptType");
+    return NWNXPopInt();
 }
 
 int NWNX_Dialog_GetCurrentNodeID()
 {
-    string sFunc = "GetCurrentNodeID";
-
-    NWNX_CallFunction(NWNX_Dialog, sFunc);
-    return NWNX_GetReturnValueInt();
+    NWNXCall(NWNX_Dialog, "GetCurrentNodeID");
+    return NWNXPopInt();
 }
 
 int NWNX_Dialog_GetCurrentNodeIndex()
 {
-    string sFunc = "GetCurrentNodeIndex";
-
-    NWNX_CallFunction(NWNX_Dialog, sFunc);
-    return NWNX_GetReturnValueInt();
+    NWNXCall(NWNX_Dialog, "GetCurrentNodeIndex");
+    return NWNXPopInt();
 }
 
 string NWNX_Dialog_GetCurrentNodeText(int language=NWNX_DIALOG_LANGUAGE_ENGLISH, int gender=GENDER_MALE)
 {
-    string sFunc = "GetCurrentNodeText";
-
-    NWNX_PushArgumentInt(gender);
-    NWNX_PushArgumentInt(language);
-    NWNX_CallFunction(NWNX_Dialog, sFunc);
-    return NWNX_GetReturnValueString();
+    NWNXPushInt(gender);
+    NWNXPushInt(language);
+    NWNXCall(NWNX_Dialog, "GetCurrentNodeText");
+    return NWNXPopString();
 }
 
 void NWNX_Dialog_SetCurrentNodeText(string text, int language=NWNX_DIALOG_LANGUAGE_ENGLISH, int gender=GENDER_MALE)
 {
-    string sFunc = "SetCurrentNodeText";
-
-    NWNX_PushArgumentInt(gender);
-    NWNX_PushArgumentInt(language);
-    NWNX_PushArgumentString(text);
-    NWNX_CallFunction(NWNX_Dialog, sFunc);
+    NWNXPushInt(gender);
+    NWNXPushInt(language);
+    NWNXPushString(text);
+    NWNXCall(NWNX_Dialog, "SetCurrentNodeText");
 }
 
 void NWNX_Dialog_End(object oObject)
 {
-    string sFunc = "End";
-
-    NWNX_PushArgumentObject(oObject);
-    NWNX_CallFunction(NWNX_Dialog, sFunc);
+    NWNXPushObject(oObject);
+    NWNXCall(NWNX_Dialog, "End");
 }

_module/nss/nwnx_effect.nss

@@ -2,7 +2,6 @@
 /// @brief Utility functions to manipulate the builtin effect type.
 /// @{
 /// @file nwnx_effect.nss
-#include "nwnx"
 
 const string NWNX_Effect = "NWNX_Effect"; ///< @private
 
@@ -143,52 +142,46 @@ effect NWNX_Effect_GetAppliedEffect(object oObject, int nNth);
 
 /// @}
 
-struct NWNX_EffectUnpacked __NWNX_Effect_ResolveUnpack(string sFunc, int bLink=TRUE)
+struct NWNX_EffectUnpacked __NWNX_Effect_ResolveUnpack(int bLink=TRUE)
 {
     struct NWNX_EffectUnpacked n;
 
-    n.sItemProp = NWNX_GetReturnValueString();
+    n.sItemProp = NWNXPopString();
 
-    n.sTag = NWNX_GetReturnValueString();
+    n.sTag = NWNXPopString();
 
-    float fZ = NWNX_GetReturnValueFloat();
-    float fY = NWNX_GetReturnValueFloat();
-    float fX = NWNX_GetReturnValueFloat();
-    n.vParam1 = Vector(fX, fY, fZ);
-    fZ = NWNX_GetReturnValueFloat();
-    fY = NWNX_GetReturnValueFloat();
-    fX = NWNX_GetReturnValueFloat();
-    n.vParam0 = Vector(fX, fY, fZ);
-    n.oParam3 = NWNX_GetReturnValueObject();
-    n.oParam2 = NWNX_GetReturnValueObject();
-    n.oParam1 = NWNX_GetReturnValueObject();
-    n.oParam0 = NWNX_GetReturnValueObject();
-    n.sParam5 = NWNX_GetReturnValueString();
-    n.sParam4 = NWNX_GetReturnValueString();
-    n.sParam3 = NWNX_GetReturnValueString();
-    n.sParam2 = NWNX_GetReturnValueString();
-    n.sParam1 = NWNX_GetReturnValueString();
-    n.sParam0 = NWNX_GetReturnValueString();
-    n.fParam3 = NWNX_GetReturnValueFloat();
-    n.fParam2 = NWNX_GetReturnValueFloat();
-    n.fParam1 = NWNX_GetReturnValueFloat();
-    n.fParam0 = NWNX_GetReturnValueFloat();
-    n.nParam7 = NWNX_GetReturnValueInt();
-    n.nParam6 = NWNX_GetReturnValueInt();
-    n.nParam5 = NWNX_GetReturnValueInt();
-    n.nParam4 = NWNX_GetReturnValueInt();
-    n.nParam3 = NWNX_GetReturnValueInt();
-    n.nParam2 = NWNX_GetReturnValueInt();
-    n.nParam1 = NWNX_GetReturnValueInt();
-    n.nParam0 = NWNX_GetReturnValueInt();
-    n.nNumIntegers = NWNX_GetReturnValueInt();
+    n.vParam1 = NWNXPopVector();
+    n.vParam0 = NWNXPopVector();
+    n.oParam3 = NWNXPopObject();
+    n.oParam2 = NWNXPopObject();
+    n.oParam1 = NWNXPopObject();
+    n.oParam0 = NWNXPopObject();
+    n.sParam5 = NWNXPopString();
+    n.sParam4 = NWNXPopString();
+    n.sParam3 = NWNXPopString();
+    n.sParam2 = NWNXPopString();
+    n.sParam1 = NWNXPopString();
+    n.sParam0 = NWNXPopString();
+    n.fParam3 = NWNXPopFloat();
+    n.fParam2 = NWNXPopFloat();
+    n.fParam1 = NWNXPopFloat();
+    n.fParam0 = NWNXPopFloat();
+    n.nParam7 = NWNXPopInt();
+    n.nParam6 = NWNXPopInt();
+    n.nParam5 = NWNXPopInt();
+    n.nParam4 = NWNXPopInt();
+    n.nParam3 = NWNXPopInt();
+    n.nParam2 = NWNXPopInt();
+    n.nParam1 = NWNXPopInt();
+    n.nParam0 = NWNXPopInt();
+    n.nNumIntegers = NWNXPopInt();
 
     if(bLink)
     {
-        n.bLinkRightValid = NWNX_GetReturnValueInt();
-        n.eLinkRight = NWNX_GetReturnValueEffect();
-        n.bLinkLeftValid = NWNX_GetReturnValueInt();
-        n.eLinkLeft = NWNX_GetReturnValueEffect();
+        n.bLinkRightValid = NWNXPopInt();
+        n.eLinkRight = NWNXPopEffect();
+        n.bLinkLeftValid = NWNXPopInt();
+        n.eLinkLeft = NWNXPopEffect();
     }
     else
     {
@@ -196,207 +189,166 @@ struct NWNX_EffectUnpacked __NWNX_Effect_ResolveUnpack(string sFunc, int bLink=T
         n.bLinkLeftValid = FALSE;
     }
 
-    n.nCasterLevel = NWNX_GetReturnValueInt();
-    n.bShowIcon = NWNX_GetReturnValueInt();
-    n.bExpose = NWNX_GetReturnValueInt();
-    n.nSpellId = NWNX_GetReturnValueInt();
-    n.oCreator = NWNX_GetReturnValueObject();
+    n.nCasterLevel = NWNXPopInt();
+    n.bShowIcon = NWNXPopInt();
+    n.bExpose = NWNXPopInt();
+    n.nSpellId = NWNXPopInt();
+    n.oCreator = NWNXPopObject();
 
-    n.nExpiryTimeOfDay = NWNX_GetReturnValueInt();
-    n.nExpiryCalendarDay = NWNX_GetReturnValueInt();
-    n.fDuration = NWNX_GetReturnValueFloat();
+    n.nExpiryTimeOfDay = NWNXPopInt();
+    n.nExpiryCalendarDay = NWNXPopInt();
+    n.fDuration = NWNXPopFloat();
 
-    n.nSubType = NWNX_GetReturnValueInt();
-    n.nType = NWNX_GetReturnValueInt();
-    n.sID = NWNX_GetReturnValueString();
+    n.nSubType = NWNXPopInt();
+    n.nType = NWNXPopInt();
+    n.sID = NWNXPopString();
 
     return n;
 }
 
-void __NWNX_Effect_ResolvePack(string sFunc, struct NWNX_EffectUnpacked e, int bReplace=FALSE)
+void __NWNX_Effect_ResolvePack(struct NWNX_EffectUnpacked e, int bReplace=FALSE)
 {
     if(!bReplace)
-        NWNX_PushArgumentInt(e.nType);
+        NWNXPushInt(e.nType);
 
-    NWNX_PushArgumentInt(e.nSubType);
+    NWNXPushInt(e.nSubType);
 
-    NWNX_PushArgumentFloat(e.fDuration);
-    NWNX_PushArgumentInt(e.nExpiryCalendarDay);
-    NWNX_PushArgumentInt(e.nExpiryTimeOfDay);
+    NWNXPushFloat(e.fDuration);
+    NWNXPushInt(e.nExpiryCalendarDay);
+    NWNXPushInt(e.nExpiryTimeOfDay);
 
-    NWNX_PushArgumentObject(e.oCreator);
-    NWNX_PushArgumentInt(e.nSpellId);
-    NWNX_PushArgumentInt(e.bExpose);
-    NWNX_PushArgumentInt(e.bShowIcon);
-    NWNX_PushArgumentInt(e.nCasterLevel);
+    NWNXPushObject(e.oCreator);
+    NWNXPushInt(e.nSpellId);
+    NWNXPushInt(e.bExpose);
+    NWNXPushInt(e.bShowIcon);
+    NWNXPushInt(e.nCasterLevel);
 
     if(!bReplace)
     {
-        NWNX_PushArgumentEffect(e.eLinkLeft);
-        NWNX_PushArgumentInt(e.bLinkLeftValid);
-        NWNX_PushArgumentEffect(e.eLinkRight);
-        NWNX_PushArgumentInt(e.bLinkRightValid);
+        NWNXPushEffect(e.eLinkLeft);
+        NWNXPushInt(e.bLinkLeftValid);
+        NWNXPushEffect(e.eLinkRight);
+        NWNXPushInt(e.bLinkRightValid);
     }
 
-    NWNX_PushArgumentInt(e.nNumIntegers);
-    NWNX_PushArgumentInt(e.nParam0);
-    NWNX_PushArgumentInt(e.nParam1);
-    NWNX_PushArgumentInt(e.nParam2);
-    NWNX_PushArgumentInt(e.nParam3);
-    NWNX_PushArgumentInt(e.nParam4);
-    NWNX_PushArgumentInt(e.nParam5);
-    NWNX_PushArgumentInt(e.nParam6);
-    NWNX_PushArgumentInt(e.nParam7);
-    NWNX_PushArgumentFloat(e.fParam0);
-    NWNX_PushArgumentFloat(e.fParam1);
-    NWNX_PushArgumentFloat(e.fParam2);
-    NWNX_PushArgumentFloat(e.fParam3);
-    NWNX_PushArgumentString(e.sParam0);
-    NWNX_PushArgumentString(e.sParam1);
-    NWNX_PushArgumentString(e.sParam2);
-    NWNX_PushArgumentString(e.sParam3);
-    NWNX_PushArgumentString(e.sParam4);
-    NWNX_PushArgumentString(e.sParam5);
-    NWNX_PushArgumentObject(e.oParam0);
-    NWNX_PushArgumentObject(e.oParam1);
-    NWNX_PushArgumentObject(e.oParam2);
-    NWNX_PushArgumentObject(e.oParam3);
+    NWNXPushInt(e.nNumIntegers);
+    NWNXPushInt(e.nParam0);
+    NWNXPushInt(e.nParam1);
+    NWNXPushInt(e.nParam2);
+    NWNXPushInt(e.nParam3);
+    NWNXPushInt(e.nParam4);
+    NWNXPushInt(e.nParam5);
+    NWNXPushInt(e.nParam6);
+    NWNXPushInt(e.nParam7);
+    NWNXPushFloat(e.fParam0);
+    NWNXPushFloat(e.fParam1);
+    NWNXPushFloat(e.fParam2);
+    NWNXPushFloat(e.fParam3);
+    NWNXPushString(e.sParam0);
+    NWNXPushString(e.sParam1);
+    NWNXPushString(e.sParam2);
+    NWNXPushString(e.sParam3);
+    NWNXPushString(e.sParam4);
+    NWNXPushString(e.sParam5);
+    NWNXPushObject(e.oParam0);
+    NWNXPushObject(e.oParam1);
+    NWNXPushObject(e.oParam2);
+    NWNXPushObject(e.oParam3);
 
-    NWNX_PushArgumentFloat(e.vParam0.x);
-    NWNX_PushArgumentFloat(e.vParam0.y);
-    NWNX_PushArgumentFloat(e.vParam0.z);
+    NWNXPushVector(e.vParam0);
+    NWNXPushVector(e.vParam1);
 
-    NWNX_PushArgumentFloat(e.vParam1.x);
-    NWNX_PushArgumentFloat(e.vParam1.y);
-    NWNX_PushArgumentFloat(e.vParam1.z);
+    NWNXPushString(e.sTag);
 
-    NWNX_PushArgumentString(e.sTag);
-
-    NWNX_PushArgumentString(e.sItemProp);
+    NWNXPushString(e.sItemProp);
 }
 
 struct NWNX_EffectUnpacked NWNX_Effect_UnpackEffect(effect e)
 {
-    string sFunc = "UnpackEffect";
-
-    NWNX_PushArgumentEffect(e);
-    NWNX_CallFunction(NWNX_Effect, sFunc);
-
-    return __NWNX_Effect_ResolveUnpack(sFunc);
+    NWNXPushEffect(e);
+    NWNXCall(NWNX_Effect, "UnpackEffect");
+    return __NWNX_Effect_ResolveUnpack();
 }
 effect NWNX_Effect_PackEffect(struct NWNX_EffectUnpacked e)
 {
-    string sFunc = "PackEffect";
-
-    __NWNX_Effect_ResolvePack(sFunc, e);
-
-    NWNX_CallFunction(NWNX_Effect, sFunc);
-    return NWNX_GetReturnValueEffect();
+    __NWNX_Effect_ResolvePack(e);
+    NWNXCall(NWNX_Effect, "PackEffect");
+    return NWNXPopEffect();
 }
 
 int NWNX_Effect_ReplaceEffect(object obj, effect eOld, effect eNew)
 {
-    string sFunc = "ReplaceEffect";
-
-    NWNX_PushArgumentEffect(eNew);
-    NWNX_PushArgumentEffect(eOld);
-    NWNX_PushArgumentObject(obj);
-
-    NWNX_CallFunction(NWNX_Effect, sFunc);
-
-    return NWNX_GetReturnValueInt();
+    NWNXPushEffect(eNew);
+    NWNXPushEffect(eOld);
+    NWNXPushObject(obj);
+    NWNXCall(NWNX_Effect, "ReplaceEffect");
+    return NWNXPopInt();
 }
 
 int NWNX_Effect_GetTrueEffectCount(object oObject)
 {
-    string sFunc = "GetTrueEffectCount";
-    NWNX_PushArgumentObject(oObject);
-    NWNX_CallFunction(NWNX_Effect, sFunc);
-
-    return  NWNX_GetReturnValueInt();
+    NWNXPushObject(oObject);
+    NWNXCall(NWNX_Effect, "GetTrueEffectCount");
+    return NWNXPopInt();
 }
 
 struct NWNX_EffectUnpacked NWNX_Effect_GetTrueEffect(object oObject, int nIndex)
 {
-    string sFunc = "GetTrueEffect";
-    NWNX_PushArgumentInt(nIndex);
-    NWNX_PushArgumentObject(oObject);
-    NWNX_CallFunction(NWNX_Effect, sFunc);
-
-    return __NWNX_Effect_ResolveUnpack(sFunc, FALSE);
+    NWNXPushInt(nIndex);
+    NWNXPushObject(oObject);
+    NWNXCall(NWNX_Effect, "GetTrueEffect");
+    return __NWNX_Effect_ResolveUnpack(FALSE);
 }
 
 void NWNX_Effect_ReplaceEffectByIndex(object oObject, int nIndex, struct  NWNX_EffectUnpacked e)
 {
-    string sFunc = "ReplaceEffectByIndex";
-
-    __NWNX_Effect_ResolvePack(sFunc, e, TRUE);
-
-    NWNX_PushArgumentInt(nIndex);
-    NWNX_PushArgumentObject(oObject);
-    NWNX_CallFunction(NWNX_Effect, sFunc);
+    __NWNX_Effect_ResolvePack(e, TRUE);
+    NWNXPushInt(nIndex);
+    NWNXPushObject(oObject);
+    NWNXCall(NWNX_Effect, "ReplaceEffectByIndex");
 }
 
 int NWNX_Effect_RemoveEffectById(object oObject,  string sID)
 {
-    string sFunc = "RemoveEffectById";
-    NWNX_PushArgumentString(sID);
-    NWNX_PushArgumentObject(oObject);
-    NWNX_CallFunction(NWNX_Effect, sFunc);
-
-    return  NWNX_GetReturnValueInt();
+    NWNXPushString(sID);
+    NWNXPushObject(oObject);
+    NWNXCall(NWNX_Effect, "RemoveEffectById");
+    return NWNXPopInt();
 }
 
 void NWNX_Effect_Apply(effect eEffect, object oObject)
 {
-    string sFunc = "Apply";
-    NWNX_PushArgumentObject(oObject);
-    NWNX_PushArgumentEffect(eEffect);
-    NWNX_CallFunction(NWNX_Effect, sFunc);
+    NWNXPushObject(oObject);
+    NWNXPushEffect(eEffect);
+    NWNXCall(NWNX_Effect, "Apply");
 }
 
 effect NWNX_Effect_SetEffectCreator(effect eEffect, object oObject)
 {
-    string sFunc = "SetEffectCreator";
-
-    NWNX_PushArgumentObject(oObject);
-    NWNX_PushArgumentEffect(eEffect);
-
-    NWNX_CallFunction(NWNX_Effect, sFunc);
-
-    return NWNX_GetReturnValueEffect();
+    NWNXPushObject(oObject);
+    NWNXPushEffect(eEffect);
+    NWNXCall(NWNX_Effect, "SetEffectCreator");
+    return NWNXPopEffect();
 }
 
 int NWNX_Effect_GetIsEffectValid(effect eEffect)
 {
-    string sFunc = "GetIsEffectValid";
-
-    NWNX_PushArgumentEffect(eEffect);
-
-    NWNX_CallFunction(NWNX_Effect, sFunc);
-
-    return NWNX_GetReturnValueInt();
+    NWNXPushEffect(eEffect);
+    NWNXCall(NWNX_Effect, "GetIsEffectValid");
+    return NWNXPopInt();
 }
 
 int NWNX_Effect_GetAppliedEffectCount(object oObject)
 {
-    string sFunc = "GetAppliedEffectCount";
-
-    NWNX_PushArgumentObject(oObject);
-
-    NWNX_CallFunction(NWNX_Effect, sFunc);
-
-    return NWNX_GetReturnValueInt();
+    NWNXPushObject(oObject);
+    NWNXCall(NWNX_Effect, "GetAppliedEffectCount");
+    return NWNXPopInt();
 }
 
 effect NWNX_Effect_GetAppliedEffect(object oObject, int nNth)
 {
-    string sFunc = "GetAppliedEffect";
-
-    NWNX_PushArgumentInt(nNth);
-    NWNX_PushArgumentObject(oObject);
-
-    NWNX_CallFunction(NWNX_Effect, sFunc);
-
-    return NWNX_GetReturnValueEffect();
+    NWNXPushInt(nNth);
+    NWNXPushObject(oObject);
+    NWNXCall(NWNX_Effect, "GetAppliedEffect");
+    return NWNXPopEffect();
 }

_module/nss/nwnx_elc.nss

@@ -2,7 +2,6 @@
 /// @brief Replacement for ValidateCharacter: ELC & ILR
 /// @{
 /// @file nwnx_elc.nss
-#include "nwnx"
 
 const string NWNX_ELC = "NWNX_ELC"; ///< @private
 
@@ -147,95 +146,71 @@ int NWNX_ELC_GetValidationFailureSpellID();
 
 void NWNX_ELC_SetELCScript(string sScript)
 {
-    string sFunc = "SetELCScript";
-
-    NWNX_PushArgumentString(sScript);
-    NWNX_CallFunction(NWNX_ELC, sFunc);
+    NWNXPushString(sScript);
+    NWNXCall(NWNX_ELC, "SetELCScript");
 }
 
 void NWNX_ELC_EnableCustomELCCheck(int bEnabled)
 {
-    string sFunc = "EnableCustomELCCheck";
-
-    NWNX_PushArgumentInt(bEnabled);
-    NWNX_CallFunction(NWNX_ELC, sFunc);
+    NWNXPushInt(bEnabled);
+    NWNXCall(NWNX_ELC, "EnableCustomELCCheck");
 }
 
 void NWNX_ELC_SkipValidationFailure()
 {
-    string sFunc = "SkipValidationFailure";
-
-    NWNX_CallFunction(NWNX_ELC, sFunc);
+    NWNXCall(NWNX_ELC, "SkipValidationFailure");
 }
 
 int NWNX_ELC_GetValidationFailureType()
 {
-    string sFunc = "GetValidationFailureType";
-
-    NWNX_CallFunction(NWNX_ELC, sFunc);
-    return NWNX_GetReturnValueInt();
+    NWNXCall(NWNX_ELC, "GetValidationFailureType");
+    return NWNXPopInt();
 }
 
 int NWNX_ELC_GetValidationFailureSubType()
 {
-    string sFunc = "GetValidationFailureSubType";
-
-    NWNX_CallFunction(NWNX_ELC, sFunc);
-    return NWNX_GetReturnValueInt();
+    NWNXCall(NWNX_ELC, "GetValidationFailureSubType");
+    return NWNXPopInt();
 }
 
 int NWNX_ELC_GetValidationFailureMessageStrRef()
 {
-    string sFunc = "GetValidationFailureMessageStrRef";
-
-    NWNX_CallFunction(NWNX_ELC, sFunc);
-    return NWNX_GetReturnValueInt();
+    NWNXCall(NWNX_ELC, "GetValidationFailureMessageStrRef");
+    return NWNXPopInt();
 }
 
 void NWNX_ELC_SetValidationFailureMessageStrRef(int nStrRef)
 {
-    string sFunc = "SetValidationFailureMessageStrRef";
-
-    NWNX_PushArgumentInt(nStrRef);
-    NWNX_CallFunction(NWNX_ELC, sFunc);
+    NWNXPushInt(nStrRef);
+    NWNXCall(NWNX_ELC, "SetValidationFailureMessageStrRef");
 }
 
 object NWNX_ELC_GetValidationFailureItem()
 {
-    string sFunc = "GetValidationFailureItem";
-
-    NWNX_CallFunction(NWNX_ELC, sFunc);
-    return NWNX_GetReturnValueObject();
+    NWNXCall(NWNX_ELC, "GetValidationFailureItem");
+    return NWNXPopObject();
 }
 
 int NWNX_ELC_GetValidationFailureLevel()
 {
-    string sFunc = "GetValidationFailureLevel";
-
-    NWNX_CallFunction(NWNX_ELC, sFunc);
-    return NWNX_GetReturnValueInt();
+    NWNXCall(NWNX_ELC, "GetValidationFailureLevel");
+    return NWNXPopInt();
 }
 
 int NWNX_ELC_GetValidationFailureSkillID()
 {
-    string sFunc = "GetValidationFailureSkillID";
-
-    NWNX_CallFunction(NWNX_ELC, sFunc);
-    return NWNX_GetReturnValueInt();
+    NWNXCall(NWNX_ELC, "GetValidationFailureSkillID");
+    return NWNXPopInt();
 }
 
 int NWNX_ELC_GetValidationFailureFeatID()
 {
-    string sFunc = "GetValidationFailureFeatID";
-
-    NWNX_CallFunction(NWNX_ELC, sFunc);
-    return NWNX_GetReturnValueInt();
+    NWNXCall(NWNX_ELC, "GetValidationFailureFeatID");
+    return NWNXPopInt();
 }
 
 int NWNX_ELC_GetValidationFailureSpellID()
 {
-    string sFunc = "GetValidationFailureSpellID";
-
-    NWNX_CallFunction(NWNX_ELC, sFunc);
-    return NWNX_GetReturnValueInt();
+    NWNXCall(NWNX_ELC, "GetValidationFailureSpellID");
+    return NWNXPopInt();
 }

_module/nss/nwnx_encounter.nss

@@ -2,7 +2,6 @@
 /// @brief Functions exposing additional encounter properties.
 /// @{
 /// @file nwnx_encounter.nss
-#include "nwnx"
 
 const string NWNX_Encounter = "NWNX_Encounter"; ///< @private
 
@@ -122,205 +121,146 @@ void NWNX_Encounter_SetGeometry(object oTrigger, string sGeometry);
 
 void NWNX_Encounter_Destroy(object encounter)
 {
-    string sFunc = "Destroy";
-
-    NWNX_PushArgumentObject(encounter);
-    NWNX_CallFunction(NWNX_Encounter, sFunc);
+    NWNXPushObject(encounter);
+    NWNXCall(NWNX_Encounter, "Destroy");
 }
 
 int NWNX_Encounter_GetNumberOfCreaturesInEncounterList(object encounter)
 {
-    string sFunc = "GetNumberOfCreaturesInEncounterList";
-
-    NWNX_PushArgumentObject(encounter);
-    NWNX_CallFunction(NWNX_Encounter, sFunc);
-
-    return NWNX_GetReturnValueInt();
+    NWNXPushObject(encounter);
+    NWNXCall(NWNX_Encounter, "GetNumberOfCreaturesInEncounterList");
+    return NWNXPopInt();
 }
 
 struct NWNX_Encounter_CreatureListEntry NWNX_Encounter_GetEncounterCreatureByIndex(object encounter, int index)
 {
-    string sFunc = "GetEncounterCreatureByIndex";
     struct NWNX_Encounter_CreatureListEntry creatureEntry;
-
-    NWNX_PushArgumentInt(index);
-    NWNX_PushArgumentObject(encounter);
-
-    NWNX_CallFunction(NWNX_Encounter, sFunc);
-
-    creatureEntry.alreadyUsed = NWNX_GetReturnValueInt();
-    creatureEntry.unique = NWNX_GetReturnValueInt();
-    creatureEntry.challengeRating = NWNX_GetReturnValueFloat();
-    creatureEntry.resref = NWNX_GetReturnValueString();
-
+    NWNXPushInt(index);
+    NWNXPushObject(encounter);
+    NWNXCall(NWNX_Encounter, "GetEncounterCreatureByIndex");
+    creatureEntry.alreadyUsed = NWNXPopInt();
+    creatureEntry.unique = NWNXPopInt();
+    creatureEntry.challengeRating = NWNXPopFloat();
+    creatureEntry.resref = NWNXPopString();
     return creatureEntry;
 }
 
 void NWNX_Encounter_SetEncounterCreatureByIndex(object encounter, int index, struct NWNX_Encounter_CreatureListEntry creatureEntry)
 {
-    string sFunc = "SetEncounterCreatureByIndex";
-
-    NWNX_PushArgumentInt(creatureEntry.alreadyUsed);
-    NWNX_PushArgumentInt(creatureEntry.unique);
-    NWNX_PushArgumentFloat(creatureEntry.challengeRating);
-    NWNX_PushArgumentString(creatureEntry.resref);
-    NWNX_PushArgumentInt(index);
-    NWNX_PushArgumentObject(encounter);
-
-    NWNX_CallFunction(NWNX_Encounter, sFunc);
+    NWNXPushInt(creatureEntry.alreadyUsed);
+    NWNXPushInt(creatureEntry.unique);
+    NWNXPushFloat(creatureEntry.challengeRating);
+    NWNXPushString(creatureEntry.resref);
+    NWNXPushInt(index);
+    NWNXPushObject(encounter);
+    NWNXCall(NWNX_Encounter, "SetEncounterCreatureByIndex");
 }
 
 int NWNX_Encounter_GetFactionId(object encounter)
 {
-    string sFunc = "GetFactionId";
-
-    NWNX_PushArgumentObject(encounter);
-    NWNX_CallFunction(NWNX_Encounter, sFunc);
-
-    return NWNX_GetReturnValueInt();
+    NWNXPushObject(encounter);
+    NWNXCall(NWNX_Encounter, "GetFactionId");
+    return NWNXPopInt();
 }
 
 void NWNX_Encounter_SetFactionId(object encounter, int factionId)
 {
-    string sFunc = "SetFactionId";
-
-    NWNX_PushArgumentInt(factionId);
-    NWNX_PushArgumentObject(encounter);
-
-    NWNX_CallFunction(NWNX_Encounter, sFunc);
+    NWNXPushInt(factionId);
+    NWNXPushObject(encounter);
+    NWNXCall(NWNX_Encounter, "SetFactionId");
 }
 
 int NWNX_Encounter_GetPlayerTriggeredOnly(object encounter)
 {
-    string sFunc = "GetPlayerTriggeredOnly";
-
-    NWNX_PushArgumentObject(encounter);
-    NWNX_CallFunction(NWNX_Encounter, sFunc);
-
-    return NWNX_GetReturnValueInt();
+    NWNXPushObject(encounter);
+    NWNXCall(NWNX_Encounter, "GetPlayerTriggeredOnly");
+    return NWNXPopInt();
 }
 
 void NWNX_Encounter_SetPlayerTriggeredOnly(object encounter, int playerTriggeredOnly)
 {
-    string sFunc = "SetPlayerTriggeredOnly";
 
-    NWNX_PushArgumentInt(playerTriggeredOnly);
-    NWNX_PushArgumentObject(encounter);
-
-    NWNX_CallFunction(NWNX_Encounter, sFunc);
+    NWNXPushInt(playerTriggeredOnly);
+    NWNXPushObject(encounter);
+    NWNXCall(NWNX_Encounter, "SetPlayerTriggeredOnly");
 }
 
 int NWNX_Encounter_GetCanReset(object encounter)
 {
-    string sFunc = "GetCanReset";
-
-    NWNX_PushArgumentObject(encounter);
-    NWNX_CallFunction(NWNX_Encounter, sFunc);
-
-    return NWNX_GetReturnValueInt();
+    NWNXPushObject(encounter);
+    NWNXCall(NWNX_Encounter, "GetCanReset");
+    return NWNXPopInt();
 }
 
 void NWNX_Encounter_SetCanReset(object encounter, int reset)
 {
-    string sFunc = "SetCanReset";
-
-    NWNX_PushArgumentInt(reset);
-    NWNX_PushArgumentObject(encounter);
-
-    NWNX_CallFunction(NWNX_Encounter, sFunc);
+    NWNXPushInt(reset);
+    NWNXPushObject(encounter);
+    NWNXCall(NWNX_Encounter, "SetCanReset");
 }
 
 int NWNX_Encounter_GetResetTime(object encounter)
 {
-    string sFunc = "GetResetTime";
-
-    NWNX_PushArgumentObject(encounter);
-    NWNX_CallFunction(NWNX_Encounter, sFunc);
-
-    return NWNX_GetReturnValueInt();
+    NWNXPushObject(encounter);
+    NWNXCall(NWNX_Encounter, "GetResetTime");
+    return NWNXPopInt();
 }
 
 void NWNX_Encounter_SetResetTime(object encounter, int resetTime)
 {
-    string sFunc = "SetResetTime";
-
-    NWNX_PushArgumentInt(resetTime);
-    NWNX_PushArgumentObject(encounter);
-
-    NWNX_CallFunction(NWNX_Encounter, sFunc);
+    NWNXPushInt(resetTime);
+    NWNXPushObject(encounter);
+    NWNXCall(NWNX_Encounter, "SetResetTime");
 }
 
 int NWNX_Encounter_GetNumberOfSpawnPoints(object encounter)
 {
-    string sFunc = "GetNumberOfSpawnPoints";
-  
-    NWNX_PushArgumentObject(encounter);
-    NWNX_CallFunction(NWNX_Encounter, sFunc);
-  
-    return NWNX_GetReturnValueInt();
+    NWNXPushObject(encounter);
+    NWNXCall(NWNX_Encounter, "GetNumberOfSpawnPoints");
+    return NWNXPopInt();
 }
 
 location NWNX_Encounter_GetSpawnPointByIndex(object encounter, int index)
 {
-    string sFunc = "GetSpawnPointByIndex";
-  
-    NWNX_PushArgumentInt(index);
-    NWNX_PushArgumentObject(encounter);
-    NWNX_CallFunction(NWNX_Encounter, sFunc);
-  
-    float o = NWNX_GetReturnValueFloat();
-    float z = NWNX_GetReturnValueFloat();
-    float y = NWNX_GetReturnValueFloat();
-    float x = NWNX_GetReturnValueFloat();
-  
-    return Location(GetArea(encounter), Vector(x, y, z), o);
+    NWNXPushInt(index);
+    NWNXPushObject(encounter);
+    NWNXCall(NWNX_Encounter, "GetSpawnPointByIndex");
+    float fOrientation = NWNXPopFloat();
+    vector vPosition = NWNXPopVector();
+    return Location(GetArea(encounter), vPosition, fOrientation);
 }
 
 int NWNX_Encounter_GetMinNumSpawned(object encounter)
 {
-    string sFunc = "GetMinNumSpawned";
-  
-    NWNX_PushArgumentObject(encounter);
-    NWNX_CallFunction(NWNX_Encounter, sFunc);
-  
-    return NWNX_GetReturnValueInt();
+    NWNXPushObject(encounter);
+    NWNXCall(NWNX_Encounter, "GetMinNumSpawned");
+    return NWNXPopInt();
 }
 
 int NWNX_Encounter_GetMaxNumSpawned(object encounter)
 {
-    string sFunc = "GetMaxNumSpawned";
-  
-    NWNX_PushArgumentObject(encounter);
-    NWNX_CallFunction(NWNX_Encounter, sFunc);
-  
-    return NWNX_GetReturnValueInt();
+    NWNXPushObject(encounter);
+    NWNXCall(NWNX_Encounter, "GetMaxNumSpawned");
+    return NWNXPopInt();
 }
 
 int NWNX_Encounter_GetCurrentNumSpawned(object encounter)
 {
-    string sFunc = "GetCurrentNumSpawned";
-  
-    NWNX_PushArgumentObject(encounter);
-    NWNX_CallFunction(NWNX_Encounter, sFunc);
-  
-    return NWNX_GetReturnValueInt();
+    NWNXPushObject(encounter);
+    NWNXCall(NWNX_Encounter, "GetCurrentNumSpawned");
+    return NWNXPopInt();
 }
 
 string NWNX_Encounter_GetGeometry(object oEncounter)
 {
-    string sFunc = "GetGeometry";
-
-    NWNX_PushArgumentObject(oEncounter);
-    NWNX_CallFunction(NWNX_Encounter, sFunc);
-
-    return NWNX_GetReturnValueString();
+    NWNXPushObject(oEncounter);
+    NWNXCall(NWNX_Encounter, "GetGeometry");
+    return NWNXPopString();
 }
 
 void NWNX_Encounter_SetGeometry(object oEncounter, string sGeometry)
 {
-    string sFunc = "SetGeometry";
-
-    NWNX_PushArgumentString(sGeometry);
-    NWNX_PushArgumentObject(oEncounter);
-    NWNX_CallFunction(NWNX_Encounter, sFunc);
+    NWNXPushString(sGeometry);
+    NWNXPushObject(oEncounter);
+    NWNXCall(NWNX_Encounter, "SetGeometry");
 }

_module/nss/nwnx_events.nss

@@ -2,7 +2,6 @@
 /// @brief Provides an interface for plugins to create event-based systems, and exposes some events through that interface.
 /// @{
 /// @file nwnx_events.nss
-#include "nwnx"
 
 const string NWNX_Events = "NWNX_Events"; ///< @private
 
@@ -562,6 +561,11 @@ _______________________________________
 
     `OBJECT_SELF` = The player disconnecting from the server
 
+    Event Data Tag        | Type   | Notes
+    ----------------------|--------|-------
+    PLAYER_NAME           | string | Player name of the disconnecting client
+    CDKEY                 | string | Public cdkey of the disconnecting client
+
     @note This event also runs when a player connects to the server but cancels out of character select.
     OBJECT_SELF will be OBJECT_INVALID in this case.
 
@@ -1650,6 +1654,18 @@ _______________________________________
           NWNX_Events_AddIDToWhitelist("NWNX_ON_BROADCAST_SAFE_PROJECTILE_SPELL", SPELL_*);
           \endcode
           `TARGET_OBJECT_ID` will be `OBJECT_INVALID` if the projectile is cast at a location
+_______________________________________
+    ## SetExperience Events
+    - NWNX_ON_SET_EXPERIENCE_BEFORE
+    - NWNX_ON_SET_EXPERIENCE_AFTER
+
+    `OBJECT_SELF` = The player the xp is being set on
+
+    Event Data Tag        | Type   | Notes
+    ----------------------|--------|-------
+    XP                    | int    | The xp value to be set. |
+
+    @note To set a different xp value in the BEFORE event: Skip the event and call NWNX_Events_SetEventResult() with the new value.
 _______________________________________
     ## Broadcast Attack of Opportunity Events
     - NWNX_ON_BROADCAST_ATTACK_OF_OPPORTUNITY_BEFORE
@@ -2282,6 +2298,7 @@ string NWNX_Events_GetEventData(string tag);
 /// - Broadcast Safe Projectile event
 /// - Attack of Opportunity events
 /// - Creature Jump events
+/// - SetExperience Events
 void NWNX_Events_SkipEvent();
 
 /// Set the return value of the event.
@@ -2355,163 +2372,127 @@ int NWNX_Events_GetNumSubscribers(string sEvent);
 
 void NWNX_Events_SubscribeEvent(string evt, string script)
 {
-    string sFunc = "SubscribeEvent";
-
-    NWNX_PushArgumentString(script);
-    NWNX_PushArgumentString(evt);
-    NWNX_CallFunction(NWNX_Events, sFunc);
+    NWNXPushString(script);
+    NWNXPushString(evt);
+    NWNXCall(NWNX_Events, "SubscribeEvent");
 }
 
 void NWNX_Events_UnsubscribeEvent(string evt, string script)
 {
-    string sFunc = "UnsubscribeEvent";
-
-    NWNX_PushArgumentString(script);
-    NWNX_PushArgumentString(evt);
-    NWNX_CallFunction(NWNX_Events, sFunc);
+    NWNXPushString(script);
+    NWNXPushString(evt);
+    NWNXCall(NWNX_Events, "UnsubscribeEvent");
 }
 
 void NWNX_Events_UnsubscribeAllStartingWith(string prefix)
 {
-    string sFunc = "UnsubscribeAllStartingWith";
-
-    NWNX_PushArgumentString(prefix);
-    NWNX_CallFunction(NWNX_Events, sFunc);
+    NWNXPushString(prefix);
+    NWNXCall(NWNX_Events, "UnsubscribeAllStartingWith");
 }
 
 void NWNX_Events_SubscribeEventScriptChunk(string sEvent, string sScriptChunk, int bWrapIntoMain = TRUE)
 {
-    string sFunc = "SubscribeEventScriptChunk";
-
-    NWNX_PushArgumentInt(bWrapIntoMain);
-    NWNX_PushArgumentString(sScriptChunk);
-    NWNX_PushArgumentString(sEvent);
-    NWNX_CallFunction(NWNX_Events, sFunc);
+    NWNXPushInt(bWrapIntoMain);
+    NWNXPushString(sScriptChunk);
+    NWNXPushString(sEvent);
+    NWNXCall(NWNX_Events, "SubscribeEventScriptChunk");
 }
 
 void NWNX_Events_UnsubscribeEventScriptChunk(string sEvent, string sScriptChunk, int bWrapIntoMain = TRUE)
 {
-    string sFunc = "UnsubscribeEventScriptChunk";
-
-    NWNX_PushArgumentInt(bWrapIntoMain);
-    NWNX_PushArgumentString(sScriptChunk);
-    NWNX_PushArgumentString(sEvent);
-    NWNX_CallFunction(NWNX_Events, sFunc);
+    NWNXPushInt(bWrapIntoMain);
+    NWNXPushString(sScriptChunk);
+    NWNXPushString(sEvent);
+    NWNXCall(NWNX_Events, "UnsubscribeEventScriptChunk");
 }
 
 void NWNX_Events_PushEventData(string tag, string data)
 {
-    string sFunc = "PushEventData";
-
-    NWNX_PushArgumentString(data);
-    NWNX_PushArgumentString(tag);
-    NWNX_CallFunction(NWNX_Events, sFunc);
+    NWNXPushString(data);
+    NWNXPushString(tag);
+    NWNXCall(NWNX_Events, "PushEventData");
 }
 
 int NWNX_Events_SignalEvent(string evt, object target)
 {
-    string sFunc = "SignalEvent";
-
-    NWNX_PushArgumentObject(target);
-    NWNX_PushArgumentString(evt);
-    NWNX_CallFunction(NWNX_Events, sFunc);
-    return NWNX_GetReturnValueInt();
+    NWNXPushObject(target);
+    NWNXPushString(evt);
+    NWNXCall(NWNX_Events, "SignalEvent");
+    return NWNXPopInt();
 }
 
 string NWNX_Events_GetEventData(string tag)
 {
-    string sFunc = "GetEventData";
-
-    NWNX_PushArgumentString(tag);
-    NWNX_CallFunction(NWNX_Events, sFunc);
-    return NWNX_GetReturnValueString();
+    NWNXPushString(tag);
+    NWNXCall(NWNX_Events, "GetEventData");
+    return NWNXPopString();
 }
 
 void NWNX_Events_SkipEvent()
 {
-    string sFunc = "SkipEvent";
-
-    NWNX_CallFunction(NWNX_Events, sFunc);
+    NWNXCall(NWNX_Events, "SkipEvent");
 }
 
 void NWNX_Events_SetEventResult(string data)
 {
-    string sFunc = "SetEventResult";
-
-    NWNX_PushArgumentString(data);
-    NWNX_CallFunction(NWNX_Events, sFunc);
+    NWNXPushString(data);
+    NWNXCall(NWNX_Events, "SetEventResult");
 }
 
 string NWNX_Events_GetCurrentEvent()
 {
-    string sFunc = "GetCurrentEvent";
-
-    NWNX_CallFunction(NWNX_Events, sFunc);
-    return NWNX_GetReturnValueString();
+    NWNXCall(NWNX_Events, "GetCurrentEvent");
+    return NWNXPopString();
 }
 
 void NWNX_Events_ToggleDispatchListMode(string sEvent, string sScriptOrChunk, int bEnable)
 {
-    string sFunc = "ToggleDispatchListMode";
-
-    NWNX_PushArgumentInt(bEnable);
-    NWNX_PushArgumentString(sScriptOrChunk);
-    NWNX_PushArgumentString(sEvent);
-    NWNX_CallFunction(NWNX_Events, sFunc);
+    NWNXPushInt(bEnable);
+    NWNXPushString(sScriptOrChunk);
+    NWNXPushString(sEvent);
+    NWNXCall(NWNX_Events, "ToggleDispatchListMode");
 }
 
 void NWNX_Events_AddObjectToDispatchList(string sEvent, string sScriptOrChunk, object oObject)
 {
-    string sFunc = "AddObjectToDispatchList";
-
-    NWNX_PushArgumentObject(oObject);
-    NWNX_PushArgumentString(sScriptOrChunk);
-    NWNX_PushArgumentString(sEvent);
-    NWNX_CallFunction(NWNX_Events, sFunc);
+    NWNXPushObject(oObject);
+    NWNXPushString(sScriptOrChunk);
+    NWNXPushString(sEvent);
+    NWNXCall(NWNX_Events, "AddObjectToDispatchList");
 }
 
 void NWNX_Events_RemoveObjectFromDispatchList(string sEvent, string sScriptOrChunk, object oObject)
 {
-    string sFunc = "RemoveObjectFromDispatchList";
-
-    NWNX_PushArgumentObject(oObject);
-    NWNX_PushArgumentString(sScriptOrChunk);
-    NWNX_PushArgumentString(sEvent);
-    NWNX_CallFunction(NWNX_Events, sFunc);
+    NWNXPushObject(oObject);
+    NWNXPushString(sScriptOrChunk);
+    NWNXPushString(sEvent);
+    NWNXCall(NWNX_Events, "RemoveObjectFromDispatchList");
 }
 
 void NWNX_Events_ToggleIDWhitelist(string sEvent, int bEnable)
 {
-    string sFunc = "ToggleIDWhitelist";
-
-    NWNX_PushArgumentInt(bEnable);
-    NWNX_PushArgumentString(sEvent);
-    NWNX_CallFunction(NWNX_Events, sFunc);
+    NWNXPushInt(bEnable);
+    NWNXPushString(sEvent);
+    NWNXCall(NWNX_Events, "ToggleIDWhitelist");
 }
 
 void NWNX_Events_AddIDToWhitelist(string sEvent, int nID)
 {
-    string sFunc = "AddIDToWhitelist";
-
-    NWNX_PushArgumentInt(nID);
-    NWNX_PushArgumentString(sEvent);
-    NWNX_CallFunction(NWNX_Events, sFunc);
+    NWNXPushInt(nID);
+    NWNXPushString(sEvent);
+    NWNXCall(NWNX_Events, "AddIDToWhitelist");
 }
 
 void NWNX_Events_RemoveIDFromWhitelist(string sEvent, int nID)
 {
-    string sFunc = "RemoveIDFromWhitelist";
-
-    NWNX_PushArgumentInt(nID);
-    NWNX_PushArgumentString(sEvent);
-    NWNX_CallFunction(NWNX_Events, sFunc);
+    NWNXPushInt(nID);
+    NWNXPushString(sEvent);
+    NWNXCall(NWNX_Events, "RemoveIDFromWhitelist");
 }
 
 int NWNX_Events_GetNumSubscribers(string sEvent)
 {
-    string sFunc = "GetNumSubscribers";
-
-    NWNX_PushArgumentString(sEvent);
-    NWNX_CallFunction(NWNX_Events, sFunc);
-    return NWNX_GetReturnValueInt();
+    NWNXPushString(sEvent);
+    NWNXCall(NWNX_Events, "GetNumSubscribers");
+    return NWNXPopInt();
 }

_module/nss/nwnx_feat.nss

@@ -2,7 +2,6 @@
 /// @brief Define feat bonuses/penalties
 /// @{
 /// @file nwnx_feat.nss
-#include "nwnx"
 
 const string NWNX_Feat = "NWNX_Feat"; ///< @private
 
@@ -53,14 +52,11 @@ void NWNX_Feat_SetFeatModifier(int iFeat, int iMod, int iParam1 = 0xDEADBEEF, in
 
 void NWNX_Feat_SetFeatModifier(int iFeat, int iMod, int iParam1 = 0xDEADBEEF, int iParam2 = 0xDEADBEEF, int iParam3 = 0xDEADBEEF, int iParam4 = 0xDEADBEEF)
 {
-    string sFunc = "SetFeatModifier";
-
-    NWNX_PushArgumentInt(iParam4);
-    NWNX_PushArgumentInt(iParam3);
-    NWNX_PushArgumentInt(iParam2);
-    NWNX_PushArgumentInt(iParam1);
-    NWNX_PushArgumentInt(iMod);
-    NWNX_PushArgumentInt(iFeat);
-
-    NWNX_CallFunction(NWNX_Feat, sFunc);
+    NWNXPushInt(iParam4);
+    NWNXPushInt(iParam3);
+    NWNXPushInt(iParam2);
+    NWNXPushInt(iParam1);
+    NWNXPushInt(iMod);
+    NWNXPushInt(iFeat);
+    NWNXCall(NWNX_Feat, "SetFeatModifier");
 }

_module/nss/nwnx_feedback.nss

@@ -10,7 +10,6 @@
 ///    * -1 = Personal state is not set for Message
 /// @{
 /// @file nwnx_feedback.nss
-#include "nwnx"
 
 const string NWNX_Feedback = "NWNX_Feedback"; ///< @private
 
@@ -402,95 +401,69 @@ void NWNX_Feedback_SetCombatLogMessageMode(int bWhitelist);
 
 int NWNX_Feedback_GetFeedbackMessageHidden(int nMessage, object oPC = OBJECT_INVALID)
 {
-    string sFunc = "GetMessageHidden";
-    int nMessageType = 0;
-
-    NWNX_PushArgumentInt(nMessage);
-    NWNX_PushArgumentInt(nMessageType);
-    NWNX_PushArgumentObject(oPC);
-    NWNX_CallFunction(NWNX_Feedback, sFunc);
-
-    return NWNX_GetReturnValueInt();
+    NWNXPushInt(nMessage);
+    NWNXPushInt(0);
+    NWNXPushObject(oPC);
+    NWNXCall(NWNX_Feedback, "GetMessageHidden");
+    return NWNXPopInt();
 }
 
 void NWNX_Feedback_SetFeedbackMessageHidden(int nMessage, int isHidden, object oPC = OBJECT_INVALID)
 {
-    string sFunc = "SetMessageHidden";
-    int nMessageType = 0;
-
-    NWNX_PushArgumentInt(isHidden);
-    NWNX_PushArgumentInt(nMessage);
-    NWNX_PushArgumentInt(nMessageType);
-    NWNX_PushArgumentObject(oPC);
-    NWNX_CallFunction(NWNX_Feedback, sFunc);
+    NWNXPushInt(isHidden);
+    NWNXPushInt(nMessage);
+    NWNXPushInt(0);
+    NWNXPushObject(oPC);
+    NWNXCall(NWNX_Feedback, "SetMessageHidden");
 }
 
 int NWNX_Feedback_GetCombatLogMessageHidden(int nMessage, object oPC = OBJECT_INVALID)
 {
-    string sFunc = "GetMessageHidden";
-    int nMessageType = 1;
+    NWNXPushInt(nMessage);
+    NWNXPushInt(1);
+    NWNXPushObject(oPC);
+    NWNXCall(NWNX_Feedback, "GetMessageHidden");
 
-    NWNX_PushArgumentInt(nMessage);
-    NWNX_PushArgumentInt(nMessageType);
-    NWNX_PushArgumentObject(oPC);
-    NWNX_CallFunction(NWNX_Feedback, sFunc);
-
-    return NWNX_GetReturnValueInt();
+    return NWNXPopInt();
 }
 
 void NWNX_Feedback_SetCombatLogMessageHidden(int nMessage, int isHidden, object oPC = OBJECT_INVALID)
 {
-    string sFunc = "SetMessageHidden";
-    int nMessageType = 1;
-
-    NWNX_PushArgumentInt(isHidden);
-    NWNX_PushArgumentInt(nMessage);
-    NWNX_PushArgumentInt(nMessageType);
-    NWNX_PushArgumentObject(oPC);
-    NWNX_CallFunction(NWNX_Feedback, sFunc);
+    NWNXPushInt(isHidden);
+    NWNXPushInt(nMessage);
+    NWNXPushInt(1);
+    NWNXPushObject(oPC);
+    NWNXCall(NWNX_Feedback, "SetMessageHidden");
 }
 
 int NWNX_Feedback_GetJournalUpdatedMessageHidden(object oPC = OBJECT_INVALID)
 {
-    string sFunc = "GetMessageHidden";
-    int nMessageType = 2;
-
-    NWNX_PushArgumentInt(0);
-    NWNX_PushArgumentInt(nMessageType);
-    NWNX_PushArgumentObject(oPC);
-    NWNX_CallFunction(NWNX_Feedback, sFunc);
-
-    return NWNX_GetReturnValueInt();
+    NWNXPushInt(0);
+    NWNXPushInt(2);
+    NWNXPushObject(oPC);
+    NWNXCall(NWNX_Feedback, "GetMessageHidden");
+    return NWNXPopInt();
 }
 
 void NWNX_Feedback_SetJournalUpdatedMessageHidden(int isHidden, object oPC = OBJECT_INVALID)
 {
-    string sFunc = "SetMessageHidden";
-    int nMessageType = 2;
-
-    NWNX_PushArgumentInt(isHidden);
-    NWNX_PushArgumentInt(0);
-    NWNX_PushArgumentInt(nMessageType);
-    NWNX_PushArgumentObject(oPC);
-    NWNX_CallFunction(NWNX_Feedback, sFunc);
+    NWNXPushInt(isHidden);
+    NWNXPushInt(0);
+    NWNXPushInt(2);
+    NWNXPushObject(oPC);
+    NWNXCall(NWNX_Feedback, "SetMessageHidden");
 }
 
 void NWNX_Feedback_SetFeedbackMessageMode(int bWhitelist)
 {
-    string sFunc = "SetFeedbackMode";
-    int nMessageType = 0;
-
-    NWNX_PushArgumentInt(bWhitelist);
-    NWNX_PushArgumentInt(nMessageType);
-    NWNX_CallFunction(NWNX_Feedback, sFunc);
+    NWNXPushInt(bWhitelist);
+    NWNXPushInt(0);
+    NWNXCall(NWNX_Feedback, "SetFeedbackMode");
 }
 
 void NWNX_Feedback_SetCombatLogMessageMode(int bWhitelist)
 {
-    string sFunc = "SetFeedbackMode";
-    int nMessageType = 1;
-
-    NWNX_PushArgumentInt(bWhitelist);
-    NWNX_PushArgumentInt(nMessageType);
-    NWNX_CallFunction(NWNX_Feedback, sFunc);
+    NWNXPushInt(bWhitelist);
+    NWNXPushInt(1);
+    NWNXCall(NWNX_Feedback, "SetFeedbackMode");
 }

_module/nss/nwnx_httpclient.nss

@@ -0,0 +1,107 @@
+/// @addtogroup httpclient HTTPClient
+/// @brief NWNX HTTPClient
+/// @{
+/// @file nwnx_httpclient.nss
+
+const string NWNX_HTTPClient = "NWNX_HTTPClient"; ///< @private
+
+/// @name Request Types
+/// @anchor request_types
+///
+/// @{
+const int NWNX_HTTPCLIENT_REQUEST_METHOD_GET     = 0;
+const int NWNX_HTTPCLIENT_REQUEST_METHOD_POST    = 1;
+const int NWNX_HTTPCLIENT_REQUEST_METHOD_DELETE  = 2;
+const int NWNX_HTTPCLIENT_REQUEST_METHOD_PATCH   = 3;
+const int NWNX_HTTPCLIENT_REQUEST_METHOD_PUT     = 4;
+const int NWNX_HTTPCLIENT_REQUEST_METHOD_OPTION  = 5;
+const int NWNX_HTTPCLIENT_REQUEST_METHOD_HEAD    = 6;
+///@}
+
+/// @name Content Types
+/// @anchor content_types
+///
+/// @{
+const int NWNX_HTTPCLIENT_CONTENT_TYPE_HTML            = 0;
+const int NWNX_HTTPCLIENT_CONTENT_TYPE_PLAINTEXT       = 1;
+const int NWNX_HTTPCLIENT_CONTENT_TYPE_JSON            = 2;
+const int NWNX_HTTPCLIENT_CONTENT_TYPE_FORM_URLENCODED = 3;
+const int NWNX_HTTPCLIENT_CONTENT_TYPE_XML             = 4;
+///@}
+
+/// @name HTTP Authentication Types
+/// @anchor auth_types
+///
+/// @{
+const int NWNX_HTTPCLIENT_AUTH_TYPE_NONE         = 0;
+const int NWNX_HTTPCLIENT_AUTH_TYPE_BASIC        = 1;
+const int NWNX_HTTPCLIENT_AUTH_TYPE_DIGEST       = 2;
+const int NWNX_HTTPCLIENT_AUTH_TYPE_BEARER_TOKEN = 3;
+///@}
+
+/// A structure for an HTTP Client Request
+struct NWNX_HTTPClient_Request
+{
+    int nRequestMethod; ///< A @ref request_types "Request Type"
+    string sTag; ///< A unique tag for this request
+    string sHost; ///< The host domain name/IP address
+    string sPath; ///< The path for the url (include the leading /)
+    string sData; ///< The data being sent
+    int nContentType; ///< A @ref content_types "Content Type"
+    int nAuthType; ///< An @ref auth_types "Authentication Type"
+    string sAuthUserOrToken; ///< The authentication username or token
+    string sAuthPassword; ///< The authentication password (ignored if just using a token)
+    int nPort; ///< The host port
+    string sHeaders; ///< Pipe (|) delimited header pairs, e.g. "User-Agent: My NWNX HTTP Client|Accept: application/vnd.github.v3+json"
+};
+
+/// @brief Sends an http method to the given host.
+/// @param s The structured NWNX_HTTPClient_Request information.
+/// @return A unique identifier for the request for later access in the REQUEST_ID event data.
+int NWNX_HTTPClient_SendRequest(struct NWNX_HTTPClient_Request s);
+
+/// @brief Returns an NWNX_HTTP_Client_Request structure
+/// @param nRequestId The request id returned from NWNX_HTTPClient_SendRequest()
+/// @return The structured NWNX_HTTPClient_Request information
+struct NWNX_HTTPClient_Request NWNX_HTTPClient_GetRequest(int nRequestId);
+
+/// @}
+
+int NWNX_HTTPClient_SendRequest(struct NWNX_HTTPClient_Request s)
+{
+    NWNXPushString(s.sHeaders);
+    NWNXPushInt(s.nPort);
+    NWNXPushString(s.sAuthPassword);
+    NWNXPushString(s.sAuthUserOrToken);
+    NWNXPushInt(s.nAuthType);
+    NWNXPushString(s.sData);
+    NWNXPushInt(s.nContentType);
+    NWNXPushString(s.sPath);
+    NWNXPushString(s.sHost);
+    NWNXPushInt(s.nRequestMethod);
+    NWNXPushString(s.sTag);
+    NWNXCall(NWNX_HTTPClient, "SendRequest");
+    return NWNXPopInt();
+}
+
+struct NWNX_HTTPClient_Request NWNX_HTTPClient_GetRequest(int nRequestId)
+{
+    NWNXPushInt(nRequestId);
+    NWNXCall(NWNX_HTTPClient, "GetRequest");
+
+    struct NWNX_HTTPClient_Request s;
+
+    s.sTag             = NWNXPopString();
+    s.nRequestMethod   = NWNXPopInt();
+    s.sHost            = NWNXPopString();
+    s.sPath            = NWNXPopString();
+    s.nContentType     = NWNXPopInt();
+    s.sData            = NWNXPopString();
+    s.nAuthType        = NWNXPopInt();
+    s.sAuthUserOrToken = NWNXPopString();
+    s.sAuthPassword    = NWNXPopString();
+    s.nPort            = NWNXPopInt();
+    s.sHeaders         = NWNXPopString();
+
+    return s;
+}

_module/nss/nwnx_item.nss

@@ -2,7 +2,6 @@
 /// @brief Functions exposing additional item properties.
 /// @{
 /// @file nwnx_item.nss
-#include "nwnx"
 
 const string NWNX_Item = "NWNX_Item"; ///< @private
 
@@ -134,169 +133,120 @@ int NWNX_Item_GetMinEquipLevelOverride(object oItem);
 
 void NWNX_Item_SetWeight(object oItem, int w)
 {
-    string sFunc = "SetWeight";
-
-    NWNX_PushArgumentInt(w);
-    NWNX_PushArgumentObject(oItem);
-
-    NWNX_CallFunction(NWNX_Item, sFunc);
+    NWNXPushInt(w);
+    NWNXPushObject(oItem);
+    NWNXCall(NWNX_Item, "SetWeight");
 }
 
 void NWNX_Item_SetBaseGoldPieceValue(object oItem, int g)
 {
-    string sFunc = "SetBaseGoldPieceValue";
-
-    NWNX_PushArgumentInt(g);
-    NWNX_PushArgumentObject(oItem);
-
-    NWNX_CallFunction(NWNX_Item, sFunc);
+    NWNXPushInt(g);
+    NWNXPushObject(oItem);
+    NWNXCall(NWNX_Item, "SetBaseGoldPieceValue");
 }
 
 void NWNX_Item_SetAddGoldPieceValue(object oItem, int g)
 {
-    string sFunc = "SetAddGoldPieceValue";
-
-    NWNX_PushArgumentInt(g);
-    NWNX_PushArgumentObject(oItem);
-
-    NWNX_CallFunction(NWNX_Item, sFunc);
+    NWNXPushInt(g);
+    NWNXPushObject(oItem);
+    NWNXCall(NWNX_Item, "SetAddGoldPieceValue");
 }
 
 int NWNX_Item_GetBaseGoldPieceValue(object oItem)
 {
-    string sFunc = "GetBaseGoldPieceValue";
-
-    NWNX_PushArgumentObject(oItem);
-
-    NWNX_CallFunction(NWNX_Item, sFunc);
-    return NWNX_GetReturnValueInt();
+    NWNXPushObject(oItem);
+    NWNXCall(NWNX_Item, "GetBaseGoldPieceValue");
+    return NWNXPopInt();
 }
 
 int NWNX_Item_GetAddGoldPieceValue(object oItem)
 {
-    string sFunc = "GetAddGoldPieceValue";
-
-    NWNX_PushArgumentObject(oItem);
-
-    NWNX_CallFunction(NWNX_Item, sFunc);
-    return NWNX_GetReturnValueInt();
+    NWNXPushObject(oItem);
+    NWNXCall(NWNX_Item, "GetAddGoldPieceValue");
+    return NWNXPopInt();
 }
 
 void NWNX_Item_SetBaseItemType(object oItem, int nBaseItem)
 {
-    string sFunc = "SetBaseItemType";
-
-    NWNX_PushArgumentInt(nBaseItem);
-    NWNX_PushArgumentObject(oItem);
-
-    NWNX_CallFunction(NWNX_Item, sFunc);
+    NWNXPushInt(nBaseItem);
+    NWNXPushObject(oItem);
+    NWNXCall(NWNX_Item, "SetBaseItemType");
 }
 
 void NWNX_Item_SetItemAppearance(object oItem, int nType, int nIndex, int nValue, int bUpdateCreatureAppearance = FALSE)
 {
-    string sFunc = "SetItemAppearance";
-
-    NWNX_PushArgumentInt(bUpdateCreatureAppearance);
-    NWNX_PushArgumentInt(nValue);
-    NWNX_PushArgumentInt(nIndex);
-    NWNX_PushArgumentInt(nType);
-    NWNX_PushArgumentObject(oItem);
-
-    NWNX_CallFunction(NWNX_Item, sFunc);
-
+    NWNXPushInt(bUpdateCreatureAppearance);
+    NWNXPushInt(nValue);
+    NWNXPushInt(nIndex);
+    NWNXPushInt(nType);
+    NWNXPushObject(oItem);
+    NWNXCall(NWNX_Item, "SetItemAppearance");
 }
 
 string NWNX_Item_GetEntireItemAppearance(object oItem)
 {
-    string sFunc = "GetEntireItemAppearance";
-
-    NWNX_PushArgumentObject(oItem);
-
-    NWNX_CallFunction(NWNX_Item, sFunc);
-    return NWNX_GetReturnValueString();
+    NWNXPushObject(oItem);
+    NWNXCall(NWNX_Item, "GetEntireItemAppearance");
+    return NWNXPopString();
 }
 
 void NWNX_Item_RestoreItemAppearance(object oItem, string sApp)
 {
-    string sFunc = "RestoreItemAppearance";
-
-    NWNX_PushArgumentString(sApp);
-    NWNX_PushArgumentObject(oItem);
-
-    NWNX_CallFunction(NWNX_Item, sFunc);
+    NWNXPushString(sApp);
+    NWNXPushObject(oItem);
+    NWNXCall(NWNX_Item, "RestoreItemAppearance");
 }
 
 int NWNX_Item_GetBaseArmorClass(object oItem)
 {
-    string sFunc = "GetBaseArmorClass";
-
-    NWNX_PushArgumentObject(oItem);
-
-    NWNX_CallFunction(NWNX_Item, sFunc);
-    return NWNX_GetReturnValueInt();
+    NWNXPushObject(oItem);
+    NWNXCall(NWNX_Item, "GetBaseArmorClass");
+    return NWNXPopInt();
 }
 
 int NWNX_Item_GetMinEquipLevel(object oItem)
 {
-    string sFunc = "GetMinEquipLevel";
-
-    NWNX_PushArgumentObject(oItem);
-
-    NWNX_CallFunction(NWNX_Item, sFunc);
-    return NWNX_GetReturnValueInt();
+    NWNXPushObject(oItem);
+    NWNXCall(NWNX_Item, "GetMinEquipLevel");
+    return NWNXPopInt();
 }
 
 int NWNX_Item_MoveTo(object oItem, object oTarget, int bHideAllFeedback = FALSE)
 {
-    string sFunc = "MoveTo";
-
-    NWNX_PushArgumentInt(bHideAllFeedback);
-    NWNX_PushArgumentObject(oTarget);
-    NWNX_PushArgumentObject(oItem);
-
-    NWNX_CallFunction(NWNX_Item, sFunc);
-
-    return NWNX_GetReturnValueInt();
+    NWNXPushInt(bHideAllFeedback);
+    NWNXPushObject(oTarget);
+    NWNXPushObject(oItem);
+    NWNXCall(NWNX_Item, "MoveTo");
+    return NWNXPopInt();
 }
 
 void NWNX_Item_SetMinEquipLevelModifier(object oItem, int nModifier, int bPersist = TRUE)
 {
-    string sFunc = "SetMinEquipLevelModifier";
-
-    NWNX_PushArgumentInt(bPersist);
-    NWNX_PushArgumentInt(nModifier);
-    NWNX_PushArgumentObject(oItem);
-
-    NWNX_CallFunction(NWNX_Item, sFunc);
+    NWNXPushInt(bPersist);
+    NWNXPushInt(nModifier);
+    NWNXPushObject(oItem);
+    NWNXCall(NWNX_Item, "SetMinEquipLevelModifier");
 }
 
 int NWNX_Item_GetMinEquipLevelModifier(object oItem)
 {
-    string sFunc = "GetMinEquipLevelModifier";
-
-    NWNX_PushArgumentObject(oItem);
-
-    NWNX_CallFunction(NWNX_Item, sFunc);
-    return NWNX_GetReturnValueInt();
+    NWNXPushObject(oItem);
+    NWNXCall(NWNX_Item, "GetMinEquipLevelModifier");
+    return NWNXPopInt();
 }
 
 void NWNX_Item_SetMinEquipLevelOverride(object oItem, int nOverride, int bPersist = TRUE)
 {
-    string sFunc = "SetMinEquipLevelOverride";
 
-    NWNX_PushArgumentInt(bPersist);
-    NWNX_PushArgumentInt(nOverride);
-    NWNX_PushArgumentObject(oItem);
-
-    NWNX_CallFunction(NWNX_Item, sFunc);
+    NWNXPushInt(bPersist);
+    NWNXPushInt(nOverride);
+    NWNXPushObject(oItem);
+    NWNXCall(NWNX_Item, "SetMinEquipLevelOverride");
 }
 
 int NWNX_Item_GetMinEquipLevelOverride(object oItem)
 {
-    string sFunc = "GetMinEquipLevelOverride";
-
-    NWNX_PushArgumentObject(oItem);
-
-    NWNX_CallFunction(NWNX_Item, sFunc);
-    return NWNX_GetReturnValueInt();
+    NWNXPushObject(oItem);
+    NWNXCall(NWNX_Item, "GetMinEquipLevelOverride");
+    return NWNXPopInt();
 }

_module/nss/nwnx_itemprop.nss

@@ -2,7 +2,6 @@
 /// @brief Utility functions to manipulate the builtin itemproperty type.
 /// @{
 /// @file nwnx_itemprop.nss
-#include "nwnx"
 
 const string NWNX_ItemProperty = "NWNX_ItemProperty"; ///< @private
 
@@ -44,70 +43,58 @@ struct NWNX_IPUnpacked NWNX_ItemProperty_GetActiveProperty(object oItem, int nIn
 
 struct NWNX_IPUnpacked NWNX_ItemProperty_UnpackIP(itemproperty ip)
 {
-    string sFunc = "UnpackIP";
-
-    NWNX_PushArgumentItemProperty(ip);
-    NWNX_CallFunction(NWNX_ItemProperty, sFunc);
-
+    NWNXPushItemProperty(ip);
+    NWNXCall(NWNX_ItemProperty, "UnpackIP");
     struct NWNX_IPUnpacked n;
-
-    n.sID             = NWNX_GetReturnValueString();
-    n.nProperty       = NWNX_GetReturnValueInt();
-    n.nSubType        = NWNX_GetReturnValueInt();
-    n.nCostTable      = NWNX_GetReturnValueInt();
-    n.nCostTableValue = NWNX_GetReturnValueInt();
-    n.nParam1         = NWNX_GetReturnValueInt();
-    n.nParam1Value    = NWNX_GetReturnValueInt();
-    n.nUsesPerDay     = NWNX_GetReturnValueInt();
-    n.nChanceToAppear = NWNX_GetReturnValueInt();
-    n.bUsable         = NWNX_GetReturnValueInt();
-    n.nSpellId        = NWNX_GetReturnValueInt();
-    n.oCreator        = NWNX_GetReturnValueObject();
-    n.sTag            = NWNX_GetReturnValueString();
-
+    n.sID             = NWNXPopString();
+    n.nProperty       = NWNXPopInt();
+    n.nSubType        = NWNXPopInt();
+    n.nCostTable      = NWNXPopInt();
+    n.nCostTableValue = NWNXPopInt();
+    n.nParam1         = NWNXPopInt();
+    n.nParam1Value    = NWNXPopInt();
+    n.nUsesPerDay     = NWNXPopInt();
+    n.nChanceToAppear = NWNXPopInt();
+    n.bUsable         = NWNXPopInt();
+    n.nSpellId        = NWNXPopInt();
+    n.oCreator        = NWNXPopObject();
+    n.sTag            = NWNXPopString();
     return n;
 }
 
 itemproperty NWNX_ItemProperty_PackIP(struct NWNX_IPUnpacked n)
 {
-    string sFunc = "PackIP";
-
-    NWNX_PushArgumentString(n.sTag);
-    NWNX_PushArgumentObject(n.oCreator);
-    NWNX_PushArgumentInt(n.nSpellId);
-    NWNX_PushArgumentInt(n.bUsable);
-    NWNX_PushArgumentInt(n.nChanceToAppear);
-    NWNX_PushArgumentInt(n.nUsesPerDay);
-    NWNX_PushArgumentInt(n.nParam1Value);
-    NWNX_PushArgumentInt(n.nParam1);
-    NWNX_PushArgumentInt(n.nCostTableValue);
-    NWNX_PushArgumentInt(n.nCostTable);
-    NWNX_PushArgumentInt(n.nSubType);
-    NWNX_PushArgumentInt(n.nProperty);
-
-    NWNX_CallFunction(NWNX_ItemProperty, sFunc);
-    return NWNX_GetReturnValueItemProperty();
+    NWNXPushString(n.sTag);
+    NWNXPushObject(n.oCreator);
+    NWNXPushInt(n.nSpellId);
+    NWNXPushInt(n.bUsable);
+    NWNXPushInt(n.nChanceToAppear);
+    NWNXPushInt(n.nUsesPerDay);
+    NWNXPushInt(n.nParam1Value);
+    NWNXPushInt(n.nParam1);
+    NWNXPushInt(n.nCostTableValue);
+    NWNXPushInt(n.nCostTable);
+    NWNXPushInt(n.nSubType);
+    NWNXPushInt(n.nProperty);
+    NWNXCall(NWNX_ItemProperty, "PackIP");
+    return NWNXPopItemProperty();
 }
 
 struct NWNX_IPUnpacked NWNX_ItemProperty_GetActiveProperty(object oItem, int nIndex)
 {
-    string sFunc = "GetActiveProperty";
-    NWNX_PushArgumentInt(nIndex);
-    NWNX_PushArgumentObject(oItem);
-    NWNX_CallFunction(NWNX_ItemProperty, sFunc);
-
+    NWNXPushInt(nIndex);
+    NWNXPushObject(oItem);
+    NWNXCall(NWNX_ItemProperty, "GetActiveProperty");
     struct NWNX_IPUnpacked n;
-
-    n.nProperty       = NWNX_GetReturnValueInt();
-    n.nSubType        = NWNX_GetReturnValueInt();
-    n.nCostTable      = NWNX_GetReturnValueInt();
-    n.nCostTableValue = NWNX_GetReturnValueInt();
-    n.nParam1         = NWNX_GetReturnValueInt();
-    n.nParam1Value    = NWNX_GetReturnValueInt();
-    n.nUsesPerDay     = NWNX_GetReturnValueInt();
-    n.nChanceToAppear = NWNX_GetReturnValueInt();
-    n.bUsable         = NWNX_GetReturnValueInt();
-    n.sTag            = NWNX_GetReturnValueString();
-
+    n.nProperty       = NWNXPopInt();
+    n.nSubType        = NWNXPopInt();
+    n.nCostTable      = NWNXPopInt();
+    n.nCostTableValue = NWNXPopInt();
+    n.nParam1         = NWNXPopInt();
+    n.nParam1Value    = NWNXPopInt();
+    n.nUsesPerDay     = NWNXPopInt();
+    n.nChanceToAppear = NWNXPopInt();
+    n.bUsable         = NWNXPopInt();
+    n.sTag            = NWNXPopString();
     return n;
 }

_module/nss/nwnx_lua.nss

@@ -2,7 +2,6 @@
 /// @brief Execute Lua code and generate events in NWScript
 /// @{
 /// @file nwnx_lua.nss
-#include "nwnx"
 
 const string NWNX_Lua = "NWNX_Lua"; ///< @private
 
@@ -25,27 +24,21 @@ void NWNX_Lua_RunEvent(string sEvent, object oObject, string sExtra="");
 
 void NWNX_Lua_EvalVoid(string sCode)
 {
-    string sFunc = "EvalVoid";
-
-    NWNX_PushArgumentString(sCode);
-    NWNX_CallFunction(NWNX_Lua, sFunc);
+    NWNXPushString(sCode);
+    NWNXCall(NWNX_Lua, "EvalVoid");
 }
 
 string NWNX_Lua_Eval(string sCode)
 {
-    string sFunc = "Eval";
-
-    NWNX_PushArgumentString(sCode);
-    NWNX_CallFunction(NWNX_Lua, sFunc);
-    return NWNX_GetReturnValueString();
+    NWNXPushString(sCode);
+    NWNXCall(NWNX_Lua, "Eval");
+    return NWNXPopString();
 }
 
 void NWNX_Lua_RunEvent(string sEvent, object oObject, string sExtra="")
 {
-    string sFunc = "RunEvent";
-
-    NWNX_PushArgumentString(sExtra);
-    NWNX_PushArgumentObject(oObject);
-    NWNX_PushArgumentString(sEvent);
-    NWNX_CallFunction(NWNX_Lua, sFunc);
+    NWNXPushString(sExtra);
+    NWNXPushObject(oObject);
+    NWNXPushString(sEvent);
+    NWNXCall(NWNX_Lua, "RunEvent");
 }

_module/nss/nwnx_nostack.nss

@@ -2,7 +2,6 @@
 /// @brief Functions to allow more control over ability/skill/bonuses stacking.
 /// @{
 /// @file nwnx_nostack.nss
-#include "nwnx"
 
 const string NWNX_NoStack = "NWNX_NoStack"; ///< @private
 
@@ -31,10 +30,7 @@ void NWNX_NoStack_SetSpellBonusType(int spell, int type);
 
 void NWNX_NoStack_SetSpellBonusType(int spell, int type)
 {
-    string sFunc = "SetSpellBonusType";
-
-    NWNX_PushArgumentInt(type);
-    NWNX_PushArgumentInt(spell);
-
-    NWNX_CallFunction(NWNX_NoStack, sFunc);
+    NWNXPushInt(type);
+    NWNXPushInt(spell);
+    NWNXCall(NWNX_NoStack, "SetSpellBonusType");
 }

_module/nss/nwnx_nwsqliteext.nss

@@ -2,7 +2,6 @@
 /// @brief Various extensions for the game's built-in sqlite database.
 /// @{
 /// @file nwnx_nwsqliteext.nss
-#include "nwnx"
 
 const string NWNX_NWSQLiteExtensions = "NWNX_NWSQLiteExtensions"; ///< @private
 
@@ -17,9 +16,9 @@ int NWNX_NWSQLiteExtensions_CreateVirtual2DATable(string s2DA, string sColumnTyp
 
 int NWNX_NWSQLiteExtensions_CreateVirtual2DATable(string s2DA, string sColumnTypeHints = "", string sTableName = "")
 {
-    NWNX_PushArgumentString(sTableName);
-    NWNX_PushArgumentString(sColumnTypeHints);
-    NWNX_PushArgumentString(s2DA);
-    NWNX_CallFunction(NWNX_NWSQLiteExtensions, "CreateVirtual2DATable");
-    return NWNX_GetReturnValueInt();
+    NWNXPushString(sTableName);
+    NWNXPushString(sColumnTypeHints);
+    NWNXPushString(s2DA);
+    NWNXCall(NWNX_NWSQLiteExtensions, "CreateVirtual2DATable");
+    return NWNXPopInt();
 }

_module/nss/nwnx_object.nss

@@ -2,7 +2,6 @@
 /// @brief Functions exposing additional object properties.
 /// @{
 /// @file nwnx_object.nss
-#include "nwnx"
 
 const string NWNX_Object = "NWNX_Object"; ///< @private
 
@@ -437,641 +436,475 @@ void NWNX_Object_SetLocalizedName(object oObject, string sName, int nLanguage, i
 
 int NWNX_Object_GetLocalVariableCount(object obj)
 {
-    string sFunc = "GetLocalVariableCount";
-
-    NWNX_PushArgumentObject(obj);
-    NWNX_CallFunction(NWNX_Object, sFunc);
-
-    return NWNX_GetReturnValueInt();
+    NWNXPushObject(obj);
+    NWNXCall(NWNX_Object, "GetLocalVariableCount");
+    return NWNXPopInt();
 }
 
 struct NWNX_Object_LocalVariable NWNX_Object_GetLocalVariable(object obj, int index)
 {
-    string sFunc = "GetLocalVariable";
-
-    NWNX_PushArgumentInt(index);
-    NWNX_PushArgumentObject(obj);
-    NWNX_CallFunction(NWNX_Object, sFunc);
-
+    NWNXPushInt(index);
+    NWNXPushObject(obj);
+    NWNXCall(NWNX_Object, "GetLocalVariable");
     struct NWNX_Object_LocalVariable var;
-    var.key  = NWNX_GetReturnValueString();
-    var.type = NWNX_GetReturnValueInt();
+    var.key  = NWNXPopString();
+    var.type = NWNXPopInt();
     return var;
 }
 
 void NWNX_Object_SetPosition(object oObject, vector vPosition, int bUpdateSubareas = TRUE)
 {
-    string sFunc = "SetPosition";
-
-    NWNX_PushArgumentInt(bUpdateSubareas);
-    NWNX_PushArgumentFloat(vPosition.x);
-    NWNX_PushArgumentFloat(vPosition.y);
-    NWNX_PushArgumentFloat(vPosition.z);
-    NWNX_PushArgumentObject(oObject);
-
-    NWNX_CallFunction(NWNX_Object, sFunc);
+    NWNXPushInt(bUpdateSubareas);
+    NWNXPushVector(vPosition);
+    NWNXPushObject(oObject);
+    NWNXCall(NWNX_Object, "SetPosition");
 }
 
 int NWNX_Object_GetCurrentHitPoints(object creature)
 {
-    string sFunc = "GetCurrentHitPoints";
-
-    NWNX_PushArgumentObject(creature);
-    NWNX_CallFunction(NWNX_Object, sFunc);
-
-    return NWNX_GetReturnValueInt();
+    NWNXPushObject(creature);
+    NWNXCall(NWNX_Object, "GetCurrentHitPoints");
+    return NWNXPopInt();
 }
 
 void NWNX_Object_SetCurrentHitPoints(object creature, int hp)
 {
-    string sFunc = "SetCurrentHitPoints";
-
-    NWNX_PushArgumentInt(hp);
-    NWNX_PushArgumentObject(creature);
-
-    NWNX_CallFunction(NWNX_Object, sFunc);
+    NWNXPushInt(hp);
+    NWNXPushObject(creature);
+    NWNXCall(NWNX_Object, "SetCurrentHitPoints");
 }
 
 void NWNX_Object_SetMaxHitPoints(object creature, int hp)
 {
-    string sFunc = "SetMaxHitPoints";
-
-    NWNX_PushArgumentInt(hp);
-    NWNX_PushArgumentObject(creature);
-
-    NWNX_CallFunction(NWNX_Object, sFunc);
+    NWNXPushInt(hp);
+    NWNXPushObject(creature);
+    NWNXCall(NWNX_Object, "SetMaxHitPoints");
 }
 
 string NWNX_Object_Serialize(object obj)
 {
-    string sFunc = "Serialize";
-
-    NWNX_PushArgumentObject(obj);
-
-    NWNX_CallFunction(NWNX_Object, sFunc);
-    return NWNX_GetReturnValueString();
+    NWNXPushObject(obj);
+    NWNXCall(NWNX_Object, "Serialize");
+    return NWNXPopString();
 }
 
 object NWNX_Object_Deserialize(string serialized)
 {
-    string sFunc = "Deserialize";
-
-    NWNX_PushArgumentString(serialized);
-
-    NWNX_CallFunction(NWNX_Object, sFunc);
-    return NWNX_GetReturnValueObject();
+    NWNXPushString(serialized);
+    NWNXCall(NWNX_Object, "Deserialize");
+    return NWNXPopObject();
 }
 
 string NWNX_Object_GetDialogResref(object obj)
 {
-    string sFunc = "GetDialogResref";
-
-    NWNX_PushArgumentObject(obj);
-
-    NWNX_CallFunction(NWNX_Object, sFunc);
-    return NWNX_GetReturnValueString();
+    NWNXPushObject(obj);
+    NWNXCall(NWNX_Object, "GetDialogResref");
+    return NWNXPopString();
 }
 
 void NWNX_Object_SetDialogResref(object obj, string dialog)
 {
-    string sFunc = "SetDialogResref";
-
-    NWNX_PushArgumentString(dialog);
-    NWNX_PushArgumentObject(obj);
-
-    NWNX_CallFunction(NWNX_Object, sFunc);
+    NWNXPushString(dialog);
+    NWNXPushObject(obj);
+    NWNXCall(NWNX_Object, "SetDialogResref");
 }
 
 void NWNX_Object_SetAppearance(object oPlaceable, int nAppearance)
 {
-    string sFunc = "SetAppearance";
-
-    NWNX_PushArgumentInt(nAppearance);
-    NWNX_PushArgumentObject(oPlaceable);
-
-    NWNX_CallFunction(NWNX_Object, sFunc);
+    NWNXPushInt(nAppearance);
+    NWNXPushObject(oPlaceable);
+    NWNXCall(NWNX_Object, "SetAppearance");
 }
 
 int NWNX_Object_GetAppearance(object oPlaceable)
 {
-    string sFunc = "GetAppearance";
-
-    NWNX_PushArgumentObject(oPlaceable);
-    NWNX_CallFunction(NWNX_Object, sFunc);
-
-    return NWNX_GetReturnValueInt();
+    NWNXPushObject(oPlaceable);
+    NWNXCall(NWNX_Object, "GetAppearance");
+    return NWNXPopInt();
 }
 
 int NWNX_Object_GetHasVisualEffect(object obj, int nVFX)
 {
-    string sFunc = "GetHasVisualEffect";
-
-    NWNX_PushArgumentInt(nVFX);
-    NWNX_PushArgumentObject(obj);
-
-    NWNX_CallFunction(NWNX_Object, sFunc);
-
-    return NWNX_GetReturnValueInt();
+    NWNXPushInt(nVFX);
+    NWNXPushObject(obj);
+    NWNXCall(NWNX_Object, "GetHasVisualEffect");
+    return NWNXPopInt();
 }
 
 int NWNX_Object_GetDamageImmunity(object obj, int damageType)
 {
-    string sFunc = "GetDamageImmunity";
-
-    NWNX_PushArgumentInt(damageType);
-    NWNX_PushArgumentObject(obj);
-
-    NWNX_CallFunction(NWNX_Object, sFunc);
-
-    return NWNX_GetReturnValueInt();
+    NWNXPushInt(damageType);
+    NWNXPushObject(obj);
+    NWNXCall(NWNX_Object, "GetDamageImmunity");
+    return NWNXPopInt();
 }
 
 void NWNX_Object_AddToArea(object obj, object area, vector pos)
 {
-    string sFunc = "AddToArea";
-
-    NWNX_PushArgumentFloat(pos.z);
-    NWNX_PushArgumentFloat(pos.y);
-    NWNX_PushArgumentFloat(pos.x);
-    NWNX_PushArgumentObject(area);
-    NWNX_PushArgumentObject(obj);
-    NWNX_CallFunction(NWNX_Object, sFunc);
+    NWNXPushVector(pos);
+    NWNXPushObject(area);
+    NWNXPushObject(obj);
+    NWNXCall(NWNX_Object, "AddToArea");
 }
 
 int NWNX_Object_GetPlaceableIsStatic(object obj)
 {
-    string sFunc = "GetPlaceableIsStatic";
-
-    NWNX_PushArgumentObject(obj);
-
-    NWNX_CallFunction(NWNX_Object, sFunc);
-    return NWNX_GetReturnValueInt();
+    NWNXPushObject(obj);
+    NWNXCall(NWNX_Object, "GetPlaceableIsStatic");
+    return NWNXPopInt();
 }
 
 void NWNX_Object_SetPlaceableIsStatic(object obj, int isStatic)
 {
-    string sFunc = "SetPlaceableIsStatic";
-
-    NWNX_PushArgumentInt(isStatic);
-    NWNX_PushArgumentObject(obj);
-
-    NWNX_CallFunction(NWNX_Object, sFunc);
+    NWNXPushInt(isStatic);
+    NWNXPushObject(obj);
+    NWNXCall(NWNX_Object, "SetPlaceableIsStatic");
 }
 
 int NWNX_Object_GetAutoRemoveKey(object obj)
 {
-    string sFunc = "GetAutoRemoveKey";
-
-    NWNX_PushArgumentObject(obj);
-    NWNX_CallFunction(NWNX_Object, sFunc);
-
-    return NWNX_GetReturnValueInt();
+    NWNXPushObject(obj);
+    NWNXCall(NWNX_Object, "GetAutoRemoveKey");
+    return NWNXPopInt();
 }
 
 void NWNX_Object_SetAutoRemoveKey(object obj, int bRemoveKey)
 {
-    string sFunc = "SetAutoRemoveKey";
-
-    NWNX_PushArgumentInt(bRemoveKey);
-    NWNX_PushArgumentObject(obj);
-
-    NWNX_CallFunction(NWNX_Object, sFunc);
+    NWNXPushInt(bRemoveKey);
+    NWNXPushObject(obj);
+    NWNXCall(NWNX_Object, "SetAutoRemoveKey");
 }
 
 string NWNX_Object_GetTriggerGeometry(object oTrigger)
 {
-    string sFunc = "GetTriggerGeometry";
-
-    NWNX_PushArgumentObject(oTrigger);
-    NWNX_CallFunction(NWNX_Object, sFunc);
-
-    return NWNX_GetReturnValueString();
+    NWNXPushObject(oTrigger);
+    NWNXCall(NWNX_Object, "GetTriggerGeometry");
+    return NWNXPopString();
 }
 
 void NWNX_Object_SetTriggerGeometry(object oTrigger, string sGeometry)
 {
-    string sFunc = "SetTriggerGeometry";
-
-    NWNX_PushArgumentString(sGeometry);
-    NWNX_PushArgumentObject(oTrigger);
-    NWNX_CallFunction(NWNX_Object, sFunc);
+    NWNXPushString(sGeometry);
+    NWNXPushObject(oTrigger);
+    NWNXCall(NWNX_Object, "SetTriggerGeometry");
 }
 
 void NWNX_Object_Export(object oObject, string sFileName, string sAlias = "NWNX")
 {
-    string sFunc = "Export";
-
-    NWNX_PushArgumentString(sAlias);
-    NWNX_PushArgumentString(sFileName);
-    NWNX_PushArgumentObject(oObject);
-    NWNX_CallFunction(NWNX_Object, sFunc);
+    NWNXPushString(sAlias);
+    NWNXPushString(sFileName);
+    NWNXPushObject(oObject);
+    NWNXCall(NWNX_Object, "Export");
 }
 
 int NWNX_Object_GetInt(object oObject, string sVarName)
 {
-    string sFunc = "GetInt";
-
-    NWNX_PushArgumentString(sVarName);
-    NWNX_PushArgumentObject(oObject);
-    NWNX_CallFunction(NWNX_Object, sFunc);
-
-    return NWNX_GetReturnValueInt();
+    NWNXPushString(sVarName);
+    NWNXPushObject(oObject);
+    NWNXCall(NWNX_Object, "GetInt");
+    return NWNXPopInt();
 }
 
 void NWNX_Object_SetInt(object oObject, string sVarName, int nValue, int bPersist)
 {
-    string sFunc = "SetInt";
-
-    NWNX_PushArgumentInt(bPersist);
-    NWNX_PushArgumentInt(nValue);
-    NWNX_PushArgumentString(sVarName);
-    NWNX_PushArgumentObject(oObject);
-    NWNX_CallFunction(NWNX_Object, sFunc);
+    NWNXPushInt(bPersist);
+    NWNXPushInt(nValue);
+    NWNXPushString(sVarName);
+    NWNXPushObject(oObject);
+    NWNXCall(NWNX_Object, "SetInt");
 }
 
 void NWNX_Object_DeleteInt(object oObject, string sVarName)
 {
-    string sFunc = "DeleteInt";
-
-    NWNX_PushArgumentString(sVarName);
-    NWNX_PushArgumentObject(oObject);
-    NWNX_CallFunction(NWNX_Object, sFunc);
+    NWNXPushString(sVarName);
+    NWNXPushObject(oObject);
+    NWNXCall(NWNX_Object, "DeleteInt");
 }
 
 string NWNX_Object_GetString(object oObject, string sVarName)
 {
-    string sFunc = "GetString";
-
-    NWNX_PushArgumentString(sVarName);
-    NWNX_PushArgumentObject(oObject);
-    NWNX_CallFunction(NWNX_Object, sFunc);
-
-    return NWNX_GetReturnValueString();
+    NWNXPushString(sVarName);
+    NWNXPushObject(oObject);
+    NWNXCall(NWNX_Object, "GetString");
+    return NWNXPopString();
 }
 
 void NWNX_Object_SetString(object oObject, string sVarName, string sValue, int bPersist)
 {
-    string sFunc = "SetString";
-
-    NWNX_PushArgumentInt(bPersist);
-    NWNX_PushArgumentString(sValue);
-    NWNX_PushArgumentString(sVarName);
-    NWNX_PushArgumentObject(oObject);
-    NWNX_CallFunction(NWNX_Object, sFunc);
+    NWNXPushInt(bPersist);
+    NWNXPushString(sValue);
+    NWNXPushString(sVarName);
+    NWNXPushObject(oObject);
+    NWNXCall(NWNX_Object, "SetString");
 }
 
 void NWNX_Object_DeleteString(object oObject, string sVarName)
 {
-    string sFunc = "DeleteString";
-
-    NWNX_PushArgumentString(sVarName);
-    NWNX_PushArgumentObject(oObject);
-    NWNX_CallFunction(NWNX_Object, sFunc);
+    NWNXPushString(sVarName);
+    NWNXPushObject(oObject);
+    NWNXCall(NWNX_Object, "DeleteString");
 }
 
 float NWNX_Object_GetFloat(object oObject, string sVarName)
 {
-    string sFunc = "GetFloat";
-
-    NWNX_PushArgumentString(sVarName);
-    NWNX_PushArgumentObject(oObject);
-    NWNX_CallFunction(NWNX_Object, sFunc);
-
-    return NWNX_GetReturnValueFloat();
+    NWNXPushString(sVarName);
+    NWNXPushObject(oObject);
+    NWNXCall(NWNX_Object, "GetFloat");
+    return NWNXPopFloat();
 }
 
 void NWNX_Object_SetFloat(object oObject, string sVarName, float fValue, int bPersist)
 {
-    string sFunc = "SetFloat";
-
-    NWNX_PushArgumentInt(bPersist);
-    NWNX_PushArgumentFloat(fValue);
-    NWNX_PushArgumentString(sVarName);
-    NWNX_PushArgumentObject(oObject);
-    NWNX_CallFunction(NWNX_Object, sFunc);
+    NWNXPushInt(bPersist);
+    NWNXPushFloat(fValue);
+    NWNXPushString(sVarName);
+    NWNXPushObject(oObject);
+    NWNXCall(NWNX_Object, "SetFloat");
 }
 
 void NWNX_Object_DeleteFloat(object oObject, string sVarName)
 {
-    string sFunc = "DeleteFloat";
-
-    NWNX_PushArgumentString(sVarName);
-    NWNX_PushArgumentObject(oObject);
-    NWNX_CallFunction(NWNX_Object, sFunc);
+    NWNXPushString(sVarName);
+    NWNXPushObject(oObject);
+    NWNXCall(NWNX_Object, "DeleteFloat");
 }
 
 void NWNX_Object_DeleteVarRegex(object oObject, string sRegex)
 {
-    string sFunc = "DeleteVarRegex";
-
-    NWNX_PushArgumentString(sRegex);
-    NWNX_PushArgumentObject(oObject);
-    NWNX_CallFunction(NWNX_Object, sFunc);
+    NWNXPushString(sRegex);
+    NWNXPushObject(oObject);
+    NWNXCall(NWNX_Object, "DeleteVarRegex");
 }
 
 int NWNX_Object_GetPositionIsInTrigger(object oTrigger, vector vPosition)
 {
-    string sFunc = "GetPositionIsInTrigger";
-
-    NWNX_PushArgumentFloat(vPosition.z);
-    NWNX_PushArgumentFloat(vPosition.y);
-    NWNX_PushArgumentFloat(vPosition.x);
-    NWNX_PushArgumentObject(oTrigger);
-    NWNX_CallFunction(NWNX_Object, sFunc);
-
-    return NWNX_GetReturnValueInt();
+    NWNXPushVector(vPosition);
+    NWNXPushObject(oTrigger);
+    NWNXCall(NWNX_Object, "GetPositionIsInTrigger");
+    return NWNXPopInt();
 }
 
 int NWNX_Object_GetInternalObjectType(object oObject)
 {
-    string sFunc = "GetInternalObjectType";
-
-    NWNX_PushArgumentObject(oObject);
-    NWNX_CallFunction(NWNX_Object, sFunc);
-
-    return NWNX_GetReturnValueInt();
+    NWNXPushObject(oObject);
+    NWNXCall(NWNX_Object, "GetInternalObjectType");
+    return NWNXPopInt();
 }
 
 int NWNX_Object_AcquireItem(object oObject, object oItem)
 {
-    string sFunc = "AcquireItem";
-
-    NWNX_PushArgumentObject(oItem);
-    NWNX_PushArgumentObject(oObject);
-    NWNX_CallFunction(NWNX_Object, sFunc);
-
-    return NWNX_GetReturnValueInt();
+    NWNXPushObject(oItem);
+    NWNXPushObject(oObject);
+    NWNXCall(NWNX_Object, "AcquireItem");
+    return NWNXPopInt();
 }
 
 void NWNX_Object_ClearSpellEffectsOnOthers(object oObject)
 {
-    string sFunc = "ClearSpellEffectsOnOthers";
-
-    NWNX_PushArgumentObject(oObject);
-    NWNX_CallFunction(NWNX_Object, sFunc);
+    NWNXPushObject(oObject);
+    NWNXCall(NWNX_Object, "ClearSpellEffectsOnOthers");
 }
 
 string NWNX_Object_PeekUUID(object oObject)
 {
-    string sFunc = "PeekUUID";
-
-    NWNX_PushArgumentObject(oObject);
-    NWNX_CallFunction(NWNX_Object, sFunc);
-
-    return NWNX_GetReturnValueString();
+    NWNXPushObject(oObject);
+    NWNXCall(NWNX_Object, "PeekUUID");
+    return NWNXPopString();
 }
 
 int NWNX_Object_GetDoorHasVisibleModel(object oDoor)
 {
-    string sFunc = "GetDoorHasVisibleModel";
-
-    NWNX_PushArgumentObject(oDoor);
-    NWNX_CallFunction(NWNX_Object, sFunc);
-
-    return NWNX_GetReturnValueInt();
+    NWNXPushObject(oDoor);
+    NWNXCall(NWNX_Object, "GetDoorHasVisibleModel");
+    return NWNXPopInt();
 }
 
 int NWNX_Object_GetIsDestroyable(object oObject)
 {
-    string sFunc = "GetIsDestroyable";
-
-    NWNX_PushArgumentObject(oObject);
-    NWNX_CallFunction(NWNX_Object, sFunc);
-
-    return NWNX_GetReturnValueInt();
+    NWNXPushObject(oObject);
+    NWNXCall(NWNX_Object, "GetIsDestroyable");
+    return NWNXPopInt();
 }
 
 int NWNX_Object_DoSpellImmunity(object oDefender, object oCaster, int nSpellId=-1)
 {
-    string sFunc = "DoSpellImmunity";
-    NWNX_PushArgumentInt(nSpellId);
-    NWNX_PushArgumentObject(oCaster);
-    NWNX_PushArgumentObject(oDefender);
-    NWNX_CallFunction(NWNX_Object, sFunc);
-
-    return  NWNX_GetReturnValueInt();
+    NWNXPushInt(nSpellId);
+    NWNXPushObject(oCaster);
+    NWNXPushObject(oDefender);
+    NWNXCall(NWNX_Object, "DoSpellImmunity");
+    return  NWNXPopInt();
 }
 
 int NWNX_Object_DoSpellLevelAbsorption(object oDefender, object oCaster, int nSpellId=-1, int nSpellLevel=-1, int nSpellSchool=-1)
 {
-    string sFunc = "DoSpellLevelAbsorption";
-    NWNX_PushArgumentInt(nSpellSchool);
-    NWNX_PushArgumentInt(nSpellLevel);
-    NWNX_PushArgumentInt(nSpellId);
-    NWNX_PushArgumentObject(oCaster);
-    NWNX_PushArgumentObject(oDefender);
-    NWNX_CallFunction(NWNX_Object, sFunc);
-
-    return  NWNX_GetReturnValueInt();
+    NWNXPushInt(nSpellSchool);
+    NWNXPushInt(nSpellLevel);
+    NWNXPushInt(nSpellId);
+    NWNXPushObject(oCaster);
+    NWNXPushObject(oDefender);
+    NWNXCall(NWNX_Object, "DoSpellLevelAbsorption");
+    return  NWNXPopInt();
 }
 
 void NWNX_Object_SetHasInventory(object obj, int bHasInventory)
 {
-    string sFunc = "SetHasInventory";
-
-    NWNX_PushArgumentInt(bHasInventory);
-    NWNX_PushArgumentObject(obj);
-
-    NWNX_CallFunction(NWNX_Object, sFunc);
+    NWNXPushInt(bHasInventory);
+    NWNXPushObject(obj);
+    NWNXCall(NWNX_Object, "SetHasInventory");
 }
 
 int NWNX_Object_GetCurrentAnimation(object oObject)
 {
-    string sFunc = "GetCurrentAnimation";
-
-    NWNX_PushArgumentObject(oObject);
-    NWNX_CallFunction(NWNX_Object, sFunc);
-
-    return NWNX_GetReturnValueInt();
+    NWNXPushObject(oObject);
+    NWNXCall(NWNX_Object, "GetCurrentAnimation");
+    return NWNXPopInt();
 }
 
 int NWNX_Object_GetAILevel(object oObject)
 {
-    string sFunc = "GetAILevel";
-
-    NWNX_PushArgumentObject(oObject);
-    NWNX_CallFunction(NWNX_Object, sFunc);
-
-    return NWNX_GetReturnValueInt();
+    NWNXPushObject(oObject);
+    NWNXCall(NWNX_Object, "GetAILevel");
+    return NWNXPopInt();
 }
 
 void NWNX_Object_SetAILevel(object oObject, int nLevel)
 {
-    string sFunc = "SetAILevel";
-
-    NWNX_PushArgumentInt(nLevel);
-    NWNX_PushArgumentObject(oObject);
-
-    NWNX_CallFunction(NWNX_Object, sFunc);
+    NWNXPushInt(nLevel);
+    NWNXPushObject(oObject);
+    NWNXCall(NWNX_Object, "SetAILevel");
 }
 
 string NWNX_Object_GetMapNote(object oObject, int nID = 0, int nGender = 0)
 {
-    string sFunc = "GetMapNote";
-
-    NWNX_PushArgumentInt(nGender);
-    NWNX_PushArgumentInt(nID);
-    NWNX_PushArgumentObject(oObject);
-    NWNX_CallFunction(NWNX_Object, sFunc);
-
-    return NWNX_GetReturnValueString();
+    NWNXPushInt(nGender);
+    NWNXPushInt(nID);
+    NWNXPushObject(oObject);
+    NWNXCall(NWNX_Object, "GetMapNote");
+    return NWNXPopString();
 }
 
 void NWNX_Object_SetMapNote(object oObject, string sMapNote, int nID = 0, int nGender = 0)
 {
-    string sFunc = "SetMapNote";
-
-    NWNX_PushArgumentInt(nGender);
-    NWNX_PushArgumentInt(nID);
-    NWNX_PushArgumentString(sMapNote);
-    NWNX_PushArgumentObject(oObject);
-    NWNX_CallFunction(NWNX_Object, sFunc);
+    NWNXPushInt(nGender);
+    NWNXPushInt(nID);
+    NWNXPushString(sMapNote);
+    NWNXPushObject(oObject);
+    NWNXCall(NWNX_Object, "SetMapNote");
 }
 
 int NWNX_Object_GetLastSpellCastFeat(object oObject)
 {
-    string sFunc = "GetLastSpellCastFeat";
-
-    NWNX_PushArgumentObject(oObject);
-    NWNX_CallFunction(NWNX_Object, sFunc);
-
-    return NWNX_GetReturnValueInt();
+    NWNXPushObject(oObject);
+    NWNXCall(NWNX_Object, "GetLastSpellCastFeat");
+    return NWNXPopInt();
 }
 
 void NWNX_Object_SetLastTriggered(object oObject, object oLast)
 {
-    string sFunc = "SetLastTriggered";
-
-    NWNX_PushArgumentObject(oLast);
-    NWNX_PushArgumentObject(oObject);
-
-    NWNX_CallFunction(NWNX_Object, sFunc);
+    NWNXPushObject(oLast);
+    NWNXPushObject(oObject);
+    NWNXCall(NWNX_Object, "SetLastTriggered");
 }
 
 float NWNX_Object_GetAoEObjectDurationRemaining(object oAoE)
 {
-    string sFunc = "GetAoEObjectDurationRemaining";
-
-    NWNX_PushArgumentObject(oAoE);
-    NWNX_CallFunction(NWNX_Object, sFunc);
-
-    return NWNX_GetReturnValueFloat();
+    NWNXPushObject(oAoE);
+    NWNXCall(NWNX_Object, "GetAoEObjectDurationRemaining");
+    return NWNXPopFloat();
 }
 
 void NWNX_Object_SetConversationPrivate(object oObject, int bPrivate)
 {
-    string sFunc = "SetConversationPrivate";
-
-    NWNX_PushArgumentInt(bPrivate);
-    NWNX_PushArgumentObject(oObject);
-
-    NWNX_CallFunction(NWNX_Object, sFunc);
+    NWNXPushInt(bPrivate);
+    NWNXPushObject(oObject);
+    NWNXCall(NWNX_Object, "SetConversationPrivate");
 }
 
 void NWNX_Object_SetAoEObjectRadius(object oAoE, float fRadius)
 {
-    string sFunc = "SetAoEObjectRadius";
-
-    NWNX_PushArgumentFloat(fRadius);
-    NWNX_PushArgumentObject(oAoE);
-    NWNX_CallFunction(NWNX_Object, sFunc);
+    NWNXPushFloat(fRadius);
+    NWNXPushObject(oAoE);
+    NWNXCall(NWNX_Object, "SetAoEObjectRadius");
 }
 
 float NWNX_Object_GetAoEObjectRadius(object oAoE)
 {
-    string sFunc = "GetAoEObjectRadius";
-
-    NWNX_PushArgumentObject(oAoE);
-    NWNX_CallFunction(NWNX_Object, sFunc);
-
-    return NWNX_GetReturnValueFloat();
+    NWNXPushObject(oAoE);
+    NWNXCall(NWNX_Object, "GetAoEObjectRadius");
+    return NWNXPopFloat();
 }
 
 int NWNX_Object_GetLastSpellCastSpontaneous(object oObject)
 {
-    string sFunc = "GetLastSpellCastSpontaneous";
-
-    NWNX_PushArgumentObject(oObject);
-    NWNX_CallFunction(NWNX_Object, sFunc);
-
-    return NWNX_GetReturnValueInt();
+    NWNXPushObject(oObject);
+    NWNXCall(NWNX_Object, "GetLastSpellCastSpontaneous");
+    return NWNXPopInt();
 }
 
 int NWNX_Object_GetLastSpellCastDomainLevel(object oObject)
 {
-    string sFunc = "GetLastSpellCastDomainLevel";
-
-    NWNX_PushArgumentObject(oObject);
-    NWNX_CallFunction(NWNX_Object, sFunc);
-
-    return NWNX_GetReturnValueInt();
+    NWNXPushObject(oObject);
+    NWNXCall(NWNX_Object, "GetLastSpellCastDomainLevel");
+    return NWNXPopInt();
 }
 
 void NWNX_Object_ForceAssignUUID(object oObject, string sUUID)
 {
-    string sFunc = "ForceAssignUUID";
-
-    NWNX_PushArgumentString(sUUID);
-    NWNX_PushArgumentObject(oObject);
-    NWNX_CallFunction(NWNX_Object, sFunc);
+    NWNXPushString(sUUID);
+    NWNXPushObject(oObject);
+    NWNXCall(NWNX_Object, "ForceAssignUUID");
 }
 
 int NWNX_Object_GetInventoryItemCount(object oObject)
 {
-    string sFunc = "GetInventoryItemCount";
-
-    NWNX_PushArgumentObject(oObject);
-    NWNX_CallFunction(NWNX_Object, sFunc);
-    return NWNX_GetReturnValueInt();
+    NWNXPushObject(oObject);
+    NWNXCall(NWNX_Object, "GetInventoryItemCount");
+    return NWNXPopInt();
 }
 
 void NWNX_Object_OverrideSpellProjectileVFX(object oCreature, int nProjectileType = -1, int nProjectilePathType = -1, int nSpellID = -1, int bPersist = FALSE)
 {
-    string sFunc = "OverrideSpellProjectileVFX";
-
-    NWNX_PushArgumentInt(bPersist);
-    NWNX_PushArgumentInt(nSpellID);
-    NWNX_PushArgumentInt(nProjectilePathType);
-    NWNX_PushArgumentInt(nProjectileType);
-    NWNX_PushArgumentObject(oCreature);
-    NWNX_CallFunction(NWNX_Object, sFunc);
+    NWNXPushInt(bPersist);
+    NWNXPushInt(nSpellID);
+    NWNXPushInt(nProjectilePathType);
+    NWNXPushInt(nProjectileType);
+    NWNXPushObject(oCreature);
+    NWNXCall(NWNX_Object, "OverrideSpellProjectileVFX");
 }
 
 int NWNX_Object_GetLastSpellInstant()
 {
-    string sFunc = "GetLastSpellInstant";
-    NWNX_CallFunction(NWNX_Object, sFunc);
-    return NWNX_GetReturnValueInt();
+    NWNXCall(NWNX_Object, "GetLastSpellInstant");
+    return NWNXPopInt();
 }
 
 void NWNX_Object_SetTrapCreator(object oObject, object oCreator)
 {
-    string sFunc = "SetTrapCreator";
-    NWNX_PushArgumentObject(oCreator);
-    NWNX_PushArgumentObject(oObject);
-    NWNX_CallFunction(NWNX_Object, sFunc);
+    NWNXPushObject(oCreator);
+    NWNXPushObject(oObject);
+    NWNXCall(NWNX_Object, "SetTrapCreator");
 }
 
 string NWNX_Object_GetLocalizedName(object oObject, int nLanguage, int nGender = 0)
 {
     string sFunc = "GetLocalizedName";
 
-    NWNX_PushArgumentInt(nGender);
-    NWNX_PushArgumentInt(nLanguage);
-    NWNX_PushArgumentObject(oObject);
+    NWNXPushInt(nGender);
+    NWNXPushInt(nLanguage);
+    NWNXPushObject(oObject);
 
-    NWNX_CallFunction(NWNX_Object, sFunc);
-    return NWNX_GetReturnValueString();
+    NWNXCall(NWNX_Object, sFunc);
+    return NWNXPopString();
 }
 
 void NWNX_Object_SetLocalizedName(object oObject, string sName, int nLanguage, int nGender = 0)
 {
     string sFunc = "SetLocalizedName";
 
-    NWNX_PushArgumentInt(nGender);
-    NWNX_PushArgumentInt(nLanguage);
-    NWNX_PushArgumentString(sName);
-    NWNX_PushArgumentObject(oObject);
+    NWNXPushInt(nGender);
+    NWNXPushInt(nLanguage);
+    NWNXPushString(sName);
+    NWNXPushObject(oObject);
 
-    NWNX_CallFunction(NWNX_Object, sFunc);
+    NWNXCall(NWNX_Object, sFunc);
 }

_module/nss/nwnx_player.nss

@@ -2,7 +2,6 @@
 /// @brief Functions exposing additional player properties.
 /// @{
 /// @file nwnx_player.nss
-#include "nwnx"
 
 const string NWNX_Player = "NWNX_Player"; ///< @private
 
@@ -458,22 +457,16 @@ void NWNX_Player_ReloadColorPalettes(object oPlayer);
 
 void NWNX_Player_ForcePlaceableExamineWindow(object player, object placeable)
 {
-    string sFunc = "ForcePlaceableExamineWindow";
-
-    NWNX_PushArgumentObject(placeable);
-    NWNX_PushArgumentObject(player);
-
-    NWNX_CallFunction(NWNX_Player, sFunc);
+    NWNXPushObject(placeable);
+    NWNXPushObject(player);
+    NWNXCall(NWNX_Player, "ForcePlaceableExamineWindow");
 }
 
 void NWNX_Player_ForcePlaceableInventoryWindow(object player, object placeable)
 {
-    string sFunc = "ForcePlaceableInventoryWindow";
-
-    NWNX_PushArgumentObject(placeable);
-    NWNX_PushArgumentObject(player);
-
-    NWNX_CallFunction(NWNX_Player, sFunc);
+    NWNXPushObject(placeable);
+    NWNXPushObject(player);
+    NWNXCall(NWNX_Player, "ForcePlaceableInventoryWindow");
 }
 
 void NWNX_Player_INTERNAL_StopGuiTimingBar(object player, string script = "", int id = -1) ///< @private
@@ -482,17 +475,12 @@ void NWNX_Player_INTERNAL_StopGuiTimingBar(object player, string script = "", in
     // Either the timing event was never started, or it already finished.
     if (activeId == 0)
         return;
-
     // If id != -1, we ended up here through DelayCommand. Make sure it's for the right ID
     if (id != -1 && id != activeId)
         return;
-
     DeleteLocalInt(player, "NWNX_PLAYER_GUI_TIMING_ACTIVE");
-
-    string sFunc = "StopGuiTimingBar";
-    NWNX_PushArgumentObject(player);
-    NWNX_CallFunction(NWNX_Player, sFunc);
-
+    NWNXPushObject(player);
+    NWNXCall(NWNX_Player, "StopGuiTimingBar");
     if(script != "")
     {
         ExecuteScript(script, player);
@@ -503,18 +491,13 @@ void NWNX_Player_StartGuiTimingBar(object player, float seconds, string script =
 {
     if (GetLocalInt(player, "NWNX_PLAYER_GUI_TIMING_ACTIVE"))
         return;
-
-    string sFunc = "StartGuiTimingBar";
-    NWNX_PushArgumentInt(type);
-    NWNX_PushArgumentFloat(seconds);
-    NWNX_PushArgumentObject(player);
-
-    NWNX_CallFunction(NWNX_Player, sFunc);
-
+    NWNXPushInt(type);
+    NWNXPushFloat(seconds);
+    NWNXPushObject(player);
+    NWNXCall(NWNX_Player, "StartGuiTimingBar");
     int id = GetLocalInt(player, "NWNX_PLAYER_GUI_TIMING_ID") + 1;
     SetLocalInt(player, "NWNX_PLAYER_GUI_TIMING_ACTIVE", id);
     SetLocalInt(player, "NWNX_PLAYER_GUI_TIMING_ID", id);
-
     DelayCommand(seconds, NWNX_Player_INTERNAL_StopGuiTimingBar(player, script, id));
 }
 
@@ -525,638 +508,471 @@ void NWNX_Player_StopGuiTimingBar(object player, string script = "")
 
 void NWNX_Player_SetAlwaysWalk(object player, int bWalk=TRUE)
 {
-    string sFunc = "SetAlwaysWalk";
-
-    NWNX_PushArgumentInt(bWalk);
-    NWNX_PushArgumentObject(player);
-
-    NWNX_CallFunction(NWNX_Player, sFunc);
+    NWNXPushInt(bWalk);
+    NWNXPushObject(player);
+    NWNXCall(NWNX_Player, "SetAlwaysWalk");
 }
 
 struct NWNX_Player_QuickBarSlot NWNX_Player_GetQuickBarSlot(object player, int slot)
 {
-    string sFunc = "GetQuickBarSlot";
     struct NWNX_Player_QuickBarSlot qbs;
-
-    NWNX_PushArgumentInt(slot);
-    NWNX_PushArgumentObject(player);
-    NWNX_CallFunction(NWNX_Player, sFunc);
-
-    qbs.oAssociate     = NWNX_GetReturnValueObject();
-    qbs.nAssociateType = NWNX_GetReturnValueInt();
-    qbs.nDomainLevel   = NWNX_GetReturnValueInt();
-    qbs.nMetaType      = NWNX_GetReturnValueInt();
-    qbs.nINTParam1     = NWNX_GetReturnValueInt();
-    qbs.sToolTip       = NWNX_GetReturnValueString();
-    qbs.sCommandLine   = NWNX_GetReturnValueString();
-    qbs.sCommandLabel  = NWNX_GetReturnValueString();
-    qbs.sResRef        = NWNX_GetReturnValueString();
-    qbs.nMultiClass    = NWNX_GetReturnValueInt();
-    qbs.nObjectType    = NWNX_GetReturnValueInt();
-    qbs.oSecondaryItem = NWNX_GetReturnValueObject();
-    qbs.oItem          = NWNX_GetReturnValueObject();
-
+    NWNXPushInt(slot);
+    NWNXPushObject(player);
+    NWNXCall(NWNX_Player, "GetQuickBarSlot");
+    qbs.oAssociate     = NWNXPopObject();
+    qbs.nAssociateType = NWNXPopInt();
+    qbs.nDomainLevel   = NWNXPopInt();
+    qbs.nMetaType      = NWNXPopInt();
+    qbs.nINTParam1     = NWNXPopInt();
+    qbs.sToolTip       = NWNXPopString();
+    qbs.sCommandLine   = NWNXPopString();
+    qbs.sCommandLabel  = NWNXPopString();
+    qbs.sResRef        = NWNXPopString();
+    qbs.nMultiClass    = NWNXPopInt();
+    qbs.nObjectType    = NWNXPopInt();
+    qbs.oSecondaryItem = NWNXPopObject();
+    qbs.oItem          = NWNXPopObject();
     return qbs;
 }
 
 void NWNX_Player_SetQuickBarSlot(object player, int slot, struct NWNX_Player_QuickBarSlot qbs)
 {
-    string sFunc = "SetQuickBarSlot";
-
-    NWNX_PushArgumentObject(qbs.oItem);
-    NWNX_PushArgumentObject(qbs.oSecondaryItem);
-    NWNX_PushArgumentInt(qbs.nObjectType);
-    NWNX_PushArgumentInt(qbs.nMultiClass);
-    NWNX_PushArgumentString(qbs.sResRef);
-    NWNX_PushArgumentString(qbs.sCommandLabel);
-    NWNX_PushArgumentString(qbs.sCommandLine);
-    NWNX_PushArgumentString(qbs.sToolTip);
-    NWNX_PushArgumentInt(qbs.nINTParam1);
-    NWNX_PushArgumentInt(qbs.nMetaType);
-    NWNX_PushArgumentInt(qbs.nDomainLevel);
-    NWNX_PushArgumentInt(qbs.nAssociateType);
-    NWNX_PushArgumentObject(qbs.oAssociate);
-
-    NWNX_PushArgumentInt(slot);
-    NWNX_PushArgumentObject(player);
-    NWNX_CallFunction(NWNX_Player, sFunc);
+    NWNXPushObject(qbs.oItem);
+    NWNXPushObject(qbs.oSecondaryItem);
+    NWNXPushInt(qbs.nObjectType);
+    NWNXPushInt(qbs.nMultiClass);
+    NWNXPushString(qbs.sResRef);
+    NWNXPushString(qbs.sCommandLabel);
+    NWNXPushString(qbs.sCommandLine);
+    NWNXPushString(qbs.sToolTip);
+    NWNXPushInt(qbs.nINTParam1);
+    NWNXPushInt(qbs.nMetaType);
+    NWNXPushInt(qbs.nDomainLevel);
+    NWNXPushInt(qbs.nAssociateType);
+    NWNXPushObject(qbs.oAssociate);
+    NWNXPushInt(slot);
+    NWNXPushObject(player);
+    NWNXCall(NWNX_Player, "SetQuickBarSlot");
 }
 
 string NWNX_Player_GetBicFileName(object player)
 {
-    string sFunc = "GetBicFileName";
-
-    NWNX_PushArgumentObject(player);
-    NWNX_CallFunction(NWNX_Player, sFunc);
-    return NWNX_GetReturnValueString();
+    NWNXPushObject(player);
+    NWNXCall(NWNX_Player, "GetBicFileName");
+    return NWNXPopString();
 }
 
 void NWNX_Player_ShowVisualEffect(object player, int effectId, vector position, float scale=1.0f, vector translate=[], vector rotate=[])
 {
-    string sFunc = "ShowVisualEffect";
-
-    NWNX_PushArgumentFloat(rotate.x);
-    NWNX_PushArgumentFloat(rotate.y);
-    NWNX_PushArgumentFloat(rotate.z);
-    NWNX_PushArgumentFloat(translate.x);
-    NWNX_PushArgumentFloat(translate.y);
-    NWNX_PushArgumentFloat(translate.z);
-    NWNX_PushArgumentFloat(scale);
-    NWNX_PushArgumentFloat(position.x);
-    NWNX_PushArgumentFloat(position.y);
-    NWNX_PushArgumentFloat(position.z);
-    NWNX_PushArgumentInt(effectId);
-    NWNX_PushArgumentObject(player);
-
-    NWNX_CallFunction(NWNX_Player, sFunc);
+    NWNXPushVector(rotate);
+    NWNXPushVector(translate);
+    NWNXPushFloat(scale);
+    NWNXPushVector(position);
+    NWNXPushInt(effectId);
+    NWNXPushObject(player);
+    NWNXCall(NWNX_Player, "ShowVisualEffect");
 }
 
 void NWNX_Player_MusicBackgroundChangeDay(object player, int track)
 {
-    string sFunc = "ChangeBackgroundMusic";
-
-    NWNX_PushArgumentInt(track);
-    NWNX_PushArgumentInt(TRUE);
-    NWNX_PushArgumentObject(player);
-
-    NWNX_CallFunction(NWNX_Player, sFunc);
+    NWNXPushInt(track);
+    NWNXPushInt(TRUE);
+    NWNXPushObject(player);
+    NWNXCall(NWNX_Player, "ChangeBackgroundMusic");
 }
 
 void NWNX_Player_MusicBackgroundChangeNight(object player, int track)
 {
-    string sFunc = "ChangeBackgroundMusic";
-
-    NWNX_PushArgumentInt(track);
-    NWNX_PushArgumentInt(FALSE);
-    NWNX_PushArgumentObject(player);
-
-    NWNX_CallFunction(NWNX_Player, sFunc);
+    NWNXPushInt(track);
+    NWNXPushInt(FALSE);
+    NWNXPushObject(player);
+    NWNXCall(NWNX_Player, "ChangeBackgroundMusic");
 }
 
 void NWNX_Player_MusicBackgroundStart(object player)
 {
-    string sFunc = "PlayBackgroundMusic";
-
-    NWNX_PushArgumentInt(TRUE);
-    NWNX_PushArgumentObject(player);
-
-    NWNX_CallFunction(NWNX_Player, sFunc);
+    NWNXPushInt(TRUE);
+    NWNXPushObject(player);
+    NWNXCall(NWNX_Player, "PlayBackgroundMusic");
 }
 
 void NWNX_Player_MusicBackgroundStop(object player)
 {
-    string sFunc = "PlayBackgroundMusic";
-
-    NWNX_PushArgumentInt(FALSE);
-    NWNX_PushArgumentObject(player);
-
-    NWNX_CallFunction(NWNX_Player, sFunc);
+    NWNXPushInt(FALSE);
+    NWNXPushObject(player);
+    NWNXCall(NWNX_Player, "PlayBackgroundMusic");
 }
 
 void NWNX_Player_MusicBattleChange(object player, int track)
 {
-    string sFunc = "ChangeBattleMusic";
-
-    NWNX_PushArgumentInt(track);
-    NWNX_PushArgumentObject(player);
-
-    NWNX_CallFunction(NWNX_Player, sFunc);
+    NWNXPushInt(track);
+    NWNXPushObject(player);
+    NWNXCall(NWNX_Player, "ChangeBattleMusic");
 }
 
 void NWNX_Player_MusicBattleStart(object player)
 {
-    string sFunc = "PlayBattleMusic";
-
-    NWNX_PushArgumentInt(TRUE);
-    NWNX_PushArgumentObject(player);
-
-    NWNX_CallFunction(NWNX_Player, sFunc);
+    NWNXPushInt(TRUE);
+    NWNXPushObject(player);
+    NWNXCall(NWNX_Player, "PlayBattleMusic");
 }
 
 void NWNX_Player_MusicBattleStop(object player)
 {
-    string sFunc = "PlayBattleMusic";
-
-    NWNX_PushArgumentInt(FALSE);
-    NWNX_PushArgumentObject(player);
-
-    NWNX_CallFunction(NWNX_Player, sFunc);
+    NWNXPushInt(FALSE);
+    NWNXPushObject(player);
+    NWNXCall(NWNX_Player, "PlayBattleMusic");
 }
 
 void NWNX_Player_PlaySound(object player, string sound, object target = OBJECT_INVALID)
 {
-    string sFunc = "PlaySound";
-
-    NWNX_PushArgumentObject(target);
-    NWNX_PushArgumentString(sound);
-    NWNX_PushArgumentObject(player);
-
-    NWNX_CallFunction(NWNX_Player, sFunc);
+    NWNXPushObject(target);
+    NWNXPushString(sound);
+    NWNXPushObject(player);
+    NWNXCall(NWNX_Player, "PlaySound");
 }
 
 void NWNX_Player_SetPlaceableUsable(object player, object placeable, int usable)
 {
-    string sFunc = "SetPlaceableUsable";
-
-    NWNX_PushArgumentInt(usable);
-    NWNX_PushArgumentObject(placeable);
-    NWNX_PushArgumentObject(player);
-
-    NWNX_CallFunction(NWNX_Player, sFunc);
+    NWNXPushInt(usable);
+    NWNXPushObject(placeable);
+    NWNXPushObject(player);
+    NWNXCall(NWNX_Player, "SetPlaceableUsable");
 }
 
 void NWNX_Player_SetRestDuration(object player, int duration)
 {
-    string sFunc = "SetRestDuration";
-
-    NWNX_PushArgumentInt(duration);
-    NWNX_PushArgumentObject(player);
-
-    NWNX_CallFunction(NWNX_Player, sFunc);
+    NWNXPushInt(duration);
+    NWNXPushObject(player);
+    NWNXCall(NWNX_Player, "SetRestDuration");
 }
 
 void NWNX_Player_ApplyInstantVisualEffectToObject(object player, object target, int visualeffect, float scale=1.0f, vector translate=[], vector rotate=[])
 {
-    string sFunc = "ApplyInstantVisualEffectToObject";
-
-    NWNX_PushArgumentFloat(rotate.z);
-    NWNX_PushArgumentFloat(rotate.y);
-    NWNX_PushArgumentFloat(rotate.x);
-    NWNX_PushArgumentFloat(translate.z);
-    NWNX_PushArgumentFloat(translate.y);
-    NWNX_PushArgumentFloat(translate.x);
-    NWNX_PushArgumentFloat(scale);
-    NWNX_PushArgumentInt(visualeffect);
-    NWNX_PushArgumentObject(target);
-    NWNX_PushArgumentObject(player);
-
-    NWNX_CallFunction(NWNX_Player, sFunc);
+    NWNXPushVector(rotate);
+    NWNXPushVector(translate);
+    NWNXPushFloat(scale);
+    NWNXPushInt(visualeffect);
+    NWNXPushObject(target);
+    NWNXPushObject(player);
+    NWNXCall(NWNX_Player, "ApplyInstantVisualEffectToObject");
 }
 
 void NWNX_Player_UpdateCharacterSheet(object player)
 {
-    string sFunc = "UpdateCharacterSheet";
-
-    NWNX_PushArgumentObject(player);
-
-    NWNX_CallFunction(NWNX_Player, sFunc);
+    NWNXPushObject(player);
+    NWNXCall(NWNX_Player, "UpdateCharacterSheet");
 }
 
 void NWNX_Player_OpenInventory(object player, object target, int open = TRUE)
 {
-    string sFunc = "OpenInventory";
-
-    NWNX_PushArgumentInt(open);
-    NWNX_PushArgumentObject(target);
-    NWNX_PushArgumentObject(player);
-
-    NWNX_CallFunction(NWNX_Player, sFunc);
+    NWNXPushInt(open);
+    NWNXPushObject(target);
+    NWNXPushObject(player);
+    NWNXCall(NWNX_Player, "OpenInventory");
 }
 
 string NWNX_Player_GetAreaExplorationState(object player, object area)
 {
-    string sFunc = "GetAreaExplorationState";
-
-    NWNX_PushArgumentObject(area);
-    NWNX_PushArgumentObject(player);
-
-    NWNX_CallFunction(NWNX_Player, sFunc);
-    return  NWNX_GetReturnValueString();
+    NWNXPushObject(area);
+    NWNXPushObject(player);
+    NWNXCall(NWNX_Player, "GetAreaExplorationState");
+    return  NWNXPopString();
 }
 
 void NWNX_Player_SetAreaExplorationState(object player, object area, string str)
 {
-    string sFunc = "SetAreaExplorationState";
-
-    NWNX_PushArgumentString(str);
-    NWNX_PushArgumentObject(area);
-    NWNX_PushArgumentObject(player);
-
-    NWNX_CallFunction(NWNX_Player, sFunc);
+    NWNXPushString(str);
+    NWNXPushObject(area);
+    NWNXPushObject(player);
+    NWNXCall(NWNX_Player, "SetAreaExplorationState");
 }
 
 void NWNX_Player_SetRestAnimation(object oPlayer, int nAnimation)
 {
-    string sFunc = "SetRestAnimation";
-
-    NWNX_PushArgumentInt(nAnimation);
-    NWNX_PushArgumentObject(oPlayer);
-
-    NWNX_CallFunction(NWNX_Player, sFunc);
+    NWNXPushInt(nAnimation);
+    NWNXPushObject(oPlayer);
+    NWNXCall(NWNX_Player, "SetRestAnimation");
 }
 
 void NWNX_Player_SetObjectVisualTransformOverride(object oPlayer, object oObject, int nTransform, float fValue)
 {
-    string sFunc = "SetObjectVisualTransformOverride";
-
-    NWNX_PushArgumentFloat(fValue);
-    NWNX_PushArgumentInt(nTransform);
-    NWNX_PushArgumentObject(oObject);
-    NWNX_PushArgumentObject(oPlayer);
-
-    NWNX_CallFunction(NWNX_Player, sFunc);
+    NWNXPushFloat(fValue);
+    NWNXPushInt(nTransform);
+    NWNXPushObject(oObject);
+    NWNXPushObject(oPlayer);
+    NWNXCall(NWNX_Player, "SetObjectVisualTransformOverride");
 }
 
 void NWNX_Player_ApplyLoopingVisualEffectToObject(object player, object target, int visualeffect)
 {
-    string sFunc = "ApplyLoopingVisualEffectToObject";
-
-    NWNX_PushArgumentInt(visualeffect);
-    NWNX_PushArgumentObject(target);
-    NWNX_PushArgumentObject(player);
-
-    NWNX_CallFunction(NWNX_Player, sFunc);
+    NWNXPushInt(visualeffect);
+    NWNXPushObject(target);
+    NWNXPushObject(player);
+    NWNXCall(NWNX_Player, "ApplyLoopingVisualEffectToObject");
 }
 
 void NWNX_Player_SetPlaceableNameOverride(object player, object placeable, string name)
 {
-    string sFunc = "SetPlaceableNameOverride";
-
-    NWNX_PushArgumentString(name);
-    NWNX_PushArgumentObject(placeable);
-    NWNX_PushArgumentObject(player);
-
-    NWNX_CallFunction(NWNX_Player, sFunc);
+    NWNXPushString(name);
+    NWNXPushObject(placeable);
+    NWNXPushObject(player);
+    NWNXCall(NWNX_Player, "SetPlaceableNameOverride");
 }
 
 int NWNX_Player_GetQuestCompleted(object player, string sQuestName)
 {
-    string sFunc = "GetQuestCompleted";
-
-    NWNX_PushArgumentString(sQuestName);
-    NWNX_PushArgumentObject(player);
-
-    NWNX_CallFunction(NWNX_Player, sFunc);
-    return NWNX_GetReturnValueInt();
+    NWNXPushString(sQuestName);
+    NWNXPushObject(player);
+    NWNXCall(NWNX_Player, "GetQuestCompleted");
+    return NWNXPopInt();
 }
 
 void NWNX_Player_SetPersistentLocation(string sCDKeyOrCommunityName, string sBicFileName, object oWP, int bFirstConnectOnly = TRUE)
 {
-    string sFunc = "SetPersistentLocation";
-
-    NWNX_PushArgumentInt(bFirstConnectOnly);
-    NWNX_PushArgumentObject(oWP);
-    NWNX_PushArgumentString(sBicFileName);
-    NWNX_PushArgumentString(sCDKeyOrCommunityName);
-
-    NWNX_CallFunction(NWNX_Player, sFunc);
+    NWNXPushInt(bFirstConnectOnly);
+    NWNXPushObject(oWP);
+    NWNXPushString(sBicFileName);
+    NWNXPushString(sCDKeyOrCommunityName);
+    NWNXCall(NWNX_Player, "SetPersistentLocation");
 }
 
 void NWNX_Player_UpdateItemName(object oPlayer, object oItem)
 {
-    string sFunc = "UpdateItemName";
-
-    NWNX_PushArgumentObject(oItem);
-    NWNX_PushArgumentObject(oPlayer);
-
-    NWNX_CallFunction(NWNX_Player, sFunc);
+    NWNXPushObject(oItem);
+    NWNXPushObject(oPlayer);
+    NWNXCall(NWNX_Player, "UpdateItemName");
 }
 
 int NWNX_Player_PossessCreature(object oPossessor, object oPossessed, int bMindImmune = TRUE, int bCreateDefaultQB = FALSE)
 {
-    string sFunc = "PossessCreature";
-
-    NWNX_PushArgumentInt(bCreateDefaultQB);
-    NWNX_PushArgumentInt(bMindImmune);
-    NWNX_PushArgumentObject(oPossessed);
-    NWNX_PushArgumentObject(oPossessor);
-
-    NWNX_CallFunction(NWNX_Player, sFunc);
-    return NWNX_GetReturnValueInt();
+    NWNXPushInt(bCreateDefaultQB);
+    NWNXPushInt(bMindImmune);
+    NWNXPushObject(oPossessed);
+    NWNXPushObject(oPossessor);
+    NWNXCall(NWNX_Player, "PossessCreature");
+    return NWNXPopInt();
 }
 
 int NWNX_Player_GetPlatformId(object oPlayer)
 {
-    string sFunc = "GetPlatformId";
-
-    NWNX_PushArgumentObject(oPlayer);
-
-    NWNX_CallFunction(NWNX_Player, sFunc);
-    return NWNX_GetReturnValueInt();
+    NWNXPushObject(oPlayer);
+    NWNXCall(NWNX_Player, "GetPlatformId");
+    return NWNXPopInt();
 }
 
 int NWNX_Player_GetLanguage(object oPlayer)
 {
-    string sFunc = "GetLanguage";
-
-    NWNX_PushArgumentObject(oPlayer);
-
-    NWNX_CallFunction(NWNX_Player, sFunc);
-    return NWNX_GetReturnValueInt();
+    NWNXPushObject(oPlayer);
+    NWNXCall(NWNX_Player, "GetLanguage");
+    return NWNXPopInt();
 }
 
 void NWNX_Player_SetResManOverride(object oPlayer, int nResType, string sOldResName, string sNewResName)
 {
-    string sFunc = "SetResManOverride";
-
-    NWNX_PushArgumentString(sNewResName);
-    NWNX_PushArgumentString(sOldResName);
-    NWNX_PushArgumentInt(nResType);
-    NWNX_PushArgumentObject(oPlayer);
-
-    NWNX_CallFunction(NWNX_Player, sFunc);
+    NWNXPushString(sNewResName);
+    NWNXPushString(sOldResName);
+    NWNXPushInt(nResType);
+    NWNXPushObject(oPlayer);
+    NWNXCall(NWNX_Player, "SetResManOverride");
 }
 
 void NWNX_Player_SetCustomToken(object oPlayer, int nCustomTokenNumber, string sTokenValue)
 {
-    string sFunc = "SetCustomToken";
-
-    NWNX_PushArgumentString(sTokenValue);
-    NWNX_PushArgumentInt(nCustomTokenNumber);
-    NWNX_PushArgumentObject(oPlayer);
-
-    NWNX_CallFunction(NWNX_Player, sFunc);
+    NWNXPushString(sTokenValue);
+    NWNXPushInt(nCustomTokenNumber);
+    NWNXPushObject(oPlayer);
+    NWNXCall(NWNX_Player, "SetCustomToken");
 }
 
 void NWNX_Player_SetCreatureNameOverride(object oPlayer, object oCreature, string sName)
 {
-    string sFunc = "SetCreatureNameOverride";
-
-    NWNX_PushArgumentString(sName);
-    NWNX_PushArgumentObject(oCreature);
-    NWNX_PushArgumentObject(oPlayer);
-
-    NWNX_CallFunction(NWNX_Player, sFunc);
+    NWNXPushString(sName);
+    NWNXPushObject(oCreature);
+    NWNXPushObject(oPlayer);
+    NWNXCall(NWNX_Player, "SetCreatureNameOverride");
 }
 
 void NWNX_Player_FloatingTextStringOnCreature(object oPlayer, object oCreature, string sText, int bChatWindow = TRUE)
 {
-    string sFunc = "FloatingTextStringOnCreature";
-
-    NWNX_PushArgumentInt(bChatWindow);
-    NWNX_PushArgumentString(sText);
-    NWNX_PushArgumentObject(oCreature);
-    NWNX_PushArgumentObject(oPlayer);
-
-    NWNX_CallFunction(NWNX_Player, sFunc);
+    NWNXPushInt(bChatWindow);
+    NWNXPushString(sText);
+    NWNXPushObject(oCreature);
+    NWNXPushObject(oPlayer);
+    NWNXCall(NWNX_Player, "FloatingTextStringOnCreature");
 }
 
 void NWNX_Player_ToggleDM(object oPlayer, int bIsDM)
 {
-    string sFunc = "ToggleDM";
-
-    NWNX_PushArgumentInt(bIsDM);
-    NWNX_PushArgumentObject(oPlayer);
-
-    NWNX_CallFunction(NWNX_Player, sFunc);
+    NWNXPushInt(bIsDM);
+    NWNXPushObject(oPlayer);
+    NWNXCall(NWNX_Player, "ToggleDM");
 }
 
 void NWNX_Player_SetObjectMouseCursorOverride(object oPlayer, object oObject, int nCursor)
 {
-    string sFunc = "SetObjectMouseCursorOverride";
-
-    NWNX_PushArgumentInt(nCursor);
-    NWNX_PushArgumentObject(oObject);
-    NWNX_PushArgumentObject(oPlayer);
-
-    NWNX_CallFunction(NWNX_Player, sFunc);
+    NWNXPushInt(nCursor);
+    NWNXPushObject(oObject);
+    NWNXPushObject(oPlayer);
+    NWNXCall(NWNX_Player, "SetObjectMouseCursorOverride");
 }
 
 void NWNX_Player_SetObjectHiliteColorOverride(object oPlayer, object oObject, int nColor)
 {
-    string sFunc = "SetObjectHiliteColorOverride";
-
-    NWNX_PushArgumentInt(nColor);
-    NWNX_PushArgumentObject(oObject);
-    NWNX_PushArgumentObject(oPlayer);
-
-    NWNX_CallFunction(NWNX_Player, sFunc);
+    NWNXPushInt(nColor);
+    NWNXPushObject(oObject);
+    NWNXPushObject(oPlayer);
+    NWNXCall(NWNX_Player, "SetObjectHiliteColorOverride");
 }
 
 void NWNX_Player_RemoveEffectFromTURD(object oPlayer, string sEffectTag)
 {
-    string sFunc = "RemoveEffectFromTURD";
-
-    NWNX_PushArgumentString(sEffectTag);
-    NWNX_PushArgumentObject(oPlayer);
-
-    NWNX_CallFunction(NWNX_Player, sFunc);
+    NWNXPushString(sEffectTag);
+    NWNXPushObject(oPlayer);
+    NWNXCall(NWNX_Player, "RemoveEffectFromTURD");
 }
 
 void NWNX_Player_SetSpawnLocation(object oPlayer, location locSpawn)
 {
-    string sFunc = "SetSpawnLocation";
-
-    vector vPosition = GetPositionFromLocation(locSpawn);
-
-    NWNX_PushArgumentFloat(GetFacingFromLocation(locSpawn));
-    NWNX_PushArgumentFloat(vPosition.z);
-    NWNX_PushArgumentFloat(vPosition.y);
-    NWNX_PushArgumentFloat(vPosition.x);
-    NWNX_PushArgumentObject(GetAreaFromLocation(locSpawn));
-    NWNX_PushArgumentObject(oPlayer);
-
-    NWNX_CallFunction(NWNX_Player, sFunc);
+    NWNXPushLocation(locSpawn);
+    NWNXPushObject(oPlayer);
+    NWNXCall(NWNX_Player, "SetSpawnLocation");
 }
 
 void NWNX_Player_SendDMAllCreatorLists(object oPlayer)
 {
-    string sFunc = "SendDMAllCreatorLists";
-    NWNX_PushArgumentObject(oPlayer);
-    NWNX_CallFunction(NWNX_Player, sFunc);
+    NWNXPushObject(oPlayer);
+    NWNXCall(NWNX_Player, "SendDMAllCreatorLists");
 }
 
 int NWNX_Player_AddCustomJournalEntry(object oPlayer, struct NWNX_Player_JournalEntry journalEntry, int nSilentUpdate = 0)
 {
-    string sFunc = "AddCustomJournalEntry";
-    NWNX_PushArgumentInt(nSilentUpdate);
-    NWNX_PushArgumentInt(journalEntry.nTimeOfDay);
-    NWNX_PushArgumentInt(journalEntry.nCalendarDay);
-    NWNX_PushArgumentInt(journalEntry.nUpdated);
-    NWNX_PushArgumentInt(journalEntry.nQuestDisplayed);
-    NWNX_PushArgumentInt(journalEntry.nQuestCompleted);
-    NWNX_PushArgumentInt(journalEntry.nPriority);
-    NWNX_PushArgumentInt(journalEntry.nState);
-    NWNX_PushArgumentString(journalEntry.sTag);
-    NWNX_PushArgumentString(journalEntry.sText);
-    NWNX_PushArgumentString(journalEntry.sName);
-    NWNX_PushArgumentObject(oPlayer);
-    NWNX_CallFunction(NWNX_Player, sFunc);
-    return NWNX_GetReturnValueInt();
+    NWNXPushInt(nSilentUpdate);
+    NWNXPushInt(journalEntry.nTimeOfDay);
+    NWNXPushInt(journalEntry.nCalendarDay);
+    NWNXPushInt(journalEntry.nUpdated);
+    NWNXPushInt(journalEntry.nQuestDisplayed);
+    NWNXPushInt(journalEntry.nQuestCompleted);
+    NWNXPushInt(journalEntry.nPriority);
+    NWNXPushInt(journalEntry.nState);
+    NWNXPushString(journalEntry.sTag);
+    NWNXPushString(journalEntry.sText);
+    NWNXPushString(journalEntry.sName);
+    NWNXPushObject(oPlayer);
+    NWNXCall(NWNX_Player, "AddCustomJournalEntry");
+    return NWNXPopInt();
 }
 
 struct NWNX_Player_JournalEntry NWNX_Player_GetJournalEntry(object oPlayer, string questTag)
 {
-    string sFunc = "GetJournalEntry";
     struct NWNX_Player_JournalEntry entry;
-
-    NWNX_PushArgumentString(questTag);
-    NWNX_PushArgumentObject(oPlayer);
-    NWNX_CallFunction(NWNX_Player, sFunc);
-
-    entry.nUpdated = NWNX_GetReturnValueInt();
+    NWNXPushString(questTag);
+    NWNXPushObject(oPlayer);
+    NWNXCall(NWNX_Player, "GetJournalEntry");
+    entry.nUpdated = NWNXPopInt();
     if(entry.nUpdated == -1) // -1 set as an indicator to say that the entry was not found
     {
         return entry;
     }
-    entry.nQuestDisplayed = NWNX_GetReturnValueInt();
-    entry.nQuestCompleted = NWNX_GetReturnValueInt();
-    entry.nPriority = NWNX_GetReturnValueInt();
-    entry.nState = NWNX_GetReturnValueInt();
-    entry.nTimeOfDay = NWNX_GetReturnValueInt();
-    entry.nCalendarDay = NWNX_GetReturnValueInt();
-    entry.sName = NWNX_GetReturnValueString();
-    entry.sText = NWNX_GetReturnValueString();
+    entry.nQuestDisplayed = NWNXPopInt();
+    entry.nQuestCompleted = NWNXPopInt();
+    entry.nPriority = NWNXPopInt();
+    entry.nState = NWNXPopInt();
+    entry.nTimeOfDay = NWNXPopInt();
+    entry.nCalendarDay = NWNXPopInt();
+    entry.sName = NWNXPopString();
+    entry.sText = NWNXPopString();
     entry.sTag = questTag;
     return entry;
 }
 
 void NWNX_Player_CloseStore(object oPlayer)
 {
-    string sFunc = "CloseStore";
-
-    NWNX_PushArgumentObject(oPlayer);
-    NWNX_CallFunction(NWNX_Player, sFunc);
+    NWNXPushObject(oPlayer);
+    NWNXCall(NWNX_Player, "CloseStore");
 }
 
 void NWNX_Player_SetTlkOverride(object oPlayer, int nStrRef, string sOverride, int bRestoreGlobal = TRUE)
 {
-    string sFunc = "SetTlkOverride";
-
-    NWNX_PushArgumentInt(bRestoreGlobal);
-    NWNX_PushArgumentString(sOverride);
-    NWNX_PushArgumentInt(nStrRef);
-    NWNX_PushArgumentObject(oPlayer);
-    NWNX_CallFunction(NWNX_Player, sFunc);
+    NWNXPushInt(bRestoreGlobal);
+    NWNXPushString(sOverride);
+    NWNXPushInt(nStrRef);
+    NWNXPushObject(oPlayer);
+    NWNXCall(NWNX_Player, "SetTlkOverride");
 }
 
 void NWNX_Player_ReloadTlk(object oPlayer)
 {
-    string sFunc = "ReloadTlk";
-
-    NWNX_PushArgumentObject(oPlayer);
-    NWNX_CallFunction(NWNX_Player, sFunc);
+    NWNXPushObject(oPlayer);
+    NWNXCall(NWNX_Player, "ReloadTlk");
 }
 
 void NWNX_Player_UpdateWind(object oPlayer, vector vDirection, float fMagnitude, float fYaw, float fPitch)
 {
-    string sFunc = "UpdateWind";
-
-    NWNX_PushArgumentFloat(fPitch);
-    NWNX_PushArgumentFloat(fYaw);
-    NWNX_PushArgumentFloat(fMagnitude);
-    NWNX_PushArgumentFloat(vDirection.x);
-    NWNX_PushArgumentFloat(vDirection.y);
-    NWNX_PushArgumentFloat(vDirection.z);
-    NWNX_PushArgumentObject(oPlayer);
-    NWNX_CallFunction(NWNX_Player, sFunc);
+    NWNXPushFloat(fPitch);
+    NWNXPushFloat(fYaw);
+    NWNXPushFloat(fMagnitude);
+    NWNXPushVector(vDirection);
+    NWNXPushObject(oPlayer);
+    NWNXCall(NWNX_Player, "UpdateWind");
 }
 
 void NWNX_Player_UpdateSkyBox(object oPlayer, int nSkyBox)
 {
-    string sFunc = "UpdateSkyBox";
-
-    NWNX_PushArgumentInt(nSkyBox);
-    NWNX_PushArgumentObject(oPlayer);
-    NWNX_CallFunction(NWNX_Player, sFunc);
+    NWNXPushInt(nSkyBox);
+    NWNXPushObject(oPlayer);
+    NWNXCall(NWNX_Player, "UpdateSkyBox");
 }
 
 void NWNX_Player_UpdateFogColor(object oPlayer, int nSunFogColor, int nMoonFogColor)
 {
-    string sFunc = "UpdateFogColor";
-
-    NWNX_PushArgumentInt(nMoonFogColor);
-    NWNX_PushArgumentInt(nSunFogColor);
-    NWNX_PushArgumentObject(oPlayer);
-    NWNX_CallFunction(NWNX_Player, sFunc);
+    NWNXPushInt(nMoonFogColor);
+    NWNXPushInt(nSunFogColor);
+    NWNXPushObject(oPlayer);
+    NWNXCall(NWNX_Player, "UpdateFogColor");
 }
 
 void NWNX_Player_UpdateFogAmount(object oPlayer, int nSunFogAmount, int nMoonFogAmount)
 {
-    string sFunc = "UpdateFogAmount";
-
-    NWNX_PushArgumentInt(nMoonFogAmount);
-    NWNX_PushArgumentInt(nSunFogAmount);
-    NWNX_PushArgumentObject(oPlayer);
-    NWNX_CallFunction(NWNX_Player, sFunc);
+    NWNXPushInt(nMoonFogAmount);
+    NWNXPushInt(nSunFogAmount);
+    NWNXPushObject(oPlayer);
+    NWNXCall(NWNX_Player, "UpdateFogAmount");
 }
 
 object NWNX_Player_GetGameObject(object oPlayer)
 {
-    string sFunc = "GetGameObject";
-
-    NWNX_PushArgumentObject(oPlayer);
-    NWNX_CallFunction(NWNX_Player, sFunc);
-    return NWNX_GetReturnValueObject();
+    NWNXPushObject(oPlayer);
+    NWNXCall(NWNX_Player, "GetGameObject");
+    return NWNXPopObject();
 }
 
 void NWNX_Player_SetObjectUiDiscoveryMaskOverride(object oPlayer, object oObject, int nMask)
 {
-    string sFunc = "SetObjectUiDiscoveryMaskOverride";
-
-    NWNX_PushArgumentInt(nMask);
-    NWNX_PushArgumentObject(oObject);
-    NWNX_PushArgumentObject(oPlayer);
-
-    NWNX_CallFunction(NWNX_Player, sFunc);
+    NWNXPushInt(nMask);
+    NWNXPushObject(oObject);
+    NWNXPushObject(oPlayer);
+    NWNXCall(NWNX_Player, "SetObjectUiDiscoveryMaskOverride");
 }
 
 void NWNX_Player_SendPartyInvite(object oPlayer, object oInviter, int bForceInvite = FALSE, int bHideDialog = FALSE)
 {
-    string sFunc = "SendPartyInvite";
-
-    NWNX_PushArgumentInt(bHideDialog);
-    NWNX_PushArgumentInt(bForceInvite);
-    NWNX_PushArgumentObject(oInviter);
-    NWNX_PushArgumentObject(oPlayer);
-
-    NWNX_CallFunction(NWNX_Player, sFunc);
+    NWNXPushInt(bHideDialog);
+    NWNXPushInt(bForceInvite);
+    NWNXPushObject(oInviter);
+    NWNXPushObject(oPlayer);
+    NWNXCall(NWNX_Player, "SendPartyInvite");
 }
 
 object NWNX_Player_GetTURD(object oPlayer)
 {
-    string sFunc = "GetTURD";
-
-    NWNX_PushArgumentObject(oPlayer);
-    NWNX_CallFunction(NWNX_Player, sFunc);
-
-    return NWNX_GetReturnValueObject();
+    NWNXPushObject(oPlayer);
+    NWNXCall(NWNX_Player, "GetTURD");
+    return NWNXPopObject();
 }
 
 void NWNX_Player_ReloadColorPalettes(object oPlayer)
 {
-    string sFunc = "ReloadColorPalettes";
-
-    NWNX_PushArgumentObject(oPlayer);
-    NWNX_CallFunction(NWNX_Player, sFunc);
+    NWNXPushObject(oPlayer);
+    NWNXCall(NWNX_Player, "ReloadColorPalettes");
 }

_module/nss/nwnx_profiler.nss

@@ -3,7 +3,6 @@
 /// @remark These functions are for advanced users.
 /// @{
 /// @file nwnx_profiler.nss
-#include "nwnx"
 
 const string NWNX_Profiler = "NWNX_Profiler"; ///< @private
 
@@ -39,22 +38,17 @@ void NWNX_Profiler_PopPerfScope();
 
 void NWNX_Profiler_PushPerfScope(string name, string tag0_tag = "", string tag0_value = "")
 {
-    string sFunc = "PushPerfScope";
-
-    NWNX_PushArgumentString(name);
-
     if (tag0_value != "" && tag0_tag != "")
     {
-        NWNX_PushArgumentString(tag0_value);
-        NWNX_PushArgumentString(tag0_tag);
+        NWNXPushString(tag0_value);
+        NWNXPushString(tag0_tag);
     }
-
-    NWNX_CallFunction(NWNX_Profiler, sFunc);
+    NWNXPushString(name);
+    NWNXCall(NWNX_Profiler, "PushPerfScope");
 }
 
 void NWNX_Profiler_PopPerfScope()
 {
-    string sFunc = "PopPerfScope";
+    NWNXCall(NWNX_Profiler, "PopPerfScope");
+}
 
-    NWNX_CallFunction(NWNX_Profiler, sFunc);
-}

_module/nss/nwnx_race.nss

@@ -2,7 +2,6 @@
 /// @brief Define racial and subrace characteristics.
 /// @{
 /// @file nwnx_race.nss
-#include "nwnx"
 
 const string NWNX_Race = "NWNX_Race"; ///< @private
 
@@ -54,37 +53,50 @@ int NWNX_Race_GetParentRace(int iRace);
 /// or Favored Enemy: Wild Elf
 void NWNX_Race_SetFavoredEnemyFeat(int iRace, int iFeat);
 
+/// @brief Removes any nwnx_race 'Effects' on the targeted creature. Suppression lasts until levelup, next login, or Reactivated by function.
+/// @param oCreature The creature to suppress
+/// @note Not all nwnx_race modifiers are achieved via effect. Those that are not directly consider the creatures current race.
+void NWNX_Race_SuppressCreatureRaceEffects(object oCreature);
+
+/// @brief Reactivates the nwnx_race 'Effects' on the targeted creature after they were Suppressed.
+/// @param oCreature The creature to reactive
+/// @note Safe to use on non-suppressed creatures - Triggers a refresh of effects but won't stack.
+void NWNX_Race_ReactivateCreatureRaceEffects(object oCreature);
+
 /// @}
 
 void NWNX_Race_SetRacialModifier(int iRace, int iMod, int iParam1, int iParam2 = 0xDEADBEEF, int iParam3 = 0xDEADBEEF)
 {
-    string sFunc = "SetRacialModifier";
-
-    NWNX_PushArgumentInt(iParam3);
-    NWNX_PushArgumentInt(iParam2);
-    NWNX_PushArgumentInt(iParam1);
-    NWNX_PushArgumentInt(iMod);
-    NWNX_PushArgumentInt(iRace);
-
-    NWNX_CallFunction(NWNX_Race, sFunc);
+    NWNXPushInt(iParam3);
+    NWNXPushInt(iParam2);
+    NWNXPushInt(iParam1);
+    NWNXPushInt(iMod);
+    NWNXPushInt(iRace);
+    NWNXCall(NWNX_Race, "SetRacialModifier");
 }
 
 int NWNX_Race_GetParentRace(int iRace)
 {
-    string sFunc = "GetParentRace";
-
-    NWNX_PushArgumentInt(iRace);
-
-    NWNX_CallFunction(NWNX_Race, sFunc);
-    return NWNX_GetReturnValueInt();
+    NWNXPushInt(iRace);
+    NWNXCall(NWNX_Race, "GetParentRace");
+    return NWNXPopInt();
 }
 
 void NWNX_Race_SetFavoredEnemyFeat(int iRace, int iFeat)
 {
-    string sFunc = "SetFavoredEnemyFeat";
-
-    NWNX_PushArgumentInt(iFeat);
-    NWNX_PushArgumentInt(iRace);
-
-    NWNX_CallFunction(NWNX_Race, sFunc);
+    NWNXPushInt(iFeat);
+    NWNXPushInt(iRace);
+    NWNXCall(NWNX_Race, "SetFavoredEnemyFeat");
+}
+
+void NWNX_Race_SuppressCreatureRaceEffects(object creature)
+{
+    NWNXPushObject(creature);
+    NWNXCall(NWNX_Race, "SuppressCreatureRaceEffects");
+}
+
+void NWNX_Race_ReactivateCreatureRaceEffects(object oCreature)
+{
+    NWNXPushObject(oCreature);
+    NWNXCall(NWNX_Race, "ReactivateCreatureRaceEffects");
 }

_module/nss/nwnx_redis_lib.nss

@@ -3,7 +3,6 @@
 /// @{
 /// @file nwnx_redis_lib.nss
 /// @brief Allows connection and interfacing with a redis server.
-#include "nwnx"
 
 /// @anchor redis_results
 /// @name Redis Results
@@ -65,44 +64,44 @@ string NWNX_Redis_GetResultAsString(int resultId);
 
 int NWNX_Redis_GetResultType(int resultId)
 {
-    NWNX_PushArgumentInt(resultId);
-    NWNX_CallFunction("NWNX_Redis", "GetResultType");
-    return NWNX_GetReturnValueInt();
+    NWNXPushInt(resultId);
+    NWNXCall("NWNX_Redis", "GetResultType");
+    return NWNXPopInt();
 }
 
 int NWNX_Redis_GetArrayLength(int resultId)
 {
-    NWNX_PushArgumentInt(resultId);
-    NWNX_CallFunction("NWNX_Redis", "GetResultArrayLength");
-    return NWNX_GetReturnValueInt();
+    NWNXPushInt(resultId);
+    NWNXCall("NWNX_Redis", "GetResultArrayLength");
+    return NWNXPopInt();
 }
 
 // Returns the last
 int NWNX_Redis_GetArrayElement(int resultId, int idx)
 {
-    NWNX_PushArgumentInt(resultId);
-    NWNX_PushArgumentInt(idx);
-    NWNX_CallFunction("NWNX_Redis", "GetResultArrayElement");
-    return NWNX_GetReturnValueInt();
+    NWNXPushInt(resultId);
+    NWNXPushInt(idx);
+    NWNXCall("NWNX_Redis", "GetResultArrayElement");
+    return NWNXPopInt();
 }
 
 float NWNX_Redis_GetResultAsFloat(int resultId)
 {
-    NWNX_PushArgumentInt(resultId);
-    NWNX_CallFunction("NWNX_Redis", "GetResultAsString");
-    return StringToFloat(NWNX_GetReturnValueString());
+    NWNXPushInt(resultId);
+    NWNXCall("NWNX_Redis", "GetResultAsString");
+    return StringToFloat(NWNXPopString());
 }
 
 int NWNX_Redis_GetResultAsInt(int resultId)
 {
-    NWNX_PushArgumentInt(resultId);
-    NWNX_CallFunction("NWNX_Redis", "GetResultAsString");
-    return StringToInt(NWNX_GetReturnValueString());
+    NWNXPushInt(resultId);
+    NWNXCall("NWNX_Redis", "GetResultAsString");
+    return StringToInt(NWNXPopString());
 }
 
 string NWNX_Redis_GetResultAsString(int resultId)
 {
-    NWNX_PushArgumentInt(resultId);
-    NWNX_CallFunction("NWNX_Redis", "GetResultAsString");
-    return NWNX_GetReturnValueString();
+    NWNXPushInt(resultId);
+    NWNXCall("NWNX_Redis", "GetResultAsString");
+    return NWNXPopString();
 }

_module/nss/nwnx_redis_ps.nss

@@ -2,7 +2,6 @@
 /// @brief Interface to Redis PUBSUB
 /// @{
 /// @file nwnx_redis_ps.nss
-#include "nwnx"
 
 /// A redis PUBSUB message
 struct NWNX_Redis_PubSubMessageData {
@@ -15,9 +14,9 @@ struct NWNX_Redis_PubSubMessageData {
 struct NWNX_Redis_PubSubMessageData NWNX_Redis_GetPubSubMessageData()
 {
     struct NWNX_Redis_PubSubMessageData ret;
-    NWNX_CallFunction("NWNX_Redis", "GetPubSubData");
-    ret.message = NWNX_GetReturnValueString();
-    ret.channel = NWNX_GetReturnValueString();
+    NWNXCall("NWNX_Redis", "GetPubSubData");
+    ret.message = NWNXPopString();
+    ret.channel = NWNXPopString();
     return ret;
 }
 /// @}

_module/nss/nwnx_rename.nss

@@ -2,7 +2,6 @@
 /// @brief Facilitates renaming, overriding and customization of player names.
 /// @{
 /// @file nwnx_rename.nss
-#include "nwnx"
 
 const string NWNX_Rename = "NWNX_Rename"; ///< @private
 
@@ -46,35 +45,26 @@ void NWNX_Rename_ClearPCNameOverride(object oTarget, object oObserver = OBJECT_I
 void NWNX_Rename_SetPCNameOverride(object oTarget, string sNewName, string sPrefix = "" , string sSuffix = "" ,
                                    int iPlayerNameState = NWNX_RENAME_PLAYERNAME_DEFAULT, object oObserver = OBJECT_INVALID)
 {
-    string sFunc = "SetPCNameOverride";
-
-    NWNX_PushArgumentObject(oObserver);
-    NWNX_PushArgumentInt(iPlayerNameState);
-    NWNX_PushArgumentString(sSuffix);
-    NWNX_PushArgumentString(sPrefix);
-    NWNX_PushArgumentString(sNewName);
-    NWNX_PushArgumentObject(oTarget);
-
-    NWNX_CallFunction(NWNX_Rename, sFunc);
+    NWNXPushObject(oObserver);
+    NWNXPushInt(iPlayerNameState);
+    NWNXPushString(sSuffix);
+    NWNXPushString(sPrefix);
+    NWNXPushString(sNewName);
+    NWNXPushObject(oTarget);
+    NWNXCall(NWNX_Rename, "SetPCNameOverride");
 }
 string NWNX_Rename_GetPCNameOverride(object oTarget, object oObserver = OBJECT_INVALID)
 {
-    string sFunc = "GetPCNameOverride";
-
-    NWNX_PushArgumentObject(oObserver);
-    NWNX_PushArgumentObject(oTarget);
-
-    NWNX_CallFunction(NWNX_Rename, sFunc);
-    return NWNX_GetReturnValueString();
+    NWNXPushObject(oObserver);
+    NWNXPushObject(oTarget);
+    NWNXCall(NWNX_Rename, "GetPCNameOverride");
+    return NWNXPopString();
 }
 
 void NWNX_Rename_ClearPCNameOverride(object oTarget, object oObserver = OBJECT_INVALID, int clearAll = FALSE)
 {
-    string sFunc = "ClearPCNameOverride";
-
-    NWNX_PushArgumentInt(clearAll);
-    NWNX_PushArgumentObject(oObserver);
-    NWNX_PushArgumentObject(oTarget);
-
-    NWNX_CallFunction(NWNX_Rename, sFunc);
+    NWNXPushInt(clearAll);
+    NWNXPushObject(oObserver);
+    NWNXPushObject(oTarget);
+    NWNXCall(NWNX_Rename, "ClearPCNameOverride");
 }

_module/nss/nwnx_reveal.nss

@@ -2,7 +2,6 @@
 /// @brief Allows the selective revealing of a stealthing character to another character or their party.
 /// @{
 /// @file nwnx_reveal.nss
-#include "nwnx"
 
 const string NWNX_Reveal = "NWNX_Reveal"; ///< @private
 
@@ -28,22 +27,16 @@ void NWNX_Reveal_SetRevealToParty(object oHiding, int bReveal, int iDetectionMet
 
 void NWNX_Reveal_RevealTo(object oHiding, object oObserver, int iDetectionMethod = NWNX_REVEAL_HEARD)
 {
-    string sFunc = "RevealTo";
-    
-    NWNX_PushArgumentInt(iDetectionMethod);
-    NWNX_PushArgumentObject(oObserver);
-    NWNX_PushArgumentObject(oHiding);
-
-    NWNX_CallFunction(NWNX_Reveal, sFunc);
+    NWNXPushInt(iDetectionMethod);
+    NWNXPushObject(oObserver);
+    NWNXPushObject(oHiding);
+    NWNXCall(NWNX_Reveal, "RevealTo");
 }
 
 void NWNX_Reveal_SetRevealToParty(object oHiding, int bReveal, int iDetectionMethod = NWNX_REVEAL_HEARD)
 {
-    string sFunc = "SetRevealToParty";
-    
-    NWNX_PushArgumentInt(iDetectionMethod);
-    NWNX_PushArgumentInt(bReveal);
-    NWNX_PushArgumentObject(oHiding);
-
-    NWNX_CallFunction(NWNX_Reveal, sFunc);
+    NWNXPushInt(iDetectionMethod);
+    NWNXPushInt(bReveal);
+    NWNXPushObject(oHiding);
+    NWNXCall(NWNX_Reveal, "SetRevealToParty");
 }

_module/nss/nwnx_ruby.nss

@@ -2,7 +2,6 @@
 /// @brief Allows users to execute arbitrary Ruby from the game.
 /// @{
 /// @file nwnx_ruby.nss
-#include "nwnx"
 
 const string NWNX_Ruby = "NWNX_Ruby"; ///< @private
 
@@ -13,11 +12,9 @@ string NWNX_Ruby_Evaluate(string sCode);
 /// @return The output of the call.
 string NWNX_Ruby_Evaluate(string sCode)
 {
-    string sFunc = "Evaluate";
-
-    NWNX_PushArgumentString(sCode);
-    NWNX_CallFunction(NWNX_Ruby, sFunc);
-    return NWNX_GetReturnValueString();
+    NWNXPushString(sCode);
+    NWNXCall(NWNX_Ruby, "Evaluate");
+    return NWNXPopString();
 }
 
 /// @}

_module/nss/nwnx_skillranks.nss

@@ -3,7 +3,6 @@
 /// skill related feats as well as modifying stock feats.
 /// @{
 /// @file nwnx_skillranks.nss
-#include "nwnx"
 
 const string NWNX_SkillRanks = "NWNX_SkillRanks"; ///< @private
 
@@ -144,82 +143,67 @@ void NWNX_SkillRanks_SetAreaModifier(object oArea, int iSkill, int iModifier);
 
 int NWNX_SkillRanks_GetSkillFeatCountForSkill(int iSkill)
 {
-    string sFunc = "GetSkillFeatCountForSkill";
-
-    NWNX_PushArgumentInt(iSkill);
-    NWNX_CallFunction(NWNX_SkillRanks, sFunc);
-
-    return NWNX_GetReturnValueInt();
+    NWNXPushInt(iSkill);
+    NWNXCall(NWNX_SkillRanks, "GetSkillFeatCountForSkill");
+    return NWNXPopInt();
 }
 
 struct NWNX_SkillRanks_SkillFeat NWNX_SkillRanks_GetSkillFeatForSkillByIndex(int iSkill, int iIndex)
 {
-    string sFunc = "GetSkillFeatForSkillByIndex";
-
-    NWNX_PushArgumentInt(iIndex);
-    NWNX_PushArgumentInt(iSkill);
-    NWNX_CallFunction(NWNX_SkillRanks, sFunc);
-
+    NWNXPushInt(iIndex);
+    NWNXPushInt(iSkill);
+    NWNXCall(NWNX_SkillRanks, "GetSkillFeatForSkillByIndex");
     struct NWNX_SkillRanks_SkillFeat skillFeat;
-
     skillFeat.iSkill                   = iSkill;
-    skillFeat.iFeat                    = NWNX_GetReturnValueInt();
-    skillFeat.iModifier                = NWNX_GetReturnValueInt();
-    skillFeat.iFocusFeat               = NWNX_GetReturnValueInt();
-    skillFeat.sClasses                 = NWNX_GetReturnValueString();
-    skillFeat.fClassLevelMod           = NWNX_GetReturnValueFloat();
-    skillFeat.iAreaFlagsRequired       = NWNX_GetReturnValueInt();
-    skillFeat.iAreaFlagsForbidden      = NWNX_GetReturnValueInt();
-    skillFeat.iDayOrNight              = NWNX_GetReturnValueInt();
-    skillFeat.bBypassArmorCheckPenalty = NWNX_GetReturnValueInt();
-    skillFeat.iKeyAbilityMask          = NWNX_GetReturnValueInt();
-
+    skillFeat.iFeat                    = NWNXPopInt();
+    skillFeat.iModifier                = NWNXPopInt();
+    skillFeat.iFocusFeat               = NWNXPopInt();
+    skillFeat.sClasses                 = NWNXPopString();
+    skillFeat.fClassLevelMod           = NWNXPopFloat();
+    skillFeat.iAreaFlagsRequired       = NWNXPopInt();
+    skillFeat.iAreaFlagsForbidden      = NWNXPopInt();
+    skillFeat.iDayOrNight              = NWNXPopInt();
+    skillFeat.bBypassArmorCheckPenalty = NWNXPopInt();
+    skillFeat.iKeyAbilityMask          = NWNXPopInt();
     return skillFeat;
 }
 
 struct NWNX_SkillRanks_SkillFeat NWNX_SkillRanks_GetSkillFeat(int iSkill, int iFeat)
 {
-    string sFunc = "GetSkillFeat";
-
-    NWNX_PushArgumentInt(iFeat);
-    NWNX_PushArgumentInt(iSkill);
-    NWNX_CallFunction(NWNX_SkillRanks, sFunc);
-
+    NWNXPushInt(iFeat);
+    NWNXPushInt(iSkill);
+    NWNXCall(NWNX_SkillRanks, "GetSkillFeat");
     struct NWNX_SkillRanks_SkillFeat skillFeat;
-
     skillFeat.iSkill                   = iSkill;
     skillFeat.iFeat                    = iFeat;
-    skillFeat.iModifier                = NWNX_GetReturnValueInt();
-    skillFeat.iFocusFeat               = NWNX_GetReturnValueInt();
-    skillFeat.sClasses                 = NWNX_GetReturnValueString();
-    skillFeat.fClassLevelMod           = NWNX_GetReturnValueFloat();
-    skillFeat.iAreaFlagsRequired       = NWNX_GetReturnValueInt();
-    skillFeat.iAreaFlagsForbidden      = NWNX_GetReturnValueInt();
-    skillFeat.iDayOrNight              = NWNX_GetReturnValueInt();
-    skillFeat.bBypassArmorCheckPenalty = NWNX_GetReturnValueInt();
-    skillFeat.iKeyAbilityMask          = NWNX_GetReturnValueInt();
-
+    skillFeat.iModifier                = NWNXPopInt();
+    skillFeat.iFocusFeat               = NWNXPopInt();
+    skillFeat.sClasses                 = NWNXPopString();
+    skillFeat.fClassLevelMod           = NWNXPopFloat();
+    skillFeat.iAreaFlagsRequired       = NWNXPopInt();
+    skillFeat.iAreaFlagsForbidden      = NWNXPopInt();
+    skillFeat.iDayOrNight              = NWNXPopInt();
+    skillFeat.bBypassArmorCheckPenalty = NWNXPopInt();
+    skillFeat.iKeyAbilityMask          = NWNXPopInt();
     return skillFeat;
 }
 
 void NWNX_SkillRanks_SetSkillFeat(struct NWNX_SkillRanks_SkillFeat skillFeat, int createIfNonExistent = FALSE)
 {
-    string sFunc = "SetSkillFeat";
-
-    NWNX_PushArgumentInt(createIfNonExistent);
-    NWNX_PushArgumentInt(skillFeat.iKeyAbilityMask);
-    NWNX_PushArgumentInt(skillFeat.bBypassArmorCheckPenalty);
-    NWNX_PushArgumentInt(skillFeat.iDayOrNight);
-    NWNX_PushArgumentInt(skillFeat.iAreaFlagsForbidden);
-    NWNX_PushArgumentInt(skillFeat.iAreaFlagsRequired);
-    NWNX_PushArgumentFloat(skillFeat.fClassLevelMod);
+    NWNXPushInt(createIfNonExistent);
+    NWNXPushInt(skillFeat.iKeyAbilityMask);
+    NWNXPushInt(skillFeat.bBypassArmorCheckPenalty);
+    NWNXPushInt(skillFeat.iDayOrNight);
+    NWNXPushInt(skillFeat.iAreaFlagsForbidden);
+    NWNXPushInt(skillFeat.iAreaFlagsRequired);
+    NWNXPushFloat(skillFeat.fClassLevelMod);
     // We only need to send the string from the point of the first set bit
-    NWNX_PushArgumentString(GetStringRight(skillFeat.sClasses,GetStringLength(skillFeat.sClasses)-FindSubString(skillFeat.sClasses,"1")));
-    NWNX_PushArgumentInt(skillFeat.iFocusFeat);
-    NWNX_PushArgumentInt(skillFeat.iModifier);
-    NWNX_PushArgumentInt(skillFeat.iFeat);
-    NWNX_PushArgumentInt(skillFeat.iSkill);
-    NWNX_CallFunction(NWNX_SkillRanks, sFunc);
+    NWNXPushString(GetStringRight(skillFeat.sClasses,GetStringLength(skillFeat.sClasses)-FindSubString(skillFeat.sClasses,"1")));
+    NWNXPushInt(skillFeat.iFocusFeat);
+    NWNXPushInt(skillFeat.iModifier);
+    NWNXPushInt(skillFeat.iFeat);
+    NWNXPushInt(skillFeat.iSkill);
+    NWNXCall(NWNX_SkillRanks, "SetSkillFeat");
 }
 
 struct NWNX_SkillRanks_SkillFeat NWNX_SkillRanks_AddSkillFeatClass(struct NWNX_SkillRanks_SkillFeat skillFeat, int iClass)
@@ -237,47 +221,35 @@ struct NWNX_SkillRanks_SkillFeat NWNX_SkillRanks_AddSkillFeatClass(struct NWNX_S
 
 void NWNX_SkillRanks_SetSkillFeatFocusModifier(int iModifier, int epicFocus = FALSE)
 {
-    string sFunc = "SetSkillFeatFocusModifier";
-
-    NWNX_PushArgumentInt(epicFocus);
-    NWNX_PushArgumentInt(iModifier);
-    NWNX_CallFunction(NWNX_SkillRanks, sFunc);
+    NWNXPushInt(epicFocus);
+    NWNXPushInt(iModifier);
+    NWNXCall(NWNX_SkillRanks, "SetSkillFeatFocusModifier");
 }
 
 int NWNX_SkillRanks_GetBlindnessPenalty()
 {
-    string sFunc = "GetBlindnessPenalty";
-
-    NWNX_CallFunction(NWNX_SkillRanks, sFunc);
-
-    return NWNX_GetReturnValueInt();
+    NWNXCall(NWNX_SkillRanks, "GetBlindnessPenalty");
+    return NWNXPopInt();
 }
 
 void NWNX_SkillRanks_SetBlindnessPenalty(int iModifier)
 {
-    string sFunc = "SetBlindnessPenalty";
-
-    NWNX_PushArgumentInt(iModifier);
-    NWNX_CallFunction(NWNX_SkillRanks, sFunc);
+    NWNXPushInt(iModifier);
+    NWNXCall(NWNX_SkillRanks, "SetBlindnessPenalty");
 }
 
 int NWNX_SkillRanks_GetAreaModifier(object oArea, int iSkill)
 {
-    string sFunc = "GetAreaModifier";
-
-    NWNX_PushArgumentInt(iSkill);
-    NWNX_PushArgumentObject(oArea);
-    NWNX_CallFunction(NWNX_SkillRanks, sFunc);
-
-    return NWNX_GetReturnValueInt();
+    NWNXPushInt(iSkill);
+    NWNXPushObject(oArea);
+    NWNXCall(NWNX_SkillRanks, "GetAreaModifier");
+    return NWNXPopInt();
 }
 
 void NWNX_SkillRanks_SetAreaModifier(object oArea, int iSkill, int iModifier)
 {
-    string sFunc = "SetAreaModifier";
-
-    NWNX_PushArgumentInt(iModifier);
-    NWNX_PushArgumentInt(iSkill);
-    NWNX_PushArgumentObject(oArea);
-    NWNX_CallFunction(NWNX_SkillRanks, sFunc);
+    NWNXPushInt(iModifier);
+    NWNXPushInt(iSkill);
+    NWNXPushObject(oArea);
+    NWNXCall(NWNX_SkillRanks, "SetAreaModifier");
 }

_module/nss/nwnx_spellcheck.nss

@@ -2,7 +2,6 @@
 /// @brief Functions related to spellchecking
 /// @{
 /// @file nwnx_spellcheck.nss
-#include "nwnx"
 
 const string NWNX_SpellChecker = "NWNX_SpellChecker"; ///< @private
 
@@ -27,17 +26,14 @@ string NWNX_SpellChecker_GetSuggestSpell(string word);
 
 string NWNX_SpellChecker_FindMisspell(string sentence)
 {
-    string sFunc = "FindMisspell";
-
-    NWNX_PushArgumentString(sentence);
-    NWNX_CallFunction(NWNX_SpellChecker, sFunc);
-    return NWNX_GetReturnValueString();
+    NWNXPushString(sentence);
+    NWNXCall(NWNX_SpellChecker, "FindMisspell");
+    return NWNXPopString();
 }
 
 string NWNX_SpellChecker_GetSuggestSpell(string word)
 {
-    string sFunc = "GetSuggestSpell";
-    NWNX_PushArgumentString(word);
-    NWNX_CallFunction(NWNX_SpellChecker, sFunc);
-    return NWNX_GetReturnValueString();
+    NWNXPushString(word);
+    NWNXCall(NWNX_SpellChecker, "GetSuggestSpell");
+    return NWNXPopString();
 }

_module/nss/nwnx_sql.nss

@@ -2,7 +2,6 @@
 /// @brief Functions to interface with a database through SQL
 /// @{
 /// @file nwnx_sql.nss
-#include "nwnx"
 
 const string NWNX_SQL = "NWNX_SQL"; ///< @private
 
@@ -116,19 +115,15 @@ void NWNX_SQL_PostgreSQL_SetNextQueryResultsBinaryMode();
 
 int NWNX_SQL_PrepareQuery(string query)
 {
-    string sFunc = "PrepareQuery";
-
-    NWNX_PushArgumentString(query);
-    NWNX_CallFunction(NWNX_SQL, sFunc);
-    return NWNX_GetReturnValueInt();
+    NWNXPushString(query);
+    NWNXCall(NWNX_SQL, "PrepareQuery");
+    return NWNXPopInt();
 }
 
 int NWNX_SQL_ExecutePreparedQuery()
 {
-    string sFunc = "ExecutePreparedQuery";
-
-    NWNX_CallFunction(NWNX_SQL, sFunc);
-    return NWNX_GetReturnValueInt();
+    NWNXCall(NWNX_SQL, "ExecutePreparedQuery");
+    return NWNXPopInt();
 }
 
 int NWNX_SQL_ExecuteQuery(string query)
@@ -146,76 +141,58 @@ int NWNX_SQL_ExecuteQuery(string query)
 
 int NWNX_SQL_ReadyToReadNextRow()
 {
-    string sFunc = "ReadyToReadNextRow";
-
-    NWNX_CallFunction(NWNX_SQL, sFunc);
-    return NWNX_GetReturnValueInt();
+    NWNXCall(NWNX_SQL, "ReadyToReadNextRow");
+    return NWNXPopInt();
 }
 
 void NWNX_SQL_ReadNextRow()
 {
-    string sFunc = "ReadNextRow";
-
-    NWNX_CallFunction(NWNX_SQL, sFunc);
+    NWNXCall(NWNX_SQL, "ReadNextRow");
 }
 
 string NWNX_SQL_ReadDataInActiveRow(int column = 0)
 {
-    string sFunc = "ReadDataInActiveRow";
-
-    NWNX_PushArgumentInt(column);
-    NWNX_CallFunction(NWNX_SQL, sFunc);
-    return NWNX_GetReturnValueString();
+    NWNXPushInt(column);
+    NWNXCall(NWNX_SQL, "ReadDataInActiveRow");
+    return NWNXPopString();
 }
 
 
 void NWNX_SQL_PreparedInt(int position, int value)
 {
-    string sFunc = "PreparedInt";
-
-    NWNX_PushArgumentInt(value);
-    NWNX_PushArgumentInt(position);
-    NWNX_CallFunction(NWNX_SQL, sFunc);
+    NWNXPushInt(value);
+    NWNXPushInt(position);
+    NWNXCall(NWNX_SQL, "PreparedInt");
 }
 void NWNX_SQL_PreparedString(int position, string value)
 {
-    string sFunc = "PreparedString";
-
-    NWNX_PushArgumentString(value);
-    NWNX_PushArgumentInt(position);
-    NWNX_CallFunction(NWNX_SQL, sFunc);
+    NWNXPushString(value);
+    NWNXPushInt(position);
+    NWNXCall(NWNX_SQL, "PreparedString");
 }
 void NWNX_SQL_PreparedFloat(int position, float value)
 {
-    string sFunc = "PreparedFloat";
-
-    NWNX_PushArgumentFloat(value);
-    NWNX_PushArgumentInt(position);
-    NWNX_CallFunction(NWNX_SQL, sFunc);
+    NWNXPushFloat(value);
+    NWNXPushInt(position);
+    NWNXCall(NWNX_SQL, "PreparedFloat");
 }
 void NWNX_SQL_PreparedObjectId(int position, object value)
 {
-    string sFunc = "PreparedObjectId";
-
-    NWNX_PushArgumentObject(value);
-    NWNX_PushArgumentInt(position);
-    NWNX_CallFunction(NWNX_SQL, sFunc);
+    NWNXPushObject(value);
+    NWNXPushInt(position);
+    NWNXCall(NWNX_SQL, "PreparedObjectId");
 }
 void NWNX_SQL_PreparedObjectFull(int position, object value, int base64 = TRUE)
 {
-    string sFunc = "PreparedObjectFull";
-
-    NWNX_PushArgumentInt(base64);
-    NWNX_PushArgumentObject(value);
-    NWNX_PushArgumentInt(position);
-    NWNX_CallFunction(NWNX_SQL, sFunc);
+    NWNXPushInt(base64);
+    NWNXPushObject(value);
+    NWNXPushInt(position);
+    NWNXCall(NWNX_SQL, "PreparedObjectFull");
 }
 void NWNX_SQL_PreparedNULL(int position)
 {
-    string sFunc = "PreparedNULL";
-
-    NWNX_PushArgumentInt(position);
-    NWNX_CallFunction(NWNX_SQL, sFunc);
+    NWNXPushInt(position);
+    NWNXCall(NWNX_SQL, "PreparedNULL");
 }
 void NWNX_SQL_PreparedJson(int position, json value)
 {
@@ -227,60 +204,46 @@ void NWNX_SQL_PreparedJson(int position, json value)
 
 object NWNX_SQL_ReadFullObjectInActiveRow(int column = 0, object owner = OBJECT_INVALID, float x = 0.0, float y = 0.0, float z = 0.0, int base64 = TRUE)
 {
-    string sFunc = "ReadFullObjectInActiveRow";
-
-    NWNX_PushArgumentInt(base64);
-    NWNX_PushArgumentFloat(z);
-    NWNX_PushArgumentFloat(y);
-    NWNX_PushArgumentFloat(x);
-    NWNX_PushArgumentObject(owner);
-    NWNX_PushArgumentInt(column);
-    NWNX_CallFunction(NWNX_SQL, sFunc);
-    return NWNX_GetReturnValueObject();
+    NWNXPushInt(base64);
+    NWNXPushFloat(z);
+    NWNXPushFloat(y);
+    NWNXPushFloat(x);
+    NWNXPushObject(owner);
+    NWNXPushInt(column);
+    NWNXCall(NWNX_SQL, "ReadFullObjectInActiveRow");
+    return NWNXPopObject();
 }
 
 int NWNX_SQL_GetAffectedRows()
 {
-    string sFunc = "GetAffectedRows";
-
-    NWNX_CallFunction(NWNX_SQL, sFunc);
-    return NWNX_GetReturnValueInt();
+    NWNXCall(NWNX_SQL, "GetAffectedRows");
+    return NWNXPopInt();
 }
 
 string NWNX_SQL_GetDatabaseType()
 {
-    string sFunc = "GetDatabaseType";
-
-    NWNX_CallFunction(NWNX_SQL, sFunc);
-    return NWNX_GetReturnValueString();
+    NWNXCall(NWNX_SQL, "GetDatabaseType");
+    return NWNXPopString();
 }
 
 void NWNX_SQL_DestroyPreparedQuery()
 {
-    string sFunc = "DestroyPreparedQuery";
-
-    NWNX_CallFunction(NWNX_SQL, sFunc);
+    NWNXCall(NWNX_SQL, "DestroyPreparedQuery");
 }
 
 string NWNX_SQL_GetLastError()
 {
-    string sFunc = "GetLastError";
-
-    NWNX_CallFunction(NWNX_SQL, sFunc);
-    return NWNX_GetReturnValueString();
+    NWNXCall(NWNX_SQL, "GetLastError");
+    return NWNXPopString();
 }
 
 int NWNX_SQL_GetPreparedQueryParamCount()
 {
-    string sFunc = "GetPreparedQueryParamCount";
-
-    NWNX_CallFunction(NWNX_SQL, sFunc);
-    return NWNX_GetReturnValueInt();
+    NWNXCall(NWNX_SQL, "GetPreparedQueryParamCount");
+    return NWNXPopInt();
 }
 
 void NWNX_SQL_PostgreSQL_SetNextQueryResultsBinaryMode()
 {
-    string sFunc = "PostgreSQL_SetNextQueryResultsBinaryMode";
-
-    NWNX_CallFunction(NWNX_SQL, sFunc);
+    NWNXCall(NWNX_SQL, "PostgreSQL_SetNextQueryResultsBinaryMode");
 }

_module/nss/nwnx_store.nss

@@ -2,7 +2,6 @@
 /// @brief Functions exposing additional store properties.
 /// @{
 /// @file nwnx_store.nss
-#include "nwnx"
 
 const string NWNX_Store = "NWNX_Store"; ///< @private
 
@@ -51,81 +50,57 @@ int NWNX_Store_GetCurrentCustomersCount(object oStore);
 
 int NWNX_Store_GetIsRestrictedBuyItem(object oStore, int nBaseItem)
 {
-    string sFunc = "GetIsRestrictedBuyItem";
-
-    NWNX_PushArgumentInt(nBaseItem);
-    NWNX_PushArgumentObject(oStore);
-
-    NWNX_CallFunction(NWNX_Store, sFunc);
-    return NWNX_GetReturnValueInt();
+    NWNXPushInt(nBaseItem);
+    NWNXPushObject(oStore);
+    NWNXCall(NWNX_Store, "GetIsRestrictedBuyItem");
+    return NWNXPopInt();
 }
 
 int NWNX_Store_GetBlackMarketMarkDown(object oStore)
 {
-    string sFunc = "GetBlackMarketMarkDown";
-
-    NWNX_PushArgumentObject(oStore);
-
-    NWNX_CallFunction(NWNX_Store, sFunc);
-    return NWNX_GetReturnValueInt();
+    NWNXPushObject(oStore);
+    NWNXCall(NWNX_Store, "GetBlackMarketMarkDown");
+    return NWNXPopInt();
 }
 
 void NWNX_Store_SetBlackMarketMarkDown(object oStore, int nValue)
 {
-    string sFunc = "SetBlackMarketMarkDown";
-
-    NWNX_PushArgumentInt(nValue);
-    NWNX_PushArgumentObject(oStore);
-
-    NWNX_CallFunction(NWNX_Store, sFunc);
+    NWNXPushInt(nValue);
+    NWNXPushObject(oStore);
+    NWNXCall(NWNX_Store, "SetBlackMarketMarkDown");
 }
 
 int NWNX_Store_GetMarkDown(object oStore)
 {
-    string sFunc = "GetMarkDown";
-
-    NWNX_PushArgumentObject(oStore);
-
-    NWNX_CallFunction(NWNX_Store, sFunc);
-    return NWNX_GetReturnValueInt();
+    NWNXPushObject(oStore);
+    NWNXCall(NWNX_Store, "GetMarkDown");
+    return NWNXPopInt();
 }
 
 void NWNX_Store_SetMarkDown(object oStore, int nValue)
 {
-    string sFunc = "SetMarkDown";
-
-    NWNX_PushArgumentInt(nValue);
-    NWNX_PushArgumentObject(oStore);
-
-    NWNX_CallFunction(NWNX_Store, sFunc);
+    NWNXPushInt(nValue);
+    NWNXPushObject(oStore);
+    NWNXCall(NWNX_Store, "SetMarkDown");
 }
 
 int NWNX_Store_GetMarkUp(object oStore)
 {
-    string sFunc = "GetMarkUp";
-
-    NWNX_PushArgumentObject(oStore);
-
-    NWNX_CallFunction(NWNX_Store, sFunc);
-    return NWNX_GetReturnValueInt();
+    NWNXPushObject(oStore);
+    NWNXCall(NWNX_Store, "GetMarkUp");
+    return NWNXPopInt();
 }
 
 void NWNX_Store_SetMarkUp(object oStore, int nValue)
 {
-    string sFunc = "SetMarkUp";
-
-    NWNX_PushArgumentInt(nValue);
-    NWNX_PushArgumentObject(oStore);
-
-    NWNX_CallFunction(NWNX_Store, sFunc);
+    NWNXPushInt(nValue);
+    NWNXPushObject(oStore);
+    NWNXCall(NWNX_Store, "SetMarkUp");
 }
 
 int NWNX_Store_GetCurrentCustomersCount(object oStore)
 {
-    string sFunc = "GetCurrentCustomersCount";
-
-    NWNX_PushArgumentObject(oStore);
-
-    NWNX_CallFunction(NWNX_Store, sFunc);
-    return NWNX_GetReturnValueInt();
+    NWNXPushObject(oStore);
+    NWNXCall(NWNX_Store, "GetCurrentCustomersCount");
+    return NWNXPopInt();
 }

_module/nss/nwnx_tileset.nss

@@ -2,7 +2,6 @@
 /// @brief An advanced plugin that exposes additional tileset and tile properties and allows builders to override the tiles of an area created with CreateArea().
 /// @{
 /// @file nwnx_tileset.nss
-#include "nwnx"
 
 const string NWNX_Tileset = "NWNX_Tileset"; ///< @private
 
@@ -166,174 +165,160 @@ void NWNX_Tileset_DeleteOverrideTileData(string sOverrideName, int nIndex);
 
 struct NWNX_Tileset_TilesetData NWNX_Tileset_GetTilesetData(string sTileset)
 {
-    NWNX_PushArgumentString(sTileset);
-    NWNX_CallFunction(NWNX_Tileset, "GetTilesetData");
-
+    NWNXPushString(sTileset);
+    NWNXCall(NWNX_Tileset, "GetTilesetData");
     struct NWNX_Tileset_TilesetData str;
-    str.bHasHeightTransition = NWNX_GetReturnValueInt();
-    str.bInterior = NWNX_GetReturnValueInt();
-    str.sUnlocalizedName = NWNX_GetReturnValueString();
-    str.nDisplayNameStrRef = NWNX_GetReturnValueInt();
-    str.sFloorTerrain = NWNX_GetReturnValueString();
-    str.sDefaultTerrain = NWNX_GetReturnValueString();
-    str.sBorderTerrain = NWNX_GetReturnValueString();
-    str.nNumGroups = NWNX_GetReturnValueInt();
-    str.nNumCrossers = NWNX_GetReturnValueInt();
-    str.nNumTerrain = NWNX_GetReturnValueInt();
-    str.fHeightTransition = NWNX_GetReturnValueFloat();
-    str.nNumTileData = NWNX_GetReturnValueInt();
-
+    str.bHasHeightTransition = NWNXPopInt();
+    str.bInterior = NWNXPopInt();
+    str.sUnlocalizedName = NWNXPopString();
+    str.nDisplayNameStrRef = NWNXPopInt();
+    str.sFloorTerrain = NWNXPopString();
+    str.sDefaultTerrain = NWNXPopString();
+    str.sBorderTerrain = NWNXPopString();
+    str.nNumGroups = NWNXPopInt();
+    str.nNumCrossers = NWNXPopInt();
+    str.nNumTerrain = NWNXPopInt();
+    str.fHeightTransition = NWNXPopFloat();
+    str.nNumTileData = NWNXPopInt();
     return str;
 }
 
 string NWNX_Tileset_GetTilesetTerrain(string sTileset, int nIndex)
 {
-    NWNX_PushArgumentInt(nIndex);
-    NWNX_PushArgumentString(sTileset);
-    NWNX_CallFunction(NWNX_Tileset, "GetTilesetTerrain");
-
-    return NWNX_GetReturnValueString();
+    NWNXPushInt(nIndex);
+    NWNXPushString(sTileset);
+    NWNXCall(NWNX_Tileset, "GetTilesetTerrain");
+    return NWNXPopString();
 }
 
 string NWNX_Tileset_GetTilesetCrosser(string sTileset, int nIndex)
 {
-    NWNX_PushArgumentInt(nIndex);
-    NWNX_PushArgumentString(sTileset);
-    NWNX_CallFunction(NWNX_Tileset, "GetTilesetCrosser");
-
-    return NWNX_GetReturnValueString();
+    NWNXPushInt(nIndex);
+    NWNXPushString(sTileset);
+    NWNXCall(NWNX_Tileset, "GetTilesetCrosser");
+    return NWNXPopString();
 }
 
 struct NWNX_Tileset_TilesetGroupData NWNX_Tileset_GetTilesetGroupData(string sTileset, int nIndex)
 {
-    NWNX_PushArgumentInt(nIndex);
-    NWNX_PushArgumentString(sTileset);
-    NWNX_CallFunction(NWNX_Tileset, "GetTilesetGroupData");
-
+    NWNXPushInt(nIndex);
+    NWNXPushString(sTileset);
+    NWNXCall(NWNX_Tileset, "GetTilesetGroupData");
     struct NWNX_Tileset_TilesetGroupData str;
-    str.nColumns = NWNX_GetReturnValueInt();
-    str.nRows = NWNX_GetReturnValueInt();
-    str.nStrRef = NWNX_GetReturnValueInt();
-    str.sName = NWNX_GetReturnValueString();
-
+    str.nColumns = NWNXPopInt();
+    str.nRows = NWNXPopInt();
+    str.nStrRef = NWNXPopInt();
+    str.sName = NWNXPopString();
     return str;
 }
 
 int NWNX_Tileset_GetTilesetGroupTile(string sTileset, int nGroupIndex, int nTileIndex)
 {
-    NWNX_PushArgumentInt(nTileIndex);
-    NWNX_PushArgumentInt(nGroupIndex);
-    NWNX_PushArgumentString(sTileset);
-    NWNX_CallFunction(NWNX_Tileset, "GetTilesetGroupTile");
-
-    return NWNX_GetReturnValueInt();
+    NWNXPushInt(nTileIndex);
+    NWNXPushInt(nGroupIndex);
+    NWNXPushString(sTileset);
+    NWNXCall(NWNX_Tileset, "GetTilesetGroupTile");
+    return NWNXPopInt();
 }
 
 string NWNX_Tileset_GetTileModel(string sTileset, int nTileID)
 {
-    NWNX_PushArgumentInt(nTileID);
-    NWNX_PushArgumentString(sTileset);
-    NWNX_CallFunction(NWNX_Tileset, "GetTileModel");
-
-    return NWNX_GetReturnValueString();
+    NWNXPushInt(nTileID);
+    NWNXPushString(sTileset);
+    NWNXCall(NWNX_Tileset, "GetTileModel");
+    return NWNXPopString();
 }
 
 string NWNX_Tileset_GetTileMinimapTexture(string sTileset, int nTileID)
 {
-    NWNX_PushArgumentInt(nTileID);
-    NWNX_PushArgumentString(sTileset);
-    NWNX_CallFunction(NWNX_Tileset, "GetTileMinimapTexture");
-
-    return NWNX_GetReturnValueString();
+    NWNXPushInt(nTileID);
+    NWNXPushString(sTileset);
+    NWNXCall(NWNX_Tileset, "GetTileMinimapTexture");
+    return NWNXPopString();
 }
 
 struct NWNX_Tileset_TileEdgesAndCorners NWNX_Tileset_GetTileEdgesAndCorners(string sTileset, int nTileID)
 {
-    NWNX_PushArgumentInt(nTileID);
-    NWNX_PushArgumentString(sTileset);
-    NWNX_CallFunction(NWNX_Tileset, "GetTileEdgesAndCorners");
-
+    NWNXPushInt(nTileID);
+    NWNXPushString(sTileset);
+    NWNXCall(NWNX_Tileset, "GetTileEdgesAndCorners");
     struct NWNX_Tileset_TileEdgesAndCorners str;
-    str.sLeft = NWNX_GetReturnValueString();
-    str.sBottomLeft = NWNX_GetReturnValueString();
-    str.sBottom = NWNX_GetReturnValueString();
-    str.sBottomRight = NWNX_GetReturnValueString();
-    str.sRight = NWNX_GetReturnValueString();
-    str.sTopRight = NWNX_GetReturnValueString();
-    str.sTop = NWNX_GetReturnValueString();
-    str.sTopLeft = NWNX_GetReturnValueString();
-
+    str.sLeft = NWNXPopString();
+    str.sBottomLeft = NWNXPopString();
+    str.sBottom = NWNXPopString();
+    str.sBottomRight = NWNXPopString();
+    str.sRight = NWNXPopString();
+    str.sTopRight = NWNXPopString();
+    str.sTop = NWNXPopString();
+    str.sTopLeft = NWNXPopString();
     return str;
 }
 
 int NWNX_Tileset_GetTileNumDoors(string sTileset, int nTileID)
 {
-    NWNX_PushArgumentInt(nTileID);
-    NWNX_PushArgumentString(sTileset);
-    NWNX_CallFunction(NWNX_Tileset, "GetTileNumDoors");
-
-    return NWNX_GetReturnValueInt();
+    NWNXPushInt(nTileID);
+    NWNXPushString(sTileset);
+    NWNXCall(NWNX_Tileset, "GetTileNumDoors");
+    return NWNXPopInt();
 }
 
 struct NWNX_Tileset_TileDoorData NWNX_Tileset_GetTileDoorData(string sTileset, int nTileID, int nIndex = 0)
 {
-    NWNX_PushArgumentInt(nIndex);
-    NWNX_PushArgumentInt(nTileID);
-    NWNX_PushArgumentString(sTileset);
-    NWNX_CallFunction(NWNX_Tileset, "GetTileDoorData");
-
+    NWNXPushInt(nIndex);
+    NWNXPushInt(nTileID);
+    NWNXPushString(sTileset);
+    NWNXCall(NWNX_Tileset, "GetTileDoorData");
     struct NWNX_Tileset_TileDoorData str;
-    str.fOrientation = NWNX_GetReturnValueFloat();
-    str.fZ = NWNX_GetReturnValueFloat();
-    str.fY = NWNX_GetReturnValueFloat();
-    str.fX = NWNX_GetReturnValueFloat();
-    str.nType = NWNX_GetReturnValueInt();
-
+    str.fOrientation = NWNXPopFloat();
+    str.fZ = NWNXPopFloat();
+    str.fY = NWNXPopFloat();
+    str.fX = NWNXPopFloat();
+    str.nType = NWNXPopInt();
     return str;
 }
 
 void NWNX_Tileset_SetAreaTileOverride(string sAreaResRef, string sOverrideName)
 {
-    NWNX_PushArgumentString(sOverrideName);
-    NWNX_PushArgumentString(sAreaResRef);
-    NWNX_CallFunction(NWNX_Tileset, "SetAreaTileOverride");
+    NWNXPushString(sOverrideName);
+    NWNXPushString(sAreaResRef);
+    NWNXCall(NWNX_Tileset, "SetAreaTileOverride");
 }
 
 void NWNX_Tileset_CreateTileOverride(string sOverrideName, string sTileSet, int nWidth, int nHeight)
 {
-    NWNX_PushArgumentInt(nHeight);
-    NWNX_PushArgumentInt(nWidth);
-    NWNX_PushArgumentString(sTileSet);
-    NWNX_PushArgumentString(sOverrideName);
-    NWNX_CallFunction(NWNX_Tileset, "CreateTileOverride");
+    NWNXPushInt(nHeight);
+    NWNXPushInt(nWidth);
+    NWNXPushString(sTileSet);
+    NWNXPushString(sOverrideName);
+    NWNXCall(NWNX_Tileset, "CreateTileOverride");
 }
 
 void NWNX_Tileset_DeleteTileOverride(string sOverrideName)
 {
-    NWNX_PushArgumentString(sOverrideName);
-    NWNX_CallFunction(NWNX_Tileset, "DeleteTileOverride");
+    NWNXPushString(sOverrideName);
+    NWNXCall(NWNX_Tileset, "DeleteTileOverride");
 }
 
 void NWNX_Tileset_SetOverrideTileData(string sOverrideName, int nIndex, struct NWNX_Tileset_CustomTileData strCustomTileData)
 {
-    NWNX_PushArgumentInt(strCustomTileData.bAnimLoop3);
-    NWNX_PushArgumentInt(strCustomTileData.bAnimLoop2);
-    NWNX_PushArgumentInt(strCustomTileData.bAnimLoop1);
-    NWNX_PushArgumentInt(strCustomTileData.nSourceLightColor2);
-    NWNX_PushArgumentInt(strCustomTileData.nSourceLightColor1);
-    NWNX_PushArgumentInt(strCustomTileData.nMainLightColor2);
-    NWNX_PushArgumentInt(strCustomTileData.nMainLightColor1);
-    NWNX_PushArgumentInt(strCustomTileData.nHeight);
-    NWNX_PushArgumentInt(strCustomTileData.nOrientation);
-    NWNX_PushArgumentInt(strCustomTileData.nTileID);
-    NWNX_PushArgumentInt(nIndex);
-    NWNX_PushArgumentString(sOverrideName);
-    NWNX_CallFunction(NWNX_Tileset, "SetOverrideTileData");
+    NWNXPushInt(strCustomTileData.bAnimLoop3);
+    NWNXPushInt(strCustomTileData.bAnimLoop2);
+    NWNXPushInt(strCustomTileData.bAnimLoop1);
+    NWNXPushInt(strCustomTileData.nSourceLightColor2);
+    NWNXPushInt(strCustomTileData.nSourceLightColor1);
+    NWNXPushInt(strCustomTileData.nMainLightColor2);
+    NWNXPushInt(strCustomTileData.nMainLightColor1);
+    NWNXPushInt(strCustomTileData.nHeight);
+    NWNXPushInt(strCustomTileData.nOrientation);
+    NWNXPushInt(strCustomTileData.nTileID);
+    NWNXPushInt(nIndex);
+    NWNXPushString(sOverrideName);
+    NWNXCall(NWNX_Tileset, "SetOverrideTileData");
 }
 
 void NWNX_Tileset_DeleteOverrideTileData(string sOverrideName, int nIndex)
 {
-    NWNX_PushArgumentInt(nIndex);
-    NWNX_PushArgumentString(sOverrideName);
-    NWNX_CallFunction(NWNX_Tileset, "DeleteOverrideTileData");
+    NWNXPushInt(nIndex);
+    NWNXPushString(sOverrideName);
+    NWNXCall(NWNX_Tileset, "DeleteOverrideTileData");
 }

_module/nss/nwnx_time.nss

@@ -2,7 +2,6 @@
 /// @brief Provides various time related functions
 /// @{
 /// @file nwnx_time.nss
-#include "nwnx"
 #include "nwnx_util"
 #include "inc_sqlite_time"
 

_module/nss/nwnx_util.nss

@@ -2,7 +2,6 @@
 /// @brief Provides various utility functions that don't have a better home
 /// @{
 /// @file nwnx_util.nss
-#include "nwnx"
 
 const string NWNX_Util = "NWNX_Util"; ///< @private
 
@@ -174,12 +173,6 @@ int NWNX_Util_RegisterServerConsoleCommand(string sCommand, string sScriptChunk)
 /// @param sCommand The name of the command.
 void NWNX_Util_UnregisterServerConsoleCommand(string sCommand);
 
-/// @brief Determines if the given plugin exists and is enabled.
-/// @param sPlugin The name of the plugin to check. This is the case sensitive plugin name as used by NWNX_CallFunction, NWNX_PushArgumentX
-/// @note Example usage: NWNX_Util_PluginExists("NWNX_Creature");
-/// @return TRUE if the plugin exists and is enabled, otherwise FALSE.
-int NWNX_Util_PluginExists(string sPlugin);
-
 /// @brief Gets the server's current working user folder.
 /// @return The absolute path of the server's home directory (-userDirectory)
 string NWNX_Util_GetUserDirectory();
@@ -228,10 +221,18 @@ int NWNX_Util_GetScriptParamIsSet(string sParamName);
 /// @param nDawnHour The new dawn hour
 void NWNX_Util_SetDawnHour(int nDawnHour);
 
+/// @brief Get the module dawn hour.
+/// @return The dawn hour
+int NWNX_Util_GetDawnHour();
+
 /// @brief Set the module dusk hour.
 /// @param nDuskHour The new dusk hour
 void NWNX_Util_SetDuskHour(int nDuskHour);
 
+/// @brief Get the module dusk hour.
+/// @return The dusk hour
+int NWNX_Util_GetDuskHour();
+
 /// @return Returns the number of microseconds since midnight on January 1, 1970.
 struct NWNX_Util_HighResTimestamp NWNX_Util_GetHighResTimeStamp();
 
@@ -263,397 +264,327 @@ int NWNX_Util_CleanResourceDirectory(string sAlias, int nResType = 0xFFFF);
 /// @return The name
 string NWNX_Util_GetModuleTlkFile();
 
+/// @brief Update a resource directory by having ResMan reindex it.
+/// @param sAlias A resource directory alias, eg: TEMP
+/// @return TRUE if successful, FALSE on error.
+int NWNX_Util_UpdateResourceDirectory(string sAlias);
+
 /// @}
 
 string NWNX_Util_GetCurrentScriptName(int depth = 0)
 {
-    string sFunc = "GetCurrentScriptName";
-    NWNX_PushArgumentInt(depth);
-    NWNX_CallFunction(NWNX_Util, sFunc);
-    return NWNX_GetReturnValueString();
+    NWNXPushInt(depth);
+    NWNXCall(NWNX_Util, "GetCurrentScriptName");
+    return NWNXPopString();
 }
 
 string NWNX_Util_GetAsciiTableString()
 {
-    string sFunc = "GetAsciiTableString";
-    NWNX_CallFunction(NWNX_Util, sFunc);
-    return NWNX_GetReturnValueString();
+    NWNXCall(NWNX_Util, "GetAsciiTableString");
+    return NWNXPopString();
 }
 
 int NWNX_Util_Hash(string str)
 {
-    string sFunc = "Hash";
-    NWNX_PushArgumentString(str);
-    NWNX_CallFunction(NWNX_Util, sFunc);
-    return NWNX_GetReturnValueInt();
+    NWNXPushString(str);
+    NWNXCall(NWNX_Util, "Hash");
+    return NWNXPopInt();
 }
 
 int NWNX_Util_GetModuleMtime()
 {
-    NWNX_CallFunction(NWNX_Util, "GetModuleMtime");
-    return NWNX_GetReturnValueInt();
+    NWNXCall(NWNX_Util, "GetModuleMtime");
+    return NWNXPopInt();
 }
 
 string NWNX_Util_GetModuleFile()
 {
-    NWNX_CallFunction(NWNX_Util, "GetModuleFile");
-    return NWNX_GetReturnValueString();
+    NWNXCall(NWNX_Util, "GetModuleFile");
+    return NWNXPopString();
 }
 
 string NWNX_Util_GetCustomToken(int customTokenNumber)
 {
-    string sFunc = "GetCustomToken";
-    NWNX_PushArgumentInt(customTokenNumber);
-    NWNX_CallFunction(NWNX_Util, sFunc);
-    return NWNX_GetReturnValueString();
+    NWNXPushInt(customTokenNumber);
+    NWNXCall(NWNX_Util, "GetCustomToken");
+    return NWNXPopString();
 }
 
 itemproperty NWNX_Util_EffectToItemProperty(effect e)
 {
-    string sFunc = "EffectTypeCast";
-    NWNX_PushArgumentEffect(e);
-    NWNX_CallFunction(NWNX_Util, sFunc);
-    return NWNX_GetReturnValueItemProperty();
+    NWNXPushEffect(e);
+    NWNXCall(NWNX_Util, "EffectTypeCast");
+    return NWNXPopItemProperty();
 }
 
 effect NWNX_Util_ItemPropertyToEffect(itemproperty ip)
 {
-    string sFunc = "EffectTypeCast";
-    NWNX_PushArgumentItemProperty(ip);
-    NWNX_CallFunction(NWNX_Util, sFunc);
-    return NWNX_GetReturnValueEffect();
+    NWNXPushItemProperty(ip);
+    NWNXCall(NWNX_Util, "EffectTypeCast");
+    return NWNXPopEffect();
 }
 
 string NWNX_Util_StripColors(string str)
 {
-    string sFunc = "StripColors";
-    NWNX_PushArgumentString(str);
-    NWNX_CallFunction(NWNX_Util, sFunc);
-    return NWNX_GetReturnValueString();
+    NWNXPushString(str);
+    NWNXCall(NWNX_Util, "StripColors");
+    return NWNXPopString();
 }
 
 string NWNX_Util_GetEnvironmentVariable(string sVarname)
 {
-    string sFunc = "GetEnvironmentVariable";
-    NWNX_PushArgumentString(sVarname);
-    NWNX_CallFunction(NWNX_Util, sFunc);
-    return NWNX_GetReturnValueString();
+    NWNXPushString(sVarname);
+    NWNXCall(NWNX_Util, "GetEnvironmentVariable");
+    return NWNXPopString();
 }
 
 int NWNX_Util_GetMinutesPerHour()
 {
-    string sFunc = "GetMinutesPerHour";
-    NWNX_CallFunction(NWNX_Util, sFunc);
-    return NWNX_GetReturnValueInt();
+    NWNXCall(NWNX_Util, "GetMinutesPerHour");
+    return NWNXPopInt();
 }
 
 void NWNX_Util_SetMinutesPerHour(int minutes)
 {
-    string sFunc = "SetMinutesPerHour";
-    NWNX_PushArgumentInt(minutes);
-    NWNX_CallFunction(NWNX_Util, sFunc);
+    NWNXPushInt(minutes);
+    NWNXCall(NWNX_Util, "SetMinutesPerHour");
 }
 
 string NWNX_Util_EncodeStringForURL(string sURL)
 {
-    string sFunc = "EncodeStringForURL";
-
-    NWNX_PushArgumentString(sURL);
-    NWNX_CallFunction(NWNX_Util, sFunc);
-
-    return NWNX_GetReturnValueString();
+    NWNXPushString(sURL);
+    NWNXCall(NWNX_Util, "EncodeStringForURL");
+    return NWNXPopString();
 }
 
 string NWNX_Util_GetFirstResRef(int nType, string sRegexFilter = "", int bModuleResourcesOnly = TRUE)
 {
-    string sFunc = "GetFirstResRef";
-
-    NWNX_PushArgumentInt(bModuleResourcesOnly);
-    NWNX_PushArgumentString(sRegexFilter);
-    NWNX_PushArgumentInt(nType);
-    NWNX_CallFunction(NWNX_Util, sFunc);
-
-    return NWNX_GetReturnValueString();
+    NWNXPushInt(bModuleResourcesOnly);
+    NWNXPushString(sRegexFilter);
+    NWNXPushInt(nType);
+    NWNXCall(NWNX_Util, "GetFirstResRef");
+    return NWNXPopString();
 }
 
 string NWNX_Util_GetNextResRef()
 {
-    string sFunc = "GetNextResRef";
-
-    NWNX_CallFunction(NWNX_Util, sFunc);
-
-    return NWNX_GetReturnValueString();
+    NWNXCall(NWNX_Util, "GetNextResRef");
+    return NWNXPopString();
 }
 
 object NWNX_Util_GetLastCreatedObject(int nObjectType, int nNthLast = 1)
 {
-    string sFunc = "GetLastCreatedObject";
-
-    NWNX_PushArgumentInt(nNthLast);
-    NWNX_PushArgumentInt(nObjectType);
-    NWNX_CallFunction(NWNX_Util, sFunc);
-
-    return NWNX_GetReturnValueObject();
+    NWNXPushInt(nNthLast);
+    NWNXPushInt(nObjectType);
+    NWNXCall(NWNX_Util, "GetLastCreatedObject");
+    return NWNXPopObject();
 }
 
 string NWNX_Util_AddScript(string sFileName, string sScriptData, int bWrapIntoMain = FALSE, string sAlias = "NWNX")
 {
-    string sFunc = "AddScript";
-
-    NWNX_PushArgumentString(sAlias);
-    NWNX_PushArgumentInt(bWrapIntoMain);
-    NWNX_PushArgumentString(sScriptData);
-    NWNX_PushArgumentString(sFileName);
-    NWNX_CallFunction(NWNX_Util, sFunc);
-
-    return NWNX_GetReturnValueString();
+    NWNXPushString(sAlias);
+    NWNXPushInt(bWrapIntoMain);
+    NWNXPushString(sScriptData);
+    NWNXPushString(sFileName);
+    NWNXCall(NWNX_Util, "AddScript");
+    return NWNXPopString();
 }
 
 int NWNX_Util_AddNSSFile(string sFileName, string sContents, string sAlias = "NWNX")
 {
-    string sFunc = "AddNSSFile";
-
-    NWNX_PushArgumentString(sAlias);
-    NWNX_PushArgumentString(sContents);
-    NWNX_PushArgumentString(sFileName);
-    NWNX_CallFunction(NWNX_Util, sFunc);
-
-    return NWNX_GetReturnValueInt();
+    NWNXPushString(sAlias);
+    NWNXPushString(sContents);
+    NWNXPushString(sFileName);
+    NWNXCall(NWNX_Util, "AddNSSFile");
+    return NWNXPopInt();
 }
 
 int NWNX_Util_RemoveNWNXResourceFile(string sFileName, int nType, string sAlias = "NWNX")
 {
-    string sFunc = "RemoveNWNXResourceFile";
-
-    NWNX_PushArgumentString(sAlias);
-    NWNX_PushArgumentInt(nType);
-    NWNX_PushArgumentString(sFileName);
-    NWNX_CallFunction(NWNX_Util, sFunc);
-
-    return NWNX_GetReturnValueInt();
+    NWNXPushString(sAlias);
+    NWNXPushInt(nType);
+    NWNXPushString(sFileName);
+    NWNXCall(NWNX_Util, "RemoveNWNXResourceFile");
+    return NWNXPopInt();
 }
 
 void NWNX_Util_SetInstructionLimit(int nInstructionLimit)
 {
-    string sFunc = "SetInstructionLimit";
-
-    NWNX_PushArgumentInt(nInstructionLimit);
-    NWNX_CallFunction(NWNX_Util, sFunc);
+    NWNXPushInt(nInstructionLimit);
+    NWNXCall(NWNX_Util, "SetInstructionLimit");
 }
 
 int NWNX_Util_GetInstructionLimit()
 {
-    string sFunc = "GetInstructionLimit";
-
-    NWNX_CallFunction(NWNX_Util, sFunc);
-
-    return NWNX_GetReturnValueInt();
+    NWNXCall(NWNX_Util, "GetInstructionLimit");
+    return NWNXPopInt();
 }
 
 void NWNX_Util_SetInstructionsExecuted(int nInstructions)
 {
-    string sFunc = "SetInstructionsExecuted";
-
-    NWNX_PushArgumentInt(nInstructions);
-    NWNX_CallFunction(NWNX_Util, sFunc);
+    NWNXPushInt(nInstructions);
+    NWNXCall(NWNX_Util, "SetInstructionsExecuted");
 }
 
 int NWNX_Util_GetInstructionsExecuted()
 {
-    string sFunc = "GetInstructionsExecuted";
-
-    NWNX_CallFunction(NWNX_Util, sFunc);
-
-    return NWNX_GetReturnValueInt();
+    NWNXCall(NWNX_Util, "GetInstructionsExecuted");
+    return NWNXPopInt();
 }
 
 int NWNX_Util_RegisterServerConsoleCommand(string sCommand, string sScriptChunk)
 {
-    string sFunc = "RegisterServerConsoleCommand";
-
-    NWNX_PushArgumentString(sScriptChunk);
-    NWNX_PushArgumentString(sCommand);
-    NWNX_CallFunction(NWNX_Util, sFunc);
-
-    return NWNX_GetReturnValueInt();
+    NWNXPushString(sScriptChunk);
+    NWNXPushString(sCommand);
+    NWNXCall(NWNX_Util, "RegisterServerConsoleCommand");
+    return NWNXPopInt();
 }
 
 void NWNX_Util_UnregisterServerConsoleCommand(string sCommand)
 {
-    string sFunc = "UnregisterServerConsoleCommand";
-
-    NWNX_PushArgumentString(sCommand);
-    NWNX_CallFunction(NWNX_Util, sFunc);
-}
-
-int NWNX_Util_PluginExists(string sPlugin)
-{
-    WriteTimestampedLogEntry("WARNING:  NWNX_Util_PluginExists is deprecated.  You should migrate to NWNX_PluginExists.");
-    return NWNX_PluginExists(sPlugin);
+    NWNXPushString(sCommand);
+    NWNXCall(NWNX_Util, "UnregisterServerConsoleCommand");
 }
 
 string NWNX_Util_GetUserDirectory()
 {
-    string sFunc = "GetUserDirectory";
-    NWNX_CallFunction(NWNX_Util, sFunc);
-    return NWNX_GetReturnValueString();
+    NWNXCall(NWNX_Util, "GetUserDirectory");
+    return NWNXPopString();
 }
 
 int NWNX_Util_GetScriptReturnValue()
 {
-    string sFunc = "GetScriptReturnValue";
-
-    NWNX_CallFunction(NWNX_Util, sFunc);
-
-    return NWNX_GetReturnValueInt();
+    NWNXCall(NWNX_Util, "GetScriptReturnValue");
+    return NWNXPopInt();
 }
 
 object NWNX_Util_CreateDoor(string sResRef, location locLocation, string sNewTag = "", int nAppearanceType = -1)
 {
-    string sFunc = "CreateDoor";
-
-    vector vPosition = GetPositionFromLocation(locLocation);
-
-    NWNX_PushArgumentInt(nAppearanceType);
-    NWNX_PushArgumentString(sNewTag);
-    NWNX_PushArgumentFloat(GetFacingFromLocation(locLocation));
-    NWNX_PushArgumentFloat(vPosition.z);
-    NWNX_PushArgumentFloat(vPosition.y);
-    NWNX_PushArgumentFloat(vPosition.x);
-    NWNX_PushArgumentObject(GetAreaFromLocation(locLocation));
-    NWNX_PushArgumentString(sResRef);
-    NWNX_CallFunction(NWNX_Util, sFunc);
-
-    return NWNX_GetReturnValueObject();
+    NWNXPushInt(nAppearanceType);
+    NWNXPushString(sNewTag);
+    NWNXPushLocation(locLocation);
+    NWNXPushString(sResRef);
+    NWNXCall(NWNX_Util, "CreateDoor");
+    return NWNXPopObject();
 }
 
 void NWNX_Util_SetItemActivator(object oObject)
 {
-    string sFunc = "SetItemActivator";
-
-    NWNX_PushArgumentObject(oObject);
-    NWNX_CallFunction(NWNX_Util, sFunc);
+    NWNXPushObject(oObject);
+    NWNXCall(NWNX_Util, "SetItemActivator");
 }
 
 struct NWNX_Util_WorldTime NWNX_Util_GetWorldTime(float fAdjustment = 0.0f)
 {
-    string sFunc = "GetWorldTime";
-
-    NWNX_PushArgumentFloat(fAdjustment);
-    NWNX_CallFunction(NWNX_Util, sFunc);
-
+    NWNXPushFloat(fAdjustment);
+    NWNXCall(NWNX_Util, "GetWorldTime");
     struct NWNX_Util_WorldTime strWorldTime;
-    strWorldTime.nTimeOfDay = NWNX_GetReturnValueInt();
-    strWorldTime.nCalendarDay = NWNX_GetReturnValueInt();
-
+    strWorldTime.nTimeOfDay = NWNXPopInt();
+    strWorldTime.nCalendarDay = NWNXPopInt();
     return strWorldTime;
 }
 
 void NWNX_Util_SetResourceOverride(int nResType, string sOldName, string sNewName)
 {
-    string sFunc = "SetResourceOverride";
-
-    NWNX_PushArgumentString(sNewName);
-    NWNX_PushArgumentString(sOldName);
-    NWNX_PushArgumentInt(nResType);
-    NWNX_CallFunction(NWNX_Util, sFunc);
+    NWNXPushString(sNewName);
+    NWNXPushString(sOldName);
+    NWNXPushInt(nResType);
+    NWNXCall(NWNX_Util, "SetResourceOverride");
 }
 
 string NWNX_Util_GetResourceOverride(int nResType, string sName)
 {
-    string sFunc = "GetResourceOverride";
-
-    NWNX_PushArgumentString(sName);
-    NWNX_PushArgumentInt(nResType);
-    NWNX_CallFunction(NWNX_Util, sFunc);
-
-    return NWNX_GetReturnValueString();
+    NWNXPushString(sName);
+    NWNXPushInt(nResType);
+    NWNXCall(NWNX_Util, "GetResourceOverride");
+    return NWNXPopString();
 }
 
 int NWNX_Util_GetScriptParamIsSet(string sParamName)
 {
-    string sFunc = "GetScriptParamIsSet";
-
-    NWNX_PushArgumentString(sParamName);
-    NWNX_CallFunction(NWNX_Util, sFunc);
-
-    return NWNX_GetReturnValueInt();
+    NWNXPushString(sParamName);
+    NWNXCall(NWNX_Util, "GetScriptParamIsSet");
+    return NWNXPopInt();
 }
 
 void NWNX_Util_SetDawnHour(int nDawnHour)
 {
-    string sFunc = "SetDawnHour";
+    NWNXPushInt(nDawnHour);
+    NWNXCall(NWNX_Util, "SetDawnHour");
+}
 
-    NWNX_PushArgumentInt(nDawnHour);
-    NWNX_CallFunction(NWNX_Util, sFunc);
+int NWNX_Util_GetDawnHour()
+{
+    NWNXCall(NWNX_Util, "GetDawnHour");
+    return NWNXPopInt();
 }
 
 void NWNX_Util_SetDuskHour(int nDuskHour)
 {
-    string sFunc = "SetDuskHour";
+    NWNXPushInt(nDuskHour);
+    NWNXCall(NWNX_Util, "SetDuskHour");
+}
 
-    NWNX_PushArgumentInt(nDuskHour);
-    NWNX_CallFunction(NWNX_Util, sFunc);
+int NWNX_Util_GetDuskHour()
+{
+    NWNXCall(NWNX_Util, "GetDuskHour");
+    return NWNXPopInt();
 }
 
 struct NWNX_Util_HighResTimestamp NWNX_Util_GetHighResTimeStamp()
 {
     struct NWNX_Util_HighResTimestamp t;
-    string sFunc = "GetHighResTimeStamp";
-
-    NWNX_CallFunction(NWNX_Util, sFunc);
-    t.microseconds = NWNX_GetReturnValueInt();
-    t.seconds = NWNX_GetReturnValueInt();
+    NWNXCall(NWNX_Util, "GetHighResTimeStamp");
+    t.microseconds = NWNXPopInt();
+    t.seconds = NWNXPopInt();
     return t;
 }
 
 string NWNX_Util_GetTTY()
 {
-    string sFunc = "GetTTY";
-
-    NWNX_CallFunction(NWNX_Util, sFunc);
-    return NWNX_GetReturnValueString();
+    NWNXCall(NWNX_Util, "GetTTY");
+    return NWNXPopString();
 }
 
 void NWNX_Util_SetCurrentlyRunningEvent(int nEventID)
 {
-    string sFunc = "SetCurrentlyRunningEvent";
-
-    NWNX_PushArgumentInt(nEventID);
-    NWNX_CallFunction(NWNX_Util, sFunc);
+    NWNXPushInt(nEventID);
+    NWNXCall(NWNX_Util, "SetCurrentlyRunningEvent");
 }
 
 int NWNX_Util_GetStringLevenshteinDistance(string sString, string sCompareTo)
 {
-    string sFunc = "LevenshteinDistance";
-
-    NWNX_PushArgumentString(sCompareTo);
-    NWNX_PushArgumentString(sString);
-    NWNX_CallFunction(NWNX_Util, sFunc);
-    return NWNX_GetReturnValueInt();
+    NWNXPushString(sCompareTo);
+    NWNXPushString(sString);
+    NWNXCall(NWNX_Util, "GetStringLevenshteinDistance");
+    return NWNXPopInt();
 }
 
 void NWNX_Util_UpdateClientObject(object oObjectToUpdate, object oPlayer = OBJECT_INVALID)
 {
-    string sFunc = "UpdateClientObject";
-
-    NWNX_PushArgumentObject(oPlayer);
-    NWNX_PushArgumentObject(oObjectToUpdate);
-    NWNX_CallFunction(NWNX_Util, sFunc);
+    NWNXPushObject(oPlayer);
+    NWNXPushObject(oObjectToUpdate);
+    NWNXCall(NWNX_Util, "UpdateClientObject");
 }
 
 int NWNX_Util_CleanResourceDirectory(string sAlias, int nResType = 0xFFFF)
 {
-    string sFunc = "CleanResourceDirectory";
-    NWNX_PushArgumentInt(nResType);
-    NWNX_PushArgumentString(sAlias);
-    NWNX_CallFunction(NWNX_Util, sFunc);
-    return NWNX_GetReturnValueInt();
+    NWNXPushInt(nResType);
+    NWNXPushString(sAlias);
+    NWNXCall(NWNX_Util, "CleanResourceDirectory");
+    return NWNXPopInt();
 }
 
 string NWNX_Util_GetModuleTlkFile()
 {
     string sFunc = "GetModuleTlkFile";
-    NWNX_CallFunction(NWNX_Util, sFunc);
-    return NWNX_GetReturnValueString();
+    NWNXCall(NWNX_Util, sFunc);
+    return NWNXPopString();
+}
+
+int NWNX_Util_UpdateResourceDirectory(string sAlias)
+{
+    NWNXPushString(sAlias);
+    NWNXCall(NWNX_Util, "UpdateResourceDirectory");
+    return NWNXPopInt();
 }

_module/nss/nwnx_visibility.nss

@@ -2,7 +2,6 @@
 /// @brief Functions to manipulate visibility of objects both globally or per observer
 /// @{
 /// @file nwnx_visibility.nss
-#include "nwnx"
 
 const string NWNX_Visibility = "NWNX_Visibility"; ///< @private
 
@@ -57,21 +56,16 @@ void NWNX_Visibility_SetVisibilityOverride(object oPlayer, object oTarget, int n
 
 int NWNX_Visibility_GetVisibilityOverride(object oPlayer, object oTarget)
 {
-    string sFunc = "GetVisibilityOverride";
-
-    NWNX_PushArgumentObject(oTarget);
-    NWNX_PushArgumentObject(oPlayer);
-    NWNX_CallFunction(NWNX_Visibility, sFunc);
-
-    return NWNX_GetReturnValueInt();
+    NWNXPushObject(oTarget);
+    NWNXPushObject(oPlayer);
+    NWNXCall(NWNX_Visibility, "GetVisibilityOverride");
+    return NWNXPopInt();
 }
 
 void NWNX_Visibility_SetVisibilityOverride(object oPlayer, object oTarget, int nOverride)
 {
-    string sFunc = "SetVisibilityOverride";
-
-    NWNX_PushArgumentInt(nOverride);
-    NWNX_PushArgumentObject(oTarget);
-    NWNX_PushArgumentObject(oPlayer);
-    NWNX_CallFunction(NWNX_Visibility, sFunc);
+    NWNXPushInt(nOverride);
+    NWNXPushObject(oTarget);
+    NWNXPushObject(oPlayer);
+    NWNXCall(NWNX_Visibility, "SetVisibilityOverride");
 }

_module/nss/nwnx_weapon.nss

@@ -2,7 +2,6 @@
 /// @brief Functions exposing additional weapon properties.
 /// @{
 /// @file nwnx_weapon.nss
-#include "nwnx"
 
 const string NWNX_Weapon = "NWNX_Weapon"; ///< @private
 
@@ -138,214 +137,152 @@ void NWNX_Weapon_SetMaxRangedAttackDistanceOverride(int nBaseItem, float fMax, f
 
 void NWNX_Weapon_SetWeaponFocusFeat(int nBaseItem, int nFeat)
 {
-    string sFunc = "SetWeaponFocusFeat";
-
-    NWNX_PushArgumentInt(nFeat);
-    NWNX_PushArgumentInt(nBaseItem);
-
-    NWNX_CallFunction(NWNX_Weapon, sFunc);
+    NWNXPushInt(nFeat);
+    NWNXPushInt(nBaseItem);
+    NWNXCall(NWNX_Weapon, "SetWeaponFocusFeat");
 }
 
 void NWNX_Weapon_SetEpicWeaponFocusFeat(int nBaseItem, int nFeat)
 {
-    string sFunc = "SetEpicWeaponFocusFeat";
-
-    NWNX_PushArgumentInt(nFeat);
-    NWNX_PushArgumentInt(nBaseItem);
-
-    NWNX_CallFunction(NWNX_Weapon, sFunc);
+    NWNXPushInt(nFeat);
+    NWNXPushInt(nBaseItem);
+    NWNXCall(NWNX_Weapon, "SetEpicWeaponFocusFeat");
 }
 
 void NWNX_Weapon_SetGreaterWeaponFocusFeat(int nBaseItem, int nFeat)
 {
-    string sFunc = "SetGreaterWeaponFocusFeat";
-
-    NWNX_PushArgumentInt(nFeat);
-    NWNX_PushArgumentInt(nBaseItem);
-
-    NWNX_CallFunction(NWNX_Weapon, sFunc);
+    NWNXPushInt(nFeat);
+    NWNXPushInt(nBaseItem);
+    NWNXCall(NWNX_Weapon, "SetGreaterWeaponFocusFeat");
 }
 
 void NWNX_Weapon_SetWeaponFinesseSize(int nBaseItem, int nSize)
 {
-    string sFunc = "SetWeaponFinesseSize";
-
-    NWNX_PushArgumentInt(nSize);
-    NWNX_PushArgumentInt(nBaseItem);
-
-    NWNX_CallFunction(NWNX_Weapon, sFunc);
+    NWNXPushInt(nSize);
+    NWNXPushInt(nBaseItem);
+    NWNXCall(NWNX_Weapon, "SetWeaponFinesseSize");
 }
 
 int NWNX_Weapon_GetWeaponFinesseSize(int nBaseItem)
 {
-    string sFunc = "GetWeaponFinesseSize";
-
-    NWNX_PushArgumentInt(nBaseItem);
-
-    NWNX_CallFunction(NWNX_Weapon, sFunc);
-
-    return NWNX_GetReturnValueInt();
+    NWNXPushInt(nBaseItem);
+    NWNXCall(NWNX_Weapon, "GetWeaponFinesseSize");
+    return NWNXPopInt();
 }
 
 void NWNX_Weapon_SetWeaponUnarmed(int nBaseItem)
 {
-    string sFunc = "SetWeaponUnarmed";
-
-    NWNX_PushArgumentInt(nBaseItem);
-
-    NWNX_CallFunction(NWNX_Weapon, sFunc);
+    NWNXPushInt(nBaseItem);
+    NWNXCall(NWNX_Weapon, "SetWeaponUnarmed");
 }
 
 void NWNX_Weapon_SetWeaponIsMonkWeapon(int nBaseItem)
 {
     WriteTimestampedLogEntry("NWNX_Weapon_SetWeaponIsMonkWeapon() is deprecated. Please use baseitems.2da instead.");
-
-    string sFunc = "SetWeaponIsMonkWeapon";
-
-    NWNX_PushArgumentInt(nBaseItem);
-
-    NWNX_CallFunction(NWNX_Weapon, sFunc);
+    NWNXPushInt(nBaseItem);
+    NWNXCall(NWNX_Weapon, "SetWeaponIsMonkWeapon");
 }
 
 void NWNX_Weapon_SetWeaponImprovedCriticalFeat(int nBaseItem, int nFeat)
 {
-    string sFunc = "SetWeaponImprovedCriticalFeat";
-
-    NWNX_PushArgumentInt(nFeat);
-    NWNX_PushArgumentInt(nBaseItem);
-
-    NWNX_CallFunction(NWNX_Weapon, sFunc);
+    NWNXPushInt(nFeat);
+    NWNXPushInt(nBaseItem);
+    NWNXCall(NWNX_Weapon, "SetWeaponImprovedCriticalFeat");
 }
 
 void NWNX_Weapon_SetWeaponSpecializationFeat(int nBaseItem, int nFeat)
 {
-    string sFunc = "SetWeaponSpecializationFeat";
-
-    NWNX_PushArgumentInt(nFeat);
-    NWNX_PushArgumentInt(nBaseItem);
-
-    NWNX_CallFunction(NWNX_Weapon, sFunc);
+    NWNXPushInt(nFeat);
+    NWNXPushInt(nBaseItem);
+    NWNXCall(NWNX_Weapon, "SetWeaponSpecializationFeat");
 }
 
 void NWNX_Weapon_SetGreaterWeaponSpecializationFeat(int nBaseItem, int nFeat)
 {
-    string sFunc = "SetGreaterWeaponSpecializationFeat";
-
-    NWNX_PushArgumentInt(nFeat);
-    NWNX_PushArgumentInt(nBaseItem);
-
-    NWNX_CallFunction(NWNX_Weapon, sFunc);
+    NWNXPushInt(nFeat);
+    NWNXPushInt(nBaseItem);
+    NWNXCall(NWNX_Weapon, "SetGreaterWeaponSpecializationFeat");
 }
 
 void NWNX_Weapon_SetEpicWeaponSpecializationFeat(int nBaseItem, int nFeat)
 {
-    string sFunc = "SetEpicWeaponSpecializationFeat";
-
-    NWNX_PushArgumentInt(nFeat);
-    NWNX_PushArgumentInt(nBaseItem);
-
-    NWNX_CallFunction(NWNX_Weapon, sFunc);
+    NWNXPushInt(nFeat);
+    NWNXPushInt(nBaseItem);
+    NWNXCall(NWNX_Weapon, "SetEpicWeaponSpecializationFeat");
 }
 
 void NWNX_Weapon_SetEpicWeaponOverwhelmingCriticalFeat(int nBaseItem, int nFeat)
 {
-    string sFunc = "SetEpicWeaponOverwhelmingCriticalFeat";
-
-    NWNX_PushArgumentInt(nFeat);
-    NWNX_PushArgumentInt(nBaseItem);
-
-    NWNX_CallFunction(NWNX_Weapon, sFunc);
+    NWNXPushInt(nFeat);
+    NWNXPushInt(nBaseItem);
+    NWNXCall(NWNX_Weapon, "SetEpicWeaponOverwhelmingCriticalFeat");
 }
 
 void NWNX_Weapon_SetEpicWeaponDevastatingCriticalFeat(int nBaseItem, int nFeat)
 {
-    string sFunc = "SetEpicWeaponDevastatingCriticalFeat";
-
-    NWNX_PushArgumentInt(nFeat);
-    NWNX_PushArgumentInt(nBaseItem);
-
-    NWNX_CallFunction(NWNX_Weapon, sFunc);
+    NWNXPushInt(nFeat);
+    NWNXPushInt(nBaseItem);
+    NWNXCall(NWNX_Weapon, "SetEpicWeaponDevastatingCriticalFeat");
 }
 
 void NWNX_Weapon_SetWeaponOfChoiceFeat(int nBaseItem, int nFeat)
 {
-    string sFunc = "SetWeaponOfChoiceFeat";
-
-    NWNX_PushArgumentInt(nFeat);
-    NWNX_PushArgumentInt(nBaseItem);
-
-    NWNX_CallFunction(NWNX_Weapon, sFunc);
+    NWNXPushInt(nFeat);
+    NWNXPushInt(nBaseItem);
+    NWNXCall(NWNX_Weapon, "SetWeaponOfChoiceFeat");
 }
 
 void NWNX_Weapon_SetOption(int nOption, int nVal)
 {
-    string sFunc = "SetOption";
-
-    NWNX_PushArgumentInt(nVal);
-    NWNX_PushArgumentInt(nOption);
-
-    NWNX_CallFunction(NWNX_Weapon, sFunc);
+    NWNXPushInt(nVal);
+    NWNXPushInt(nOption);
+    NWNXCall(NWNX_Weapon, "SetOption");
 }
 
 void NWNX_Weapon_SetDevastatingCriticalEventScript(string sScript)
 {
-    string sFunc = "SetDevastatingCriticalEventScript";
-
-    NWNX_PushArgumentString(sScript);
-
-    NWNX_CallFunction(NWNX_Weapon, sFunc);
+    NWNXPushString(sScript);
+    NWNXCall(NWNX_Weapon, "SetDevastatingCriticalEventScript");
 }
 
 void NWNX_Weapon_BypassDevastatingCritical()
 {
-    string sFunc = "SetEventData";
-
-    NWNX_PushArgumentInt(1);
-    NWNX_PushArgumentInt(NWNX_WEAPON_SETDATA_DC_BYPASS);
-
-    NWNX_CallFunction(NWNX_Weapon, sFunc);
+    NWNXPushInt(1);
+    NWNXPushInt(NWNX_WEAPON_SETDATA_DC_BYPASS);
+    NWNXCall(NWNX_Weapon, "SetEventData");
 }
 
 struct NWNX_Weapon_DevastatingCriticalEvent_Data NWNX_Weapon_GetDevastatingCriticalEventData()
 {
-    string sFunc = "GetEventData";
     struct NWNX_Weapon_DevastatingCriticalEvent_Data data;
-
-    NWNX_PushArgumentInt(NWNX_WEAPON_GETDATA_DC);
-    NWNX_CallFunction(NWNX_Weapon, sFunc);
-
-    data.oWeapon = NWNX_GetReturnValueObject();
-    data.oTarget = NWNX_GetReturnValueObject();
-    data.nDamage = NWNX_GetReturnValueInt();
-
+    NWNXPushInt(NWNX_WEAPON_GETDATA_DC);
+    NWNXCall(NWNX_Weapon, "GetEventData");
+    data.oWeapon = NWNXPopObject();
+    data.oTarget = NWNXPopObject();
+    data.nDamage = NWNXPopInt();
     return data;
 }
 
 void NWNX_Weapon_SetOneHalfStrength(object oWeapon, int nEnable, int bPersist = FALSE)
 {
-    string sFunc = "SetOneHalfStrength";
-    NWNX_PushArgumentInt(bPersist);
-    NWNX_PushArgumentInt(nEnable);
-    NWNX_PushArgumentObject(oWeapon);
-    NWNX_CallFunction(NWNX_Weapon, sFunc);
+    NWNXPushInt(bPersist);
+    NWNXPushInt(nEnable);
+    NWNXPushObject(oWeapon);
+    NWNXCall(NWNX_Weapon, "SetOneHalfStrength");
 }
 
 int NWNX_Weapon_GetOneHalfStrength(object oWeapon)
 {
-    string sFunc = "GetOneHalfStrength";
-    NWNX_PushArgumentObject(oWeapon);
-    NWNX_CallFunction(NWNX_Weapon, sFunc);
-
-    return NWNX_GetReturnValueInt();
+    NWNXPushObject(oWeapon);
+    NWNXCall(NWNX_Weapon, "GetOneHalfStrength");
+    return NWNXPopInt();
 }
 
 void NWNX_Weapon_SetMaxRangedAttackDistanceOverride(int nBaseItem, float fMax, float fMaxPassive, float fPreferred)
 {
-    string sFunc = "SetMaxRangedAttackDistanceOverride";
-
-    NWNX_PushArgumentFloat(fPreferred);
-    NWNX_PushArgumentFloat(fMaxPassive);
-    NWNX_PushArgumentFloat(fMax);
-    NWNX_PushArgumentInt(nBaseItem);
-    NWNX_CallFunction(NWNX_Weapon, sFunc);
+    NWNXPushFloat(fPreferred);
+    NWNXPushFloat(fMaxPassive);
+    NWNXPushFloat(fMax);
+    NWNXPushInt(nBaseItem);
+    NWNXCall(NWNX_Weapon, "SetMaxRangedAttackDistanceOverride");
 }

_module/nss/nwnx_webhook.nss

@@ -2,7 +2,6 @@
 /// @brief Send messages to external entities through web hooks.
 /// @{
 /// @file nwnx_webhook.nss
-#include "nwnx"
 
 const string NWNX_WebHook = "NWNX_WebHook"; ///< @private
 
@@ -28,13 +27,12 @@ void NWNX_WebHook_ResendWebHookHTTPS(string host, string path, string sMessage,
 
 void NWNX_WebHook_SendWebHookHTTPS(string host, string path, string message, string username = "", int mrkdwn = 1)
 {
-    string sFunc = "SendWebHookHTTPS";
-    NWNX_PushArgumentInt(mrkdwn);
-    NWNX_PushArgumentString(username);
-    NWNX_PushArgumentString(message);
-    NWNX_PushArgumentString(path);
-    NWNX_PushArgumentString(host);
-    NWNX_CallFunction(NWNX_WebHook, sFunc);
+    NWNXPushInt(mrkdwn);
+    NWNXPushString(username);
+    NWNXPushString(message);
+    NWNXPushString(path);
+    NWNXPushString(host);
+    NWNXCall(NWNX_WebHook, "SendWebHookHTTPS");
 }
 
 void NWNX_WebHook_ResendWebHookHTTPS(string host, string path, string sMessage, float delay = 0.0f)