DarkflameServer/dGame/dComponents/PetComponent.h
2024-04-20 11:23:35 -05:00

544 lines
13 KiB
C++

#ifndef PETCOMPONENT_H
#define PETCOMPONENT_H
#include "Entity.h"
#include "Flag.h"
#include "MovementAIComponent.h"
#include "Component.h"
#include "Preconditions.h"
#include "ePetAbilityType.h"
#include "eReplicaComponentType.h"
#include "ePetAbilityType.h"
#include "CDPetComponentTable.h"
#include "CDClientManager.h"
#include <optional>
/*
* The current state of the pet AI
*/
enum class PetAiState : uint8_t {
idle = 0, // Doing nothing
spawn, // Spawning into the world
follow, // Begin following
goToObj, // Go to object
interact, // Interact with an object
despawn // Despawning from world
};
/*
* The type of object the pet is interacting with
*/
enum class PetInteractType : uint8_t {
none, // Not interacting
treasure, // Treasure dig
bouncer // Bouncer switch
};
/**
* The flags governing the status of the pet: Governs the icon above their head and the interactions available
*/
enum class PetFlag : uint32_t {
NONE,
IDLE, //0x01 - Seems to be "idle," which the game doesn't differentiate from "follow"
UNKNOWN2, //0x02,
UNKNOWN4, //0x04 - FOLLOWING(?)
BEING_TAMED, //0x10,
NOT_WAITING, //0x20,
IMMOBILE, //0x40 - Seems to be the "stop moving" flag - called when taming begins and stays active until a name is submitted
SPAWNING, //0x80
ON_SWITCH, //0x100
UNKNOWN1024 = 10, //0x400
TAMEABLE = 26 //0x4000000
};
/**
* The pet emote animation ids that can used in PetComponent::Command()
*/
enum class PetEmote : int32_t {
ActivateSwitch = 201,
DigTreasure,
Bounce
};
/**
* Represents an entity that is a pet. This pet can be tamed and consequently follows the tamer around, allowing it
* to dig for treasure and activate pet bouncers.
*/
class PetComponent final : public Component {
public:
static constexpr eReplicaComponentType ComponentType = eReplicaComponentType::PET;
/**
* PetComponent constructor
* @param parentEntity The parent entity
* @param componentId The component id
*/
explicit PetComponent(Entity* parentEntity, uint32_t componentId);
~PetComponent() override = default;
/**
* Serializes the pet
* @param outBitStream The output bitstream
* @param bIsInitialUpdate Boolean value of whether this is the initial update
*/
void Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) override;
/**
* Sets the AI state of the pet
* @param newState New pet AI state
*/
void SetPetAiState(const PetAiState newState) noexcept {
m_State = newState;
};
/**
* Gets the AI state of the pet
*/
[[nodiscard]]
PetAiState GetPetAiState() const noexcept {
return m_State;
}
/**
* Governs the pet update loop
* @param deltaTime Time elapsed since last update
*/
void Update(float deltaTime) override;
/**
* Handles an OnUse event from another entity, initializing the pet taming minigame if this pet is untamed.
* @param originator the entity that triggered the event
*/
void OnUse(Entity* originator) override;
/**
* Attempts to complete the pet minigame by passing a list of bricks to build the minigame model.
* @param bricks the bricks to try to complete the minigame with
* @param clientFailed unused
*/
void TryBuild(uint32_t numBricks, bool clientFailed);
/**
* Handles a notification from the client regarding the completion of the pet minigame, adding the pet to their
* inventory.
* @param position the position to spawn the completed model at
*/
void NotifyTamingBuildSuccess(NiPoint3 position);
/**
* Handles the notification of the client to set the name of the pet (indicating that minigame was completed
* successfully).
* @param name the name of the pet to set
*/
void RequestSetPetName(const std::u16string& name);
/**
* Handles a notification of the client that the taming entity is leaving the minigame, either voluntary or because
* time ran out.
* @param voluntaryExit whether the client voluntarily exited the minigame
*/
void ClientExitTamingMinigame(bool voluntaryExit);
/**
* Starts the internal timer for the build limit for building the minigame model
*/
void StartTimer();
/**
* Notifies the client that they failed the minigame because time ran out
*/
void ClientFailTamingMinigame();
/**
* Makes the pet wander around
*/
void Wander();
/**
* Called when the pet is first spawned
*/
void OnSpawn();
/**
* Continues a step in the follow state, making sure that the entity is around its start position
*/
void OnFollow(const float deltaTime);
/**
* Continues a step in the interact state, handling the pet's interaction with an entity
*/
void OnInteract();
/**
* Start a pet interaction with an object at a given position
*/
void StartInteract(const NiPoint3 position, const PetInteractType interactionType, const LWOOBJID interactID);
/**
* Stop a pet interaction with an object
* @param bDontSerialize optional parameter, set to true to not serialize afterwards
*/
void StopInteract(bool bDontSerialize = false);
/**
* Spawns a pet from an item in the inventory of an owner
* @param item the item to create the pet from
* @param registerPet notifies the client that the pet was spawned, not necessary if this pet is being tamed
*/
void Activate(Item* item, bool registerPet = true, bool fromTaming = false);
/**
* Despawns the pet
*/
void Deactivate(eHelpType msg = eHelpType::NONE);
/**
* Removes the pet from the inventory
*/
void Release();
/**
* Commands the pet to do an action, actions are still a relative mystery, next to playing emotes
* @param position a position to execute the command at, currently unused
* @param source the source object that triggered the command
* @param commandType the type of the command (see function body for types)
* @param typeId extra information about the command, e.g. the emote to play
* @param overrideObey unused
*/
void Command(const NiPoint3& position, const LWOOBJID source, const int32_t commandType, const int32_t typeId, const bool overrideObey);
/**
* Returns the ID of the owner of this pet (if any)
* @return the ID of the owner of this pet
*/
[[nodiscard]]
LWOOBJID GetOwnerId() const noexcept {
return m_Owner;
};
/**
* Returns the entity that owns this pet (if any)
* @return the entity that owns this pet
*/
[[nodiscard]]
Entity* GetOwner() const;
/**
* Returns the ID that is stored in the database with regards to this pet, only set for pets that are tamed
* @return the ID that is stored in the database with regards to this pet
*/
[[nodiscard]]
LWOOBJID GetDatabaseId() const noexcept {
return m_DatabaseId;
}
/**
* Returns the ID that this pet was spawned from, only set for tamed pets
* @return the ID that this pet was spawned from
*/
[[nodiscard]]
LWOOBJID GetItemId() const noexcept {
return m_ItemId;
}
/**
* Sets preconditions for the pet that need to be met before it can be tamed
* @param conditions the preconditions to set
*/
void SetPreconditions(const std::string& preconditions) {
m_Preconditions = PreconditionExpression(preconditions);
}
/**
* Sets if the pet is ready to interact with an object
* @param isReady whether the pet is ready to interact (true) or not (false)
*/
void SetIsReadyToInteract(const bool isReady) {
m_ReadyToInteract = isReady;
};
/**
* @return is pet ready to interact with an object
*/
[[nodiscard]]
bool IsReadyToInteract() const noexcept {
return m_ReadyToInteract;
}
/**
* Sets if the pet is currently handling an interaction with an object
* @param isHandlingInteraction whether the pet is currently handling an interaction with an object
*/
void SetIsHandlingInteraction(const bool isHandlingInteraction) {
m_IsHandlingInteraction = isHandlingInteraction;
}
/**
* @return is pet currently handling an interaction with an object
*/
[[nodiscard]]
bool IsHandlingInteraction() const noexcept {
return m_IsHandlingInteraction;
};
/**
* Set up the pet bouncer interaction
*/
void SetupInteractBouncer();
/**
* Starts the pet bouncer interaction
*/
void StartInteractBouncer();
/**
* Handles the pet bouncer interaction
*/
void HandleInteractBouncer();
/**
* Set up the treasure dig interaction
*/
void SetupInteractTreasureDig();
/**
* Starts the pet treasure dig interaction
*/
void StartInteractTreasureDig();
/**
* Handles the pet treasure dig interaction
*/
void HandleInteractTreasureDig();
/**
* Returns the entity that this component belongs to
* @return the entity that this component belongs to
*/
[[nodiscard]]
Entity* GetParentEntity() const noexcept {
return m_Parent;
}
/**
* Sets the name of the pet to be moderated
* @param petName the name of the pet to set
*/
void SetPetNameForModeration(const std::string& petName);
/**
* Loads the pet name up for moderation along with the moderation status from the database and sets them for this
* pet.
*/
void LoadPetNameFromModeration();
/**
* Returns the component of the pet some entity is currently taming (if any)
* @param tamer the entity that's currently taming
* @return the pet component of the entity that's being tamed
*/
[[nodiscard]]
static PetComponent* GetTamingPet(LWOOBJID tamer);
/**
* Returns the pet that's currently spawned for some entity (if any)
* @param owner the owner of the pet that's spawned
* @return the pet component of the entity that was spawned by the owner
*/
[[nodiscard]]
static PetComponent* GetActivePet(LWOOBJID owner);
/**
* Adds the timer to the owner of this pet to drain imagination at the rate
* specified by the parameter imaginationDrainRate
*
* @param item The item that represents this pet in the inventory.
*/
void AddDrainImaginationTimer(Item* item, bool fromTaming = false);
private:
// Needed so it can access flags
friend class DamagingPets;
/**
* Information for the minigame to be completed
*/
struct PuzzleData {
/**
* The LOT of the object that is to be created
*/
LOT puzzleModelLot;
/**
* That file that contains the bricks required to build the model
*/
std::string buildFile;
/**
* The time limit to complete the build
*/
int32_t timeLimit;
/**
* The imagination cost for the tamer to start the minigame
*/
int32_t imaginationCost;
/**
* The number of pieces required to complete the minigame
*/
int32_t numValidPieces;
};
struct Interaction {
/**
* The type of object that the pet is currently interacting with (e.g. a treasure chest or switch)
*/
PetInteractType type = PetInteractType::none;
/**
* The interaction ability
*/
ePetAbilityType ability = ePetAbilityType::Invalid;
/**
* The ID of the object that the pet is currently interacting with (e.g. a treasure chest or switch)
*/
LWOOBJID obj = LWOOBJID_EMPTY;
};
/**
* Pet interaction info
*/
Interaction m_Interaction{};
/**
* Cache of all the pets that are currently spawned, indexed by tamer
*/
static std::unordered_map<LWOOBJID, LWOOBJID> activePets;
/**
* Cache of all the pets that are currently being tamed, indexed by tamer
*/
static std::unordered_map<LWOOBJID, LWOOBJID> currentActivities;
/**
* Cache of all the minigames and their information from the database
*/
static std::unordered_map<LOT, PetComponent::PuzzleData> buildCache;
/**
* Flags that indicate that a player has tamed a pet, indexed by the LOT of the pet
*/
static std::map<LOT, int32_t> petFlags;
/**
* The halting radius of the pet while following a player TODO: Move into struct?
*/
float m_FollowRadius;
/**
* The ID of the component in the pet component table
*/
uint32_t m_ComponentId;
/**
* The ID of the model that was built to complete the taming minigame for this pet
*/
LWOOBJID m_ModelId = LWOOBJID_EMPTY;
/**
* The ID of the entity that owns this pet
*/
LWOOBJID m_Owner = LWOOBJID_EMPTY;
/**
* The ID of the entity that is currently taming this pet
*/
LWOOBJID m_Tamer = LWOOBJID_EMPTY;
/**
* The ID under which this pet is stored in the database (if it's tamed)
*/
LWOOBJID m_DatabaseId = LWOOBJID_EMPTY;
/**
* The ID of the item from which this pet was created
*/
LWOOBJID m_ItemId;
/**
* The moderation status for the name of this pet
*/
uint32_t m_ModerationStatus = 0;
/**
* The name of this pet
*/
std::string m_Name;
/**
* The name of the owner of this pet
*/
std::string m_OwnerName;
/**
* The current flags of the pet (e.g. tamable, tamed, etc).
*/
Flag<PetFlag> m_Flags;
/**
* The current state of the pet AI
*/
PetAiState m_State;
/**
* The time an entity has left to complete the minigame
*/
float m_Timer = 0;
/**
* A timer that tracks how long a tamed pet has been to far away from its owner, triggering a teleport after timeout
*/
float m_TimerAway = 0;
/**
* A timer that tracks how long until a tamed pet will bounce again when standing over a treasure dig site
*/
float m_TimerBounce = 0;
/**
* Boolean that sets if a pet is ready to interact with an object
*/
bool m_ReadyToInteract;
/**
* Boolean that sets if a pet is currently handling an interaction with an object
*/
bool m_IsHandlingInteraction;
/**
* The position that this pet was spawned at
*/
NiPoint3 m_StartPosition;
/**
* The movement AI component that is related to this pet, required to move it around
*/
MovementAIComponent* m_MovementAI;
/**
* Preconditions that need to be met before an entity can tame this pet
*/
std::optional<PreconditionExpression> m_Preconditions;
/**
* Pet information loaded from the CDClientDatabase
*/
CDPetComponent m_PetInfo;
};
#endif // !PETCOMPONENT_H