void CSteamGameServerRecordingWrapper::SetMapName(const char *pszMapName)
{
CGameServerSetMapNameCall fcall(pszMapName); CRecorderFuncCall frec(&fcall);
m_Recorder->PushFunc(&frec);
m_Wrapped->SetMapName(pszMapName);
m_Recorder->PopFunc(&frec);
}
void CSteamGameServerRecordingWrapper::SetPasswordProtected(bool bPasswordProtected)
{
CGameServerSetPasswordProtectedCall fcall(bPasswordProtected); CRecorderFuncCall frec(&fcall);
m_Recorder->PushFunc(&frec);
m_Wrapped->SetPasswordProtected(bPasswordProtected);
m_Recorder->PopFunc(&frec);
}
void CSteamGameServerRecordingWrapper::SetBotPlayerCount(int cBotplayers)
{
CGameServerSetBotCountCall fcall(cBotplayers); CRecorderFuncCall frec(&fcall);
m_Recorder->PushFunc(&frec);
m_Wrapped->SetBotPlayerCount(cBotplayers);
m_Recorder->PopFunc(&frec);
}
void CSteamGameServerRecordingWrapper::SetMaxPlayerCount(int cPlayersMax)
{
CGameServerSetMaxPlayersCall fcall(cPlayersMax); CRecorderFuncCall frec(&fcall);
m_Recorder->PushFunc(&frec);
m_Wrapped->SetMaxPlayerCount(cPlayersMax);
m_Recorder->PopFunc(&frec);
}
void CSteamGameServerRecordingWrapper::SetDedicatedServer(bool bDedicated)
{
CGameServerSetDedicatedServerCall fcall(bDedicated); CRecorderFuncCall frec(&fcall);
m_Recorder->PushFunc(&frec);
m_Wrapped->SetDedicatedServer(bDedicated);
m_Recorder->PopFunc(&frec);
}
void CSteamGameServerRecordingWrapper::SetKeyValue(const char *pKey, const char *pValue)
{
CGameServerSetKeyValueCall fcall(pKey, pValue); CRecorderFuncCall frec(&fcall);
m_Recorder->PushFunc(&frec);
m_Wrapped->SetKeyValue(pKey, pValue);
m_Recorder->PopFunc(&frec);
}
void CRecordingEngExtInterceptor::srand(uint32 seed)
{
CStdSrandCall fcall(seed); CRecorderFuncCall frec(&fcall);
PushFunc(&frec);
m_BasePlatform->srand(seed);
PopFunc(&frec);
}
//////////////////////////////////
// Cast an expression to a type //
//////////////////////////////////
TNode *CastNode::translate( Codegen *g ){
TNode *t=expr->translate( g );
if( expr->sem_type==Type::float_type && sem_type==Type::int_type ){
//float->int
return d_new TNode( IR_CAST,t,0 );
}
if( expr->sem_type==Type::int_type && sem_type==Type::float_type ){
//int->float
return d_new TNode( IR_FCAST,t,0 );
}
if( expr->sem_type==Type::string_type && sem_type==Type::int_type ){
//str->int
return call( "__bbStrToInt",t );
}
if( expr->sem_type==Type::int_type && sem_type==Type::string_type ){
//int->str
return strcall( "__bbStrFromInt",t );
}
if( expr->sem_type==Type::string_type && sem_type==Type::float_type ){
//str->float
return fcall( "__bbStrToFloat",t );
}
if( expr->sem_type==Type::float_type && sem_type==Type::string_type ){
//float->str
return strcall( "__bbStrFromFloat",t );
}
if( expr->sem_type->structType() && sem_type==Type::string_type ){
//obj->str
return strcall( "__bbObjToStr",t );
}
return t;
}
void CSteamGameServerRecordingWrapper::SendUserDisconnect(CSteamID steamIDUser)
{
CGameServerSendUserDisconnectCall fcall(steamIDUser); CRecorderFuncCall frec(&fcall);
m_Recorder->PushFunc(&frec);
m_Wrapped->SendUserDisconnect(steamIDUser);
m_Recorder->PopFunc(&frec);
}
void CSteamGameServerRecordingWrapper::SetGameDescription(const char *pszGameDescription)
{
CGameServerSetGameDescCall fcall(pszGameDescription); CRecorderFuncCall frec(&fcall);
m_Recorder->PushFunc(&frec);
m_Wrapped->SetGameDescription(pszGameDescription);
m_Recorder->PopFunc(&frec);
}
void CRecordingEngExtInterceptor::SteamAPI_SetBreakpadAppID(uint32 unAppID)
{
CSteamApiSetBreakpadAppIdCall fcall(unAppID); CRecorderFuncCall frec(&fcall);
PushFunc(&frec);
m_BasePlatform->SteamAPI_SetBreakpadAppID(unAppID);
PopFunc(&frec);
}
void CRecordingEngExtInterceptor::Sleep(DWORD msec)
{
CSleepExtCall fcall(msec); CRecorderFuncCall frec(&fcall);
PushFunc(&frec);
m_BasePlatform->Sleep(msec);
PopFunc(&frec);
}
void CSteamGameServerRecordingWrapper::EnableHeartbeats(bool bActive)
{
CGameServerEnableHeartbeatsCall fcall(bActive); CRecorderFuncCall frec(&fcall);
m_Recorder->PushFunc(&frec);
m_Wrapped->EnableHeartbeats(bActive);
m_Recorder->PopFunc(&frec);
}
void CSteamGameServerRecordingWrapper::SetHeartbeatInterval(int iHeartbeatInterval)
{
CGameServerSetHeartbeatIntervalCall fcall(iHeartbeatInterval); CRecorderFuncCall frec(&fcall);
m_Recorder->PushFunc(&frec);
m_Wrapped->SetHeartbeatInterval(iHeartbeatInterval);
m_Recorder->PopFunc(&frec);
}
void CSteamGameServerRecordingWrapper::SetProduct(const char *pszProduct)
{
CGameServerSetProductCall fcall(pszProduct); CRecorderFuncCall frec(&fcall);
m_Recorder->PushFunc(&frec);
m_Wrapped->SetProduct(pszProduct);
m_Recorder->PopFunc(&frec);
}
int CRecordingEngExtInterceptor::bind(SOCKET s, const struct sockaddr* addr, int namelen)
{
CBindCall fcall(s, addr, namelen); CRecorderFuncCall frec(&fcall);
PushFunc(&frec);
int res = m_BasePlatform->bind(s, addr, namelen);
fcall.setResult(res);
PopFunc(&frec);
return res;
}
int CRecordingEngExtInterceptor::sendto(SOCKET s, const char* buf, int len, int flags, const struct sockaddr* to, int tolen)
{
CSendToCall fcall(s, buf, len, flags, to, tolen); CRecorderFuncCall frec(&fcall);
PushFunc(&frec);
int res = m_BasePlatform->sendto(s, buf, len, flags, to, tolen);
fcall.setResult(res);
PopFunc(&frec);
return res;
}
int CRecordingEngExtInterceptor::recvfrom(SOCKET s, char* buf, int len, int flags, struct sockaddr* from, socklen_t *fromlen)
{
CRecvFromCall fcall(s, len, flags, *fromlen); CRecorderFuncCall frec(&fcall);
PushFunc(&frec);
int res = m_BasePlatform->recvfrom(s, buf, len, flags, from, fromlen);
fcall.setResult(buf, from, *fromlen, res);
PopFunc(&frec);
return res;
}
int CRecordingEngExtInterceptor::closesocket(SOCKET s)
{
CCloseSocketCall fcall(s); CRecorderFuncCall frec(&fcall);
PushFunc(&frec);
int res = m_BasePlatform->closesocket(s);
fcall.setResult(s);
PopFunc(&frec);
return res;
}
int CRecordingEngExtInterceptor::gethostname(char *name, int namelen)
{
CGetHostNameCall fcall(namelen); CRecorderFuncCall frec(&fcall);
PushFunc(&frec);
int res = m_BasePlatform->gethostname(name, namelen);
fcall.setResult(name, res);
PopFunc(&frec);
return res;
}
int CSteamGameServerRecordingWrapper::GetNextOutgoingPacket(void *pOut, int cbMaxOut, uint32 *pNetAdr, uint16 *pPort)
{
CGameServerGetNextOutgoingPacketCall fcall(cbMaxOut); CRecorderFuncCall frec(&fcall);
m_Recorder->PushFunc(&frec);
int res = m_Wrapped->GetNextOutgoingPacket(pOut, cbMaxOut, pNetAdr, pPort);
fcall.setResult(pOut, res, pNetAdr, pPort);
m_Recorder->PopFunc(&frec);
return res;
}
bool CSteamGameServerRecordingWrapper::HandleIncomingPacket(const void *pData, int cbData, uint32 srcIP, uint16 srcPort)
{
CGameServerHandleIncomingPacketCall fcall(pData, cbData, srcIP, srcPort); CRecorderFuncCall frec(&fcall);
m_Recorder->PushFunc(&frec);
bool res = m_Wrapped->HandleIncomingPacket(pData, cbData, srcIP, srcPort);
fcall.setResult(res);
m_Recorder->PopFunc(&frec);
return res;
}
bool CSteamGameServerRecordingWrapper::BUpdateUserData(CSteamID steamIDUser, const char *pchPlayerName, uint32 uScore)
{
CGameServerBUpdateUserDataCall fcall(steamIDUser, pchPlayerName, uScore); CRecorderFuncCall frec(&fcall);
m_Recorder->PushFunc(&frec);
bool res = m_Wrapped->BUpdateUserData(steamIDUser, pchPlayerName, uScore);
fcall.setResult(res);
m_Recorder->PopFunc(&frec);
return res;
}
int CRecordingEngExtInterceptor::getsockname(SOCKET s, struct sockaddr* name, socklen_t* namelen)
{
CGetSockNameCall fcall(s, *namelen); CRecorderFuncCall frec(&fcall);
PushFunc(&frec);
int res = m_BasePlatform->getsockname(s, name, namelen);
fcall.setResult(name, *namelen, res);
PopFunc(&frec);
return res;
}
struct hostent* CRecordingEngExtInterceptor::gethostbyname(const char *name)
{
CGetHostByNameCall fcall(name); CRecorderFuncCall frec(&fcall);
PushFunc(&frec);
struct hostent* res = m_BasePlatform->gethostbyname(name);
fcall.setResult(res);
PopFunc(&frec);
return res;
}
SOCKET CRecordingEngExtInterceptor::socket(int af, int type, int protocol)
{
CSocketCall fcall(af, type, protocol); CRecorderFuncCall frec(&fcall);
PushFunc(&frec);
SOCKET s = m_BasePlatform->socket(af, type, protocol);
fcall.setResult(s);
PopFunc(&frec);
return s;
}
bool CRecordingEngExtInterceptor::SteamGameServer_Init(uint32 unIP, uint16 usSteamPort, uint16 usGamePort, uint16 usQueryPort, EServerMode eServerMode, const char *pchVersionString)
{
CSteamGameServerInitCall fcall(unIP, usSteamPort, usGamePort, usQueryPort, eServerMode, pchVersionString); CRecorderFuncCall frec(&fcall);
PushFunc(&frec);
bool res = m_BasePlatform->SteamGameServer_Init(unIP, usSteamPort, usGamePort, usQueryPort, eServerMode, pchVersionString);
fcall.setResult(res);
PopFunc(&frec);
return res;
}
int CRecordingEngExtInterceptor::ioctlsocket(SOCKET s, long cmd, u_long *argp)
{
CIoCtlSocketCall fcall(s, cmd, *argp); CRecorderFuncCall frec(&fcall);
PushFunc(&frec);
int res = m_BasePlatform->ioctlsocket(s, cmd, argp);
fcall.setResult(*argp, res);
PopFunc(&frec);
return res;
}
int CRecordingEngExtInterceptor::setsockopt(SOCKET s, int level, int optname, const char* optval, int optlen)
{
CSetSockOptCall fcall(s, level, optname, optval, optlen); CRecorderFuncCall frec(&fcall);
PushFunc(&frec);
int res = m_BasePlatform->setsockopt(s, level, optname, optval, optlen);
fcall.setResult(res);
PopFunc(&frec);
return res;
}
bool CSteamGameServerRecordingWrapper::SendUserConnectAndAuthenticate(uint32 unIPClient, const void *pvAuthBlob, uint32 cubAuthBlobSize, CSteamID *pSteamIDUser)
{
CGameServerSendUserConnectAndAuthenticateCall fcall(unIPClient, pvAuthBlob, cubAuthBlobSize); CRecorderFuncCall frec(&fcall);
m_Recorder->PushFunc(&frec);
bool res = m_Wrapped->SendUserConnectAndAuthenticate(unIPClient, pvAuthBlob, cubAuthBlobSize, pSteamIDUser);
fcall.setResult(*pSteamIDUser, res);
m_Recorder->PopFunc(&frec);
return res;
}
