Public release of the DLU server code!

Have fun!
2025-10-21 14:58:09 +00:00 · 2021-12-05 18:54:36 +01:00
parent 5f7270e4ad
commit 0545adfac3
1146 changed files with 368646 additions and 1 deletions
--- a/dGame/Entity.h
+++ b/dGame/Entity.h
@@ -0,0 +1,490 @@
+#pragma once
+
+#include <map>
+#include <functional>
+#include <typeinfo>
+#include <type_traits>
+#include <vector>
+
+#include "../thirdparty/raknet/Source/Replica.h"
+#include "../thirdparty/raknet/Source/ReplicaManager.h"
+
+#include "dCommonVars.h"
+#include "User.h"
+#include "NiPoint3.h"
+#include "NiQuaternion.h"
+#include "LDFFormat.h"
+#include "Loot.h"
+#include "Zone.h"
+
+#include "EntityTimer.h"
+#include "EntityCallbackTimer.h"
+#include "EntityInfo.h"
+
+class Player;
+class Spawner;
+class ScriptComponent;
+class dpEntity;
+class Component;
+class Character;
+
+/**
+ * An entity in the world. Has multiple components.
+ */
+class Entity {
+public:
+    explicit Entity(const LWOOBJID& objectID, EntityInfo info, Entity* parentEntity = nullptr);
+    virtual ~Entity();
+
+	virtual void Initialize();
+	
+    bool operator==(const Entity& other) const;
+    bool operator!=(const Entity& other) const;
+
+	/**
+	 * Getters
+	 */
+    
+    const LWOOBJID& GetObjectID() const { return m_ObjectID; }
+
+    const LOT GetLOT() const { return m_TemplateID; }
+
+    Character* GetCharacter() const { return m_Character; }
+
+    uint8_t GetGMLevel() const { return m_GMLevel; }
+
+    uint8_t GetCollectibleID() const { return uint8_t(m_CollectibleID); }
+
+	Entity* GetParentEntity() const { return m_ParentEntity; }
+
+	LUTriggers::Trigger* GetTrigger() const { return m_Trigger; }
+
+	std::vector<std::string>& GetGroups() { return m_Groups; };
+
+	Spawner* GetSpawner() const { return m_Spawner; }
+	
+	LWOOBJID GetSpawnerID() const { return m_SpawnerID; }
+
+	const std::vector<LDFBaseData*>& GetSettings() const { return m_Settings; }
+
+	const std::vector<LDFBaseData*>& GetNetworkSettings() const { return m_NetworkSettings; }
+
+	bool GetIsDead() const;
+
+	bool GetPlayerReadyForUpdates() const { return m_PlayerIsReadyForUpdates;}
+
+	bool GetIsGhostingCandidate() const;
+
+	int8_t GetObservers() const;
+
+	uint16_t GetNetworkId() const;
+
+	Entity* GetOwner() const;
+
+	const NiPoint3& GetDefaultPosition() const;
+
+	const NiQuaternion& GetDefaultRotation() const;
+
+	float GetDefaultScale() const;
+	
+	const NiPoint3& GetPosition() const;
+
+	const NiQuaternion& GetRotation() const;
+
+	virtual User* GetParentUser() const;
+
+	virtual SystemAddress GetSystemAddress() const { return UNASSIGNED_SYSTEM_ADDRESS; };
+
+	/**
+	 * Setters
+	 */
+
+    void SetCharacter(Character* value) { m_Character = value; }
+	
+    void SetGMLevel(uint8_t value);
+
+	void SetOwnerOverride(LWOOBJID value);
+
+	void SetPlayerReadyForUpdates() { m_PlayerIsReadyForUpdates = true; }
+
+	void SetObservers(int8_t value);
+
+	void SetNetworkId(uint16_t id);
+
+	void SetPosition(NiPoint3 position);
+
+	void SetRotation(NiQuaternion rotation);
+
+	virtual void SetRespawnPos(NiPoint3 position) {}
+
+	virtual void SetRespawnRot(NiQuaternion rotation) {}
+	
+	virtual void SetSystemAddress(const SystemAddress& value) {};
+
+	/**
+	 * Component management
+	 */
+
+    Component* GetComponent(int32_t componentID) const;
+
+	template<typename T>
+	T* GetComponent() const;
+
+	template<typename T>
+	bool TryGetComponent(int32_t componentId, T*& component) const;
+
+	bool HasComponent(int32_t componentId) const;
+
+	void AddComponent(int32_t componentId, Component* component);
+
+	std::vector<ScriptComponent*> GetScriptComponents();
+
+	void SetProximityRadius(float proxRadius, std::string name);
+	void SetProximityRadius(dpEntity* entity, std::string name);
+
+	void AddChild(Entity* child);
+	void AddTimer(std::string name, float time);
+	void AddCallbackTimer(float time, std::function<void()> callback);
+	bool HasTimer(const std::string& name);
+	void CancelCallbackTimers();
+	void CancelAllTimers();
+	void CancelTimer(const std::string& name);
+
+    void AddToGroup(const std::string& group);
+	bool IsPlayer() const;
+
+	std::unordered_map<int32_t, Component*>& GetComponents() { return m_Components; } // TODO: Remove
+	
+	void WriteBaseReplicaData(RakNet::BitStream* outBitStream, eReplicaPacketType packetType);
+	void WriteComponents(RakNet::BitStream* outBitStream, eReplicaPacketType packetType);
+    void ResetFlags();
+    void UpdateXMLDoc(tinyxml2::XMLDocument* doc);
+	void Update(float deltaTime);
+
+	// Events
+	void OnCollisionProximity(LWOOBJID otherEntity, const std::string& proxName, const std::string& status);
+	void OnCollisionPhantom(LWOOBJID otherEntity);
+    void OnCollisionLeavePhantom(LWOOBJID otherEntity);
+
+    void OnFireEventServerSide(Entity* sender, std::string args, int32_t param1 = -1, int32_t param2 = -1, int32_t param3 = -1);
+    void OnActivityStateChangeRequest(const LWOOBJID senderID, const int32_t value1, const int32_t value2,
+                                      const std::u16string& stringValue);
+    void OnCinematicUpdate(Entity* self, Entity* sender, eCinematicEvent event, const std::u16string& pathName,
+                           float_t pathTime, float_t totalTime, int32_t waypoint);
+
+	void NotifyObject(Entity* sender, const std::string& name, int32_t param1 = 0, int32_t param2 = 0);
+	void OnEmoteReceived(int32_t emote, Entity* target);
+    
+    void OnUse(Entity* originator);
+
+	void OnHitOrHealResult(Entity* attacker, int32_t damage);
+	void OnHit(Entity* attacker);
+
+	void OnZonePropertyEditBegin();
+	void OnZonePropertyEditEnd();
+	void OnZonePropertyModelEquipped();
+	void OnZonePropertyModelPlaced(Entity* player);
+	void OnZonePropertyModelPickedUp(Entity* player);
+	void OnZonePropertyModelRemoved(Entity* player);
+	void OnZonePropertyModelRemovedWhileEquipped(Entity* player);
+	void OnZonePropertyModelRotated(Entity* player);
+
+	void OnMessageBoxResponse(Entity* sender, int32_t button, const std::u16string& identifier, const std::u16string& userData);
+	void OnChoiceBoxResponse(Entity* sender, int32_t button, const std::u16string& buttonIdentifier, const std::u16string& identifier);
+
+	void Smash(const LWOOBJID source = LWOOBJID_EMPTY, const eKillType killType = eKillType::VIOLENT, const std::u16string& deathType = u"");
+	void Kill(Entity* murderer = nullptr);
+    void AddRebuildCompleteCallback(const std::function<void(Entity* user)>& callback) const;
+	void AddCollisionPhantomCallback(const std::function<void(Entity* target)>& callback);
+	void AddDieCallback(const std::function<void()>& callback);
+	void Resurrect();
+
+	void AddLootItem(const Loot::Info& info);
+	void PickupItem(const LWOOBJID& objectID);
+
+	void ScheduleKillAfterUpdate(Entity* murderer = nullptr);
+	void TriggerEvent(std::string eveneventtID, Entity* optionalTarget = nullptr);
+	void ScheduleDestructionAfterUpdate() { m_ShouldDestroyAfterUpdate = true; }
+	void HandleTriggerCommand(std::string id, std::string target, std::string targetName, std::string args, Entity* optionalTarget);
+
+	virtual NiPoint3 GetRespawnPosition() const { return NiPoint3::ZERO; }
+	virtual NiQuaternion GetRespawnRotation() const { return NiQuaternion::IDENTITY; }
+
+	void Sleep();
+	void Wake();
+	bool IsSleeping() const;
+
+	/*
+	 * Utility
+	 */
+
+	bool GetBoolean(const std::u16string& name) const;
+	int32_t GetI32(const std::u16string& name) const;
+	int64_t GetI64(const std::u16string& name) const;
+	
+	void SetBoolean(const std::u16string& name, bool value);
+	void SetI32(const std::u16string& name, int32_t value);
+	void SetI64(const std::u16string& name, int64_t value);
+
+	bool HasVar(const std::u16string& name) const;
+
+	template<typename T>
+	const T& GetVar(const std::u16string& name) const;
+
+	template<typename T>
+	void SetVar(const std::u16string& name, T value);
+
+	void SendNetworkVar(const std::string& data, const SystemAddress& sysAddr);
+
+	template<typename T>
+	void SetNetworkVar(const std::u16string& name, T value, const SystemAddress& sysAddr = UNASSIGNED_SYSTEM_ADDRESS);
+
+    template<typename T>
+    void SetNetworkVar(const std::u16string& name, std::vector<T> value, const SystemAddress& sysAddr = UNASSIGNED_SYSTEM_ADDRESS);
+
+    template<typename T>
+    T GetNetworkVar(const std::u16string& name);
+
+	/**
+	 * Get the LDF value and cast it as T.
+	 */
+	template<typename T>
+	T GetVarAs(const std::u16string& name) const;
+
+	/**
+	 * Get the LDF data.
+	 */
+	LDFBaseData* GetVarData(const std::u16string& name) const;
+
+	/**
+	 * Get the LDF value and convert it to a string.
+	 */
+	std::string GetVarAsString(const std::u16string& name) const;
+
+	/*
+	 * Collision
+	 */
+	std::vector<LWOOBJID>& GetTargetsInPhantom();
+
+	Entity* GetScheduledKiller() { return m_ScheduleKiller; }
+
+protected:
+    LWOOBJID m_ObjectID;
+	
+    LOT m_TemplateID;
+	
+    std::vector<LDFBaseData*> m_Settings;
+    std::vector<LDFBaseData*> m_NetworkSettings;
+
+    NiPoint3 m_DefaultPosition;
+    NiQuaternion m_DefaultRotation;
+	float m_Scale;
+
+	Spawner* m_Spawner;
+    LWOOBJID m_SpawnerID;
+    
+    bool m_HasSpawnerNodeID;
+    uint32_t m_SpawnerNodeID;
+    
+	LUTriggers::Trigger* m_Trigger;
+
+	Character* m_Character;
+	
+    Entity* m_ParentEntity; //For spawners and the like
+	std::vector<Entity*> m_ChildEntities;
+    uint8_t m_GMLevel;
+    uint16_t m_CollectibleID;
+	std::vector<std::string> m_Groups;
+	uint16_t m_NetworkID;
+	std::vector<std::function<void()>> m_DieCallbacks;
+    std::vector<std::function<void(Entity* target)>> m_PhantomCollisionCallbacks;
+    
+    std::unordered_map<int32_t, Component*> m_Components; //The int is the ID of the component
+	std::vector<EntityTimer*> m_Timers;
+	std::vector<EntityCallbackTimer*> m_CallbackTimers;
+
+	bool m_ShouldDestroyAfterUpdate = false;
+
+	LWOOBJID m_OwnerOverride;
+
+	Entity* m_ScheduleKiller;
+
+	bool m_PlayerIsReadyForUpdates = false;
+
+	bool m_IsGhostingCandidate = false;
+
+	int8_t m_Observers = 0;
+
+	/*
+	 * Collision
+	 */
+	std::vector<LWOOBJID> m_TargetsInPhantom;
+};
+
+/**
+ * Template definitions.
+ */
+
+template<typename T>
+bool Entity::TryGetComponent(const int32_t componentId, T*& component) const
+{
+	const auto& index = m_Components.find(componentId);
+
+	if (index == m_Components.end())
+	{
+		component = nullptr;
+
+		return false;
+	}
+
+	component = dynamic_cast<T*>(index->second);
+
+	return true;
+}
+
+template <typename T>
+T* Entity::GetComponent() const
+{
+	return dynamic_cast<T*>(GetComponent(T::ComponentType));
+}
+
+
+template<typename T>
+const T& Entity::GetVar(const std::u16string& name) const
+{
+	auto* data = GetVarData(name);
+
+	if (data == nullptr)
+	{
+		return LDFData<T>::Default;
+	}
+
+	auto* typed = dynamic_cast<LDFData<T>*>(data);
+
+	if (typed == nullptr)
+	{
+		return LDFData<T>::Default;
+	}
+
+	return typed->GetValue();
+}
+
+template<typename T>
+T Entity::GetVarAs(const std::u16string& name) const
+{
+	const auto data = GetVarAsString(name);
+
+	T value;
+
+	if (!GeneralUtils::TryParse(data, value))
+	{
+		return LDFData<T>::Default;
+	}
+
+	return value;
+}
+
+template<typename T>
+void Entity::SetVar(const std::u16string& name, T value)
+{
+	auto* data = GetVarData(name);
+
+	if (data == nullptr)
+	{
+		auto* data = new LDFData<T>(name, value);
+
+		m_Settings.push_back(data);
+
+		return;
+	}
+
+	auto* typed = dynamic_cast<LDFData<T>*>(data);
+
+	if (typed == nullptr)
+	{
+		return;
+	}
+
+	typed->SetValue(value);
+}
+
+template<typename T>
+void Entity::SetNetworkVar(const std::u16string& name, T value, const SystemAddress& sysAddr) {
+    LDFData<T>* newData = nullptr;
+
+    for (auto* data :m_NetworkSettings) {
+        if (data->GetKey() != name)
+            continue;
+
+        newData = dynamic_cast<LDFData<T>*>(data);
+        if (newData != nullptr) {
+            newData->SetValue(value);
+        } else {  // If we're changing types
+            m_NetworkSettings.erase(
+				std::remove(m_NetworkSettings.begin(), m_NetworkSettings.end(), data), m_NetworkSettings.end()
+			);
+            delete data;
+        }
+
+        break;
+    }
+
+    if (newData == nullptr) {
+        newData = new LDFData<T>(name, value);
+    }
+
+    m_NetworkSettings.push_back(newData);
+    SendNetworkVar(newData->GetString(true), sysAddr);
+}
+
+template<typename T>
+void Entity::SetNetworkVar(const std::u16string& name, std::vector<T> values, const SystemAddress& sysAddr) {
+    std::stringstream updates;
+    auto index = 1;
+
+    for (const auto& value : values) {
+        LDFData<T>* newData = nullptr;
+        const auto& indexedName = name + u"." + GeneralUtils::to_u16string(index);
+
+        for (auto* data : m_NetworkSettings) {
+            if (data->GetKey() != indexedName)
+                continue;
+
+            newData = dynamic_cast<LDFData<T>*>(data);
+            newData->SetValue(value);
+            break;
+        }
+
+        if (newData == nullptr) {
+            newData = new LDFData<T>(indexedName, value);
+        }
+
+        m_NetworkSettings.push_back(newData);
+
+        if (index == values.size()) {
+            updates << newData->GetString(true);
+        } else {
+            updates << newData->GetString(true) << "\n";
+        }
+
+        index++;
+    }
+
+    SendNetworkVar(updates.str(), sysAddr);
+}
+
+template<typename T>
+T Entity::GetNetworkVar(const std::u16string& name) {
+    for (auto* data : m_NetworkSettings) {
+        if (data == nullptr || data->GetKey() != name)
+            continue;
+
+        auto* typed = dynamic_cast<LDFData<T>*>(data);
+        if (typed == nullptr)
+            continue;
+
+        return typed->GetValue();
+    }
+
+    return LDFData<T>::Default;
+}