mirror of
https://github.com/DarkflameUniverse/DarkflameServer
synced 2024-08-30 18:43:58 +00:00
c6f220ee31
* Grammatical changes in comments * Grammatical fixes in comments Small grammatical fixes found in comments throughout the code. * Added descriptions to functions Added descriptions to functions that didn't have them to keep the code well documented * Created RacingTaskParam.h Created RacingTaskParam so eliminate magic numbers in the original implementation of completing racing missions. * Updated magic numbers in Mission.cpp Updated magic numbers in Mission.cpp to a meaningful name. * Implemented racing smashable task progression Previously, races did not progress tasks for smashing Entities. Now all achievements tracking smashables track them correctly. This has been implemented in the three Entities that can be smashed in a race (imagination boxes, track specific smashables, Forbidden Valley dragon eggs). * Updated race imagination task progression Race imagination now no longer uses a magic number when passed to missionComponent. Instead we use a number defined in an enum located in RacingTaskParam.h * Updated Race task checks Racing tasks for completing races without smashing now no longer auto complete the whole chain of missions. Tasks that track placing on tracks and races overall now properly complete. Tasks that count how many missions in a zone are completed now function. Tasks that track race completions in multiple areas now function. * Updated RacingControlComponent.cpp Fixed any tasks that required 3 players to now require 3 or more players in a race to progress. This restriction is ignored if the world config opted in for solo racing to allow progression in solo worlds. Updated magic numbers sent into missionComponent->Progress to an enum created in this PR. Fixed some indentation. * Fixed a grammatical error in variable name Fixed a grammatical error in the enum for task params
902 lines
30 KiB
C++
902 lines
30 KiB
C++
/**
|
|
* Thanks to Simon for his early research on the racing system.
|
|
*/
|
|
|
|
#include "RacingControlComponent.h"
|
|
|
|
#include "CharacterComponent.h"
|
|
#include "DestroyableComponent.h"
|
|
#include "EntityManager.h"
|
|
#include "GameMessages.h"
|
|
#include "InventoryComponent.h"
|
|
#include "Item.h"
|
|
#include "MissionComponent.h"
|
|
#include "ModuleAssemblyComponent.h"
|
|
#include "Player.h"
|
|
#include "PossessableComponent.h"
|
|
#include "PossessorComponent.h"
|
|
#include "RacingTaskParam.h"
|
|
#include "Spawner.h"
|
|
#include "VehiclePhysicsComponent.h"
|
|
#include "dServer.h"
|
|
#include "dZoneManager.h"
|
|
#include "dConfig.h"
|
|
|
|
#ifndef M_PI
|
|
#define M_PI 3.14159265358979323846264338327950288
|
|
#endif
|
|
|
|
RacingControlComponent::RacingControlComponent(Entity *parent)
|
|
: Component(parent) {
|
|
m_PathName = u"MainPath";
|
|
m_RemainingLaps = 3;
|
|
m_LeadingPlayer = LWOOBJID_EMPTY;
|
|
m_RaceBestTime = 0;
|
|
m_RaceBestLap = 0;
|
|
m_Started = false;
|
|
m_StartTimer = 0;
|
|
m_Loaded = false;
|
|
m_LoadedPlayers = 0;
|
|
m_LoadTimer = 0;
|
|
m_Finished = 0;
|
|
m_StartTime = 0;
|
|
m_EmptyTimer = 0;
|
|
m_SoloRacing = Game::config->GetValue("solo_racing") == "1";
|
|
|
|
// Select the main world ID as fallback when a player fails to load.
|
|
|
|
const auto worldID = Game::server->GetZoneID();
|
|
|
|
switch (worldID) {
|
|
case 1203:
|
|
m_ActivityID = 42;
|
|
m_MainWorld = 1200;
|
|
break;
|
|
|
|
case 1303:
|
|
m_ActivityID = 39;
|
|
m_MainWorld = 1300;
|
|
break;
|
|
|
|
case 1403:
|
|
m_ActivityID = 54;
|
|
m_MainWorld = 1400;
|
|
break;
|
|
|
|
default:
|
|
m_ActivityID = 42;
|
|
m_MainWorld = 1200;
|
|
break;
|
|
}
|
|
}
|
|
|
|
RacingControlComponent::~RacingControlComponent() {}
|
|
|
|
void RacingControlComponent::OnPlayerLoaded(Entity *player) {
|
|
// If the race has already started, send the player back to the main world.
|
|
if (m_Loaded) {
|
|
auto *playerInstance = dynamic_cast<Player *>(player);
|
|
|
|
playerInstance->SendToZone(m_MainWorld);
|
|
|
|
return;
|
|
}
|
|
|
|
const auto objectID = player->GetObjectID();
|
|
|
|
m_LoadedPlayers++;
|
|
|
|
Game::logger->Log("RacingControlComponent", "Loading player %i\n",
|
|
m_LoadedPlayers);
|
|
|
|
m_LobbyPlayers.push_back(objectID);
|
|
}
|
|
|
|
void RacingControlComponent::LoadPlayerVehicle(Entity *player,
|
|
bool initialLoad) {
|
|
// Load the player's vehicle.
|
|
|
|
if (player == nullptr) {
|
|
return;
|
|
}
|
|
|
|
auto *inventoryComponent = player->GetComponent<InventoryComponent>();
|
|
|
|
if (inventoryComponent == nullptr) {
|
|
return;
|
|
}
|
|
|
|
// Find the player's vehicle.
|
|
|
|
auto *item = inventoryComponent->FindItemByLot(8092);
|
|
|
|
if (item == nullptr) {
|
|
Game::logger->Log("RacingControlComponent", "Failed to find item\n");
|
|
|
|
return;
|
|
}
|
|
|
|
// Calculate the vehicle's starting position.
|
|
|
|
auto *path = dZoneManager::Instance()->GetZone()->GetPath(
|
|
GeneralUtils::UTF16ToWTF8(m_PathName));
|
|
|
|
auto startPosition = path->pathWaypoints[0].position + NiPoint3::UNIT_Y * 3;
|
|
|
|
const auto spacing = 15;
|
|
|
|
// This sometimes spawns the vehicle out of the map if there are lots of
|
|
// players loaded.
|
|
|
|
const auto range = m_LoadedPlayers * spacing;
|
|
|
|
startPosition =
|
|
startPosition + NiPoint3::UNIT_Z * ((m_LeadingPlayer / 2) +
|
|
m_RacingPlayers.size() * spacing);
|
|
|
|
auto startRotation =
|
|
NiQuaternion::LookAt(startPosition, startPosition + NiPoint3::UNIT_X);
|
|
|
|
auto angles = startRotation.GetEulerAngles();
|
|
|
|
angles.y -= M_PI;
|
|
|
|
startRotation = NiQuaternion::FromEulerAngles(angles);
|
|
|
|
Game::logger->Log("RacingControlComponent",
|
|
"Start position <%f, %f, %f>, <%f, %f, %f>\n",
|
|
startPosition.x, startPosition.y, startPosition.z,
|
|
angles.x * (180.0f / M_PI), angles.y * (180.0f / M_PI),
|
|
angles.z * (180.0f / M_PI));
|
|
|
|
// Make sure the player is at the correct position.
|
|
|
|
GameMessages::SendTeleport(player->GetObjectID(), startPosition,
|
|
startRotation, player->GetSystemAddress(), true,
|
|
true);
|
|
|
|
// Spawn the vehicle entity.
|
|
|
|
EntityInfo info{};
|
|
info.lot = 8092;
|
|
info.pos = startPosition;
|
|
info.rot = startRotation;
|
|
info.spawnerID = m_Parent->GetObjectID();
|
|
|
|
auto *carEntity =
|
|
EntityManager::Instance()->CreateEntity(info, nullptr, m_Parent);
|
|
|
|
// Make the vehicle a child of the racing controller.
|
|
m_Parent->AddChild(carEntity);
|
|
|
|
auto *destroyableComponent =
|
|
carEntity->GetComponent<DestroyableComponent>();
|
|
|
|
// Setup the vehicle stats.
|
|
if (destroyableComponent != nullptr) {
|
|
destroyableComponent->SetMaxImagination(60);
|
|
destroyableComponent->SetImagination(0);
|
|
}
|
|
|
|
// Setup the vehicle as being possessed by the player.
|
|
auto *possessableComponent =
|
|
carEntity->GetComponent<PossessableComponent>();
|
|
|
|
if (possessableComponent != nullptr) {
|
|
possessableComponent->SetPossessor(player->GetObjectID());
|
|
}
|
|
|
|
// Load the vehicle's assemblyPartLOTs for display.
|
|
auto *moduleAssemblyComponent =
|
|
carEntity->GetComponent<ModuleAssemblyComponent>();
|
|
|
|
if (moduleAssemblyComponent) {
|
|
moduleAssemblyComponent->SetSubKey(item->GetSubKey());
|
|
moduleAssemblyComponent->SetUseOptionalParts(false);
|
|
|
|
for (auto *config : item->GetConfig()) {
|
|
if (config->GetKey() == u"assemblyPartLOTs") {
|
|
moduleAssemblyComponent->SetAssemblyPartsLOTs(
|
|
GeneralUtils::ASCIIToUTF16(config->GetValueAsString()));
|
|
}
|
|
}
|
|
}
|
|
|
|
// Setup the player as possessing the vehicle.
|
|
auto *possessorComponent = player->GetComponent<PossessorComponent>();
|
|
|
|
if (possessorComponent != nullptr) {
|
|
possessorComponent->SetPossessable(carEntity->GetObjectID());
|
|
}
|
|
|
|
// Set the player's current activity as racing.
|
|
auto *characterComponent = player->GetComponent<CharacterComponent>();
|
|
|
|
if (characterComponent != nullptr) {
|
|
characterComponent->SetIsRacing(true);
|
|
characterComponent->SetVehicleObjectID(carEntity->GetObjectID());
|
|
}
|
|
|
|
// Init the player's racing entry.
|
|
if (initialLoad) {
|
|
m_RacingPlayers.push_back(
|
|
{player->GetObjectID(),
|
|
carEntity->GetObjectID(),
|
|
static_cast<uint32_t>(m_RacingPlayers.size()),
|
|
false,
|
|
{},
|
|
startPosition,
|
|
startRotation,
|
|
0,
|
|
0,
|
|
0,
|
|
0});
|
|
}
|
|
|
|
// Construct and serialize everything when done.
|
|
|
|
EntityManager::Instance()->ConstructEntity(carEntity);
|
|
EntityManager::Instance()->SerializeEntity(player);
|
|
EntityManager::Instance()->SerializeEntity(m_Parent);
|
|
|
|
GameMessages::SendRacingSetPlayerResetInfo(
|
|
m_Parent->GetObjectID(), 0, 0, player->GetObjectID(), startPosition, 1,
|
|
UNASSIGNED_SYSTEM_ADDRESS);
|
|
|
|
const auto playerID = player->GetObjectID();
|
|
|
|
// Reset the player to the start position during downtime, in case something
|
|
// went wrong.
|
|
m_Parent->AddCallbackTimer(1, [this, playerID]() {
|
|
auto *player = EntityManager::Instance()->GetEntity(playerID);
|
|
|
|
if (player == nullptr) {
|
|
return;
|
|
}
|
|
|
|
GameMessages::SendRacingResetPlayerToLastReset(
|
|
m_Parent->GetObjectID(), playerID, UNASSIGNED_SYSTEM_ADDRESS);
|
|
});
|
|
|
|
GameMessages::SendSetJetPackMode(player, false);
|
|
|
|
// Set the vehicle's state.
|
|
GameMessages::SendNotifyVehicleOfRacingObject(carEntity->GetObjectID(),
|
|
m_Parent->GetObjectID(),
|
|
UNASSIGNED_SYSTEM_ADDRESS);
|
|
|
|
GameMessages::SendVehicleSetWheelLockState(carEntity->GetObjectID(), false,
|
|
initialLoad,
|
|
UNASSIGNED_SYSTEM_ADDRESS);
|
|
|
|
// Make sure everything has the correct position.
|
|
GameMessages::SendTeleport(player->GetObjectID(), startPosition,
|
|
startRotation, player->GetSystemAddress(), true,
|
|
true);
|
|
GameMessages::SendTeleport(carEntity->GetObjectID(), startPosition,
|
|
startRotation, player->GetSystemAddress(), true,
|
|
true);
|
|
}
|
|
|
|
void RacingControlComponent::OnRacingClientReady(Entity *player) {
|
|
// Notify the other players that this player is ready.
|
|
|
|
for (auto &racingPlayer : m_RacingPlayers) {
|
|
if (racingPlayer.playerID != player->GetObjectID()) {
|
|
if (racingPlayer.playerLoaded) {
|
|
GameMessages::SendRacingPlayerLoaded(
|
|
m_Parent->GetObjectID(), racingPlayer.playerID,
|
|
racingPlayer.vehicleID, UNASSIGNED_SYSTEM_ADDRESS);
|
|
}
|
|
|
|
continue;
|
|
}
|
|
|
|
racingPlayer.playerLoaded = true;
|
|
|
|
GameMessages::SendRacingPlayerLoaded(
|
|
m_Parent->GetObjectID(), racingPlayer.playerID,
|
|
racingPlayer.vehicleID, UNASSIGNED_SYSTEM_ADDRESS);
|
|
}
|
|
|
|
EntityManager::Instance()->SerializeEntity(m_Parent);
|
|
}
|
|
|
|
void RacingControlComponent::OnRequestDie(Entity *player) {
|
|
// Sent by the client when they collide with something which should smash
|
|
// them.
|
|
|
|
for (auto &racingPlayer : m_RacingPlayers) {
|
|
if (racingPlayer.playerID != player->GetObjectID()) {
|
|
continue;
|
|
}
|
|
|
|
auto *vehicle =
|
|
EntityManager::Instance()->GetEntity(racingPlayer.vehicleID);
|
|
|
|
if (vehicle == nullptr) {
|
|
return;
|
|
}
|
|
|
|
if (!racingPlayer.noSmashOnReload) {
|
|
racingPlayer.smashedTimes++;
|
|
}
|
|
|
|
// Reset player to last checkpoint
|
|
GameMessages::SendRacingSetPlayerResetInfo(
|
|
m_Parent->GetObjectID(), racingPlayer.lap,
|
|
racingPlayer.respawnIndex, player->GetObjectID(),
|
|
racingPlayer.respawnPosition, racingPlayer.respawnIndex + 1,
|
|
UNASSIGNED_SYSTEM_ADDRESS);
|
|
GameMessages::SendRacingResetPlayerToLastReset(
|
|
m_Parent->GetObjectID(), racingPlayer.playerID,
|
|
UNASSIGNED_SYSTEM_ADDRESS);
|
|
|
|
auto *characterComponent = player->GetComponent<CharacterComponent>();
|
|
if (characterComponent != nullptr) {
|
|
characterComponent->UpdatePlayerStatistic(RacingTimesWrecked);
|
|
}
|
|
|
|
return;
|
|
}
|
|
}
|
|
|
|
void RacingControlComponent::OnRacingPlayerInfoResetFinished(Entity *player) {
|
|
// When the player has respawned.
|
|
|
|
for (auto &racingPlayer : m_RacingPlayers) {
|
|
if (racingPlayer.playerID != player->GetObjectID()) {
|
|
continue;
|
|
}
|
|
|
|
auto *vehicle =
|
|
EntityManager::Instance()->GetEntity(racingPlayer.vehicleID);
|
|
|
|
if (vehicle == nullptr) {
|
|
return;
|
|
}
|
|
|
|
if (!racingPlayer.noSmashOnReload) {
|
|
GameMessages::SendDie(vehicle, LWOOBJID_EMPTY, LWOOBJID_EMPTY, true,
|
|
VIOLENT, u"", 0, 0, 0, true, false, 0);
|
|
|
|
GameMessages::SendVehicleUnlockInput(racingPlayer.vehicleID, false,
|
|
UNASSIGNED_SYSTEM_ADDRESS);
|
|
GameMessages::SendVehicleSetWheelLockState(
|
|
racingPlayer.vehicleID, false, false,
|
|
UNASSIGNED_SYSTEM_ADDRESS);
|
|
|
|
GameMessages::SendResurrect(vehicle);
|
|
}
|
|
|
|
racingPlayer.noSmashOnReload = false;
|
|
|
|
return;
|
|
}
|
|
}
|
|
|
|
void RacingControlComponent::HandleMessageBoxResponse(Entity *player,
|
|
const std::string &id) {
|
|
auto *data = GetPlayerData(player->GetObjectID());
|
|
|
|
if (data == nullptr) {
|
|
return;
|
|
}
|
|
|
|
if (id == "rewardButton") {
|
|
if (data->collectedRewards) {
|
|
return;
|
|
}
|
|
|
|
data->collectedRewards = true;
|
|
|
|
// Calculate the score, different loot depending on player count
|
|
const auto score = m_LoadedPlayers * 10 + data->finished;
|
|
|
|
LootGenerator::Instance().GiveActivityLoot(player, m_Parent, m_ActivityID, score);
|
|
|
|
// Giving rewards
|
|
GameMessages::SendNotifyRacingClient(
|
|
m_Parent->GetObjectID(), 2, 0, LWOOBJID_EMPTY, u"",
|
|
player->GetObjectID(), UNASSIGNED_SYSTEM_ADDRESS);
|
|
|
|
auto *missionComponent = player->GetComponent<MissionComponent>();
|
|
|
|
if (missionComponent == nullptr) return;
|
|
|
|
missionComponent->Progress(MissionTaskType::MISSION_TASK_TYPE_RACING, 0, (LWOOBJID)RacingTaskParam::RACING_TASK_PARAM_COMPETED_IN_RACE); // Progress task for competing in a race
|
|
missionComponent->Progress(MissionTaskType::MISSION_TASK_TYPE_RACING, data->smashedTimes, (LWOOBJID)RacingTaskParam::RACING_TASK_PARAM_SAFE_DRIVER); // Finish a race without being smashed.
|
|
|
|
// If solo racing is enabled OR if there are 3 players in the race, progress placement tasks.
|
|
if(m_SoloRacing || m_LoadedPlayers > 2) {
|
|
missionComponent->Progress(MissionTaskType::MISSION_TASK_TYPE_RACING, data->finished, (LWOOBJID)RacingTaskParam::RACING_TASK_PARAM_FINISH_WITH_PLACEMENT); // Finish in 1st place on a race
|
|
missionComponent->Progress(MissionTaskType::MISSION_TASK_TYPE_RACING, data->finished, (LWOOBJID)RacingTaskParam::RACING_TASK_PARAM_FIRST_PLACE_MULTIPLE_TRACKS); // Finish in 1st place on multiple tracks.
|
|
if(m_Finished != 1) return;
|
|
missionComponent->Progress(MissionTaskType::MISSION_TASK_TYPE_RACING, dZoneManager::Instance()->GetZone()->GetWorldID(), (LWOOBJID)RacingTaskParam::RACING_TASK_PARAM_WIN_RACE_IN_WORLD); // Finished first place in specific world.
|
|
|
|
}
|
|
} else if (id == "ACT_RACE_EXIT_THE_RACE?" || id == "Exit") {
|
|
auto *vehicle = EntityManager::Instance()->GetEntity(data->vehicleID);
|
|
|
|
if (vehicle == nullptr) {
|
|
return;
|
|
}
|
|
|
|
// Exiting race
|
|
GameMessages::SendNotifyRacingClient(
|
|
m_Parent->GetObjectID(), 3, 0, LWOOBJID_EMPTY, u"",
|
|
player->GetObjectID(), UNASSIGNED_SYSTEM_ADDRESS);
|
|
|
|
auto *playerInstance = dynamic_cast<Player *>(player);
|
|
|
|
playerInstance->SendToZone(m_MainWorld);
|
|
|
|
vehicle->Kill();
|
|
}
|
|
}
|
|
|
|
void RacingControlComponent::Serialize(RakNet::BitStream *outBitStream,
|
|
bool bIsInitialUpdate,
|
|
unsigned int &flags) {
|
|
// BEGIN Scripted Activity
|
|
|
|
outBitStream->Write1();
|
|
|
|
outBitStream->Write(static_cast<uint32_t>(m_RacingPlayers.size()));
|
|
for (const auto &player : m_RacingPlayers) {
|
|
outBitStream->Write(player.playerID);
|
|
|
|
for (int i = 0; i < 10; i++) {
|
|
outBitStream->Write(player.data[i]);
|
|
}
|
|
}
|
|
|
|
// END Scripted Activity
|
|
|
|
outBitStream->Write1(); // Dirty?
|
|
outBitStream->Write(static_cast<uint16_t>(m_RacingPlayers.size()));
|
|
|
|
outBitStream->Write(!m_RacingPlayers.empty());
|
|
if (!m_RacingPlayers.empty()) {
|
|
for (const auto &player : m_RacingPlayers) {
|
|
outBitStream->Write1(); // Has more date
|
|
|
|
outBitStream->Write(player.playerID);
|
|
outBitStream->Write(player.vehicleID);
|
|
outBitStream->Write(player.playerIndex);
|
|
outBitStream->Write(player.playerLoaded);
|
|
}
|
|
|
|
outBitStream->Write0(); // No more data
|
|
}
|
|
|
|
outBitStream->Write(!m_RacingPlayers.empty());
|
|
if (!m_RacingPlayers.empty()) {
|
|
for (const auto &player : m_RacingPlayers) {
|
|
outBitStream->Write1(); // Has more date
|
|
|
|
outBitStream->Write(player.playerID);
|
|
outBitStream->Write<uint32_t>(0);
|
|
}
|
|
|
|
outBitStream->Write0(); // No more data
|
|
}
|
|
|
|
outBitStream->Write1(); // Dirty?
|
|
|
|
outBitStream->Write(m_RemainingLaps);
|
|
|
|
outBitStream->Write(static_cast<uint16_t>(m_PathName.size()));
|
|
for (const auto character : m_PathName) {
|
|
outBitStream->Write(character);
|
|
}
|
|
|
|
outBitStream->Write1(); // ???
|
|
outBitStream->Write1(); // ???
|
|
|
|
outBitStream->Write(m_LeadingPlayer);
|
|
outBitStream->Write(m_RaceBestLap);
|
|
outBitStream->Write(m_RaceBestTime);
|
|
}
|
|
|
|
RacingPlayerInfo *RacingControlComponent::GetPlayerData(LWOOBJID playerID) {
|
|
for (auto &player : m_RacingPlayers) {
|
|
if (player.playerID == playerID) {
|
|
return &player;
|
|
}
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
void RacingControlComponent::Update(float deltaTime) {
|
|
// This method is a mess.
|
|
|
|
// Pre-load routine
|
|
if (!m_Loaded) {
|
|
// Check if any players has disconnected before loading in
|
|
for (size_t i = 0; i < m_LobbyPlayers.size(); i++) {
|
|
auto *playerEntity =
|
|
EntityManager::Instance()->GetEntity(m_LobbyPlayers[i]);
|
|
|
|
if (playerEntity == nullptr) {
|
|
--m_LoadedPlayers;
|
|
|
|
m_LobbyPlayers.erase(m_LobbyPlayers.begin() + i);
|
|
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (m_LoadedPlayers >= 2 || (m_LoadedPlayers == 1 && m_SoloRacing)) {
|
|
m_LoadTimer += deltaTime;
|
|
} else {
|
|
m_EmptyTimer += deltaTime;
|
|
}
|
|
|
|
// If a player happens to be left alone for more then 30 seconds without
|
|
// anyone else loading in, send them back to the main world
|
|
if (m_EmptyTimer >= 30) {
|
|
for (const auto player : m_LobbyPlayers) {
|
|
auto *playerEntity =
|
|
EntityManager::Instance()->GetEntity(player);
|
|
|
|
if (playerEntity == nullptr) {
|
|
continue;
|
|
}
|
|
|
|
auto *playerInstance = dynamic_cast<Player *>(playerEntity);
|
|
|
|
playerInstance->SendToZone(m_MainWorld);
|
|
}
|
|
|
|
m_LobbyPlayers.clear();
|
|
}
|
|
|
|
// From the first 2 players loading in the rest have a max of 15 seconds
|
|
// to load in, can raise this if it's too low
|
|
if (m_LoadTimer >= 15) {
|
|
Game::logger->Log("RacingControlComponent",
|
|
"Loading all players...\n");
|
|
|
|
for (size_t i = 0; i < m_LobbyPlayers.size(); i++) {
|
|
Game::logger->Log("RacingControlComponent",
|
|
"Loading player now!\n");
|
|
|
|
auto *player =
|
|
EntityManager::Instance()->GetEntity(m_LobbyPlayers[i]);
|
|
|
|
if (player == nullptr) {
|
|
return;
|
|
}
|
|
|
|
Game::logger->Log("RacingControlComponent",
|
|
"Loading player now NOW!\n");
|
|
|
|
LoadPlayerVehicle(player, true);
|
|
|
|
m_Loaded = true;
|
|
}
|
|
|
|
m_Loaded = true;
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
// The players who will be participating have loaded
|
|
if (!m_Started) {
|
|
// Check if anyone has disconnected during this period
|
|
for (size_t i = 0; i < m_RacingPlayers.size(); i++) {
|
|
auto *playerEntity = EntityManager::Instance()->GetEntity(
|
|
m_RacingPlayers[i].playerID);
|
|
|
|
if (playerEntity == nullptr) {
|
|
m_RacingPlayers.erase(m_RacingPlayers.begin() + i);
|
|
|
|
--m_LoadedPlayers;
|
|
|
|
return;
|
|
}
|
|
}
|
|
|
|
// If less then 2 players are left, send the rest back to the main world
|
|
if (m_LoadedPlayers < 2 && !(m_LoadedPlayers == 1 && m_SoloRacing)) {
|
|
for (const auto player : m_LobbyPlayers) {
|
|
auto *playerEntity =
|
|
EntityManager::Instance()->GetEntity(player);
|
|
|
|
if (playerEntity == nullptr) {
|
|
continue;
|
|
}
|
|
|
|
auto *playerInstance = dynamic_cast<Player *>(playerEntity);
|
|
|
|
playerInstance->SendToZone(m_MainWorld);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
// Check if all players have send a ready message
|
|
|
|
int32_t readyPlayers = 0;
|
|
|
|
for (const auto &player : m_RacingPlayers) {
|
|
if (player.playerLoaded) {
|
|
++readyPlayers;
|
|
}
|
|
}
|
|
|
|
if (readyPlayers >= m_LoadedPlayers) {
|
|
// Setup for racing
|
|
if (m_StartTimer == 0) {
|
|
GameMessages::SendNotifyRacingClient(
|
|
m_Parent->GetObjectID(), 1, 0, LWOOBJID_EMPTY, u"",
|
|
LWOOBJID_EMPTY, UNASSIGNED_SYSTEM_ADDRESS);
|
|
|
|
for (const auto &player : m_RacingPlayers) {
|
|
auto *vehicle =
|
|
EntityManager::Instance()->GetEntity(player.vehicleID);
|
|
auto *playerEntity =
|
|
EntityManager::Instance()->GetEntity(player.playerID);
|
|
|
|
if (vehicle != nullptr && playerEntity != nullptr) {
|
|
GameMessages::SendTeleport(
|
|
player.playerID, player.respawnPosition,
|
|
player.respawnRotation,
|
|
playerEntity->GetSystemAddress(), true, true);
|
|
|
|
vehicle->SetPosition(player.respawnPosition);
|
|
vehicle->SetRotation(player.respawnRotation);
|
|
|
|
auto *destroyableComponent =
|
|
vehicle->GetComponent<DestroyableComponent>();
|
|
|
|
if (destroyableComponent != nullptr) {
|
|
destroyableComponent->SetImagination(0);
|
|
}
|
|
|
|
EntityManager::Instance()->SerializeEntity(vehicle);
|
|
EntityManager::Instance()->SerializeEntity(
|
|
playerEntity);
|
|
}
|
|
}
|
|
|
|
// Spawn imagination pickups
|
|
auto *minSpawner = dZoneManager::Instance()->GetSpawnersByName(
|
|
"ImaginationSpawn_Min")[0];
|
|
auto *medSpawner = dZoneManager::Instance()->GetSpawnersByName(
|
|
"ImaginationSpawn_Med")[0];
|
|
auto *maxSpawner = dZoneManager::Instance()->GetSpawnersByName(
|
|
"ImaginationSpawn_Max")[0];
|
|
|
|
minSpawner->Activate();
|
|
|
|
if (m_LoadedPlayers > 2) {
|
|
medSpawner->Activate();
|
|
}
|
|
|
|
if (m_LoadedPlayers > 4) {
|
|
maxSpawner->Activate();
|
|
}
|
|
|
|
// Reset players to their start location, without smashing them
|
|
for (auto &player : m_RacingPlayers) {
|
|
auto *vehicleEntity =
|
|
EntityManager::Instance()->GetEntity(player.vehicleID);
|
|
auto *playerEntity =
|
|
EntityManager::Instance()->GetEntity(player.playerID);
|
|
|
|
if (vehicleEntity == nullptr || playerEntity == nullptr) {
|
|
continue;
|
|
}
|
|
|
|
player.noSmashOnReload = true;
|
|
|
|
OnRequestDie(playerEntity);
|
|
}
|
|
}
|
|
// This 6 seconds seems to be hardcoded in the client, start race
|
|
// after that amount of time
|
|
else if (m_StartTimer >= 6) {
|
|
// Activate the players movement
|
|
for (auto &player : m_RacingPlayers) {
|
|
auto *vehicleEntity =
|
|
EntityManager::Instance()->GetEntity(player.vehicleID);
|
|
auto *playerEntity =
|
|
EntityManager::Instance()->GetEntity(player.playerID);
|
|
|
|
if (vehicleEntity == nullptr || playerEntity == nullptr) {
|
|
continue;
|
|
}
|
|
|
|
GameMessages::SendVehicleUnlockInput(
|
|
player.vehicleID, false, UNASSIGNED_SYSTEM_ADDRESS);
|
|
}
|
|
|
|
// Start the race
|
|
GameMessages::SendActivityStart(m_Parent->GetObjectID(),
|
|
UNASSIGNED_SYSTEM_ADDRESS);
|
|
|
|
m_Started = true;
|
|
|
|
Game::logger->Log("RacingControlComponent", "Starting race\n");
|
|
|
|
EntityManager::Instance()->SerializeEntity(m_Parent);
|
|
|
|
m_StartTime = std::time(nullptr);
|
|
}
|
|
|
|
m_StartTimer += deltaTime;
|
|
} else {
|
|
m_StartTimer = 0;
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
// Race routines
|
|
auto *path = dZoneManager::Instance()->GetZone()->GetPath(
|
|
GeneralUtils::UTF16ToWTF8(m_PathName));
|
|
|
|
for (auto &player : m_RacingPlayers) {
|
|
auto *vehicle = EntityManager::Instance()->GetEntity(player.vehicleID);
|
|
auto *playerEntity =
|
|
EntityManager::Instance()->GetEntity(player.playerID);
|
|
|
|
if (vehicle == nullptr || playerEntity == nullptr) {
|
|
continue;
|
|
}
|
|
|
|
const auto vehiclePosition = vehicle->GetPosition();
|
|
|
|
// If the player is this far below the map, safe to assume they should
|
|
// be smashed by death plane
|
|
if (vehiclePosition.y < -500) {
|
|
GameMessages::SendDie(vehicle, m_Parent->GetObjectID(),
|
|
LWOOBJID_EMPTY, true, VIOLENT, u"", 0, 0, 0,
|
|
true, false, 0);
|
|
|
|
OnRequestDie(playerEntity);
|
|
|
|
continue;
|
|
}
|
|
|
|
// Loop through all the waypoints and see if the player has reached a
|
|
// new checkpoint
|
|
uint32_t respawnIndex = 0;
|
|
for (const auto &waypoint : path->pathWaypoints) {
|
|
if (player.lap == 3) {
|
|
break;
|
|
}
|
|
|
|
if (player.respawnIndex == respawnIndex) {
|
|
++respawnIndex;
|
|
|
|
continue;
|
|
}
|
|
|
|
const auto &position = waypoint.position;
|
|
|
|
if (std::abs((int)respawnIndex - (int)player.respawnIndex) > 10 &&
|
|
player.respawnIndex != path->pathWaypoints.size() - 1) {
|
|
++respawnIndex;
|
|
|
|
continue;
|
|
}
|
|
|
|
if (Vector3::DistanceSquared(position, vehiclePosition) > 50 * 50) {
|
|
++respawnIndex;
|
|
|
|
continue;
|
|
}
|
|
|
|
// Only go upwards, except if we've lapped
|
|
// Not sure how we are supposed to check if they've reach a
|
|
// checkpoint, within 50 units seems safe
|
|
if (!(respawnIndex > player.respawnIndex ||
|
|
player.respawnIndex == path->pathWaypoints.size() - 1)) {
|
|
++respawnIndex;
|
|
|
|
continue;
|
|
}
|
|
|
|
// Some offset up to make they don't fall through the terrain on a
|
|
// respawn, seems to fix itself to the track anyhow
|
|
player.respawnPosition = position + NiPoint3::UNIT_Y * 5;
|
|
player.respawnRotation = vehicle->GetRotation();
|
|
player.respawnIndex = respawnIndex;
|
|
|
|
// Reached the start point, lapped
|
|
if (respawnIndex == 0) {
|
|
time_t lapTime = std::time(nullptr) - (player.lap == 1 ? m_StartTime : player.lapTime);
|
|
|
|
// Cheating check
|
|
if (lapTime < 40) {
|
|
continue;
|
|
}
|
|
|
|
player.lap++;
|
|
|
|
player.lapTime = std::time(nullptr);
|
|
|
|
if (player.bestLapTime == 0 || player.bestLapTime > lapTime) {
|
|
player.bestLapTime = lapTime;
|
|
|
|
Game::logger->Log("RacingControlComponent",
|
|
"Best lap time (%llu)\n", lapTime);
|
|
}
|
|
|
|
auto *missionComponent =
|
|
playerEntity->GetComponent<MissionComponent>();
|
|
|
|
if (missionComponent != nullptr) {
|
|
|
|
// Progress lap time tasks
|
|
missionComponent->Progress(MissionTaskType::MISSION_TASK_TYPE_RACING, (lapTime)*1000, (LWOOBJID)RacingTaskParam::RACING_TASK_PARAM_LAP_TIME);
|
|
|
|
if (player.lap == 3) {
|
|
m_Finished++;
|
|
player.finished = m_Finished;
|
|
|
|
const auto raceTime =
|
|
(std::time(nullptr) - m_StartTime);
|
|
|
|
player.raceTime = raceTime;
|
|
|
|
Game::logger->Log("RacingControlComponent",
|
|
"Completed time %llu, %llu\n",
|
|
raceTime, raceTime * 1000);
|
|
|
|
// Entire race time
|
|
missionComponent->Progress(MissionTaskType::MISSION_TASK_TYPE_RACING, (raceTime)*1000, (LWOOBJID)RacingTaskParam::RACING_TASK_PARAM_TOTAL_TRACK_TIME);
|
|
|
|
auto *characterComponent = playerEntity->GetComponent<CharacterComponent>();
|
|
if (characterComponent != nullptr) {
|
|
characterComponent->TrackRaceCompleted(m_Finished == 1);
|
|
}
|
|
|
|
// TODO: Figure out how to update the GUI leaderboard.
|
|
}
|
|
}
|
|
|
|
Game::logger->Log("RacingControlComponent",
|
|
"Lapped (%i) in (%llu)\n", player.lap,
|
|
lapTime);
|
|
}
|
|
|
|
Game::logger->Log("RacingControlComponent",
|
|
"Reached point (%i)/(%i)\n", player.respawnIndex,
|
|
path->pathWaypoints.size());
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
std::string RacingControlComponent::FormatTimeString(time_t time) {
|
|
int32_t min = time / 60;
|
|
time -= min * 60;
|
|
int32_t sec = time;
|
|
|
|
std::string minText;
|
|
std::string secText;
|
|
|
|
if (min <= 0) {
|
|
minText = "0";
|
|
} else {
|
|
minText = std::to_string(min);
|
|
}
|
|
|
|
if (sec <= 0) {
|
|
secText = "00";
|
|
} else if (sec <= 9) {
|
|
secText = "0" + std::to_string(sec);
|
|
} else {
|
|
secText = std::to_string(sec);
|
|
}
|
|
|
|
return minText + ":" + secText + ".00";
|
|
}
|