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;
}
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 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);
}
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);
	}
}
Example #5
0
void CPlayerManager::HandleClientJoin(EntityId playerId)
{
	if(GetPlayerCount() > 1)
 	{
		for(EntityId x = 0; x < MAX_PLAYERS; x++)
		{
			if(m_bActive[x] && x != playerId)
			{
				m_pPlayers[x]->AddForPlayer(playerId);
				m_pPlayers[x]->SpawnForPlayer(playerId);

				if(g_pBlipManager->DoesPlayerBlipExist(x)) {
					CBitStream bsSend;
					bsSend.WriteCompressed(x);
					bsSend.Write(g_pBlipManager->GetPlayerBlipSprite(x));
					bsSend.Write(true);
					bsSend.Write(g_pBlipManager->GetPlayerBlipShow(x));
					g_pNetworkManager->RPC(RPC_ScriptingCreatePlayerBlip, &bsSend, PRIORITY_HIGH, RELIABILITY_RELIABLE_ORDERED, playerId, true);
					bsSend.Reset();
				}
				m_pPlayers[x]->SetDimension(m_pPlayers[x]->GetDimension());
			} else if(x == playerId) {
				m_pPlayers[x]->SetDimension(m_pPlayers[x]->GetDimension());
			}
		}
	}
}
Example #6
0
// 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;
}
Example #7
0
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);
}
Example #8
0
LabelId C3DLabelManager::Add(const String& text, const CVector3& vecPosition, DWORD dwColor, bool bVisible, float fStreamingDistance)
{
	for(LabelId i = 0; i < MAX_3D_LABELS; i++) 
	{
		if(!DoesExist(i))
		{
			m_Labels[i] = new C3DLabel(i, text, vecPosition, dwColor, bVisible, fStreamingDistance);
			m_Labels[i]->SetText(text);
			m_Labels[i]->SetPosition(vecPosition);
			m_Labels[i]->SetVisible(true);

			CBitStream bsSend;
			bsSend.WriteCompressed(i);
			bsSend.Write(m_Labels[i]->GetText());
			bsSend.Write(m_Labels[i]->GetPosition());
			bsSend.Write(m_Labels[i]->GetColor());
			bsSend.Write(m_Labels[i]->GetStreamingDistance());
			bsSend.Write(m_Labels[i]->GetDimension());
			bsSend.WriteBit(m_Labels[i]->IsVisible());
			g_pNetworkManager->RPC(RPC_New3DLabel, &bsSend, PRIORITY_HIGH, RELIABILITY_RELIABLE_ORDERED, INVALID_ENTITY_ID, true);
			return i;
		}
	}
	return MAX_3D_LABELS; /* INVALID ID */
}
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);
}
Example #10
0
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);
}
Example #11
0
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);
}
Example #12
0
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);
}
Example #13
0
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);
}
Example #14
0
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);
}
Example #15
0
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);
}
Example #16
0
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);
}
Example #17
0
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);
}
Example #18
0
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);
}
Example #19
0
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);
}
Example #20
0
void CVehicle::SetCarDoorAngle(unsigned int uiDoor, bool bClosed, float fAngle)
{
	m_fDoor[uiDoor] = fAngle;

	CBitStream bsSend;
	bsSend.Write(m_vehicleId);
	bsSend.Write(uiDoor);
	bsSend.Write(bClosed);
	bsSend.Write(fAngle);
	g_pNetworkManager->RPC(RPC_ScriptingControlCar, &bsSend, PRIORITY_HIGH, RELIABILITY_RELIABLE_ORDERED, INVALID_ENTITY_ID, true);
}
void CBlipManager::SetName(EntityId blipId, String strName)
{
	if(DoesExist(blipId))
	{
		m_Blips[blipId].strName = strName;
		CBitStream bsSend;
		bsSend.Write(blipId);
		bsSend.Write(strName);
		g_pNetworkManager->RPC(RPC_ScriptingSetBlipName, &bsSend, PRIORITY_HIGH, RELIABILITY_RELIABLE_ORDERED, INVALID_ENTITY_ID, true);
	}
}
void CBlipManager::SetColor(EntityId blipId, unsigned int uiColor) 
{
	if(DoesExist(blipId))
	{
		m_Blips[blipId].uiColor = uiColor;

		CBitStream bsSend;
		bsSend.Write(blipId);
		bsSend.Write(uiColor);
		g_pNetworkManager->RPC(RPC_ScriptingSetBlipColor, &bsSend, PRIORITY_HIGH, RELIABILITY_RELIABLE_ORDERED, INVALID_ENTITY_ID, true);
	}
}
void CBlipManager::SetSize(EntityId blipId, float fSize)
{
	if(DoesExist(blipId) && fSize > 0.0f && fSize <= 4.0f)
	{
		m_Blips[blipId].fSize = fSize;

		CBitStream bsSend;
		bsSend.Write(blipId);
		bsSend.Write(fSize);
		g_pNetworkManager->RPC(RPC_ScriptingSetBlipSize, &bsSend, PRIORITY_HIGH, RELIABILITY_RELIABLE_ORDERED, INVALID_ENTITY_ID, true);
	}
}
Example #24
0
void CVehicle::SetColors(BYTE byteColor1, BYTE byteColor2, BYTE byteColor3, BYTE byteColor4)
{
	m_byteColors[0] = byteColor1;
	m_byteColors[1] = byteColor2;
	m_byteColors[2] = byteColor3;
	m_byteColors[3] = byteColor4;

	CBitStream bsSend;
	bsSend.Write(m_vehicleId);
	bsSend.Write((char *)m_byteColors, sizeof(m_byteColors));
	g_pNetworkManager->RPC(RPC_ScriptingSetVehicleColor, &bsSend, PRIORITY_HIGH, RELIABILITY_RELIABLE_ORDERED, INVALID_ENTITY_ID, true);
}
Example #25
0
void CVehicle::SetIndicatorState(bool bFrontLeft, bool bFrontRight, bool bBackLeft, bool bBackRight)
{
	m_bIndicatorState[0] = bFrontLeft;
	m_bIndicatorState[1] = bFrontRight;
	m_bIndicatorState[2] = bBackLeft;
	m_bIndicatorState[3] = bBackRight;

	CBitStream bsSend;
	bsSend.Write(m_vehicleId);
	bsSend.Write((unsigned char)(bFrontLeft + 2*bFrontRight + 4*bBackLeft + 8*bBackRight));
	g_pNetworkManager->RPC(RPC_ScriptingSetVehicleIndicators, &bsSend, PRIORITY_HIGH, RELIABILITY_RELIABLE_ORDERED, INVALID_ENTITY_ID, true);
}
void CBlipManager::ToggleShortRange(EntityId blipId, bool bShortRange)
{
	if(DoesExist(blipId))
	{
		m_Blips[blipId].bShortRange = bShortRange;

		CBitStream bsSend;
		bsSend.Write(blipId);
		bsSend.Write(bShortRange);
		g_pNetworkManager->RPC(RPC_ScriptingToggleBlipShortRange, &bsSend, PRIORITY_HIGH, RELIABILITY_RELIABLE_ORDERED, INVALID_ENTITY_ID, true);
	}
}
void CObjectManager::RotateObject(EntityId objectId, const CVector3& vecMoveRot, int iTime)
{
	if(DoesExist(objectId))
	{
		CBitStream bsSend;
		bsSend.WriteCompressed(objectId);
		bsSend.Write(vecMoveRot);
		bsSend.Write(iTime);
		m_Objects[objectId].vecRotation = vecMoveRot;

		g_pNetworkManager->RPC(RPC_ScriptingRotateObject, &bsSend, PRIORITY_HIGH, RELIABILITY_RELIABLE_ORDERED, INVALID_ENTITY_ID, true);
	}
}
void CBlipManager::TogglePlayerShortRangeForPlayer(EntityId playerId, EntityId toPlayerId, bool bToggle)
{
	// Check if we have a blip for the player
	if(!m_bPlayerActive[playerId])
		return;

	CBitStream bsSend;
	bsSend.WriteCompressed(playerId);
	bsSend.Write(m_PlayerBlips[playerId].iSprite);
	bsSend.Write(bToggle);
	bsSend.Write(m_PlayerBlips[playerId].bShow);
	g_pNetworkManager->RPC(RPC_ScriptingChangePlayerBlip, &bsSend, PRIORITY_HIGH, RELIABILITY_RELIABLE_ORDERED, toPlayerId, false);
}
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::HandleClientJoinFire(EntityId playerId)
{
	CBitStream bsSend;
	for(EntityId x = 0; x < MAX_FIRE; x++)
	{
		if(m_bFireActive[x])
		{
			bsSend.Write(x);
			bsSend.Write(m_FireObject[x].vecPosition);
			bsSend.Write(m_FireObject[x].fdensity);
			g_pNetworkManager->RPC(RPC_ScriptingCreateFire, &bsSend, PRIORITY_HIGH, RELIABILITY_RELIABLE_ORDERED, playerId, false);
		}
	}
}