// getVehicleOccupants(vehicleid) SQInteger CVehicleNatives::GetOccupants(SQVM * pVM) { EntityId vehicleId; sq_getentity(pVM, -1, &vehicleId); CNetworkVehicle * pVehicle = g_pClient->GetVehicleManager()->Get(vehicleId); if(pVehicle) { CSquirrelArguments args; for(BYTE i = 0; i < (MAX_VEHICLE_PASSENGERS + 1); i++) { args.push((int)(i + 1)); CNetworkPlayer * pOccupant = pVehicle->GetOccupant(i); args.push(pOccupant ? (int)pOccupant->GetPlayerId() : (int)INVALID_ENTITY_ID); } sq_pusharg(pVM, CSquirrelArgument(args, false)); return 1; } sq_pushbool(pVM, false); return 1; }
void CServerRPCHandler::ChatInput(CBitStream * pBitStream, CPlayerSocket senderSocket) { CLogFile::Printf("Got ChatInput RPC from player %d", senderSocket.playerId); // Ensure we have a valid bitstream if(!pBitStream) { CLogFile::Printf("Warning: Invalid bitstream for ChatInput RPC"); return; } // Get the player pointer CPlayer * pPlayer = g_pServer->GetPlayerManager()->Get(senderSocket.playerId); // Is the player pointer valid? if(pPlayer) { // Read the data they sent us bool bIsCommand; String strInput; // Read if its a command or not bIsCommand = pBitStream->ReadBit(); // Read the input if(!pBitStream->Read(strInput)) return; // Prepare the event arguments CSquirrelArguments arguments; arguments.push(strInput); // Is it not a command? if(!bIsCommand) { // Trigger the event, if it is canceled, don't output the line to other players if(pPlayer->CallEvent("playerChat", &arguments)) { // Construct the chat input bit stream CBitStream bitStream; // Write the player id bitStream.WriteCompressed(senderSocket.playerId); // Write the input bitStream.Write(strInput); // Send it to all other players g_pServer->GetNetworkManager()->RPC(RPC_CHAT_INPUT, &bitStream, PRIORITY_HIGH, RELIABILITY_RELIABLE_ORDERED, INVALID_ENTITY_ID, true); } } else { // Trigger the event pPlayer->CallEvent("playerCommand", &arguments); } CLogFile::Printf("Recieved chat input from player %d (Command?: %s, Input: %s)", senderSocket.playerId, bIsCommand ? "Yes" : "No", strInput.C_String()); } }
EntityId CVehicleManager::Add(int iModelId, CVector3 vecSpawnPosition, CVector3 vecSpawnRotation, BYTE byteColor1, BYTE byteColor2, BYTE byteColor3, BYTE byteColor4, int respawn_delay) { for(EntityId x = 0; x < MAX_VEHICLES; x++) { if(!m_bActive[x]) { m_pVehicles[x] = new CVehicle(x, iModelId, vecSpawnPosition, vecSpawnRotation, byteColor1, byteColor2, byteColor3, byteColor4); if(m_pVehicles[x]) { m_bActive[x] = true; m_pVehicles[x]->SetRespawnDelay(respawn_delay); CSquirrelArguments pArguments; pArguments.push(x); g_pEvents->Call("vehicleCreate", &pArguments); return x; } return INVALID_ENTITY_ID; } } return INVALID_ENTITY_ID; }
void CServerRPCHandler::Chat(CBitStream * pBitStream, CPlayerSocket * pSenderSocket) { // Ensure we have a valid bit stream if(!pBitStream) return; EntityId playerId = pSenderSocket->playerId; CPlayer * pPlayer = g_pPlayerManager->GetAt(playerId); if(pPlayer) { String strChat; if(!pBitStream->Read(strChat)) return; strChat.Truncate(128); CSquirrelArguments pArguments; pArguments.push(playerId); pArguments.push(strChat); if(g_pEvents->Call("playerText", &pArguments).GetInteger() == 1) { CLogFile::Printf("[Chat] %s: %s", pPlayer->GetName().C_String(), strChat.Get()); CBitStream bsSend; bsSend.WriteCompressed(playerId); bsSend.Write(String(strChat)); g_pNetworkManager->RPC(RPC_Chat, &bsSend, PRIORITY_HIGH, RELIABILITY_RELIABLE_ORDERED, INVALID_ENTITY_ID, true); } } }
void CServerRPCHandler::EmptyVehicleSync(CBitStream * pBitStream, CPlayerSocket * pSenderSocket) { // Ensure we have a valid bit stream if(!pBitStream) return; EntityId playerId = pSenderSocket->playerId; if(CVAR_GET_BOOL("frequentevents")) { CSquirrelArguments pArguments; pArguments.push(playerId); if(g_pEvents->Call("playerEmptyVehicleSyncReceived", &pArguments).GetInteger() != 1 || g_pEvents->Call("playerSyncReceived", &pArguments).GetInteger() != 1) return; } CBitStream bsSend; EMPTYVEHICLESYNCPACKET syncPacket; if(!pBitStream->Read((PCHAR)&syncPacket, sizeof(EMPTYVEHICLESYNCPACKET))) return; CVehicle * pVehicle = g_pVehicleManager->GetAt(syncPacket.vehicleId); if(pVehicle && g_pVehicleManager->DoesExist(syncPacket.vehicleId)) pVehicle->StoreEmptyVehicle(&syncPacket); //bsSend.Write((char *)&syncPacket, sizeof(EMPTYVEHICLESYNCPACKET)); //g_pNetworkManager->RPC(RPC_EmptyVehicleSync, &bsSend, PRIORITY_LOW, RELIABILITY_UNRELIABLE_SEQUENCED, playerId, false); }
_MEMBER_FUNCTION_IMPL(GUIElement, getPosition) { SQBool relative; sq_getbool(pVM, -1, &relative); CGUIFrameWindow * pWindow = sq_getinstance<CGUIFrameWindow *>(pVM); if(!pWindow) { sq_pushbool(pVM, false); return 1; } CEGUI::Vector2 pos; if(relative != 0) { pos = pWindow->getPosition().asRelative((CEGUI::Size(g_pClient->GetGUI()->GetDisplayWidth (), g_pClient->GetGUI()->GetDisplayHeight()))); } else { pos = pWindow->getPosition().asAbsolute((CEGUI::Size(g_pClient->GetGUI()->GetDisplayWidth (), g_pClient->GetGUI()->GetDisplayHeight()))); } CSquirrelArguments args; args.push(pos.d_x); args.push(pos.d_y); sq_pusharg(pVM, CSquirrelArgument(args, true)); return 1; }
EntityId CObjectManager::Create(DWORD dwModelHash, const CVector3& vecPosition, const CVector3& vecRotation) { for(EntityId x = 0; x < MAX_OBJECTS; x++) { if(!m_bActive[x]) { CBitStream bsSend; bsSend.WriteCompressed(x); bsSend.Write(dwModelHash); bsSend.Write(vecPosition); bsSend.Write(vecRotation); g_pNetworkManager->RPC(RPC_NewObject, &bsSend, PRIORITY_HIGH, RELIABILITY_RELIABLE_ORDERED, INVALID_ENTITY_ID, true); m_Objects[x].dwModelHash = dwModelHash; m_Objects[x].vecPosition = vecPosition; m_Objects[x].vecRotation = vecRotation; m_bActive[x] = true; m_Objects[x].iBone = -1; CSquirrelArguments pArguments; pArguments.push(x); g_pEvents->Call("objectCreate", &pArguments); return x; } } return INVALID_ENTITY_ID; }
// getVehicleRotation(vehicleid) SQInteger CVehicleNatives::GetRotation(SQVM * pVM) { EntityId vehicleId; sq_getentity(pVM, -1, &vehicleId); if(g_pVehicleManager->Exists(vehicleId)) { CNetworkVehicle * pVehicle = g_pVehicleManager->Get(vehicleId); if(pVehicle) { CVector3 vecRotation; pVehicle->GetRotation(vecRotation); CSquirrelArguments args; args.push(vecRotation.fX); args.push(vecRotation.fY); args.push(vecRotation.fZ); sq_pusharg(pVM, CSquirrelArgument(args, true)); return 1; } } sq_pushbool(pVM, false); return 1; }
void CServerRPCHandler::Death(CBitStream * pBitStream, CPlayerSocket * pSenderSocket) { // Ensure we have a valid bit stream if(!pBitStream) return; EntityId playerId = pSenderSocket->playerId; CPlayer * pPlayer = g_pPlayerManager->GetAt(playerId); if(pPlayer) { EntityId killerPlayerId; EntityId killerVehicleId; EntityId killerWeaponId; if(!pBitStream->ReadCompressed(killerPlayerId)) return; if(!pBitStream->ReadCompressed(killerVehicleId)) return; if(!pBitStream->ReadCompressed(killerWeaponId)) return; if(killerPlayerId != INVALID_ENTITY_ID) { CPlayer * pKiller = g_pPlayerManager->GetAt(killerPlayerId); if(pKiller) CLogFile::Printf("[Death] %s was killed by %s(Weapon %d).", pPlayer->GetName().C_String(), pKiller->GetName().C_String(), killerWeaponId); else killerPlayerId = INVALID_ENTITY_ID; } if(killerVehicleId != INVALID_ENTITY_ID) { CVehicle * pKillerVehicle = g_pVehicleManager->GetAt(killerVehicleId); if(pKillerVehicle) CLogFile::Printf("[Death] %s was killed by vehicle %d.", pPlayer->GetName().C_String(), killerVehicleId); else killerVehicleId = INVALID_ENTITY_ID; } if(killerPlayerId == INVALID_ENTITY_ID && killerVehicleId == INVALID_ENTITY_ID) CLogFile::Printf("[Death] %s died.", pPlayer->GetName().C_String()); CSquirrelArguments pArguments; pArguments.push(playerId); pArguments.push(killerPlayerId); pArguments.push(killerWeaponId); pArguments.push(killerVehicleId); g_pEvents->Call("playerDeath", &pArguments); pPlayer->KillForWorld(); } }
void CVehicleManager::Remove(EntityId vehicleId) { if(!DoesExist(vehicleId)) return; CSquirrelArguments pArguments; pArguments.push(vehicleId); g_pEvents->Call("vehicleDelete", &pArguments); delete m_pVehicles[vehicleId]; m_pVehicles[vehicleId] = NULL; m_bActive[vehicleId] = false; }
SQInteger CEventNatives::TriggerEvent ( SQVM *pVM ) { const char * szEventName; sq_getstring ( pVM, 2, &szEventName ); CSquirrelArguments pArguments; pArguments.fromVM ( pVM, 3 ); g_pServer->GetResourceManager()->GetEventManager()->Call(szEventName, &pArguments); sq_pushbool ( pVM, true ); return 1; }
void CServerRPCHandler::InVehicleSync(CBitStream * pBitStream, CPlayerSocket * pSenderSocket) { // Ensure we have a valid bit stream if(!pBitStream) return; EntityId playerId = pSenderSocket->playerId; CPlayer * pPlayer = g_pPlayerManager->GetAt(playerId); if(pPlayer) { if(CVAR_GET_BOOL("frequentevents")) { CSquirrelArguments pArguments; pArguments.push(playerId); if(g_pEvents->Call("playerInVehicleSyncReceived", &pArguments).GetInteger() != 1 || g_pEvents->Call("playerSyncReceived", &pArguments).GetInteger() != 1) return; } EntityId vehicleId; InVehicleSyncData syncPacket; AimSyncData aimSyncData; if(!pBitStream->ReadCompressed(vehicleId)) return; if(g_pVehicleManager->DoesExist(vehicleId)) { if(!pBitStream->Read((char *)&syncPacket, sizeof(InVehicleSyncData))) return; bool bHasAimSyncData = pBitStream->ReadBit(); if(bHasAimSyncData) { if(!pBitStream->Read((char *)&aimSyncData, sizeof(AimSyncData))) return; } CVehicle * pVehicle = g_pVehicleManager->GetAt(vehicleId); if(pVehicle) { pPlayer->StoreInVehicleSync(pVehicle, &syncPacket, bHasAimSyncData, &aimSyncData); pVehicle->StoreInVehicleSync(&syncPacket); //pVehicle->SetLastTimeOccupied(SharedUtility::GetTime()); } } } }
void CServerRPCHandler::VehicleDeath(CBitStream * pBitStream, CPlayerSocket * pSenderSocket) { // Ensure we have a valid bit stream if(!pBitStream) return; EntityId vehicleId; pBitStream->Read(vehicleId); CVehicle * pVehicle = g_pVehicleManager->GetAt(vehicleId); if(!pVehicle) return; if(pVehicle->GetDeathTime() != 0) return; CSquirrelArguments pArguments; pArguments.push(vehicleId); g_pEvents->Call("vehicleDeath",&pArguments); if(g_pEvents->Call("vehicleRespawn", &pArguments).GetInteger() == 1) { // Sure that we have no player in vehicle(otherwise crash >.<) if(pVehicle->GetDriver()) { EntityId playerId = pVehicle->GetDriver()->GetPlayerId(); CBitStream bsSend; bsSend.Write(playerId); bsSend.Write0(); g_pNetworkManager->RPC(RPC_ScriptingRemovePlayerFromVehicle,&bsSend,PRIORITY_HIGH, RELIABILITY_RELIABLE_ORDERED, playerId, false); } // Loop trough all players for(EntityId i = 0; i < MAX_PLAYERS; i++) { if(g_pPlayerManager->DoesExist(i)) { if(!g_pPlayerManager->GetAt(i)->IsOnFoot()) { if(g_pPlayerManager->GetAt(i)->GetVehicle()->GetVehicleId() == pVehicle->GetVehicleId()) { CBitStream bsSend; bsSend.Write(i); bsSend.Write0(); g_pNetworkManager->RPC(RPC_ScriptingRemovePlayerFromVehicle,&bsSend,PRIORITY_HIGH, RELIABILITY_RELIABLE_ORDERED, i, false); } } } } pVehicle->SetDeathTime(SharedUtility::GetTime()); } }
void CObjectManager::Delete(EntityId objectId) { if(!m_bActive[objectId]) return; CSquirrelArguments pArguments; pArguments.push(objectId); g_pEvents->Call("objectDelete", &pArguments); CBitStream bsSend; bsSend.WriteCompressed(objectId); g_pNetworkManager->RPC(RPC_DeleteObject, &bsSend, PRIORITY_HIGH, RELIABILITY_RELIABLE_ORDERED, INVALID_ENTITY_ID, true); m_bActive[objectId] = false; }
void CClientScriptGUIManager::HandleEvent( const char * szEventName, CGUIElement_Impl * pElement ) { // Get the element script CSquirrel * pScript = GetScript ( pElement ); // Is the script invalid? if ( !pScript ) return; // Call the scripting event CSquirrelArguments args; args.pushUserPointer( (void *)pElement ); pCore->GetClientScriptingManager()->GetEvents()->Call( szEventName, &args, pScript ); }
void CBlipManager::Delete(EntityId blipId) { if(!DoesExist(blipId)) return; CSquirrelArguments pArguments; pArguments.push(blipId); g_pEvents->Call("blipDelete", &pArguments); CBitStream bsSend; bsSend.WriteCompressed(blipId); g_pNetworkManager->RPC(RPC_DeleteBlip, &bsSend, PRIORITY_HIGH, RELIABILITY_RELIABLE_ORDERED, INVALID_ENTITY_ID, true); m_bActive[blipId] = false; }
// event checkBoxCheckedChanged(checkBoxName) bool OnCheckboxCheckStateChanged(const CEGUI::EventArgs &eventArgs) { CEvents * pEvents = g_pClient->GetEvents(); String eventName("checkBoxCheckedChanged"); if(!pEvents->IsEventRegistered(eventName)) return false; CEGUI::Window * pWindow = static_cast<const CEGUI::WindowEventArgs&>(eventArgs).window; CSquirrel * pScript = g_pClient->GetClientScriptManager()->GetGUIManager()->GetScript(pWindow); CSquirrelArguments pArguments; pArguments.push(pWindow->getName().c_str()); pEvents->Call(eventName, &pArguments, pScript); return true; }
EntityId CObjectManager::Create(DWORD dwModelHash, const CVector3& vecPosition, const CVector3& vecRotation) { for(EntityId x = 0; x < MAX_OBJECTS; x++) { if(!m_bActive[x]) { m_Objects[x].dwModelHash = dwModelHash; m_Objects[x].vecPosition = vecPosition; m_Objects[x].vecRotation = vecRotation; m_bActive[x] = true; m_Objects[x].iBone = -1; m_Objects[x].m_iInterior = -1; m_Objects[x].bAttached = false; CBitStream bsSend; bsSend.WriteCompressed(x); bsSend.Write(m_Objects[x].dwModelHash); bsSend.Write(m_Objects[x].vecPosition); bsSend.Write(m_Objects[x].vecRotation); bsSend.Write(m_Objects[x].m_iInterior); bsSend.Write(m_Objects[x].bAttached); bsSend.Write(m_Objects[x].bVehicleAttached); bsSend.Write(m_Objects[x].uiVehiclePlayerId); bsSend.Write(m_Objects[x].vecAttachPosition); bsSend.Write(m_Objects[x].vecAttachRotation); if(m_Objects[x].iBone == -1) bsSend.Write0(); else { bsSend.Write1(); bsSend.Write(m_Objects[x].iBone); } g_pNetworkManager->RPC(RPC_NewObject, &bsSend, PRIORITY_HIGH, RELIABILITY_RELIABLE_ORDERED, INVALID_ENTITY_ID, true); CSquirrelArguments pArguments; pArguments.push(x); g_pEvents->Call("objectCreate", &pArguments); SetDimension(x, this->GetDimension(x)); return x; } } return INVALID_ENTITY_ID; }
void TriggerEvent( RakNet::BitStream * pBitStream, RakNet::Packet * pPacket ) { CSquirrelArguments * pArgs = new CSquirrelArguments( pBitStream ); CSquirrelArgument * pEventName = (pArgs->size() > 0 ? pArgs->front() : 0); // if( pEventName && pEventName->GetType() == OT_STRING ) { String strEventName = *pEventName->data.str; pArgs->pop_front(); pCore->GetClientScriptingManager()->GetEvents()->Call( strEventName, pArgs ); SAFE_DELETE( pEventName ); } SAFE_DELETE( pArgs ); }
_MEMBER_FUNCTION_IMPL(GUIElement, getSize) { CGUIFrameWindow * pWindow = sq_getinstance<CGUIFrameWindow *>(pVM); if(pWindow) { CEGUI::UVector2 sz = pWindow->getSize(); CSquirrelArguments args; args.push(sz.d_x.d_offset); args.push(sz.d_y.d_offset); sq_pusharg(pVM, CSquirrelArgument(args, true)); return 1; } sq_pushbool(pVM, false); return 1; }
// event buttonClick(buttonName, bState) // TODO: remove it. We have better alternative guiClick (OnClick) for any gui element bool OnButtonClick(const CEGUI::EventArgs &eventArgs) { CEvents * pEvents = g_pClient->GetEvents(); String eventName("buttonClick"); if(!pEvents->IsEventRegistered(eventName)) return false; CEGUI::Window * pWindow = static_cast<const CEGUI::WindowEventArgs&>(eventArgs).window; CSquirrel * pScript = g_pClient->GetClientScriptManager()->GetGUIManager()->GetScript(pWindow); CSquirrelArguments pArguments; pArguments.push(pWindow->getName().c_str()); pArguments.push(0); // FIXME or what? pEvents->Call(eventName, &pArguments, pScript); return true; }
void CServerRPCHandler::CheckpointLeft(CBitStream * pBitStream, CPlayerSocket * pSenderSocket) { // Ensure we have a valid bit stream if(!pBitStream) return; EntityId playerId = pSenderSocket->playerId; EntityId checkpointId; if(!pBitStream->Read(checkpointId)) return; CSquirrelArguments pArguments; pArguments.push(playerId); pArguments.push(checkpointId); g_pEvents->Call("playerLeaveCheckpoint", &pArguments); }
// toRGBA( colour ); SQInteger CUtilNatives::ToRGBA( SQVM * pVM ) { SQInteger iColour; sq_getinteger( pVM, -1, &iColour ); CColor m_color( (unsigned long)iColour ); CSquirrelArguments args; args.push( m_color.R ); args.push( m_color.G ); args.push( m_color.B ); args.push( m_color.A ); CSquirrelArgument arguments(args, true); arguments.push( pVM ); return 1; }
// event guiMouseLeave(guiName) bool OnMouseLeaves(const CEGUI::EventArgs &eventArgs) { CEvents * pEvents = g_pClient->GetEvents(); String eventName("guiMouseLeave"); if(!pEvents->IsEventRegistered(eventName)) return false; const CEGUI::MouseEventArgs eArgs = static_cast<const CEGUI::MouseEventArgs&>(eventArgs); CEGUI::Window * pWindow = eArgs.window; CSquirrel * pScript = g_pClient->GetClientScriptManager()->GetGUIManager()->GetScript(pWindow); CSquirrelArguments pArguments; pArguments.push(pWindow->getName().c_str()); pEvents->Call(eventName, &pArguments, pScript); return true; }
void CSquirrel::CompilerErrorFunction(SQVM * pVM, const char * szError, const char * szSource, int iLine, int iColumn) { // Find the script CSquirrel * pScript = g_pScriptingManager->Get(pVM); if(pScript) { // Call the 'scriptError' event CSquirrelArguments arguments; arguments.push(szError); arguments.push(szSource); arguments.push(iLine); arguments.push(iColumn); if(g_pEvents->Call("compilerError", &arguments, pScript).GetInteger() == 1) CLogFile::Printf("Error: Failed to compile script %s on Line %d Column %d (%s).", pScript->GetName().Get(), iLine, iColumn, szError); } }
void CSquirrel::CompilerErrorFunction(SQVM * pVM, const char * szError, const char * szSource, int iLine, int iColumn) { // Find the script CSquirrel * pScript = CScriptingManager::GetInstance()->Get(pVM); if(pScript) { // Call the 'compilerError' event CSquirrelArguments arguments; arguments.push(szError); arguments.push(szSource); arguments.push(iLine); arguments.push(iColumn); if(CEvents::GetInstance()->Call("compilerError", &arguments, pScript).GetInteger() == 1) CLogFile::Printf("Error: Failed to compile script %s (Error: %s (Line %d, Column %d)).", pScript->GetName().Get(), szError, iLine, iColumn); } }
// getActorCoordinates(actorid) SQInteger CActorNatives::GetCoordinates(SQVM * pVM) { EntityId actorId; sq_getentity(pVM, -1, &actorId); if(g_pActorManager->DoesExist(actorId)) { CVector3 vecPosition = g_pActorManager->GetPosition(actorId); CSquirrelArguments args; args.push(vecPosition.fX); args.push(vecPosition.fY); args.push(vecPosition.fZ); sq_pusharg(pVM, CSquirrelArgument(args, true)); return 1; } sq_pushbool(pVM, false); return 1; }
int CEventNatives::Call(SQVM* pVM) { // we need enough parameters if(sq_gettop(pVM)<3) { sq_pushbool(pVM, false); return 1; } // get the event name const char* szEventName; if(SQ_FAILED(sq_getstring(pVM, 2, &szEventName))) { sq_pushbool(pVM, false); return 1; } // get the entity which it should effect CEntity* pEntity = sq_toentity(pVM, 3); // if we have a valid entity, use it if(pEntity) { // collect the parameters CSquirrelArguments* pArguments = new CSquirrelArguments(); for(int i = 4; i <= sq_gettop(pVM); ++ i) { // push all arguments from the stack if(!pArguments->pushFromStack(pVM, i)) { sq_pushbool(pVM, false); delete pArguments; return 1; } } sq_pushbool(pVM, pEntity->CallEvent(szEventName, pArguments)); delete pArguments; } else sq_pushbool(pVM, false); return 1; }
// event guiKeyPress(string guiName, string key, string keyState) bool OnKeyPress(const CEGUI::KeyEventArgs &eArgs, String keyState) { CEvents * pEvents = g_pClient->GetEvents(); String eventName("guiKeyPress"); if(!pEvents->IsEventRegistered(eventName)) return false; CEGUI::Window * pWindow = eArgs.window; CSquirrel * pScript = g_pClient->GetClientScriptManager()->GetGUIManager()->GetScript(pWindow); CEGUI::Key::Scan keyCode = eArgs.scancode; CSquirrelArguments pArguments; pArguments.push(eArgs.window->getName().c_str()); pArguments.push(GetKeyNameByScan(eArgs.scancode)); pArguments.push(keyState); CSquirrelArgument pReturn = pEvents->Call(eventName, &pArguments, pScript); return pReturn.GetBool(); }
bool CPlayerManager::Remove(EntityId playerId, BYTE byteReason) { if(!DoesExist(playerId)) return false; CSquirrelArguments pArguments; pArguments.push(playerId); pArguments.push(byteReason); g_pEvents->Call("playerDisconnect", &pArguments); // Clear player variables: g_pGlobalsManager->Remove(playerId); // Delete player blip g_pBlipManager->DeleteForPlayer(playerId); m_pPlayers[playerId]->SetState(STATE_TYPE_DISCONNECT); m_pPlayers[playerId]->DeleteForWorld(); // Mark player as false m_bActive[playerId] = false; String strReason = "None"; if(byteReason == 0) strReason = "Disconnected"; else if(byteReason == 1) strReason = "Lost Connection"; else if(byteReason == 3) strReason = "Classremove"; CLogFile::Printf("[Quit] %s (%d) left the server (%s).", m_pPlayers[playerId]->GetName().Get(), playerId, strReason.Get()); // Only works on windows, if we have linux don't use it! #ifdef _WIN32 SAFE_DELETE( m_pPlayers[playerId] ); #else SAFE_DELETE( m_pPlayers[playerId] ); #endif return true; }