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::AttachToPlayer(EntityId objectId, EntityId playerId, const CVector3& vecPos, const CVector3& vecRot, int iBone)
{
	if(DoesExist(objectId))
	{
		m_Objects[objectId].bAttached = true;
		m_Objects[objectId].bVehicleAttached = false;
		m_Objects[objectId].uiVehiclePlayerId = playerId;
		m_Objects[objectId].vecAttachPosition = vecPos;
		m_Objects[objectId].vecAttachRotation = vecRot;
		m_Objects[objectId].iBone = iBone;

		CBitStream bsSend;
		bsSend.WriteCompressed(objectId);
		bsSend.Write(m_Objects[objectId].bAttached);
		bsSend.Write(m_Objects[objectId].bVehicleAttached);
		bsSend.Write(m_Objects[objectId].uiVehiclePlayerId);
		bsSend.Write(m_Objects[objectId].vecAttachPosition);
		bsSend.Write(m_Objects[objectId].vecAttachRotation);
		if(iBone != -1)
		{
			bsSend.Write1();
			bsSend.Write(m_Objects[objectId].iBone);
		}
		else
			bsSend.Write0();
		g_pNetworkManager->RPC(RPC_ScriptingAttachObject,&bsSend,PRIORITY_HIGH, RELIABILITY_RELIABLE_ORDERED, INVALID_ENTITY_ID, true);
	}
}
void CObjectManager::HandleClientJoin(EntityId playerId)
{
	if(GetObjectCount() > 0)
	{
		CBitStream bsSend;

		for(EntityId x = 0; x < MAX_OBJECTS; x++)
		{
			if(m_bActive[x])
			{
				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].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);
				}

				this->SetDimension(x, this->GetDimension(x));			
			}
		}

		g_pNetworkManager->RPC(RPC_NewObject, &bsSend, PRIORITY_HIGH, RELIABILITY_RELIABLE_ORDERED, playerId, false);
	}
}
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 CObjectManager::MoveObject(EntityId objectId, const CVector3& vecMoveTarget, const CVector3& vecMoveRot, float fSpeed)
{
	if(DoesExist(objectId))
	{
		CBitStream bsSend;
		bsSend.WriteCompressed(objectId);
		bsSend.Write(vecMoveTarget);
		bsSend.Write(fSpeed);
		m_Objects[objectId].vecPosition = vecMoveTarget;

		if((vecMoveRot - m_Objects[objectId].vecPosition).Length() != 0) {
			bsSend.Write1();
			bsSend.Write(vecMoveRot);
			m_Objects[objectId].vecRotation = vecMoveRot;
		} else {
			bsSend.Write0();
		}
		g_pNetworkManager->RPC(RPC_ScriptingMoveObject, &bsSend, PRIORITY_HIGH, RELIABILITY_RELIABLE_ORDERED, INVALID_ENTITY_ID, true);
	}
}
void CNetworkEntity::Deserialize(ePackageType pType)
{
	// Get Sync package here and recieve it to the server
	CBitStream * pBitStream = new CBitStream();
	pBitStream->Write0();
}
void CNetworkEntity::Serialize(ePackageType pType)
{
	// Create Sync package here and send it to the server
	CBitStream * pBitStream = new CBitStream();
	pBitStream->Write0();
}
void CServerRPCHandler::PlayerConnect(CBitStream * pBitStream, CPlayerSocket * pSenderSocket)
{
	// Ensure we have a valid bit stream
	if(!pBitStream)
		return;

	// Read packet data
	EntityId playerId = pSenderSocket->playerId;
	int iVersion;
	pBitStream->Read(iVersion);

	String strName;
	pBitStream->Read(strName);

	CheckGTAFiles pCheckFiles;
	bool bGameFilesModded = false;
	pBitStream->Read((char *)&pCheckFiles, sizeof(CheckGTAFiles));

	if(pCheckFiles.bGTAFileChecksum || pCheckFiles.bHandleFileChanged) {
		if(CVAR_GET_BOOL("checkGTAFiles"))
			CLogFile::Printf("[FileCheckSum] Warning, detected modded GTA IV files at player %s", strName.Get());

		bGameFilesModded = true;
	}

	// Apply serial and ip
	String strIP = pSenderSocket->GetAddress(true);
	String strSerial = pSenderSocket->GetSerial();

	// Setup our reply packet
	CBitStream bsSend;
	
	// Check for matching network versions
	if(iVersion != NETWORK_VERSION)
	{
		bsSend.Write(REFUSE_REASON_INVALID_VERSION);
		g_pNetworkManager->RPC(RPC_ConnectionRefused, &bsSend, PRIORITY_HIGH, RELIABILITY_RELIABLE, playerId, false);
		CLogFile::Printf("[Connect] Authorization for %s (%s) failed (Invalid version (Client: %x, Server: %x))!", strIP.Get(), strName.Get(), iVersion, NETWORK_VERSION);
		return;
	}

	// Check that their name is valid
	if(strName.IsEmpty() || strName.GetLength() > MAX_NAME_LENGTH)
	{
		bsSend.Write(REFUSE_REASON_NAME_INVALID);
		g_pNetworkManager->RPC(RPC_ConnectionRefused, &bsSend, PRIORITY_HIGH, RELIABILITY_RELIABLE, playerId, false);
		CLogFile::Printf("[Connect] Authorization for %s (%s) failed (name invalid).", strIP.Get(), strName.Get());
		return;
	}

	// Check that their name is not already in use
	if(g_pPlayerManager->IsNameInUse(strName))
	{
		bsSend.Write(REFUSE_REASON_NAME_IN_USE);
		g_pNetworkManager->RPC(RPC_ConnectionRefused, &bsSend, PRIORITY_HIGH, RELIABILITY_RELIABLE, playerId, false);
		CLogFile::Printf("[Connect] Authorization for %s (%s) failed (name in use).", strIP.Get(), strName.Get());
		return;
	}

	CSquirrelArguments nameCheckArguments;
	nameCheckArguments.push(playerId);
	nameCheckArguments.push(strName);

	if(g_pEvents->Call("playerNameCheck", &nameCheckArguments).GetInteger() != 1)
	{
		bsSend.Write(REFUSE_REASON_NAME_INVALID);
		g_pNetworkManager->RPC(RPC_ConnectionRefused, &bsSend, PRIORITY_HIGH, RELIABILITY_RELIABLE, playerId, false);
		CLogFile::Printf("[Connect] Authorization for %s (%s) failed (name invalid).", strIP.Get(), strName.Get());
		return;
	}

	// Call the playerAuth event, and process the return value
	CSquirrelArguments playerAuthArguments;
	playerAuthArguments.push(playerId);
	playerAuthArguments.push(strName);
	playerAuthArguments.push(strIP);
	playerAuthArguments.push(strSerial);
	playerAuthArguments.push(bGameFilesModded);

	if(g_pEvents->Call("playerAuth", &playerAuthArguments).GetInteger() != 1)
	{
		bsSend.Write(REFUSE_REASON_ABORTED_BY_SCRIPT);
		g_pNetworkManager->RPC(RPC_ConnectionRefused, &bsSend, PRIORITY_HIGH, RELIABILITY_RELIABLE, playerId, false);
		CLogFile::Printf("[Connect] Authorization for %s (%s) failed (aborted by script).", strIP.Get(), strName.Get());
		return;
	}

	CLogFile::Printf("[Connect] Authorization for %s (%s) complete.", strIP.Get(), strName.Get());

	// Setup the player
	g_pPlayerManager->Add(playerId, strName);
	CPlayer * pPlayer = g_pPlayerManager->GetAt(playerId);
	
	// Check player creation
	if(!pPlayer)
	{
		CLogFile::Printf("[Connect] Failed to create player instance for %s.", strName.Get());
		return;
	}

	// Apply files
	pPlayer->SetFileCheck(pCheckFiles);

	// Let the vehicle manager handle the client join
	g_pVehicleManager->HandleClientJoin(playerId);

	// Let the player manager handle the client join
	g_pPlayerManager->HandleClientJoin(playerId);

	// Let the object manager handle the client join
	g_pObjectManager->HandleClientJoin(playerId);

	// Let the fire manager handle the client join
	g_pObjectManager->HandleClientJoinFire(playerId);

	// Let the blip manager handle the client join
	g_pBlipManager->HandleClientJoin(playerId);

	// Let the checkpoint manager handle the client join
	g_pCheckpointManager->HandleClientJoin(playerId);

	// Let the pickup manager handle the client join
	g_pPickupManager->HandleClientJoin(playerId);

	// Let the actor manager handle the client join
	g_pActorManager->HandleClientJoin(playerId);

	g_p3DLabelManager->HandleClientJoin(playerId);

	// Construct the reply bit stream
	bsSend.Write(playerId);
	bsSend.Write(CVAR_GET_STRING("hostname"));
	bsSend.WriteBit(CVAR_GET_BOOL("paynspray"));
	bsSend.WriteBit(CVAR_GET_BOOL("autoaim"));
	bsSend.Write(pPlayer->GetColor());
	bsSend.Write(CVAR_GET_STRING("httpserver"));
	bsSend.Write((unsigned short)CVAR_GET_INTEGER("httpport"));
	bsSend.Write((unsigned char)CVAR_GET_INTEGER("weather"));
	bsSend.WriteBit(CVAR_GET_BOOL("guinametags"));
	bsSend.WriteBit(CVAR_GET_BOOL("vehicledamage"));
	bsSend.WriteBit(CVAR_GET_BOOL("vehiclewaterdeath"));
	bsSend.WriteBit(CVAR_GET_BOOL("headmovement"));
	bsSend.Write(CVAR_GET_INTEGER("maxplayers"));

	// Time
	unsigned char ucHour = 0, ucMinute = 0;
	g_pTime->GetTime(&ucHour, &ucMinute);
	bsSend.Write((unsigned char)(ucHour + (24 * (1 + g_pTime->GetDayOfWeek()))));
	bsSend.Write(ucMinute);

	if(g_pTime->GetMinuteDuration() != CTime::DEFAULT_MINUTE_DURATION)
	{
		bsSend.Write1();
		bsSend.Write(g_pTime->GetMinuteDuration());
	}
	else
		bsSend.Write0();

	// Traffic Lights
	bsSend.Write((unsigned char)g_pTrafficLights->GetSetState());
	bsSend.Write(g_pTrafficLights->GetTimeThisCylce());

	if(g_pTrafficLights->GetSetState() != CTrafficLights::TRAFFIC_LIGHT_STATE_DISABLED_DISABLED)
	{
		if(g_pTrafficLights->IsLocked())
			bsSend.Write1();
		else
			bsSend.Write0();

		if(!g_pTrafficLights->IsUsingDefaultDurations())
		{
			bsSend.Write1();
			if(g_pTrafficLights->GetSetState() >= CTrafficLights::TRAFFIC_LIGHT_STATE_FLASHING_FLASHING)
				bsSend.Write(g_pTrafficLights->GetYellowDuration());
			else
			{
				bsSend.Write(g_pTrafficLights->GetGreenDuration());
				bsSend.Write(g_pTrafficLights->GetYellowDuration());
				bsSend.Write(g_pTrafficLights->GetRedDuration());
			}
		}
		else
			bsSend.Write0();
	}

	// Send the joined game RPC
	g_pNetworkManager->RPC(RPC_JoinedGame, &bsSend, PRIORITY_HIGH, RELIABILITY_RELIABLE_ORDERED, playerId, false);

	// Inform the resource file manager of the client join
	g_pClientResourceFileManager->HandleClientJoin(playerId);

	// Inform the script file manager of the client join
	g_pClientScriptFileManager->HandleClientJoin(playerId);

	CLogFile::Printf("[Join] %s (%d) is joining the game.", strName.Get(), playerId);

	CSquirrelArguments playerConnectArguments;
	playerConnectArguments.push(playerId);
	playerConnectArguments.push(strName);
	g_pEvents->Call("playerConnect", &playerConnectArguments);
}
Example #9
0
void CVehicle::SpawnForPlayer(EntityId playerId)
{
	CBitStream bsSend;
	bsSend.WriteCompressed(m_vehicleId);
	bsSend.Write(m_iModelId);
	bsSend.Write(m_uiHealth);
	bsSend.Write(m_fPetrolTankHealth);
	bsSend.Write(m_vecPosition);

	if(!m_vecRotation.IsEmpty())
	{
		bsSend.Write1();
		bsSend.Write(m_vecRotation);
	}
	else
		bsSend.Write0();

	if(!m_vecTurnSpeed.IsEmpty())
	{
		bsSend.Write1();
		bsSend.Write(m_vecTurnSpeed);
	}
	else
		bsSend.Write0();

	if(!m_vecMoveSpeed.IsEmpty())
	{
		bsSend.Write1();
		bsSend.Write(m_vecMoveSpeed);
	}
	else
		bsSend.Write0();

	bsSend.Write(m_iRespawnDelay);
	bsSend.Write((char *)m_byteColors, sizeof(m_byteColors));

	bsSend.Write(m_fDirtLevel);

	for(int i = 0; i < 4; ++ i)
		bsSend.WriteBit(m_bIndicatorState[i]);

	for(int i = 0; i < 9; ++ i)
		bsSend.WriteBit(m_bComponents[i]);

	bsSend.Write(m_iHornDuration);
	bsSend.Write(m_bSirenState);
	bsSend.Write(m_iLocked);
	bsSend.Write(m_bEngineStatus);
	bsSend.Write(m_bLights);

	for(int i = 0; i < 6; i++)
		bsSend.Write(m_fDoor[i]);

	for(int i = 0; i < 4; i++)
		bsSend.Write(m_bWindow[i]);

	bsSend.Write(m_bTaxiLight);
	bsSend.Write(m_bGpsState);

	if(m_ucVariation != 0)
	{
		bsSend.Write1();
		bsSend.Write(m_ucVariation);
	}
	else
		bsSend.Write0();

	g_pNetworkManager->RPC(RPC_NewVehicle, &bsSend, PRIORITY_HIGH, RELIABILITY_RELIABLE_ORDERED, playerId, false);

	// Mark vehicle as actor vehicle
	bsSend.Reset();
	bsSend.Write(m_vehicleId);
	bsSend.Write(m_bActorVehicle);
	g_pNetworkManager->RPC(RPC_ScriptingMarkVehicleAsActorVehicle, &bsSend, PRIORITY_HIGH, RELIABILITY_RELIABLE_ORDERED, playerId, false);

	SetColors(m_byteColors[0],m_byteColors[1],m_byteColors[2],m_byteColors[3]);
}