mirror of
https://github.com/DarkflameUniverse/DarkflameServer.git
synced 2024-11-26 07:27:18 +00:00
3de3932503
Remove the CDClientDatabase::ExecuteQueryWithArgs() function and replace it with CDClientDatabase::CreatePreppedStmt(). This prevents a developer from accidently using %s, or incorrectly passing std::string, and causing a silent error.
1248 lines
32 KiB
C++
1248 lines
32 KiB
C++
#include "PetComponent.h"
|
|
#include "GameMessages.h"
|
|
#include "BrickDatabase.h"
|
|
#include "CDClientDatabase.h"
|
|
#include "ChatPackets.h"
|
|
#include "EntityManager.h"
|
|
#include "Character.h"
|
|
#include "CharacterComponent.h"
|
|
#include "InventoryComponent.h"
|
|
#include "Item.h"
|
|
#include "MissionComponent.h"
|
|
#include "SwitchComponent.h"
|
|
#include "DestroyableComponent.h"
|
|
#include "dpWorld.h"
|
|
#include "PetDigServer.h"
|
|
#include "../dWorldServer/ObjectIDManager.h"
|
|
|
|
#include "Game.h"
|
|
#include "dChatFilter.h"
|
|
#include "Database.h"
|
|
|
|
std::unordered_map<LOT, PetComponent::PetPuzzleData> PetComponent::buildCache {};
|
|
std::unordered_map<LWOOBJID, LWOOBJID> PetComponent::currentActivities {};
|
|
std::unordered_map<LWOOBJID, LWOOBJID> PetComponent::activePets {};
|
|
|
|
/**
|
|
* Maps all the pet lots to a flag indicating that the player has caught it. All basic pets have been guessed by ObjID
|
|
* while the faction ones could be checked using their respective missions.
|
|
*/
|
|
std::map<LOT, uint32_t> PetComponent::petFlags = {
|
|
{ 3050, 801 }, // Elephant
|
|
{ 3054, 803 }, // Cat
|
|
{ 3195, 806 }, // Triceratops
|
|
{ 3254, 807 }, // Terrier
|
|
{ 3261, 811 }, // Skunk
|
|
{ 3672, 813 }, // Bunny
|
|
{ 3994, 814 }, // Crocodile
|
|
{ 5635, 815 }, // Doberman
|
|
{ 5636, 816 }, // Buffalo
|
|
{ 5637, 818 }, // Robot Dog
|
|
{ 5639, 819 }, // Red Dragon
|
|
{ 5640, 820 }, // Tortoise
|
|
{ 5641, 821 }, // Green Dragon
|
|
{ 5643, 822 }, // Panda, see mission 786
|
|
{ 5642, 823 }, // Mantis
|
|
{ 6720, 824 }, // Warthog
|
|
{ 3520, 825 }, // Lion, see mission 1318
|
|
{ 7638, 826 }, // Goat
|
|
{ 7694, 827 }, // Crab
|
|
{ 12294, 829 }, // Reindeer
|
|
{ 12431, 830 }, // Stegosaurus, see mission 1386
|
|
{ 12432, 831 }, // Saber cat, see mission 1389
|
|
{ 12433, 832 }, // Gryphon, see mission 1392
|
|
{ 12434, 833 }, // Alien, see mission 1188
|
|
// 834: unknown?, see mission 506, 688
|
|
{ 16210, 836 }, // Ninjago Earth Dragon, see mission 1836
|
|
{ 13067, 838 }, // Skeleton dragon
|
|
};
|
|
|
|
PetComponent::PetComponent(Entity* parent, uint32_t componentId) : Component(parent)
|
|
{
|
|
m_ComponentId = componentId;
|
|
|
|
m_Interaction = LWOOBJID_EMPTY;
|
|
m_Owner = LWOOBJID_EMPTY;
|
|
m_ModerationStatus = 0;
|
|
m_Tamer = LWOOBJID_EMPTY;
|
|
m_ModelId = LWOOBJID_EMPTY;
|
|
m_Timer = 0;
|
|
m_TimerAway = 0;
|
|
m_DatabaseId = LWOOBJID_EMPTY;
|
|
m_Status = 67108866; // Tamable
|
|
m_Ability = PetAbilityType::Invalid;
|
|
m_StartPosition = NiPoint3::ZERO;
|
|
m_MovementAI = nullptr;
|
|
m_TresureTime = 0;
|
|
m_Preconditions = nullptr;
|
|
}
|
|
|
|
void PetComponent::Serialize(RakNet::BitStream* outBitStream, bool bIsInitialUpdate, unsigned int& flags)
|
|
{
|
|
const bool tamed = m_Owner != LWOOBJID_EMPTY;
|
|
|
|
outBitStream->Write1(); // Dirty?
|
|
|
|
outBitStream->Write<uint32_t>(static_cast<unsigned int>(m_Status));
|
|
outBitStream->Write<uint32_t>(static_cast<uint32_t>(tamed ? m_Ability : PetAbilityType::Invalid)); // Something with the overhead icon?
|
|
|
|
const bool interacting = m_Interaction != LWOOBJID_EMPTY;
|
|
|
|
outBitStream->Write(interacting);
|
|
if (interacting)
|
|
{
|
|
outBitStream->Write(m_Interaction);
|
|
}
|
|
|
|
outBitStream->Write(tamed);
|
|
if (tamed)
|
|
{
|
|
outBitStream->Write(m_Owner);
|
|
}
|
|
|
|
outBitStream->Write(tamed);
|
|
if (tamed)
|
|
{
|
|
outBitStream->Write(m_ModerationStatus);
|
|
|
|
const auto nameData = GeneralUtils::ASCIIToUTF16(m_Name);
|
|
const auto ownerNameData = GeneralUtils::ASCIIToUTF16(m_OwnerName);
|
|
|
|
outBitStream->Write(static_cast<uint8_t>(nameData.size()));
|
|
for (const auto c : nameData)
|
|
{
|
|
outBitStream->Write(c);
|
|
}
|
|
|
|
outBitStream->Write(static_cast<uint8_t>(ownerNameData.size()));
|
|
for (const auto c : ownerNameData)
|
|
{
|
|
outBitStream->Write(c);
|
|
}
|
|
}
|
|
}
|
|
|
|
void PetComponent::OnUse(Entity* originator)
|
|
{
|
|
if (m_Owner != LWOOBJID_EMPTY)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (m_Tamer != LWOOBJID_EMPTY)
|
|
{
|
|
auto* tamer = EntityManager::Instance()->GetEntity(m_Tamer);
|
|
|
|
if (tamer != nullptr)
|
|
{
|
|
return;
|
|
}
|
|
|
|
m_Tamer = LWOOBJID_EMPTY;
|
|
}
|
|
|
|
auto* inventoryComponent = originator->GetComponent<InventoryComponent>();
|
|
|
|
if (inventoryComponent == nullptr)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (m_Preconditions != nullptr && !m_Preconditions->Check(originator, true)) {
|
|
return;
|
|
}
|
|
|
|
auto* movementAIComponent = m_Parent->GetComponent<MovementAIComponent>();
|
|
|
|
if (movementAIComponent != nullptr)
|
|
{
|
|
movementAIComponent->Stop();
|
|
}
|
|
|
|
inventoryComponent->DespawnPet();
|
|
|
|
const auto& cached = buildCache.find(m_Parent->GetLOT());
|
|
int32_t imaginationCost = 0;
|
|
|
|
std::string buildFile;
|
|
|
|
if (cached == buildCache.end()) {
|
|
auto query = CDClientDatabase::CreatePreppedStmt(
|
|
"SELECT ValidPiecesLXF, PuzzleModelLot, Timelimit, NumValidPieces, imagCostPerBuild FROM TamingBuildPuzzles WHERE NPCLot = ?;");
|
|
query.bind(1, (int) m_Parent->GetLOT());
|
|
|
|
auto result = query.execQuery();
|
|
|
|
if (result.eof())
|
|
{
|
|
ChatPackets::SendSystemMessage(originator->GetSystemAddress(), u"Failed to find the puzzle minigame for this pet.");
|
|
|
|
return;
|
|
}
|
|
|
|
if (result.fieldIsNull(0))
|
|
{
|
|
result.finalize();
|
|
|
|
return;
|
|
}
|
|
|
|
auto lxfAsset = std::string(result.getStringField(0));
|
|
|
|
std::vector<std::string> lxfAssetSplit = GeneralUtils::SplitString(lxfAsset, '\\');
|
|
|
|
lxfAssetSplit.erase(lxfAssetSplit.begin());
|
|
|
|
buildFile = "res/BrickModels";
|
|
|
|
for (auto part: lxfAssetSplit)
|
|
{
|
|
std::transform(part.begin(), part.end(), part.begin(), [](unsigned char c) {
|
|
return std::tolower(c);
|
|
});
|
|
|
|
buildFile += "/" + part;
|
|
}
|
|
|
|
PetPuzzleData data;
|
|
data.buildFile = buildFile;
|
|
data.puzzleModelLot = result.getIntField(1);
|
|
data.timeLimit = result.getFloatField(2);
|
|
data.numValidPieces = result.getIntField(3);
|
|
data.imaginationCost = result.getIntField(4);
|
|
if (data.timeLimit <= 0) data.timeLimit = 60;
|
|
imaginationCost = data.imaginationCost;
|
|
|
|
buildCache[m_Parent->GetLOT()] = data;
|
|
|
|
result.finalize();
|
|
}
|
|
else
|
|
{
|
|
buildFile = cached->second.buildFile;
|
|
imaginationCost = cached->second.imaginationCost;
|
|
}
|
|
|
|
auto* destroyableComponent = originator->GetComponent<DestroyableComponent>();
|
|
|
|
if (destroyableComponent == nullptr)
|
|
{
|
|
return;
|
|
}
|
|
|
|
auto imagination = destroyableComponent->GetImagination();
|
|
|
|
if (imagination < imaginationCost)
|
|
{
|
|
return;
|
|
}
|
|
|
|
auto& bricks = BrickDatabase::Instance()->GetBricks(buildFile);
|
|
|
|
if (bricks.empty())
|
|
{
|
|
ChatPackets::SendSystemMessage(originator->GetSystemAddress(), u"Failed to load the puzzle minigame for this pet.");
|
|
Game::logger->Log("PetComponent", "Couldn't find %s for minigame!\n", buildFile.c_str());
|
|
|
|
return;
|
|
}
|
|
|
|
auto petPosition = m_Parent->GetPosition();
|
|
|
|
auto originatorPosition = originator->GetPosition();
|
|
|
|
m_Parent->SetRotation(NiQuaternion::LookAt(petPosition, originatorPosition));
|
|
|
|
float interactionDistance = m_Parent->GetVar<float>(u"interaction_distance");
|
|
|
|
if (interactionDistance <= 0)
|
|
{
|
|
interactionDistance = 15;
|
|
}
|
|
|
|
auto position = originatorPosition;
|
|
|
|
NiPoint3 forward = NiQuaternion::LookAt(m_Parent->GetPosition(), originator->GetPosition()).GetForwardVector(); //m_Parent->GetRotation().GetForwardVector();
|
|
forward.y = 0;
|
|
|
|
if (dpWorld::Instance().IsLoaded())
|
|
{
|
|
/*
|
|
if (interactionDistance > 2)
|
|
{
|
|
interactionDistance -= 1;
|
|
}
|
|
*/
|
|
|
|
NiPoint3 attempt = petPosition + forward * interactionDistance;
|
|
|
|
/*
|
|
float deg = std::atan2(petPosition.z - originatorPosition.z, petPosition.x - originatorPosition.x); //* 180 / M_PI;
|
|
|
|
auto position = NiPoint3(
|
|
petPosition.x + interactionDistance * std::cos(-deg),
|
|
petPosition.y,
|
|
petPosition.z + interactionDistance * std::sin(-deg)
|
|
);
|
|
*/
|
|
|
|
float y = dpWorld::Instance().GetHeightAtPoint(attempt);
|
|
|
|
while (std::abs(y - petPosition.y) > 4 && interactionDistance > 10)
|
|
{
|
|
const NiPoint3 forward = m_Parent->GetRotation().GetForwardVector();
|
|
|
|
attempt = originatorPosition + forward * interactionDistance;
|
|
|
|
y = dpWorld::Instance().GetHeightAtPoint(attempt);
|
|
|
|
interactionDistance -= 0.5f;
|
|
}
|
|
|
|
position = attempt;
|
|
}
|
|
else
|
|
{
|
|
position = petPosition + forward * interactionDistance;
|
|
}
|
|
|
|
|
|
auto rotation = NiQuaternion::LookAt(position, petPosition);
|
|
|
|
//GameMessages::SendTeleport(originator->GetObjectID(), position, rotation, originator->GetSystemAddress(), true);
|
|
|
|
GameMessages::SendNotifyPetTamingMinigame(
|
|
originator->GetObjectID(),
|
|
m_Parent->GetObjectID(),
|
|
LWOOBJID_EMPTY,
|
|
true,
|
|
NOTIFY_TYPE_BEGIN,
|
|
petPosition,
|
|
position,
|
|
rotation,
|
|
UNASSIGNED_SYSTEM_ADDRESS
|
|
);
|
|
|
|
GameMessages::SendNotifyPetTamingMinigame(
|
|
m_Parent->GetObjectID(),
|
|
LWOOBJID_EMPTY,
|
|
originator->GetObjectID(),
|
|
true,
|
|
NOTIFY_TYPE_BEGIN,
|
|
petPosition,
|
|
position,
|
|
rotation,
|
|
UNASSIGNED_SYSTEM_ADDRESS
|
|
);
|
|
|
|
GameMessages::SendNotifyPetTamingPuzzleSelected(originator->GetObjectID(), bricks, originator->GetSystemAddress());
|
|
|
|
m_Tamer = originator->GetObjectID();
|
|
SetStatus(5);
|
|
|
|
currentActivities.insert_or_assign(m_Tamer, m_Parent->GetObjectID());
|
|
|
|
// Notify the start of a pet taming minigame
|
|
for (CppScripts::Script* script : CppScripts::GetEntityScripts(m_Parent)) {
|
|
script->OnNotifyPetTamingMinigame(m_Parent, originator, NOTIFY_TYPE_BEGIN);
|
|
}
|
|
}
|
|
|
|
void PetComponent::Update(float deltaTime)
|
|
{
|
|
if (m_StartPosition == NiPoint3::ZERO)
|
|
{
|
|
m_StartPosition = m_Parent->GetPosition();
|
|
}
|
|
|
|
if (m_Owner == LWOOBJID_EMPTY)
|
|
{
|
|
if (m_Tamer != LWOOBJID_EMPTY)
|
|
{
|
|
if (m_Timer > 0)
|
|
{
|
|
m_Timer -= deltaTime;
|
|
|
|
if (m_Timer <= 0)
|
|
{
|
|
m_Timer = 0;
|
|
|
|
ClientFailTamingMinigame();
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (m_Timer > 0)
|
|
{
|
|
m_Timer -= deltaTime;
|
|
|
|
if (m_Timer <= 0)
|
|
{
|
|
Wander();
|
|
EntityManager::Instance()->SerializeEntity(m_Parent);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
m_Timer = 5;
|
|
}
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
auto* owner = GetOwner();
|
|
|
|
if (owner == nullptr)
|
|
{
|
|
m_Parent->Kill();
|
|
|
|
return;
|
|
}
|
|
|
|
m_MovementAI = m_Parent->GetComponent<MovementAIComponent>();
|
|
|
|
if (m_MovementAI == nullptr)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (m_TresureTime > 0)
|
|
{
|
|
auto* tresure = EntityManager::Instance()->GetEntity(m_Interaction);
|
|
|
|
if (tresure == nullptr)
|
|
{
|
|
m_TresureTime = 0;
|
|
|
|
return;
|
|
}
|
|
|
|
m_TresureTime -= deltaTime;
|
|
|
|
m_MovementAI->Stop();
|
|
|
|
if (m_TresureTime <= 0)
|
|
{
|
|
m_Parent->SetOwnerOverride(m_Owner);
|
|
|
|
tresure->Smash(m_Parent->GetObjectID());
|
|
|
|
m_Interaction = LWOOBJID_EMPTY;
|
|
|
|
m_TresureTime = 0;
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
auto destination = owner->GetPosition();
|
|
NiPoint3 position = m_MovementAI->GetCurrentPosition();
|
|
|
|
float distanceToOwner = Vector3::DistanceSquared(position, destination);
|
|
|
|
if (distanceToOwner > 50 * 50 || m_TimerAway > 5)
|
|
{
|
|
m_MovementAI->Warp(destination);
|
|
|
|
m_Timer = 1;
|
|
m_TimerAway = 0;
|
|
|
|
return;
|
|
}
|
|
|
|
if (distanceToOwner > 15 * 15 || std::abs(destination.y - position.y) >= 3)
|
|
{
|
|
m_TimerAway += deltaTime;
|
|
}
|
|
else
|
|
{
|
|
m_TimerAway = 0;
|
|
}
|
|
|
|
if (m_Timer > 0)
|
|
{
|
|
m_Timer -= deltaTime;
|
|
|
|
return;
|
|
}
|
|
|
|
SwitchComponent* closestSwitch = SwitchComponent::GetClosestSwitch(position);
|
|
|
|
float haltDistance = 5;
|
|
|
|
if (closestSwitch != nullptr)
|
|
{
|
|
if (!closestSwitch->GetActive())
|
|
{
|
|
NiPoint3 switchPosition = closestSwitch->GetParentEntity()->GetPosition();
|
|
float distance = Vector3::DistanceSquared(position, switchPosition);
|
|
if (distance < 3 * 3)
|
|
{
|
|
m_Interaction = closestSwitch->GetParentEntity()->GetObjectID();
|
|
closestSwitch->EntityEnter(m_Parent);
|
|
}
|
|
else if (distance < 20 * 20)
|
|
{
|
|
haltDistance = 1;
|
|
|
|
destination = switchPosition;
|
|
}
|
|
}
|
|
}
|
|
|
|
Entity* closestTresure = PetDigServer::GetClosestTresure(position);
|
|
|
|
if (closestTresure != nullptr)
|
|
{
|
|
// Skeleton Dragon Pat special case for bone digging
|
|
if (closestTresure->GetLOT() == 12192 && m_Parent->GetLOT() != 13067)
|
|
{
|
|
goto skipTresure;
|
|
}
|
|
|
|
NiPoint3 tresurePosition = closestTresure->GetPosition();
|
|
float distance = Vector3::DistanceSquared(position, tresurePosition);
|
|
if (distance < 3 * 3)
|
|
{
|
|
m_Interaction = closestTresure->GetObjectID();
|
|
|
|
Command(NiPoint3::ZERO, LWOOBJID_EMPTY, 1, 202, true);
|
|
|
|
m_TresureTime = 2;
|
|
}
|
|
else if (distance < 10 * 10)
|
|
{
|
|
haltDistance = 1;
|
|
|
|
destination = tresurePosition;
|
|
}
|
|
}
|
|
|
|
skipTresure:
|
|
|
|
m_MovementAI->SetHaltDistance(haltDistance);
|
|
|
|
m_MovementAI->SetSpeed(2.5f);
|
|
|
|
m_MovementAI->SetDestination(destination);
|
|
|
|
m_Timer = 1;
|
|
}
|
|
|
|
void PetComponent::TryBuild(std::vector<Brick>& bricks, bool clientFailed)
|
|
{
|
|
if (m_Tamer == LWOOBJID_EMPTY) return;
|
|
|
|
auto* tamer = EntityManager::Instance()->GetEntity(m_Tamer);
|
|
|
|
if (tamer == nullptr)
|
|
{
|
|
m_Tamer = LWOOBJID_EMPTY;
|
|
|
|
return;
|
|
}
|
|
|
|
const auto& cached = buildCache.find(m_Parent->GetLOT());
|
|
|
|
if (cached == buildCache.end())
|
|
{
|
|
GameMessages::SendPetTamingTryBuildResult(m_Tamer, false, 0, tamer->GetSystemAddress());
|
|
|
|
return;
|
|
}
|
|
|
|
auto* destroyableComponent = tamer->GetComponent<DestroyableComponent>();
|
|
|
|
if (destroyableComponent == nullptr)
|
|
{
|
|
return;
|
|
}
|
|
|
|
auto imagination = destroyableComponent->GetImagination();
|
|
|
|
imagination -= cached->second.imaginationCost;
|
|
|
|
destroyableComponent->SetImagination(imagination);
|
|
|
|
EntityManager::Instance()->SerializeEntity(tamer);
|
|
|
|
const auto& trueBricks = BrickDatabase::Instance()->GetBricks(cached->second.buildFile);
|
|
|
|
if (trueBricks.empty() || bricks.empty())
|
|
{
|
|
GameMessages::SendPetTamingTryBuildResult(m_Tamer, false, 0, tamer->GetSystemAddress());
|
|
|
|
return;
|
|
}
|
|
|
|
auto* brickIDTable = CDClientManager::Instance()->GetTable<CDBrickIDTableTable>("BrickIDTable");
|
|
|
|
int32_t correct = 0;
|
|
|
|
for (const auto& brick : bricks)
|
|
{
|
|
const auto brickEntries = brickIDTable->Query([brick](const CDBrickIDTable& entry)
|
|
{
|
|
return entry.NDObjectID == brick.designerID;
|
|
});
|
|
|
|
if (brickEntries.empty())
|
|
{
|
|
continue;
|
|
}
|
|
|
|
const auto designerID = brickEntries[0].LEGOBrickID;
|
|
|
|
for (const auto& trueBrick : trueBricks)
|
|
{
|
|
if (designerID == trueBrick.designerID && brick.materialID == trueBrick.materialID)
|
|
{
|
|
correct++;
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
const auto success = correct >= cached->second.numValidPieces;
|
|
|
|
GameMessages::SendPetTamingTryBuildResult(m_Tamer, success, correct, tamer->GetSystemAddress());
|
|
|
|
if (!success)
|
|
{
|
|
if (imagination < cached->second.imaginationCost)
|
|
{
|
|
ClientFailTamingMinigame();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
m_Timer = 0;
|
|
}
|
|
}
|
|
|
|
void PetComponent::NotifyTamingBuildSuccess(NiPoint3 position)
|
|
{
|
|
if (m_Tamer == LWOOBJID_EMPTY) return;
|
|
|
|
auto* tamer = EntityManager::Instance()->GetEntity(m_Tamer);
|
|
|
|
if (tamer == nullptr)
|
|
{
|
|
m_Tamer = LWOOBJID_EMPTY;
|
|
|
|
return;
|
|
}
|
|
|
|
const auto& cached = buildCache.find(m_Parent->GetLOT());
|
|
|
|
if (cached == buildCache.end())
|
|
{
|
|
return;
|
|
}
|
|
|
|
GameMessages::SendPlayFXEffect(tamer, -1, u"petceleb", "", LWOOBJID_EMPTY, 1, 1, true);
|
|
GameMessages::SendPlayAnimation(tamer, u"rebuild-celebrate");
|
|
|
|
EntityInfo info {};
|
|
info.lot = cached->second.puzzleModelLot;
|
|
info.pos = position;
|
|
info.rot = NiQuaternion::IDENTITY;
|
|
info.spawnerID = tamer->GetObjectID();
|
|
|
|
auto* modelEntity = EntityManager::Instance()->CreateEntity(info);
|
|
|
|
m_ModelId = modelEntity->GetObjectID();
|
|
|
|
EntityManager::Instance()->ConstructEntity(modelEntity);
|
|
|
|
GameMessages::SendNotifyTamingModelLoadedOnServer(m_Tamer, tamer->GetSystemAddress());
|
|
|
|
GameMessages::SendPetResponse(m_Tamer, m_Parent->GetObjectID(), 0, 10, 0, tamer->GetSystemAddress());
|
|
|
|
auto* inventoryComponent = tamer->GetComponent<InventoryComponent>();
|
|
|
|
if (inventoryComponent == nullptr)
|
|
{
|
|
return;
|
|
}
|
|
|
|
LWOOBJID petSubKey = ObjectIDManager::Instance()->GenerateRandomObjectID();
|
|
|
|
petSubKey = GeneralUtils::SetBit(petSubKey, OBJECT_BIT_CHARACTER);
|
|
petSubKey = GeneralUtils::SetBit(petSubKey, OBJECT_BIT_PERSISTENT);
|
|
|
|
m_DatabaseId = petSubKey;
|
|
|
|
std::string petName = tamer->GetCharacter()->GetName();
|
|
petName += "'s Pet";
|
|
|
|
GameMessages::SendAddPetToPlayer(m_Tamer, 0, GeneralUtils::ASCIIToUTF16(petName), petSubKey, m_Parent->GetLOT(), tamer->GetSystemAddress());
|
|
|
|
GameMessages::SendRegisterPetID(m_Tamer, m_Parent->GetObjectID(), tamer->GetSystemAddress());
|
|
|
|
GameMessages::SendRegisterPetDBID(m_Tamer, petSubKey, tamer->GetSystemAddress());
|
|
|
|
inventoryComponent->AddItem(m_Parent->GetLOT(), 1, MODELS, {}, LWOOBJID_EMPTY, true, false, petSubKey);
|
|
auto* item = inventoryComponent->FindItemBySubKey(petSubKey, MODELS);
|
|
|
|
if (item == nullptr)
|
|
{
|
|
return;
|
|
}
|
|
|
|
DatabasePet databasePet {};
|
|
|
|
databasePet.lot = m_Parent->GetLOT();
|
|
databasePet.moderationState = 1;
|
|
databasePet.name = petName;
|
|
|
|
inventoryComponent->SetDatabasePet(petSubKey, databasePet);
|
|
|
|
Activate(item, false);
|
|
|
|
m_Timer = 0;
|
|
|
|
GameMessages::SendNotifyPetTamingMinigame(
|
|
m_Tamer,
|
|
LWOOBJID_EMPTY,
|
|
LWOOBJID_EMPTY,
|
|
false,
|
|
NOTIFY_TYPE_NAMINGPET,
|
|
NiPoint3::ZERO,
|
|
NiPoint3::ZERO,
|
|
NiQuaternion::IDENTITY,
|
|
UNASSIGNED_SYSTEM_ADDRESS
|
|
);
|
|
|
|
// Triggers the catch a pet missions
|
|
if (petFlags.find(m_Parent->GetLOT()) != petFlags.end()) {
|
|
tamer->GetCharacter()->SetPlayerFlag(petFlags.at(m_Parent->GetLOT()), true);
|
|
}
|
|
|
|
auto* missionComponent = tamer->GetComponent<MissionComponent>();
|
|
|
|
if (missionComponent != nullptr)
|
|
{
|
|
//missionComponent->ForceProgress(506, 768, 1, false);
|
|
missionComponent->Progress(MissionTaskType::MISSION_TASK_TYPE_PET_TAMING, m_Parent->GetLOT());
|
|
}
|
|
|
|
SetStatus(1);
|
|
|
|
auto* characterComponent = tamer->GetComponent<CharacterComponent>();
|
|
if (characterComponent != nullptr) {
|
|
characterComponent->UpdatePlayerStatistic(PetsTamed);
|
|
}
|
|
}
|
|
|
|
void PetComponent::RequestSetPetName(std::u16string name)
|
|
{
|
|
if (m_Tamer == LWOOBJID_EMPTY)
|
|
{
|
|
if (m_Owner != LWOOBJID_EMPTY)
|
|
{
|
|
auto* owner = GetOwner();
|
|
|
|
m_ModerationStatus = 1; // Pending
|
|
m_Name = "";
|
|
|
|
//Save our pet's new name to the db:
|
|
SetPetNameForModeration(GeneralUtils::UTF16ToWTF8(name));
|
|
|
|
GameMessages::SendSetPetName(m_Owner, GeneralUtils::ASCIIToUTF16(m_Name), m_DatabaseId, owner->GetSystemAddress());
|
|
GameMessages::SendSetPetNameModerated(m_Owner, m_DatabaseId, m_ModerationStatus, owner->GetSystemAddress());
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
auto* tamer = EntityManager::Instance()->GetEntity(m_Tamer);
|
|
|
|
if (tamer == nullptr)
|
|
{
|
|
m_Tamer = LWOOBJID_EMPTY;
|
|
|
|
return;
|
|
}
|
|
|
|
Game::logger->Log("PetComponent", "Got set pet name (%s)\n", GeneralUtils::UTF16ToWTF8(name).c_str());
|
|
|
|
auto* inventoryComponent = tamer->GetComponent<InventoryComponent>();
|
|
|
|
if (inventoryComponent == nullptr)
|
|
{
|
|
return;
|
|
}
|
|
|
|
m_ModerationStatus = 1; // Pending
|
|
m_Name = "";
|
|
|
|
//Save our pet's new name to the db:
|
|
SetPetNameForModeration(GeneralUtils::UTF16ToWTF8(name));
|
|
|
|
EntityManager::Instance()->SerializeEntity(m_Parent);
|
|
|
|
GameMessages::SendSetPetName(m_Tamer, GeneralUtils::ASCIIToUTF16(m_Name), m_DatabaseId, tamer->GetSystemAddress());
|
|
GameMessages::SendSetPetName(m_Tamer, GeneralUtils::ASCIIToUTF16(m_Name), LWOOBJID_EMPTY, tamer->GetSystemAddress());
|
|
GameMessages::SendPetNameChanged(m_Parent->GetObjectID(), m_ModerationStatus, GeneralUtils::ASCIIToUTF16(m_Name), GeneralUtils::ASCIIToUTF16(m_OwnerName), UNASSIGNED_SYSTEM_ADDRESS);
|
|
GameMessages::SendSetPetNameModerated(m_Tamer, m_DatabaseId, m_ModerationStatus, tamer->GetSystemAddress());
|
|
|
|
GameMessages::SendNotifyPetTamingMinigame(
|
|
m_Tamer,
|
|
m_Parent->GetObjectID(),
|
|
m_Tamer,
|
|
false,
|
|
NOTIFY_TYPE_SUCCESS,
|
|
NiPoint3::ZERO,
|
|
NiPoint3::ZERO,
|
|
NiQuaternion::IDENTITY,
|
|
UNASSIGNED_SYSTEM_ADDRESS
|
|
);
|
|
|
|
GameMessages::SendTerminateInteraction(m_Tamer, eTerminateType::FROM_INTERACTION, m_Parent->GetObjectID());
|
|
|
|
auto* modelEntity = EntityManager::Instance()->GetEntity(m_ModelId);
|
|
|
|
if (modelEntity != nullptr)
|
|
{
|
|
modelEntity->Smash(m_Tamer);
|
|
}
|
|
|
|
currentActivities.erase(m_Tamer);
|
|
|
|
m_Tamer = LWOOBJID_EMPTY;
|
|
|
|
// Notify the end of a pet taming minigame
|
|
for (CppScripts::Script* script : CppScripts::GetEntityScripts(m_Parent)) {
|
|
script->OnNotifyPetTamingMinigame(m_Parent, tamer, NOTIFY_TYPE_SUCCESS);
|
|
}
|
|
}
|
|
|
|
void PetComponent::ClientExitTamingMinigame(bool voluntaryExit)
|
|
{
|
|
if (m_Tamer == LWOOBJID_EMPTY) return;
|
|
|
|
auto* tamer = EntityManager::Instance()->GetEntity(m_Tamer);
|
|
|
|
if (tamer == nullptr)
|
|
{
|
|
m_Tamer = LWOOBJID_EMPTY;
|
|
|
|
return;
|
|
}
|
|
|
|
GameMessages::SendNotifyPetTamingMinigame(
|
|
m_Tamer,
|
|
m_Parent->GetObjectID(),
|
|
m_Tamer,
|
|
false,
|
|
NOTIFY_TYPE_QUIT,
|
|
NiPoint3::ZERO,
|
|
NiPoint3::ZERO,
|
|
NiQuaternion::IDENTITY,
|
|
UNASSIGNED_SYSTEM_ADDRESS
|
|
);
|
|
|
|
GameMessages::SendNotifyTamingModelLoadedOnServer(m_Tamer, tamer->GetSystemAddress());
|
|
|
|
GameMessages::SendTerminateInteraction(m_Tamer, eTerminateType::FROM_INTERACTION, m_Parent->GetObjectID());
|
|
|
|
currentActivities.erase(m_Tamer);
|
|
|
|
SetStatus(67108866);
|
|
m_Tamer = LWOOBJID_EMPTY;
|
|
m_Timer = 0;
|
|
|
|
EntityManager::Instance()->SerializeEntity(m_Parent);
|
|
|
|
// Notify the end of a pet taming minigame
|
|
for (CppScripts::Script* script : CppScripts::GetEntityScripts(m_Parent)) {
|
|
script->OnNotifyPetTamingMinigame(m_Parent, tamer, NOTIFY_TYPE_QUIT);
|
|
}
|
|
}
|
|
|
|
void PetComponent::StartTimer()
|
|
{
|
|
const auto& cached = buildCache.find(m_Parent->GetLOT());
|
|
|
|
if (cached == buildCache.end())
|
|
{
|
|
return;
|
|
}
|
|
|
|
m_Timer = cached->second.timeLimit;
|
|
}
|
|
|
|
void PetComponent::ClientFailTamingMinigame()
|
|
{
|
|
if (m_Tamer == LWOOBJID_EMPTY) return;
|
|
|
|
auto* tamer = EntityManager::Instance()->GetEntity(m_Tamer);
|
|
|
|
if (tamer == nullptr)
|
|
{
|
|
m_Tamer = LWOOBJID_EMPTY;
|
|
|
|
return;
|
|
}
|
|
|
|
GameMessages::SendNotifyPetTamingMinigame(
|
|
m_Tamer,
|
|
m_Parent->GetObjectID(),
|
|
m_Tamer,
|
|
false,
|
|
NOTIFY_TYPE_FAILED,
|
|
NiPoint3::ZERO,
|
|
NiPoint3::ZERO,
|
|
NiQuaternion::IDENTITY,
|
|
UNASSIGNED_SYSTEM_ADDRESS
|
|
);
|
|
|
|
GameMessages::SendNotifyTamingModelLoadedOnServer(m_Tamer, tamer->GetSystemAddress());
|
|
|
|
GameMessages::SendTerminateInteraction(m_Tamer, eTerminateType::FROM_INTERACTION, m_Parent->GetObjectID());
|
|
|
|
currentActivities.erase(m_Tamer);
|
|
|
|
SetStatus(67108866);
|
|
m_Tamer = LWOOBJID_EMPTY;
|
|
m_Timer = 0;
|
|
|
|
EntityManager::Instance()->SerializeEntity(m_Parent);
|
|
|
|
// Notify the end of a pet taming minigame
|
|
for (CppScripts::Script* script : CppScripts::GetEntityScripts(m_Parent)) {
|
|
script->OnNotifyPetTamingMinigame(m_Parent, tamer, NOTIFY_TYPE_FAILED);
|
|
}
|
|
}
|
|
|
|
void PetComponent::Wander()
|
|
{
|
|
m_MovementAI = m_Parent->GetComponent<MovementAIComponent>();
|
|
|
|
if (m_MovementAI == nullptr || !m_MovementAI->AtFinalWaypoint()) {
|
|
return;
|
|
}
|
|
|
|
m_MovementAI->SetHaltDistance(0);
|
|
|
|
const auto& info = m_MovementAI->GetInfo();
|
|
|
|
const auto div = static_cast<int>(info.wanderDelayMax);
|
|
m_Timer = (div == 0 ? 0 : GeneralUtils::GenerateRandomNumber<int>(0, div)) + info.wanderDelayMin; //set a random timer to stay put.
|
|
|
|
const float radius = info.wanderRadius * sqrt(static_cast<double>(GeneralUtils::GenerateRandomNumber<float>(0, 1))); //our wander radius + a bit of random range
|
|
const float theta = ((static_cast<double>(GeneralUtils::GenerateRandomNumber<float>(0, 1)) * 2 * PI));
|
|
|
|
const NiPoint3 delta =
|
|
{
|
|
radius * cos(theta),
|
|
0,
|
|
radius * sin(theta)
|
|
};
|
|
|
|
auto destination = m_StartPosition + delta;
|
|
|
|
if (dpWorld::Instance().IsLoaded()) {
|
|
destination.y = dpWorld::Instance().GetHeightAtPoint(destination);
|
|
}
|
|
|
|
if (Vector3::DistanceSquared(destination, m_MovementAI->GetCurrentPosition()) < 2 * 2) {
|
|
m_MovementAI->Stop();
|
|
|
|
return;
|
|
}
|
|
|
|
m_MovementAI->SetSpeed(info.wanderSpeed);
|
|
|
|
m_MovementAI->SetDestination(destination);
|
|
|
|
m_Timer += (m_MovementAI->GetCurrentPosition().x - destination.x) / info.wanderSpeed;
|
|
}
|
|
|
|
void PetComponent::Activate(Item* item, bool registerPet)
|
|
{
|
|
m_ItemId = item->GetId();
|
|
m_DatabaseId = item->GetSubKey();
|
|
|
|
auto* inventoryComponent = item->GetInventory()->GetComponent();
|
|
|
|
if (inventoryComponent == nullptr) return;
|
|
|
|
inventoryComponent->DespawnPet();
|
|
|
|
m_Owner = inventoryComponent->GetParent()->GetObjectID();
|
|
|
|
auto* owner = GetOwner();
|
|
|
|
if (owner == nullptr) return;
|
|
SetStatus(1);
|
|
|
|
auto databaseData = inventoryComponent->GetDatabasePet(m_DatabaseId);
|
|
|
|
m_ModerationStatus = databaseData.moderationState;
|
|
|
|
bool updatedModerationStatus = false;
|
|
|
|
//Load mod status from db:
|
|
if (m_ModerationStatus != 2)
|
|
{
|
|
LoadPetNameFromModeration();
|
|
|
|
databaseData.name = m_Name;
|
|
databaseData.moderationState = m_ModerationStatus;
|
|
|
|
inventoryComponent->SetDatabasePet(m_DatabaseId, databaseData);
|
|
|
|
updatedModerationStatus = true;
|
|
}
|
|
else
|
|
{
|
|
m_Name = databaseData.name;
|
|
}
|
|
|
|
m_OwnerName = owner->GetCharacter()->GetName();
|
|
|
|
if (updatedModerationStatus)
|
|
{
|
|
GameMessages::SendSetPetName(m_Owner, GeneralUtils::ASCIIToUTF16(m_Name), m_DatabaseId, owner->GetSystemAddress());
|
|
GameMessages::SendSetPetNameModerated(m_Owner, m_DatabaseId, m_ModerationStatus, owner->GetSystemAddress());
|
|
}
|
|
|
|
GameMessages::SendMarkInventoryItemAsActive(m_Owner, true, 0, m_ItemId, GetOwner()->GetSystemAddress());
|
|
|
|
activePets[m_Owner] = m_Parent->GetObjectID();
|
|
|
|
m_Timer = 3;
|
|
|
|
EntityManager::Instance()->SerializeEntity(m_Parent);
|
|
|
|
owner->GetCharacter()->SetPlayerFlag(69, true);
|
|
|
|
if (registerPet)
|
|
{
|
|
GameMessages::SendAddPetToPlayer(m_Owner, 0, GeneralUtils::ASCIIToUTF16(m_Name), m_DatabaseId, m_Parent->GetLOT(), owner->GetSystemAddress());
|
|
|
|
GameMessages::SendRegisterPetID(m_Owner, m_Parent->GetObjectID(), owner->GetSystemAddress());
|
|
|
|
GameMessages::SendRegisterPetDBID(m_Owner, m_DatabaseId, owner->GetSystemAddress());
|
|
}
|
|
|
|
GameMessages::SendShowPetActionButton(m_Owner, 3, true, owner->GetSystemAddress());
|
|
}
|
|
|
|
void PetComponent::Deactivate()
|
|
{
|
|
GameMessages::SendPlayFXEffect(m_Parent->GetObjectID(), -1, u"despawn", "", LWOOBJID_EMPTY, 1, 1, true);
|
|
|
|
GameMessages::SendMarkInventoryItemAsActive(m_Owner, false, 0, m_ItemId, GetOwner()->GetSystemAddress());
|
|
|
|
activePets.erase(m_Owner);
|
|
|
|
m_Parent->Kill();
|
|
|
|
auto* owner = GetOwner();
|
|
|
|
if (owner == nullptr) return;
|
|
|
|
GameMessages::SendAddPetToPlayer(m_Owner, 0, u"", LWOOBJID_EMPTY, LOT_NULL, owner->GetSystemAddress());
|
|
|
|
GameMessages::SendRegisterPetID(m_Owner, LWOOBJID_EMPTY, owner->GetSystemAddress());
|
|
|
|
GameMessages::SendRegisterPetDBID(m_Owner, LWOOBJID_EMPTY, owner->GetSystemAddress());
|
|
|
|
GameMessages::SendShowPetActionButton(m_Owner, 0, false, owner->GetSystemAddress());
|
|
}
|
|
|
|
void PetComponent::Release()
|
|
{
|
|
auto* inventoryComponent = GetOwner()->GetComponent<InventoryComponent>();
|
|
|
|
if (inventoryComponent == nullptr)
|
|
{
|
|
return;
|
|
}
|
|
|
|
Deactivate();
|
|
|
|
inventoryComponent->RemoveDatabasePet(m_DatabaseId);
|
|
|
|
auto* item = inventoryComponent->FindItemBySubKey(m_DatabaseId);
|
|
|
|
item->SetCount(0, false, false);
|
|
}
|
|
|
|
void PetComponent::Command(NiPoint3 position, LWOOBJID source, int32_t commandType, int32_t typeId, bool overrideObey)
|
|
{
|
|
auto* owner = GetOwner();
|
|
|
|
if (owner == nullptr)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (commandType == 1) {
|
|
// Emotes
|
|
GameMessages::SendPlayEmote(m_Parent->GetObjectID(), typeId, owner->GetObjectID(), UNASSIGNED_SYSTEM_ADDRESS);
|
|
} else if (commandType == 3) {
|
|
// Follow me, ???
|
|
} else if (commandType == 6) {
|
|
// TODO: Go to player
|
|
}
|
|
|
|
if (owner->GetGMLevel() >= GAME_MASTER_LEVEL_DEVELOPER)
|
|
{
|
|
ChatPackets::SendSystemMessage(owner->GetSystemAddress(), u"Commmand Type: " + (GeneralUtils::to_u16string(commandType)) + u" - Type Id: " + (GeneralUtils::to_u16string(typeId)));
|
|
}
|
|
}
|
|
|
|
LWOOBJID PetComponent::GetOwnerId() const
|
|
{
|
|
return m_Owner;
|
|
}
|
|
|
|
Entity* PetComponent::GetOwner() const
|
|
{
|
|
return EntityManager::Instance()->GetEntity(m_Owner);
|
|
}
|
|
|
|
LWOOBJID PetComponent::GetDatabaseId() const
|
|
{
|
|
return m_DatabaseId;
|
|
}
|
|
|
|
LWOOBJID PetComponent::GetInteraction() const
|
|
{
|
|
return m_Interaction;
|
|
}
|
|
|
|
LWOOBJID PetComponent::GetItemId() const
|
|
{
|
|
return m_ItemId;
|
|
}
|
|
|
|
uint32_t PetComponent::GetStatus() const
|
|
{
|
|
return m_Status;
|
|
}
|
|
|
|
PetAbilityType PetComponent::GetAbility() const
|
|
{
|
|
return m_Ability;
|
|
}
|
|
|
|
void PetComponent::SetInteraction(LWOOBJID value)
|
|
{
|
|
m_Interaction = value;
|
|
}
|
|
|
|
void PetComponent::SetStatus(uint32_t value)
|
|
{
|
|
m_Status = value;
|
|
}
|
|
|
|
void PetComponent::SetAbility(PetAbilityType value)
|
|
{
|
|
m_Ability = value;
|
|
}
|
|
|
|
PetComponent* PetComponent::GetTamingPet(LWOOBJID tamer)
|
|
{
|
|
const auto& pair = currentActivities.find(tamer);
|
|
|
|
if (pair == currentActivities.end())
|
|
{
|
|
return nullptr;
|
|
}
|
|
|
|
auto* entity = EntityManager::Instance()->GetEntity(pair->second);
|
|
|
|
if (entity == nullptr)
|
|
{
|
|
currentActivities.erase(tamer);
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
return entity->GetComponent<PetComponent>();
|
|
}
|
|
|
|
PetComponent* PetComponent::GetActivePet(LWOOBJID owner)
|
|
{
|
|
const auto& pair = activePets.find(owner);
|
|
|
|
if (pair == activePets.end())
|
|
{
|
|
return nullptr;
|
|
}
|
|
|
|
auto* entity = EntityManager::Instance()->GetEntity(pair->second);
|
|
|
|
if (entity == nullptr)
|
|
{
|
|
activePets.erase(owner);
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
return entity->GetComponent<PetComponent>();
|
|
}
|
|
|
|
Entity* PetComponent::GetParentEntity() const
|
|
{
|
|
return m_Parent;
|
|
}
|
|
|
|
PetComponent::~PetComponent()
|
|
{
|
|
}
|
|
|
|
void PetComponent::SetPetNameForModeration(const std::string& petName) {
|
|
int approved = 1; //default, in mod
|
|
|
|
//Make sure that the name isn't already auto-approved:
|
|
if (Game::chatFilter->IsSentenceOkay(petName, 0)) {
|
|
approved = 2; //approved
|
|
}
|
|
|
|
auto deleteStmt = Database::CreatePreppedStmt("DELETE FROM pet_names WHERE id = ? LIMIT 1;");
|
|
deleteStmt->setUInt64(1, m_DatabaseId);
|
|
|
|
deleteStmt->execute();
|
|
|
|
delete deleteStmt;
|
|
|
|
//Save to db:
|
|
auto stmt = Database::CreatePreppedStmt("INSERT INTO `pet_names` (`id`, `pet_name`, `approved`) VALUES (?, ?, ?);");
|
|
stmt->setUInt64(1, m_DatabaseId);
|
|
stmt->setString(2, petName);
|
|
stmt->setInt(3, approved);
|
|
stmt->execute();
|
|
delete stmt;
|
|
}
|
|
|
|
void PetComponent::LoadPetNameFromModeration() {
|
|
auto stmt = Database::CreatePreppedStmt("SELECT pet_name, approved FROM pet_names WHERE id = ? LIMIT 1;");
|
|
stmt->setUInt64(1, m_DatabaseId);
|
|
|
|
auto res = stmt->executeQuery();
|
|
while (res->next()) {
|
|
m_ModerationStatus = res->getInt(2);
|
|
|
|
if (m_ModerationStatus == 2)
|
|
{
|
|
m_Name = res->getString(1);
|
|
}
|
|
}
|
|
|
|
delete res;
|
|
delete stmt;
|
|
}
|
|
|
|
void PetComponent::SetPreconditions(std::string& preconditions) {
|
|
m_Preconditions = new PreconditionExpression(preconditions);
|
|
}
|