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 CLocalPlayer::DoDeathCheck()
{
// Have we not yet processed the death and is the local player dead?
if(!CLocalPlayer::m_bIsDead && IsDead())
{
// Get the kill info
EntityId playerId = INVALID_ENTITY_ID;
EntityId vehicleId = INVALID_ENTITY_ID;
EntityId weaponId = INVALID_ENTITY_ID;
GetKillInfo(&playerId, &vehicleId,&weaponId);
CLogFile::Printf("HandleDeath(LocalPlayer, %d, %d, %d)", playerId, vehicleId, weaponId);
g_pCore->GetChat()->Outputf(false, "HandleDeath(LocalPlayer, %d, %d, %d)", playerId, vehicleId, weaponId);
// Send the death notification to the server
CBitStream bsSend;
bsSend.WriteCompressed(playerId);
bsSend.WriteCompressed(vehicleId);
bsSend.WriteCompressed(weaponId);
//g_pCore->GetNetworkManager()->Call(NULL, &bsSend, PRIORITY_HIGH, RELIABILITY_RELIABLE_ORDERED, 0, false);
// Mark ourselves as dead
CLocalPlayer::m_bIsDead = true;
// Delete the object
CIVScript::DeleteObject(&m_pObj);
// Reset vehicle entry/exit flags
SetExitFlag(true);
ResetVehicleEnterExit();
// Get current day time so we don't have to set the time always..
CGameFunction::GetTime(&m_iRespawnTime[0], &m_iRespawnTime[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());
}
}
void CServerRPCHandler::PlayerSync(CBitStream * pBitStream, CPlayerSocket senderSocket)
{
// Ensure we have a valid bitstream
if(!pBitStream)
{
CLogFile::Printf("Warning: Invalid bitstream for PlayerSync RPC");
return;
}
// Get the player pointer
CPlayer * pPlayer = g_pServer->GetPlayerManager()->Get(senderSocket.playerId);
// Is the player pointer valid?
if(pPlayer)
{
// Deserialize the player from the bit stream
pPlayer->Deserialize(pBitStream);
// Construct the bit stream
CBitStream bitStream;
// Write the player id
bitStream.WriteCompressed(pPlayer->GetPlayerId());
// Serialize the player to the bit stream
pPlayer->Serialize(&bitStream);
// Send it to all other players
g_pServer->GetNetworkManager()->RPC(RPC_PLAYER_SYNC, &bitStream, PRIORITY_LOW, RELIABILITY_UNRELIABLE_SEQUENCED, senderSocket.playerId, true);
}
}
void CObjectManager::CreateExplosion(const CVector3& vecPos, float fdensity)
{
CBitStream bsSend;
bsSend.Write(vecPos);
bsSend.Write(fdensity);
g_pNetworkManager->RPC(RPC_ScriptingCreateExplosion,&bsSend,PRIORITY_HIGH, RELIABILITY_RELIABLE_ORDERED, INVALID_ENTITY_ID, true);
}
bool CClientFileManager::Start(CMetaFile & mf)
{
if(Exists(mf))
return false;
CFileChecksum fileChecksum;
if(!g_pWebserver->FileCopy(mf, fileChecksum))
{
CLogFile::Printf("Failed to copy client file %s/%s to web server.\n", mf.m_Meta.Get(), mf.m_File.Get());
return false;
}
CClientFile cf;
cf.m_MetaFile = mf;
cf.m_Checksum = fileChecksum;
m_Files.push_back(cf);
CBitStream bsSend;
bsSend.Write((char)mf.m_Type);
bsSend.Write(mf.m_Meta);
bsSend.Write(mf.m_File);
bsSend.Write((char *)&fileChecksum, sizeof(CFileChecksum));
g_pNetworkManager->RPC(RPC_NewFile, &bsSend, PRIORITY_HIGH, RELIABILITY_RELIABLE_ORDERED, INVALID_ENTITY_ID, true);
return true;
}
bool ProgramStreamDecoder::ReadPrivateStream1(CBitStream& stream)
{
bool result = true;
PRIVATE_STREAM1_INFO streamInfo;
uint32 packetLength = static_cast<uint16>(stream.GetBits_MSBF(16));
packetLength -= ReadPesExtension(stream);
//Read private stream 1 stuff
streamInfo.subStreamNumber = static_cast<uint8>(stream.GetBits_MSBF(8));
streamInfo.frameCount = static_cast<uint8>(stream.GetBits_MSBF(8));
streamInfo.firstAccessUnit = static_cast<uint16>(stream.GetBits_MSBF(16));
packetLength -= 4;
if(m_privateStream1Handler)
{
result = m_privateStream1Handler(stream, streamInfo, packetLength);
}
else
{
for(unsigned int i = 0; i < packetLength; i++)
{
uint8 stuff = static_cast<uint8>(stream.GetBits_MSBF(8));
}
}
return result;
}
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;
}
void CVehicle::SetAlarm(int iDuration)
{
CBitStream bsSend;
bsSend.Write(m_vehicleId);
bsSend.Write(iDuration);
g_pNetworkManager->RPC(RPC_ScriptingSetVehicleAlarm, &bsSend, PRIORITY_HIGH, RELIABILITY_RELIABLE_ORDERED, INVALID_ENTITY_ID, true);
}
// actorWalkToCoordinatesForPlayer(playerid, actorid, x, y, z)
SQInteger CActorNatives::WalkToCoordinates(SQVM * pVM)
{
EntityId playerId;
EntityId actorId;
CVector3 vecPosition;
SQInteger iType;
sq_getentity(pVM, -6, &playerId);
sq_getentity(pVM, -5, &actorId);
sq_getvector3(pVM, -4, &vecPosition);
sq_getinteger(pVM, -1, &iType);
if(g_pPlayerManager->DoesExist(playerId))
{
CBitStream bsSend;
bsSend.Write(actorId);
bsSend.Write(vecPosition);
bsSend.Write((int)iType);
g_pNetworkManager->RPC(RPC_ScriptingActorWalkToCoordinates, &bsSend, PRIORITY_HIGH, RELIABILITY_RELIABLE_ORDERED, playerId, false);
sq_pushbool(pVM, true);
return 1;
}
sq_pushbool(pVM, false);
return 1;
}
void C3DLabel::SetDimension(DimensionId dimensionId)
{
m_dimensionId = dimensionId;
CBitStream bsSend;
bsSend.WriteCompressed(m_labelId);
bsSend.Write(dimensionId);
g_pNetworkManager->RPC(RPC_ScriptingSet3DLabelDimension, &bsSend, PRIORITY_HIGH, RELIABILITY_RELIABLE_ORDERED, INVALID_ENTITY_ID, false);
}
void C3DLabel::SetStreamingDistance(float fDistance)
{
m_fStreamingDistance = fDistance;
CBitStream bsSend;
bsSend.WriteCompressed(m_labelId);
bsSend.Write(m_fStreamingDistance);
g_pNetworkManager->RPC(RPC_ScriptingSet3DLabelStreamingDistance, &bsSend, PRIORITY_HIGH, RELIABILITY_RELIABLE_ORDERED, INVALID_ENTITY_ID, false);
}
void C3DLabel::SetVisible(bool bVisible)
{
m_bVisible = bVisible;
CBitStream bsSend;
bsSend.WriteCompressed(m_labelId);
bsSend.Write(m_bVisible);
g_pNetworkManager->RPC(RPC_ScriptingSet3DLabelVisible, &bsSend, PRIORITY_HIGH, RELIABILITY_RELIABLE_ORDERED, INVALID_ENTITY_ID, false);
}
void C3DLabel::SetColor(DWORD dwColor)
{
m_dwColor = dwColor;
CBitStream bsSend;
bsSend.WriteCompressed(m_labelId);
bsSend.Write(m_dwColor);
g_pNetworkManager->RPC(RPC_ScriptingSet3DLabelColor, &bsSend, PRIORITY_HIGH, RELIABILITY_RELIABLE_ORDERED, INVALID_ENTITY_ID, false);
}
void C3DLabel::SetText(const String& strText)
{
m_strText = strText;
CBitStream bsSend;
bsSend.WriteCompressed(m_labelId);
bsSend.Write(m_strText);
g_pNetworkManager->RPC(RPC_ScriptingSet3DLabelText, &bsSend, PRIORITY_HIGH, RELIABILITY_RELIABLE_ORDERED, INVALID_ENTITY_ID, false);
}
void CCheckpoint::ShowForPlayer(EntityId playerId)
{
CBitStream bsSend;
bsSend.Write(m_checkpointId);
bsSend.Write(m_vecPosition);
bsSend.Write(m_vecTargetPosition);
g_pNetworkManager->RPC(RPC_ScriptingShowCheckpointForPlayer, &bsSend, PRIORITY_HIGH, RELIABILITY_RELIABLE_ORDERED, playerId, false);
}
void C3DLabel::SetPosition(const CVector3& vecPosition)
{
m_vecPosition = vecPosition;
CBitStream bsSend;
bsSend.WriteCompressed(m_labelId);
bsSend.Write(m_vecPosition);
g_pNetworkManager->RPC(RPC_ScriptingSet3DLabelPosition, &bsSend, PRIORITY_HIGH, RELIABILITY_RELIABLE_ORDERED, INVALID_ENTITY_ID, false);
}
void ProgramStreamDecoder::ReadPrivateStream2(CBitStream& stream)
{
uint32 packetLength = static_cast<uint16>(stream.GetBits_MSBF(16));
for(unsigned int i = 0; i < packetLength; i++)
{
uint8 stuff = static_cast<uint8>(stream.GetBits_MSBF(8));
}
}
void CVehicle::SetDirtLevel(float fDirtLevel)
{
m_fDirtLevel = fDirtLevel;
CBitStream bsSend;
bsSend.Write(m_vehicleId);
bsSend.Write(fDirtLevel);
g_pNetworkManager->RPC(RPC_ScriptingSetVehicleDirtLevel, &bsSend, PRIORITY_HIGH, RELIABILITY_RELIABLE_ORDERED, INVALID_ENTITY_ID, true);
}
void CVehicle::SoundHorn(unsigned int iDuration)
{
m_iHornDuration = iDuration;
CBitStream bsSend;
bsSend.Write(m_vehicleId);
bsSend.Write(iDuration);
g_pNetworkManager->RPC(RPC_ScriptingSoundVehicleHorn, &bsSend, PRIORITY_HIGH, RELIABILITY_RELIABLE_ORDERED, INVALID_ENTITY_ID, true);
}
void CVehicle::SetMoveSpeed(const CVector3& vecMoveSpeed)
{
m_vecMoveSpeed = vecMoveSpeed;
CBitStream bsSend;
bsSend.Write(m_vehicleId);
bsSend.Write(vecMoveSpeed);
g_pNetworkManager->RPC(RPC_ScriptingSetVehicleMoveSpeed, &bsSend, PRIORITY_HIGH, RELIABILITY_RELIABLE_ORDERED, INVALID_ENTITY_ID, true);
}
void CVehicle::TurnTaxiLights(bool bTaxilights)
{
m_bTaxiLight = bTaxilights;
CBitStream bsSend;
bsSend.Write(m_vehicleId);
bsSend.Write(m_bTaxiLight);
g_pNetworkManager->RPC(RPC_ScriptingTurnTaxiLights, &bsSend, PRIORITY_HIGH, RELIABILITY_RELIABLE_ORDERED, INVALID_ENTITY_ID, true);
}
void CVehicle::SetEngineStatus(bool bEngineStatus)
{
m_bEngineStatus = bEngineStatus;
CBitStream bsSend;
bsSend.Write(m_vehicleId);
bsSend.Write(bEngineStatus);
g_pNetworkManager->RPC(RPC_ScriptingSetVehicleEngineState, &bsSend, PRIORITY_HIGH, RELIABILITY_RELIABLE_ORDERED, INVALID_ENTITY_ID, true);
}
void CVehicle::SetTyreState(unsigned int uiTyre, bool bState)
{
m_bTyre[uiTyre] = bState;
CBitStream bsSend;
bsSend.Write(m_vehicleId);
bsSend.Write(m_bTyre[uiTyre]);
g_pNetworkManager->RPC(RPC_ScriptingSetVehicleTryeState, &bsSend, PRIORITY_HIGH, RELIABILITY_RELIABLE_ORDERED, INVALID_ENTITY_ID, true);
}
void CVehicle::SetLights(bool bLights)
{
m_bLights = bLights;
CBitStream bsSend;
bsSend.Write(m_vehicleId);
bsSend.Write(bLights);
g_pNetworkManager->RPC(RPC_ScriptingSetCarLights, &bsSend, PRIORITY_HIGH, RELIABILITY_RELIABLE_ORDERED, INVALID_ENTITY_ID, true);
}
void CVehicle::SetPetrolTankHealth(float fHealth)
{
m_fPetrolTankHealth = fHealth;
CBitStream bsSend;
bsSend.Write(m_vehicleId);
bsSend.Write(m_fPetrolTankHealth);
g_pNetworkManager->RPC(RPC_ScriptingSetVehiclePetrolTankHealth, &bsSend, PRIORITY_HIGH, RELIABILITY_RELIABLE_ORDERED, INVALID_ENTITY_ID, true);
}
void CVehicle::SetVehicleGPSState(bool bState)
{
m_bGpsState = bState;
CBitStream bsSend;
bsSend.Write(m_vehicleId);
bsSend.Write(bState);
g_pNetworkManager->RPC(RPC_ScriptingSetVehicleGPSState, &bsSend, PRIORITY_HIGH, RELIABILITY_RELIABLE_ORDERED, INVALID_ENTITY_ID, true);
}
void CPlayer::DestroyForPlayer(EntityId playerId)
{
// Construct the BitStream
CBitStream bitStream;
bitStream.WriteCompressed(m_playerId);
// Send it to the player
g_pServer->GetNetworkManager()->RPC(RPC_DESTROY_PLAYER, &bitStream, PRIORITY_HIGH, RELIABILITY_RELIABLE_ORDERED, playerId, false);
}
void CVehicle::SetDimension(DimensionId ucDimension)
{
m_ucDimension = ucDimension;
CBitStream bsSend;
bsSend.Write(m_vehicleId);
bsSend.Write(ucDimension);
g_pNetworkManager->RPC(RPC_ScriptingSetPlayerDimension, &bsSend, PRIORITY_HIGH, RELIABILITY_RELIABLE_ORDERED, INVALID_ENTITY_ID, true);
}
void CVehicle::MarkVehicle(bool bToggle)
{
m_bActorVehicle = bToggle;
CBitStream bsSend;
bsSend.Write(m_vehicleId);
bsSend.Write(m_bActorVehicle);
g_pNetworkManager->RPC(RPC_ScriptingMarkVehicleAsActorVehicle, &bsSend, PRIORITY_HIGH, RELIABILITY_RELIABLE_ORDERED, INVALID_ENTITY_ID, true);
}
