lsteamclient: Wrap parameters in structures.

CW-Bug-Id: #22729
2025-12-21 21:26:03 +01:00 · 2023-09-27 14:34:23 +02:00 · 2023-09-27 14:34:23 +02:00 · 6b21c32d2a
commit 6b21c32d2a
parent e4d75b2fb0
439 changed files with 109952 additions and 43685 deletions
--- a/lsteamclient/cppISteamGameServer_SteamGameServer015.cpp
+++ b/lsteamclient/cppISteamGameServer_SteamGameServer015.cpp
@ -13,260 +13,224 @@ extern "C" {
 #define SDKVER_158
 #include "struct_converters.h"
 #include "cppISteamGameServer_SteamGameServer015.h"
-bool cppISteamGameServer_SteamGameServer015_InitGameServer(void *linux_side, uint32 unIP, uint16 usGamePort, uint16 usQueryPort, uint32 unFlags, AppId_t nGameAppId, const char *pchVersionString)
+void cppISteamGameServer_SteamGameServer015_InitGameServer( struct cppISteamGameServer_SteamGameServer015_InitGameServer_params *params )
 {
-    bool _ret;
-    _ret = ((ISteamGameServer*)linux_side)->InitGameServer((uint32)unIP, (uint16)usGamePort, (uint16)usQueryPort, (uint32)unFlags, (AppId_t)nGameAppId, (const char *)pchVersionString);
-    return (_ret);
+    params->_ret = ((ISteamGameServer*)params->linux_side)->InitGameServer( (uint32)params->unIP, (uint16)params->usGamePort, (uint16)params->usQueryPort, (uint32)params->unFlags, (AppId_t)params->nGameAppId, (const char *)params->pchVersionString );
 }

-void cppISteamGameServer_SteamGameServer015_SetProduct(void *linux_side, const char *pszProduct)
+void cppISteamGameServer_SteamGameServer015_SetProduct( struct cppISteamGameServer_SteamGameServer015_SetProduct_params *params )
 {
-    ((ISteamGameServer*)linux_side)->SetProduct((const char *)pszProduct);
+    ((ISteamGameServer*)params->linux_side)->SetProduct( (const char *)params->pszProduct );
 }

-void cppISteamGameServer_SteamGameServer015_SetGameDescription(void *linux_side, const char *pszGameDescription)
+void cppISteamGameServer_SteamGameServer015_SetGameDescription( struct cppISteamGameServer_SteamGameServer015_SetGameDescription_params *params )
 {
-    ((ISteamGameServer*)linux_side)->SetGameDescription((const char *)pszGameDescription);
+    ((ISteamGameServer*)params->linux_side)->SetGameDescription( (const char *)params->pszGameDescription );
 }

-void cppISteamGameServer_SteamGameServer015_SetModDir(void *linux_side, const char *pszModDir)
+void cppISteamGameServer_SteamGameServer015_SetModDir( struct cppISteamGameServer_SteamGameServer015_SetModDir_params *params )
 {
-    ((ISteamGameServer*)linux_side)->SetModDir((const char *)pszModDir);
+    ((ISteamGameServer*)params->linux_side)->SetModDir( (const char *)params->pszModDir );
 }

-void cppISteamGameServer_SteamGameServer015_SetDedicatedServer(void *linux_side, bool bDedicated)
+void cppISteamGameServer_SteamGameServer015_SetDedicatedServer( struct cppISteamGameServer_SteamGameServer015_SetDedicatedServer_params *params )
 {
-    ((ISteamGameServer*)linux_side)->SetDedicatedServer((bool)bDedicated);
+    ((ISteamGameServer*)params->linux_side)->SetDedicatedServer( (bool)params->bDedicated );
 }

-void cppISteamGameServer_SteamGameServer015_LogOn(void *linux_side, const char *pszToken)
+void cppISteamGameServer_SteamGameServer015_LogOn( struct cppISteamGameServer_SteamGameServer015_LogOn_params *params )
 {
-    ((ISteamGameServer*)linux_side)->LogOn((const char *)pszToken);
+    ((ISteamGameServer*)params->linux_side)->LogOn( (const char *)params->pszToken );
 }

-void cppISteamGameServer_SteamGameServer015_LogOnAnonymous(void *linux_side)
+void cppISteamGameServer_SteamGameServer015_LogOnAnonymous( struct cppISteamGameServer_SteamGameServer015_LogOnAnonymous_params *params )
 {
-    ((ISteamGameServer*)linux_side)->LogOnAnonymous();
+    ((ISteamGameServer*)params->linux_side)->LogOnAnonymous(  );
 }

-void cppISteamGameServer_SteamGameServer015_LogOff(void *linux_side)
+void cppISteamGameServer_SteamGameServer015_LogOff( struct cppISteamGameServer_SteamGameServer015_LogOff_params *params )
 {
-    ((ISteamGameServer*)linux_side)->LogOff();
+    ((ISteamGameServer*)params->linux_side)->LogOff(  );
 }

-bool cppISteamGameServer_SteamGameServer015_BLoggedOn(void *linux_side)
+void cppISteamGameServer_SteamGameServer015_BLoggedOn( struct cppISteamGameServer_SteamGameServer015_BLoggedOn_params *params )
 {
-    bool _ret;
-    _ret = ((ISteamGameServer*)linux_side)->BLoggedOn();
-    return (_ret);
+    params->_ret = ((ISteamGameServer*)params->linux_side)->BLoggedOn(  );
 }

-bool cppISteamGameServer_SteamGameServer015_BSecure(void *linux_side)
+void cppISteamGameServer_SteamGameServer015_BSecure( struct cppISteamGameServer_SteamGameServer015_BSecure_params *params )
 {
-    bool _ret;
-    _ret = ((ISteamGameServer*)linux_side)->BSecure();
-    return (_ret);
+    params->_ret = ((ISteamGameServer*)params->linux_side)->BSecure(  );
 }

-CSteamID cppISteamGameServer_SteamGameServer015_GetSteamID(void *linux_side)
+void cppISteamGameServer_SteamGameServer015_GetSteamID( struct cppISteamGameServer_SteamGameServer015_GetSteamID_params *params )
 {
-    CSteamID _ret;
-    _ret = ((ISteamGameServer*)linux_side)->GetSteamID();
-    return (_ret);
+    *params->_ret = ((ISteamGameServer*)params->linux_side)->GetSteamID(  );
 }

-bool cppISteamGameServer_SteamGameServer015_WasRestartRequested(void *linux_side)
+void cppISteamGameServer_SteamGameServer015_WasRestartRequested( struct cppISteamGameServer_SteamGameServer015_WasRestartRequested_params *params )
 {
-    bool _ret;
-    _ret = ((ISteamGameServer*)linux_side)->WasRestartRequested();
-    return (_ret);
+    params->_ret = ((ISteamGameServer*)params->linux_side)->WasRestartRequested(  );
 }

-void cppISteamGameServer_SteamGameServer015_SetMaxPlayerCount(void *linux_side, int cPlayersMax)
+void cppISteamGameServer_SteamGameServer015_SetMaxPlayerCount( struct cppISteamGameServer_SteamGameServer015_SetMaxPlayerCount_params *params )
 {
-    ((ISteamGameServer*)linux_side)->SetMaxPlayerCount((int)cPlayersMax);
+    ((ISteamGameServer*)params->linux_side)->SetMaxPlayerCount( (int)params->cPlayersMax );
 }

-void cppISteamGameServer_SteamGameServer015_SetBotPlayerCount(void *linux_side, int cBotplayers)
+void cppISteamGameServer_SteamGameServer015_SetBotPlayerCount( struct cppISteamGameServer_SteamGameServer015_SetBotPlayerCount_params *params )
 {
-    ((ISteamGameServer*)linux_side)->SetBotPlayerCount((int)cBotplayers);
+    ((ISteamGameServer*)params->linux_side)->SetBotPlayerCount( (int)params->cBotplayers );
 }

-void cppISteamGameServer_SteamGameServer015_SetServerName(void *linux_side, const char *pszServerName)
+void cppISteamGameServer_SteamGameServer015_SetServerName( struct cppISteamGameServer_SteamGameServer015_SetServerName_params *params )
 {
-    ((ISteamGameServer*)linux_side)->SetServerName((const char *)pszServerName);
+    ((ISteamGameServer*)params->linux_side)->SetServerName( (const char *)params->pszServerName );
 }

-void cppISteamGameServer_SteamGameServer015_SetMapName(void *linux_side, const char *pszMapName)
+void cppISteamGameServer_SteamGameServer015_SetMapName( struct cppISteamGameServer_SteamGameServer015_SetMapName_params *params )
 {
-    ((ISteamGameServer*)linux_side)->SetMapName((const char *)pszMapName);
+    ((ISteamGameServer*)params->linux_side)->SetMapName( (const char *)params->pszMapName );
 }

-void cppISteamGameServer_SteamGameServer015_SetPasswordProtected(void *linux_side, bool bPasswordProtected)
+void cppISteamGameServer_SteamGameServer015_SetPasswordProtected( struct cppISteamGameServer_SteamGameServer015_SetPasswordProtected_params *params )
 {
-    ((ISteamGameServer*)linux_side)->SetPasswordProtected((bool)bPasswordProtected);
+    ((ISteamGameServer*)params->linux_side)->SetPasswordProtected( (bool)params->bPasswordProtected );
 }

-void cppISteamGameServer_SteamGameServer015_SetSpectatorPort(void *linux_side, uint16 unSpectatorPort)
+void cppISteamGameServer_SteamGameServer015_SetSpectatorPort( struct cppISteamGameServer_SteamGameServer015_SetSpectatorPort_params *params )
 {
-    ((ISteamGameServer*)linux_side)->SetSpectatorPort((uint16)unSpectatorPort);
+    ((ISteamGameServer*)params->linux_side)->SetSpectatorPort( (uint16)params->unSpectatorPort );
 }

-void cppISteamGameServer_SteamGameServer015_SetSpectatorServerName(void *linux_side, const char *pszSpectatorServerName)
+void cppISteamGameServer_SteamGameServer015_SetSpectatorServerName( struct cppISteamGameServer_SteamGameServer015_SetSpectatorServerName_params *params )
 {
-    ((ISteamGameServer*)linux_side)->SetSpectatorServerName((const char *)pszSpectatorServerName);
+    ((ISteamGameServer*)params->linux_side)->SetSpectatorServerName( (const char *)params->pszSpectatorServerName );
 }

-void cppISteamGameServer_SteamGameServer015_ClearAllKeyValues(void *linux_side)
+void cppISteamGameServer_SteamGameServer015_ClearAllKeyValues( struct cppISteamGameServer_SteamGameServer015_ClearAllKeyValues_params *params )
 {
-    ((ISteamGameServer*)linux_side)->ClearAllKeyValues();
+    ((ISteamGameServer*)params->linux_side)->ClearAllKeyValues(  );
 }

-void cppISteamGameServer_SteamGameServer015_SetKeyValue(void *linux_side, const char *pKey, const char *pValue)
+void cppISteamGameServer_SteamGameServer015_SetKeyValue( struct cppISteamGameServer_SteamGameServer015_SetKeyValue_params *params )
 {
-    ((ISteamGameServer*)linux_side)->SetKeyValue((const char *)pKey, (const char *)pValue);
+    ((ISteamGameServer*)params->linux_side)->SetKeyValue( (const char *)params->pKey, (const char *)params->pValue );
 }

-void cppISteamGameServer_SteamGameServer015_SetGameTags(void *linux_side, const char *pchGameTags)
+void cppISteamGameServer_SteamGameServer015_SetGameTags( struct cppISteamGameServer_SteamGameServer015_SetGameTags_params *params )
 {
-    ((ISteamGameServer*)linux_side)->SetGameTags((const char *)pchGameTags);
+    ((ISteamGameServer*)params->linux_side)->SetGameTags( (const char *)params->pchGameTags );
 }

-void cppISteamGameServer_SteamGameServer015_SetGameData(void *linux_side, const char *pchGameData)
+void cppISteamGameServer_SteamGameServer015_SetGameData( struct cppISteamGameServer_SteamGameServer015_SetGameData_params *params )
 {
-    ((ISteamGameServer*)linux_side)->SetGameData((const char *)pchGameData);
+    ((ISteamGameServer*)params->linux_side)->SetGameData( (const char *)params->pchGameData );
 }

-void cppISteamGameServer_SteamGameServer015_SetRegion(void *linux_side, const char *pszRegion)
+void cppISteamGameServer_SteamGameServer015_SetRegion( struct cppISteamGameServer_SteamGameServer015_SetRegion_params *params )
 {
-    ((ISteamGameServer*)linux_side)->SetRegion((const char *)pszRegion);
+    ((ISteamGameServer*)params->linux_side)->SetRegion( (const char *)params->pszRegion );
 }

-void cppISteamGameServer_SteamGameServer015_SetAdvertiseServerActive(void *linux_side, bool bActive)
+void cppISteamGameServer_SteamGameServer015_SetAdvertiseServerActive( struct cppISteamGameServer_SteamGameServer015_SetAdvertiseServerActive_params *params )
 {
-    ((ISteamGameServer*)linux_side)->SetAdvertiseServerActive((bool)bActive);
+    ((ISteamGameServer*)params->linux_side)->SetAdvertiseServerActive( (bool)params->bActive );
 }

-HAuthTicket cppISteamGameServer_SteamGameServer015_GetAuthSessionTicket(void *linux_side, void *pTicket, int cbMaxTicket, uint32 *pcbTicket, const SteamNetworkingIdentity *pSnid)
+void cppISteamGameServer_SteamGameServer015_GetAuthSessionTicket( struct cppISteamGameServer_SteamGameServer015_GetAuthSessionTicket_params *params )
 {
-    HAuthTicket _ret;
-    _ret = ((ISteamGameServer*)linux_side)->GetAuthSessionTicket((void *)pTicket, (int)cbMaxTicket, (uint32 *)pcbTicket, (const SteamNetworkingIdentity *)pSnid);
-    return (_ret);
+    params->_ret = ((ISteamGameServer*)params->linux_side)->GetAuthSessionTicket( (void *)params->pTicket, (int)params->cbMaxTicket, (uint32 *)params->pcbTicket, (const SteamNetworkingIdentity *)params->pSnid );
 }

-EBeginAuthSessionResult cppISteamGameServer_SteamGameServer015_BeginAuthSession(void *linux_side, const void *pAuthTicket, int cbAuthTicket, CSteamID steamID)
+void cppISteamGameServer_SteamGameServer015_BeginAuthSession( struct cppISteamGameServer_SteamGameServer015_BeginAuthSession_params *params )
 {
-    EBeginAuthSessionResult _ret;
-    _ret = ((ISteamGameServer*)linux_side)->BeginAuthSession((const void *)pAuthTicket, (int)cbAuthTicket, (CSteamID)steamID);
-    return (_ret);
+    params->_ret = ((ISteamGameServer*)params->linux_side)->BeginAuthSession( (const void *)params->pAuthTicket, (int)params->cbAuthTicket, (CSteamID)params->steamID );
 }

-void cppISteamGameServer_SteamGameServer015_EndAuthSession(void *linux_side, CSteamID steamID)
+void cppISteamGameServer_SteamGameServer015_EndAuthSession( struct cppISteamGameServer_SteamGameServer015_EndAuthSession_params *params )
 {
-    ((ISteamGameServer*)linux_side)->EndAuthSession((CSteamID)steamID);
+    ((ISteamGameServer*)params->linux_side)->EndAuthSession( (CSteamID)params->steamID );
 }

-void cppISteamGameServer_SteamGameServer015_CancelAuthTicket(void *linux_side, HAuthTicket hAuthTicket)
+void cppISteamGameServer_SteamGameServer015_CancelAuthTicket( struct cppISteamGameServer_SteamGameServer015_CancelAuthTicket_params *params )
 {
-    ((ISteamGameServer*)linux_side)->CancelAuthTicket((HAuthTicket)hAuthTicket);
+    ((ISteamGameServer*)params->linux_side)->CancelAuthTicket( (HAuthTicket)params->hAuthTicket );
 }

-EUserHasLicenseForAppResult cppISteamGameServer_SteamGameServer015_UserHasLicenseForApp(void *linux_side, CSteamID steamID, AppId_t appID)
+void cppISteamGameServer_SteamGameServer015_UserHasLicenseForApp( struct cppISteamGameServer_SteamGameServer015_UserHasLicenseForApp_params *params )
 {
-    EUserHasLicenseForAppResult _ret;
-    _ret = ((ISteamGameServer*)linux_side)->UserHasLicenseForApp((CSteamID)steamID, (AppId_t)appID);
-    return (_ret);
+    params->_ret = ((ISteamGameServer*)params->linux_side)->UserHasLicenseForApp( (CSteamID)params->steamID, (AppId_t)params->appID );
 }

-bool cppISteamGameServer_SteamGameServer015_RequestUserGroupStatus(void *linux_side, CSteamID steamIDUser, CSteamID steamIDGroup)
+void cppISteamGameServer_SteamGameServer015_RequestUserGroupStatus( struct cppISteamGameServer_SteamGameServer015_RequestUserGroupStatus_params *params )
 {
-    bool _ret;
-    _ret = ((ISteamGameServer*)linux_side)->RequestUserGroupStatus((CSteamID)steamIDUser, (CSteamID)steamIDGroup);
-    return (_ret);
+    params->_ret = ((ISteamGameServer*)params->linux_side)->RequestUserGroupStatus( (CSteamID)params->steamIDUser, (CSteamID)params->steamIDGroup );
 }

-void cppISteamGameServer_SteamGameServer015_GetGameplayStats(void *linux_side)
+void cppISteamGameServer_SteamGameServer015_GetGameplayStats( struct cppISteamGameServer_SteamGameServer015_GetGameplayStats_params *params )
 {
-    ((ISteamGameServer*)linux_side)->GetGameplayStats();
+    ((ISteamGameServer*)params->linux_side)->GetGameplayStats(  );
 }

-SteamAPICall_t cppISteamGameServer_SteamGameServer015_GetServerReputation(void *linux_side)
+void cppISteamGameServer_SteamGameServer015_GetServerReputation( struct cppISteamGameServer_SteamGameServer015_GetServerReputation_params *params )
 {
-    SteamAPICall_t _ret;
-    _ret = ((ISteamGameServer*)linux_side)->GetServerReputation();
-    return (_ret);
+    params->_ret = ((ISteamGameServer*)params->linux_side)->GetServerReputation(  );
 }

-SteamIPAddress_t cppISteamGameServer_SteamGameServer015_GetPublicIP(void *linux_side)
+void cppISteamGameServer_SteamGameServer015_GetPublicIP( struct cppISteamGameServer_SteamGameServer015_GetPublicIP_params *params )
 {
-    SteamIPAddress_t _ret;
-    _ret = ((ISteamGameServer*)linux_side)->GetPublicIP();
-    return (_ret);
+    *params->_ret = ((ISteamGameServer*)params->linux_side)->GetPublicIP(  );
 }

-bool cppISteamGameServer_SteamGameServer015_HandleIncomingPacket(void *linux_side, const void *pData, int cbData, uint32 srcIP, uint16 srcPort)
+void cppISteamGameServer_SteamGameServer015_HandleIncomingPacket( struct cppISteamGameServer_SteamGameServer015_HandleIncomingPacket_params *params )
 {
-    bool _ret;
-    _ret = ((ISteamGameServer*)linux_side)->HandleIncomingPacket((const void *)pData, (int)cbData, (uint32)srcIP, (uint16)srcPort);
-    return (_ret);
+    params->_ret = ((ISteamGameServer*)params->linux_side)->HandleIncomingPacket( (const void *)params->pData, (int)params->cbData, (uint32)params->srcIP, (uint16)params->srcPort );
 }

-int cppISteamGameServer_SteamGameServer015_GetNextOutgoingPacket(void *linux_side, void *pOut, int cbMaxOut, uint32 *pNetAdr, uint16 *pPort)
+void cppISteamGameServer_SteamGameServer015_GetNextOutgoingPacket( struct cppISteamGameServer_SteamGameServer015_GetNextOutgoingPacket_params *params )
 {
-    int _ret;
-    _ret = ((ISteamGameServer*)linux_side)->GetNextOutgoingPacket((void *)pOut, (int)cbMaxOut, (uint32 *)pNetAdr, (uint16 *)pPort);
-    return (_ret);
+    params->_ret = ((ISteamGameServer*)params->linux_side)->GetNextOutgoingPacket( (void *)params->pOut, (int)params->cbMaxOut, (uint32 *)params->pNetAdr, (uint16 *)params->pPort );
 }

-SteamAPICall_t cppISteamGameServer_SteamGameServer015_AssociateWithClan(void *linux_side, CSteamID steamIDClan)
+void cppISteamGameServer_SteamGameServer015_AssociateWithClan( struct cppISteamGameServer_SteamGameServer015_AssociateWithClan_params *params )
 {
-    SteamAPICall_t _ret;
-    _ret = ((ISteamGameServer*)linux_side)->AssociateWithClan((CSteamID)steamIDClan);
-    return (_ret);
+    params->_ret = ((ISteamGameServer*)params->linux_side)->AssociateWithClan( (CSteamID)params->steamIDClan );
 }

-SteamAPICall_t cppISteamGameServer_SteamGameServer015_ComputeNewPlayerCompatibility(void *linux_side, CSteamID steamIDNewPlayer)
+void cppISteamGameServer_SteamGameServer015_ComputeNewPlayerCompatibility( struct cppISteamGameServer_SteamGameServer015_ComputeNewPlayerCompatibility_params *params )
 {
-    SteamAPICall_t _ret;
-    _ret = ((ISteamGameServer*)linux_side)->ComputeNewPlayerCompatibility((CSteamID)steamIDNewPlayer);
-    return (_ret);
+    params->_ret = ((ISteamGameServer*)params->linux_side)->ComputeNewPlayerCompatibility( (CSteamID)params->steamIDNewPlayer );
 }

-bool cppISteamGameServer_SteamGameServer015_SendUserConnectAndAuthenticate_DEPRECATED(void *linux_side, uint32 unIPClient, const void *pvAuthBlob, uint32 cubAuthBlobSize, CSteamID *pSteamIDUser)
+void cppISteamGameServer_SteamGameServer015_SendUserConnectAndAuthenticate_DEPRECATED( struct cppISteamGameServer_SteamGameServer015_SendUserConnectAndAuthenticate_DEPRECATED_params *params )
 {
-    bool _ret;
-    _ret = ((ISteamGameServer*)linux_side)->SendUserConnectAndAuthenticate_DEPRECATED((uint32)unIPClient, (const void *)pvAuthBlob, (uint32)cubAuthBlobSize, (CSteamID *)pSteamIDUser);
-    return (_ret);
+    params->_ret = ((ISteamGameServer*)params->linux_side)->SendUserConnectAndAuthenticate_DEPRECATED( (uint32)params->unIPClient, (const void *)params->pvAuthBlob, (uint32)params->cubAuthBlobSize, (CSteamID *)params->pSteamIDUser );
 }

-CSteamID cppISteamGameServer_SteamGameServer015_CreateUnauthenticatedUserConnection(void *linux_side)
+void cppISteamGameServer_SteamGameServer015_CreateUnauthenticatedUserConnection( struct cppISteamGameServer_SteamGameServer015_CreateUnauthenticatedUserConnection_params *params )
 {
-    CSteamID _ret;
-    _ret = ((ISteamGameServer*)linux_side)->CreateUnauthenticatedUserConnection();
-    return (_ret);
+    *params->_ret = ((ISteamGameServer*)params->linux_side)->CreateUnauthenticatedUserConnection(  );
 }

-void cppISteamGameServer_SteamGameServer015_SendUserDisconnect_DEPRECATED(void *linux_side, CSteamID steamIDUser)
+void cppISteamGameServer_SteamGameServer015_SendUserDisconnect_DEPRECATED( struct cppISteamGameServer_SteamGameServer015_SendUserDisconnect_DEPRECATED_params *params )
 {
-    ((ISteamGameServer*)linux_side)->SendUserDisconnect_DEPRECATED((CSteamID)steamIDUser);
+    ((ISteamGameServer*)params->linux_side)->SendUserDisconnect_DEPRECATED( (CSteamID)params->steamIDUser );
 }

-bool cppISteamGameServer_SteamGameServer015_BUpdateUserData(void *linux_side, CSteamID steamIDUser, const char *pchPlayerName, uint32 uScore)
+void cppISteamGameServer_SteamGameServer015_BUpdateUserData( struct cppISteamGameServer_SteamGameServer015_BUpdateUserData_params *params )
 {
-    bool _ret;
-    _ret = ((ISteamGameServer*)linux_side)->BUpdateUserData((CSteamID)steamIDUser, (const char *)pchPlayerName, (uint32)uScore);
-    return (_ret);
+    params->_ret = ((ISteamGameServer*)params->linux_side)->BUpdateUserData( (CSteamID)params->steamIDUser, (const char *)params->pchPlayerName, (uint32)params->uScore );
 }

-void cppISteamGameServer_SteamGameServer015_SetMasterServerHeartbeatInterval_DEPRECATED(void *linux_side, int iHeartbeatInterval)
+void cppISteamGameServer_SteamGameServer015_SetMasterServerHeartbeatInterval_DEPRECATED( struct cppISteamGameServer_SteamGameServer015_SetMasterServerHeartbeatInterval_DEPRECATED_params *params )
 {
-    ((ISteamGameServer*)linux_side)->SetMasterServerHeartbeatInterval_DEPRECATED((int)iHeartbeatInterval);
+    ((ISteamGameServer*)params->linux_side)->SetMasterServerHeartbeatInterval_DEPRECATED( (int)params->iHeartbeatInterval );
 }

-void cppISteamGameServer_SteamGameServer015_ForceMasterServerHeartbeat_DEPRECATED(void *linux_side)
+void cppISteamGameServer_SteamGameServer015_ForceMasterServerHeartbeat_DEPRECATED( struct cppISteamGameServer_SteamGameServer015_ForceMasterServerHeartbeat_DEPRECATED_params *params )
 {
-    ((ISteamGameServer*)linux_side)->ForceMasterServerHeartbeat_DEPRECATED();
+    ((ISteamGameServer*)params->linux_side)->ForceMasterServerHeartbeat_DEPRECATED(  );
 }

 #ifdef __cplusplus