// 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;
}
