Merge remote-tracking branch 'origin/main' into dCinema

dGame/dComponents/ActivityComponent.cpp

@@ -21,7 +21,7 @@
 #include "eMissionTaskType.h"
 #include "eMatchUpdate.h"
 #include "eConnectionType.h"
-#include "eChatMessageType.h"
+#include "MessageType/Chat.h"
 
 #include "CDCurrencyTableTable.h"
 #include "CDActivityRewardsTable.h"
@@ -501,7 +501,7 @@ void ActivityInstance::StartZone() {
 	// only make a team if we have more than one participant
 	if (participants.size() > 1) {
 		CBITSTREAM;
-		BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::CREATE_TEAM);
+		BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, MessageType::Chat::CREATE_TEAM);
 
 		bitStream.Write(leader->GetObjectID());
 		bitStream.Write(m_Participants.size());

dGame/dComponents/BaseCombatAIComponent.cpp

@@ -16,6 +16,7 @@
 #include "DestroyableComponent.h"
 
 #include <algorithm>
+#include <ranges>
 #include <sstream>
 #include <vector>
 
@@ -27,7 +28,7 @@
 #include "CDPhysicsComponentTable.h"
 #include "dNavMesh.h"
 
-BaseCombatAIComponent::BaseCombatAIComponent(Entity* parent, const uint32_t id): Component(parent) {
+BaseCombatAIComponent::BaseCombatAIComponent(Entity* parent, const uint32_t id) : Component(parent) {
 	m_Target = LWOOBJID_EMPTY;
 	m_DirtyStateOrTarget = true;
 	m_State = AiState::spawn;
@@ -37,6 +38,7 @@ BaseCombatAIComponent::BaseCombatAIComponent(Entity* parent, const uint32_t id):
 	m_Disabled = false;
 	m_SkillEntries = {};
 	m_SoftTimer = 5.0f;
+	m_ForcedTetherTime = 0.0f;
 
 	//Grab the aggro information from BaseCombatAI:
 	auto componentQuery = CDClientDatabase::CreatePreppedStmt(
@@ -170,6 +172,17 @@ void BaseCombatAIComponent::Update(const float deltaTime) {
 			GameMessages::SendStopFXEffect(m_Parent, true, "tether");
 			m_TetherEffectActive = false;
 		}
+		m_ForcedTetherTime -= deltaTime;
+		if (m_ForcedTetherTime >= 0) return;
+	}
+
+	for (auto entry = m_RemovedThreatList.begin(); entry != m_RemovedThreatList.end();) {
+		entry->second -= deltaTime;
+		if (entry->second <= 0.0f) {
+			entry = m_RemovedThreatList.erase(entry);
+		} else {
+			++entry;
+		}
 	}
 
 	if (m_SoftTimer <= 0.0f) {
@@ -287,40 +300,7 @@ void BaseCombatAIComponent::CalculateCombat(const float deltaTime) {
 	}
 
 	if (!m_TetherEffectActive && m_OutOfCombat && (m_OutOfCombatTime -= deltaTime) <= 0) {
-		auto* destroyableComponent = m_Parent->GetComponent<DestroyableComponent>();
-
-		if (destroyableComponent != nullptr && destroyableComponent->HasFaction(4)) {
-			auto serilizationRequired = false;
-
-			if (destroyableComponent->GetHealth() != destroyableComponent->GetMaxHealth()) {
-				destroyableComponent->SetHealth(destroyableComponent->GetMaxHealth());
-
-				serilizationRequired = true;
-			}
-
-			if (destroyableComponent->GetArmor() != destroyableComponent->GetMaxArmor()) {
-				destroyableComponent->SetArmor(destroyableComponent->GetMaxArmor());
-
-				serilizationRequired = true;
-			}
-
-			if (serilizationRequired) {
-				Game::entityManager->SerializeEntity(m_Parent);
-			}
-
-			GameMessages::SendPlayFXEffect(m_Parent->GetObjectID(), 6270, u"tether", "tether");
-
-			m_TetherEffectActive = true;
-
-			m_TetherTime = 3.0f;
-		}
-
-		// Speed towards start position
-		if (m_MovementAI != nullptr) {
-			m_MovementAI->SetHaltDistance(0);
-			m_MovementAI->SetMaxSpeed(m_PursuitSpeed);
-			m_MovementAI->SetDestination(m_StartPosition);
-		}
+		TetherLogic();
 
 		m_OutOfCombat = false;
 		m_OutOfCombatTime = 0.0f;
@@ -499,7 +479,7 @@ std::vector<LWOOBJID> BaseCombatAIComponent::GetTargetWithinAggroRange() const {
 
 		const auto distance = Vector3::DistanceSquared(m_Parent->GetPosition(), other->GetPosition());
 
-		if (distance > m_AggroRadius * m_AggroRadius) continue;
+		if (distance > m_AggroRadius * m_AggroRadius || m_RemovedThreatList.contains(id)) continue;
 
 		targets.push_back(id);
 	}
@@ -626,6 +606,7 @@ const NiPoint3& BaseCombatAIComponent::GetStartPosition() const {
 
 void BaseCombatAIComponent::ClearThreat() {
 	m_ThreatEntries.clear();
+	m_Target = LWOOBJID_EMPTY;
 
 	m_DirtyThreat = true;
 }
@@ -854,3 +835,55 @@ void BaseCombatAIComponent::Wake() {
 	m_dpEntity->SetSleeping(false);
 	m_dpEntityEnemy->SetSleeping(false);
 }
+
+void BaseCombatAIComponent::TetherLogic() {
+	auto* destroyableComponent = m_Parent->GetComponent<DestroyableComponent>();
+
+	if (destroyableComponent != nullptr && destroyableComponent->HasFaction(4)) {
+		auto serilizationRequired = false;
+
+		if (destroyableComponent->GetHealth() != destroyableComponent->GetMaxHealth()) {
+			destroyableComponent->SetHealth(destroyableComponent->GetMaxHealth());
+
+			serilizationRequired = true;
+		}
+
+		if (destroyableComponent->GetArmor() != destroyableComponent->GetMaxArmor()) {
+			destroyableComponent->SetArmor(destroyableComponent->GetMaxArmor());
+
+			serilizationRequired = true;
+		}
+
+		if (serilizationRequired) {
+			Game::entityManager->SerializeEntity(m_Parent);
+		}
+
+		GameMessages::SendPlayFXEffect(m_Parent->GetObjectID(), 6270, u"tether", "tether");
+
+		m_TetherEffectActive = true;
+
+		m_TetherTime = 3.0f;
+	}
+
+	// Speed towards start position
+	if (m_MovementAI != nullptr) {
+		m_MovementAI->SetHaltDistance(0);
+		m_MovementAI->SetMaxSpeed(m_PursuitSpeed);
+		m_MovementAI->SetDestination(m_StartPosition);
+	}
+}
+
+void BaseCombatAIComponent::ForceTether() {
+	SetTarget(LWOOBJID_EMPTY);
+	m_ThreatEntries.clear();
+	TetherLogic();
+	m_ForcedTetherTime = m_TetherTime;
+
+	SetAiState(AiState::aggro);
+}
+
+void BaseCombatAIComponent::IgnoreThreat(const LWOOBJID threat, const float value) {
+	m_RemovedThreatList[threat] = value;
+	SetThreat(threat, 0.0f);
+	m_Target = LWOOBJID_EMPTY;
+}

dGame/dComponents/BaseCombatAIComponent.h

@@ -278,6 +278,16 @@ public:
 	 */
 	void Wake();
 
+	// Force this entity to tether and ignore all other actions
+	void ForceTether();
+
+	// heals the entity to full health and armor
+	// and tethers them to their spawn point
+	void TetherLogic();
+
+	// Ignore a threat for a certain amount of time
+	void IgnoreThreat(const LWOOBJID target, const float time);
+
 private:
 	/**
 	 * Returns the current target or the target that currently is the largest threat to this entity
@@ -436,6 +446,12 @@ private:
 	 */
 	bool m_DirtyStateOrTarget = false;
 
+	// The amount of time the entity will be forced to tether for
+	float m_ForcedTetherTime = 0.0f;
+
+	// The amount of time a removed threat will be ignored for. 
+	std::map<LWOOBJID, float> m_RemovedThreatList;
+
 	/**
 	 * A position that the entity should stay around
 	 */

dGame/dComponents/CMakeLists.txt

@@ -7,7 +7,6 @@ set(DGAME_DCOMPONENTS_SOURCES
 	"BuildBorderComponent.cpp"
 	"CharacterComponent.cpp"
 	"CollectibleComponent.cpp"
-	"Component.cpp"
 	"ControllablePhysicsComponent.cpp"
 	"DestroyableComponent.cpp"
 	"DonationVendorComponent.cpp"
@@ -65,7 +64,6 @@ target_include_directories(dComponents PUBLIC "."
 	"${PROJECT_SOURCE_DIR}/dDatabase/CDClientDatabase/CDClientTables"
 	"${PROJECT_SOURCE_DIR}/dDatabase/GameDatabase"
 	"${PROJECT_SOURCE_DIR}/dDatabase/GameDatabase/ITables"
-	"${PROJECT_SOURCE_DIR}/thirdparty/mariadb-connector-cpp/include"
 	# dPhysics (via dpWorld.h)
 	"${PROJECT_SOURCE_DIR}/thirdparty/recastnavigation/Recast/Include"
 	"${PROJECT_SOURCE_DIR}/thirdparty/recastnavigation/Detour/Include"

dGame/dComponents/CharacterComponent.cpp

@@ -22,6 +22,7 @@
 #include "Mail.h"
 #include "ZoneInstanceManager.h"
 #include "WorldPackets.h"
+#include "MessageType/Game.h"
 #include <ctime>
 
 CharacterComponent::CharacterComponent(Entity* parent, Character* character, const SystemAddress& systemAddress) : Component(parent) {
@@ -47,6 +48,45 @@ CharacterComponent::CharacterComponent(Entity* parent, Character* character, con
 	m_CountryCode = 0;
 	m_LastUpdateTimestamp = std::time(nullptr);
 	m_SystemAddress = systemAddress;
+
+	RegisterMsg(MessageType::Game::REQUEST_SERVER_OBJECT_INFO, this, &CharacterComponent::OnRequestServerObjectInfo);
+}
+
+bool CharacterComponent::OnRequestServerObjectInfo(GameMessages::GameMsg& msg) {
+	auto& request = static_cast<GameMessages::RequestServerObjectInfo&>(msg);
+	AMFArrayValue response;
+
+	response.Insert("visible", true);
+	response.Insert("objectID", std::to_string(request.targetForReport));
+	response.Insert("serverInfo", true);
+
+	auto& data = *response.InsertArray("data");
+	auto& cmptType = data.PushDebug("Character");
+
+	cmptType.PushDebug<AMFIntValue>("Component ID") = GeneralUtils::ToUnderlying(ComponentType);
+	cmptType.PushDebug<AMFIntValue>("Character's account ID") = m_Character->GetParentUser()->GetAccountID();
+	cmptType.PushDebug<AMFBoolValue>("Last log out time") = m_Character->GetLastLogin();
+	cmptType.PushDebug<AMFDoubleValue>("Seconds played this session") = 0;
+	cmptType.PushDebug<AMFBoolValue>("Editor enabled") = false;
+	cmptType.PushDebug<AMFDoubleValue>("Total number of seconds played") = m_TotalTimePlayed;
+	cmptType.PushDebug<AMFStringValue>("Total currency") = std::to_string(m_Character->GetCoins());
+	cmptType.PushDebug<AMFStringValue>("Currency able to be picked up") = std::to_string(m_DroppedCoins);
+	cmptType.PushDebug<AMFStringValue>("Tooltip flags value") = "0";
+	// visited locations
+	cmptType.PushDebug<AMFBoolValue>("is a GM") = m_GMLevel > eGameMasterLevel::CIVILIAN;
+	cmptType.PushDebug<AMFBoolValue>("Has PVP flag turned on") = m_PvpEnabled;
+	cmptType.PushDebug<AMFIntValue>("GM Level") = GeneralUtils::ToUnderlying(m_GMLevel);
+	cmptType.PushDebug<AMFIntValue>("Editor level") = GeneralUtils::ToUnderlying(m_EditorLevel);
+	cmptType.PushDebug<AMFStringValue>("Guild ID") = "0";
+	cmptType.PushDebug<AMFStringValue>("Guild Name") = "";
+	cmptType.PushDebug<AMFDoubleValue>("Reputation") = m_Reputation;
+	cmptType.PushDebug<AMFIntValue>("Current Activity Type") = GeneralUtils::ToUnderlying(m_CurrentActivity);
+	cmptType.PushDebug<AMFDoubleValue>("Property Clone ID") = m_Character->GetPropertyCloneID();
+
+	GameMessages::SendUIMessageServerToSingleClient("ToggleObjectDebugger", response, m_Parent->GetSystemAddress());
+
+	LOG("Handled!");
+	return true;
 }
 
 bool CharacterComponent::LandingAnimDisabled(int zoneID) {
@@ -81,6 +121,8 @@ CharacterComponent::~CharacterComponent() {
 void CharacterComponent::Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) {
 
 	if (bIsInitialUpdate) {
+		if (!m_Character || !m_Character->GetParentUser()) return;
+
 		outBitStream.Write(m_ClaimCodes[0] != 0);
 		if (m_ClaimCodes[0] != 0) outBitStream.Write(m_ClaimCodes[0]);
 		outBitStream.Write(m_ClaimCodes[1] != 0);
@@ -100,7 +142,7 @@ void CharacterComponent::Serialize(RakNet::BitStream& outBitStream, bool bIsInit
 		outBitStream.Write(m_Character->GetEyebrows());
 		outBitStream.Write(m_Character->GetEyes());
 		outBitStream.Write(m_Character->GetMouth());
-		outBitStream.Write<uint64_t>(0); //AccountID, trying out if 0 works.
+		outBitStream.Write<uint64_t>(m_Character->GetParentUser()->GetAccountID());
 		outBitStream.Write(m_Character->GetLastLogin()); //Last login
 		outBitStream.Write<uint64_t>(0); //"prop mod last display time"
 		outBitStream.Write<uint64_t>(m_Uscore); //u-score
@@ -786,7 +828,7 @@ void CharacterComponent::AwardClaimCodes() {
 		subject << "%[RewardCodes_" << rewardCode << "_subjectText]";
 		std::ostringstream body;
 		body << "%[RewardCodes_" << rewardCode << "_bodyText]";
-		Mail::SendMail(LWOOBJID_EMPTY, "%[MAIL_SYSTEM_NOTIFICATION]", m_Parent, subject.str(), body.str(), attachmentLOT, 1);
+		Mail::SendMail(m_Parent, subject.str(), body.str(), attachmentLOT, 1);
 	}
 }
 

dGame/dComponents/CharacterComponent.h

@@ -25,6 +25,8 @@ struct ZoneStatistics {
 	uint64_t m_CoinsCollected;
 	uint64_t m_EnemiesSmashed;
 	uint64_t m_QuickBuildsCompleted;
+
+	bool operator==(const ZoneStatistics& rhs) const = default;
 };
 
 /**
@@ -279,9 +281,9 @@ public:
 	 */
 	void UpdateClientMinimap(bool showFaction, std::string ventureVisionType) const;
 
-	void SetCurrentInteracting(LWOOBJID objectID) {m_CurrentInteracting = objectID;};
+	void SetCurrentInteracting(LWOOBJID objectID) { m_CurrentInteracting = objectID; };
 
-	LWOOBJID GetCurrentInteracting() {return m_CurrentInteracting;};
+	LWOOBJID GetCurrentInteracting() { return m_CurrentInteracting; };
 
 	/**
 	 * Sends a player to another zone with an optional clone ID
@@ -307,12 +309,22 @@ public:
 
 	void SetDroppedCoins(const uint64_t value) { m_DroppedCoins = value; };
 
+	const std::array<uint64_t, 4>& GetClaimCodes() const { return m_ClaimCodes; };
+
+	const std::map<LWOMAPID, ZoneStatistics>& GetZoneStatistics() const { return m_ZoneStatistics; };
+
+	const std::u16string& GetLastRocketConfig() const { return m_LastRocketConfig; };
+
+	uint64_t GetTotalTimePlayed() const { return m_TotalTimePlayed; };
+
 	/**
 	 * Character info regarding this character, including clothing styles, etc.
 	 */
 	Character* m_Character;
 private:
 
+	bool OnRequestServerObjectInfo(GameMessages::GameMsg& msg);
+
 	/**
 	 * The map of active venture vision effects
 	 */

dGame/dComponents/Component.cpp

@@ -1,34 +0,0 @@
-#include "Component.h"
-
-
-Component::Component(Entity* parent) {
-	m_Parent = parent;
-}
-
-Component::~Component() {
-
-}
-
-Entity* Component::GetParent() const {
-	return m_Parent;
-}
-
-void Component::Update(float deltaTime) {
-
-}
-
-void Component::OnUse(Entity* originator) {
-
-}
-
-void Component::UpdateXml(tinyxml2::XMLDocument& doc) {
-
-}
-
-void Component::LoadFromXml(const tinyxml2::XMLDocument& doc) {
-
-}
-
-void Component::Serialize(RakNet::BitStream& outBitStream, bool isConstruction) {
-
-}

dGame/dComponents/Component.h

@@ -1,6 +1,16 @@
 #pragma once
 
-#include "tinyxml2.h"
+namespace tinyxml2 {
+	class XMLDocument;
+}
+
+namespace RakNet {
+	class BitStream;
+}
+
+namespace GameMessages {
+	struct GameMsg;
+}
 
 class Entity;
 
@@ -9,43 +19,47 @@ class Entity;
  */
 class Component {
 public:
-	Component(Entity* parent);
-	virtual ~Component();
+	Component(Entity* parent) : m_Parent{ parent } {}
+	virtual ~Component() = default;
 
 	/**
 	 * Gets the owner of this component
 	 * @return the owner of this component
 	 */
-	Entity* GetParent() const;
+	Entity* GetParent() const { return m_Parent; }
 
 	/**
 	 * Updates the component in the game loop
 	 * @param deltaTime time passed since last update
 	 */
-	virtual void Update(float deltaTime);
+	virtual void Update(float deltaTime) {}
 
 	/**
 	 * Event called when this component is being used, e.g. when some entity interacted with it
 	 * @param originator
 	 */
-	virtual void OnUse(Entity* originator);
+	virtual void OnUse(Entity* originator) {}
 
 	/**
 	 * Save data from this componennt to character XML
 	 * @param doc the document to write data to
 	 */
-	virtual void UpdateXml(tinyxml2::XMLDocument& doc);
+	virtual void UpdateXml(tinyxml2::XMLDocument& doc) {}
 
 	/**
 	 * Load base data for this component from character XML
 	 * @param doc the document to read data from
 	 */
-	virtual void LoadFromXml(const tinyxml2::XMLDocument& doc);
+	virtual void LoadFromXml(const tinyxml2::XMLDocument& doc) {}
 
-	virtual void Serialize(RakNet::BitStream& outBitStream, bool isConstruction);
+	virtual void Serialize(RakNet::BitStream& outBitStream, bool isConstruction) {}
 
 protected:
 
+	void RegisterMsg(const MessageType::Game msgId, auto* self, const auto handler) {
+		m_Parent->RegisterMsg(msgId, std::bind(handler, self, std::placeholders::_1));
+	}
+
 	/**
 	 * The entity that owns this component
 	 */

dGame/dComponents/ControllablePhysicsComponent.cpp

@@ -15,7 +15,7 @@
 #include "LevelProgressionComponent.h"
 #include "eStateChangeType.h"
 
-ControllablePhysicsComponent::ControllablePhysicsComponent(Entity* entity) : PhysicsComponent(entity) {
+ControllablePhysicsComponent::ControllablePhysicsComponent(Entity* entity, int32_t componentId) : PhysicsComponent(entity, componentId) {
 	m_Velocity = {};
 	m_AngularVelocity = {};
 	m_InJetpackMode = false;

dGame/dComponents/ControllablePhysicsComponent.h

@@ -23,7 +23,7 @@ class ControllablePhysicsComponent : public PhysicsComponent {
 public:
 	static constexpr eReplicaComponentType ComponentType = eReplicaComponentType::CONTROLLABLE_PHYSICS;
 
-	ControllablePhysicsComponent(Entity* entity);
+	ControllablePhysicsComponent(Entity* entity, int32_t componentId);
 	~ControllablePhysicsComponent() override;
 
 	void Update(float deltaTime) override;

dGame/dComponents/DestroyableComponent.cpp

@@ -38,6 +38,9 @@
 
 #include "CDComponentsRegistryTable.h"
 
+Implementation<bool, const Entity*> DestroyableComponent::IsEnemyImplentation;
+Implementation<bool, const Entity*> DestroyableComponent::IsFriendImplentation;
+
 DestroyableComponent::DestroyableComponent(Entity* parent) : Component(parent) {
 	m_iArmor = 0;
 	m_fMaxArmor = 0.0f;
@@ -418,6 +421,7 @@ void DestroyableComponent::AddFaction(const int32_t factionID, const bool ignore
 }
 
 bool DestroyableComponent::IsEnemy(const Entity* other) const {
+	if (IsEnemyImplentation.ExecuteWithDefault(other, false)) return true;
 	if (m_Parent->IsPlayer() && other->IsPlayer()) {
 		auto* thisCharacterComponent = m_Parent->GetComponent<CharacterComponent>();
 		if (!thisCharacterComponent) return false;
@@ -440,6 +444,7 @@ bool DestroyableComponent::IsEnemy(const Entity* other) const {
 }
 
 bool DestroyableComponent::IsFriend(const Entity* other) const {
+	if (IsFriendImplentation.ExecuteWithDefault(other, false)) return true;
 	const auto* otherDestroyableComponent = other->GetComponent<DestroyableComponent>();
 	if (otherDestroyableComponent != nullptr) {
 		for (const auto enemyFaction : m_EnemyFactionIDs) {

dGame/dComponents/DestroyableComponent.h

@@ -7,6 +7,7 @@
 #include "Entity.h"
 #include "Component.h"
 #include "eReplicaComponentType.h"
+#include "Implementation.h"
 
 namespace CppScripts {
 	class Script;
@@ -463,6 +464,9 @@ public:
 	// handle hardcode mode drops
 	void DoHardcoreModeDrops(const LWOOBJID source);
 
+	static Implementation<bool, const Entity*> IsEnemyImplentation;
+	static Implementation<bool, const Entity*> IsFriendImplentation;
+
 private:
 	/**
 	 * Whether or not the health should be serialized

dGame/dComponents/HavokVehiclePhysicsComponent.cpp

@@ -1,7 +1,7 @@
 #include "HavokVehiclePhysicsComponent.h"
 #include "EntityManager.h"
 
-HavokVehiclePhysicsComponent::HavokVehiclePhysicsComponent(Entity* parent) : PhysicsComponent(parent) {
+HavokVehiclePhysicsComponent::HavokVehiclePhysicsComponent(Entity* parent, int32_t componentId) : PhysicsComponent(parent, componentId) {
 	m_Velocity = NiPoint3Constant::ZERO;
 	m_AngularVelocity = NiPoint3Constant::ZERO;
 	m_IsOnGround = true;

dGame/dComponents/HavokVehiclePhysicsComponent.h

@@ -13,7 +13,7 @@ class HavokVehiclePhysicsComponent : public PhysicsComponent {
 public:
 	static constexpr eReplicaComponentType ComponentType = eReplicaComponentType::HAVOK_VEHICLE_PHYSICS;
 
-	HavokVehiclePhysicsComponent(Entity* parentEntity);
+	HavokVehiclePhysicsComponent(Entity* parentEntity, int32_t componentId);
 
 	void Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) override;
 

dGame/dComponents/InventoryComponent.cpp

@@ -31,6 +31,7 @@
 #include "eStateChangeType.h"
 #include "eUseItemResponse.h"
 #include "Mail.h"
+#include "ProximityMonitorComponent.h"
 
 #include "CDComponentsRegistryTable.h"
 #include "CDInventoryComponentTable.h"
@@ -68,9 +69,10 @@ InventoryComponent::InventoryComponent(Entity* parent) : Component(parent) {
 	auto slot = 0u;
 
 	for (const auto& item : items) {
-		if (!item.equip || !Inventory::IsValidItem(item.itemid)) {
-			continue;
-		}
+		if (!Inventory::IsValidItem(item.itemid)) continue;
+		AddItem(item.itemid, item.count);
+
+		if (!item.equip) continue;
 
 		const LWOOBJID id = ObjectIDManager::GenerateObjectID();
 
@@ -148,11 +150,11 @@ uint32_t InventoryComponent::GetLotCount(const LOT lot) const {
 	return count;
 }
 
-uint32_t InventoryComponent::GetLotCountNonTransfer(LOT lot) const {
+uint32_t InventoryComponent::GetLotCountNonTransfer(LOT lot, bool includeVault) const {
 	uint32_t count = 0;
 
 	for (const auto& inventory : m_Inventories) {
-		if (IsTransferInventory(inventory.second->GetType())) continue;
+		if (IsTransferInventory(inventory.second->GetType(), includeVault)) continue;
 
 		count += inventory.second->GetLotCount(lot);
 	}
@@ -272,7 +274,7 @@ void InventoryComponent::AddItem(
 
 			switch (sourceType) {
 			case 0:
-				Mail::SendMail(LWOOBJID_EMPTY, "Darkflame Universe", m_Parent, "Lost Reward", "You received an item and didn't have room for it.", lot, size);
+				Mail::SendMail(m_Parent, "%[MAIL_ACTIVITY_OVERFLOW_HEADER]", "%[MAIL_ACTIVITY_OVERFLOW_BODY]", lot, size);
 				break;
 
 			case 1:
@@ -303,21 +305,35 @@ bool InventoryComponent::RemoveItem(const LOT lot, const uint32_t count, eInvent
 		LOG("Attempted to remove 0 of item (%i) from the inventory!", lot);
 		return false;
 	}
-	if (inventoryType == INVALID) inventoryType = Inventory::FindInventoryTypeForLot(lot);
-	auto* inventory = GetInventory(inventoryType);
-	if (!inventory) return false;
+	if (inventoryType != eInventoryType::ALL) {
+		if (inventoryType == INVALID) inventoryType = Inventory::FindInventoryTypeForLot(lot);
+		auto* inventory = GetInventory(inventoryType);
+		if (!inventory) return false;
 
-	auto left = std::min<uint32_t>(count, inventory->GetLotCount(lot));
-	if (left != count) return false;
+		auto left = std::min<uint32_t>(count, inventory->GetLotCount(lot));
+		if (left != count) return false;
 
-	while (left > 0) {
-		auto* item = FindItemByLot(lot, inventoryType, false, ignoreBound);
-		if (!item) break;
-		const auto delta = std::min<uint32_t>(left, item->GetCount());
-		item->SetCount(item->GetCount() - delta, silent);
-		left -= delta;
+		while (left > 0) {
+			auto* item = FindItemByLot(lot, inventoryType, false, ignoreBound);
+			if (!item) break;
+			const auto delta = std::min<uint32_t>(left, item->GetCount());
+			item->SetCount(item->GetCount() - delta, silent);
+			left -= delta;
+		}
+		return true;
+	} else {
+		auto left = count;
+		for (const auto& inventory : m_Inventories | std::views::values) {
+			while (left > 0 && inventory->GetLotCount(lot) > 0) {
+				auto* item = inventory->FindItemByLot(lot, false, ignoreBound);
+				if (!item) break;
+				const auto delta = std::min<uint32_t>(item->GetCount(), left);
+				item->SetCount(item->GetCount() - delta, silent);
+				left -= delta;
+			}
+		}
+		return left == 0;
 	}
-	return true;
 }
 
 void InventoryComponent::MoveItemToInventory(Item* item, const eInventoryType inventory, const uint32_t count, const bool showFlyingLot, bool isModMoveAndEquip, const bool ignoreEquipped, const int32_t preferredSlot) {
@@ -829,6 +845,30 @@ void InventoryComponent::EquipItem(Item* item, const bool skipChecks) {
 				break;
 			}
 
+			return;
+		} else if (item->GetLot() == 8092) {
+			// Trying to equip a car
+			const auto proximityObjects = Game::entityManager->GetEntitiesByComponent(eReplicaComponentType::PROXIMITY_MONITOR);
+
+			// look for car instancers and check if we are in its setup range
+			for (auto* const entity : proximityObjects) {
+				if (!entity) continue;
+
+				auto* proximityMonitorComponent = entity->GetComponent<ProximityMonitorComponent>();
+				if (!proximityMonitorComponent) continue;
+
+				if (proximityMonitorComponent->IsInProximity("Interaction_Distance", m_Parent->GetObjectID())) {
+					// in the range of a car instancer
+					entity->OnUse(m_Parent);
+					GameMessages::UseItemOnClient itemMsg;
+					itemMsg.target = entity->GetObjectID();
+					itemMsg.itemLOT = item->GetLot();
+					itemMsg.itemToUse = item->GetId();
+					itemMsg.playerId = m_Parent->GetObjectID();
+					itemMsg.Send(m_Parent->GetSystemAddress());
+					break;
+				}
+			}
 			return;
 		}
 
@@ -1141,6 +1181,25 @@ void InventoryComponent::AddItemSkills(const LOT lot) {
 	SetSkill(slot, skill);
 }
 
+void InventoryComponent::FixInvisibleItems() {
+	const auto numberItemsLoadedPerFrame = 12.0f;
+	const auto callbackTime = 0.125f;
+	const auto arbitaryInventorySize = 300.0f; // max in live + dlu is less than 300, seems like a good number.
+	auto* const items = GetInventory(eInventoryType::ITEMS);
+	if (!items) return;
+
+	// Add an extra update to make sure the client can see all the items.
+	const auto something = static_cast<int32_t>(std::ceil(items->GetItems().size() / arbitaryInventorySize)) + 1;
+	LOG_DEBUG("Fixing invisible items with %i updates", something);
+
+	for (int32_t i = 1; i < something + 1; i++) {
+		// client loads 12 items every 1/8 seconds, we're adding a small hack to fix invisible inventory items due to closing the news screen too fast.
+		m_Parent->AddCallbackTimer((arbitaryInventorySize / numberItemsLoadedPerFrame) * callbackTime * i, [this]() {
+			GameMessages::SendUpdateInventoryUi(m_Parent->GetObjectID(), m_Parent->GetSystemAddress());
+			});
+	}
+}
+
 void InventoryComponent::RemoveItemSkills(const LOT lot) {
 	const auto info = Inventory::FindItemComponent(lot);
 
@@ -1273,8 +1332,8 @@ BehaviorSlot InventoryComponent::FindBehaviorSlot(const eItemType type) {
 	}
 }
 
-bool InventoryComponent::IsTransferInventory(eInventoryType type) {
-	return type == VENDOR_BUYBACK || type == VAULT_ITEMS || type == VAULT_MODELS || type == TEMP_ITEMS || type == TEMP_MODELS || type == MODELS_IN_BBB;
+bool InventoryComponent::IsTransferInventory(eInventoryType type, bool includeVault) {
+	return type == VENDOR_BUYBACK || (includeVault && (type == VAULT_ITEMS || type == VAULT_MODELS)) || type == TEMP_ITEMS || type == TEMP_MODELS || type == MODELS_IN_BBB;
 }
 
 uint32_t InventoryComponent::FindSkill(const LOT lot) {

dGame/dComponents/InventoryComponent.h

@@ -100,7 +100,7 @@ public:
 	 * @param lot the lot to search for
 	 * @return the amount of items this entity possesses of the specified lot
 	 */
-	uint32_t GetLotCountNonTransfer(LOT lot) const;
+	uint32_t GetLotCountNonTransfer(LOT lot, bool includeVault = true) const;
 
 	/**
 	 * Returns the items that are currently equipped by this entity
@@ -373,7 +373,7 @@ public:
 	 * @param type the inventory type to check
 	 * @return if the inventory type is a temp inventory
 	 */
-	static bool IsTransferInventory(eInventoryType type);
+	static bool IsTransferInventory(eInventoryType type, bool includeVault = true);
 
 	/**
 	 * Finds the skill related to the passed LOT from the ObjectSkills table
@@ -404,6 +404,8 @@ public:
 	void UpdateGroup(const GroupUpdate& groupUpdate);
 	void RemoveGroup(const std::string& groupId);
 
+	void FixInvisibleItems();
+
 	~InventoryComponent() override;
 
 private:

dGame/dComponents/MissionComponent.cpp

@@ -99,17 +99,8 @@ void MissionComponent::AcceptMission(const uint32_t missionId, const bool skipCh
 	mission->Accept();
 
 	this->m_Missions.insert_or_assign(missionId, mission);
-
-	if (missionId == 1728) {
-		//Needs to send a mail
-
-		auto address = m_Parent->GetSystemAddress();
-
-		Mail::HandleNotificationRequest(address, m_Parent->GetObjectID());
-	}
 }
 
-
 void MissionComponent::CompleteMission(const uint32_t missionId, const bool skipChecks, const bool yieldRewards) {
 	// Get the mission first
 	auto* mission = this->GetMission(missionId);
@@ -521,7 +512,7 @@ void MissionComponent::LoadFromXml(const tinyxml2::XMLDocument& doc) {
 
 		auto* mission = new Mission(this, missionId);
 
-		mission->LoadFromXml(*doneM);
+		mission->LoadFromXmlDone(*doneM);
 
 		doneM = doneM->NextSiblingElement();
 
@@ -536,9 +527,9 @@ void MissionComponent::LoadFromXml(const tinyxml2::XMLDocument& doc) {
 
 		currentM->QueryAttribute("id", &missionId);
 
-		auto* mission = new Mission(this, missionId);
+		auto* mission = m_Missions.contains(missionId) ? m_Missions[missionId] : new Mission(this, missionId);
 
-		mission->LoadFromXml(*currentM);
+		mission->LoadFromXmlCur(*currentM);
 
 		if (currentM->QueryAttribute("o", &missionOrder) == tinyxml2::XML_SUCCESS && mission->IsMission()) {
 			mission->SetUniqueMissionOrderID(missionOrder);
@@ -574,20 +565,23 @@ void MissionComponent::UpdateXml(tinyxml2::XMLDocument& doc) {
 		auto* mission = pair.second;
 
 		if (mission) {
-			const auto complete = mission->IsComplete();
+			const auto completions = mission->GetCompletions();
 
 			auto* m = doc.NewElement("m");
 
-			if (complete) {
-				mission->UpdateXml(*m);
+			if (completions > 0) {
+				mission->UpdateXmlDone(*m);
 
 				done->LinkEndChild(m);
 
-				continue;
+				if (mission->IsComplete()) continue;
+
+				m = doc.NewElement("m");
 			}
+
 			if (mission->IsMission()) m->SetAttribute("o", mission->GetUniqueMissionOrderID());
 
-			mission->UpdateXml(*m);
+			mission->UpdateXmlCur(*m);
 
 			cur->LinkEndChild(m);
 		}

dGame/dComponents/ModelComponent.cpp

@@ -7,6 +7,7 @@
 #include "BehaviorStates.h"
 #include "ControlBehaviorMsgs.h"
 #include "tinyxml2.h"
+#include "SimplePhysicsComponent.h"
 
 #include "Database.h"
 
@@ -95,12 +96,24 @@ void ModelComponent::AddBehavior(AddMessage& msg) {
 	for (auto& behavior : m_Behaviors) if (behavior.GetBehaviorId() == msg.GetBehaviorId()) return;
 	m_Behaviors.insert(m_Behaviors.begin() + msg.GetBehaviorIndex(), PropertyBehavior());
 	m_Behaviors.at(msg.GetBehaviorIndex()).HandleMsg(msg);
+	auto* const simplePhysComponent = m_Parent->GetComponent<SimplePhysicsComponent>();
+	if (simplePhysComponent) {
+		simplePhysComponent->SetPhysicsMotionState(1);
+		Game::entityManager->SerializeEntity(m_Parent);
+	}
 }
 
 void ModelComponent::MoveToInventory(MoveToInventoryMessage& msg) {
 	if (msg.GetBehaviorIndex() >= m_Behaviors.size() || m_Behaviors.at(msg.GetBehaviorIndex()).GetBehaviorId() != msg.GetBehaviorId()) return;
 	m_Behaviors.erase(m_Behaviors.begin() + msg.GetBehaviorIndex());
 	// TODO move to the inventory
+	if (m_Behaviors.empty()) {
+		auto* const simplePhysComponent = m_Parent->GetComponent<SimplePhysicsComponent>();
+		if (simplePhysComponent) {
+			simplePhysComponent->SetPhysicsMotionState(4);
+			Game::entityManager->SerializeEntity(m_Parent);
+		}
+	}
 }
 
 std::array<std::pair<int32_t, std::string>, 5> ModelComponent::GetBehaviorsForSave() const {

dGame/dComponents/ModelComponent.h

@@ -66,8 +66,8 @@ public:
 	template<typename Msg>
 	void HandleControlBehaviorsMsg(const AMFArrayValue& args) {
 		static_assert(std::is_base_of_v<BehaviorMessageBase, Msg>, "Msg must be a BehaviorMessageBase");
-		Msg msg(args);
-		for (auto& behavior : m_Behaviors) {
+		Msg msg{ args };
+		for (auto&& behavior : m_Behaviors) {
 			if (behavior.GetBehaviorId() == msg.GetBehaviorId()) { 
 				behavior.HandleMsg(msg);
 				return;

dGame/dComponents/MovementAIComponent.cpp

@@ -269,6 +269,7 @@ void MovementAIComponent::PullToPoint(const NiPoint3& point) {
 
 void MovementAIComponent::SetPath(std::vector<PathWaypoint> path) {
 	if (path.empty()) return;
+	while (!m_CurrentPath.empty()) m_CurrentPath.pop();
 	std::for_each(path.rbegin(), path.rend() - 1, [this](const PathWaypoint& point) {
 		this->m_CurrentPath.push(point);
 		});

dGame/dComponents/PetComponent.cpp

@@ -88,7 +88,7 @@ PetComponent::PetComponent(Entity* parentEntity, uint32_t componentId) : Compone
 	m_Ability = ePetAbilityType::Invalid;
 	m_StartPosition = NiPoint3Constant::ZERO;
 	m_MovementAI = nullptr;
-	m_TresureTime = 0;
+	m_TreasureTime = 0;
 
 	std::string checkPreconditions = GeneralUtils::UTF16ToWTF8(parentEntity->GetVar<std::u16string>(u"CheckPrecondition"));
 
@@ -319,27 +319,27 @@ void PetComponent::Update(float deltaTime) {
 		return;
 	}
 
-	if (m_TresureTime > 0) {
-		auto* tresure = Game::entityManager->GetEntity(m_Interaction);
+	if (m_TreasureTime > 0) {
+		auto* treasure = Game::entityManager->GetEntity(m_Interaction);
 
-		if (tresure == nullptr) {
-			m_TresureTime = 0;
+		if (treasure == nullptr) {
+			m_TreasureTime = 0;
 
 			return;
 		}
 
-		m_TresureTime -= deltaTime;
+		m_TreasureTime -= deltaTime;
 
 		m_MovementAI->Stop();
 
-		if (m_TresureTime <= 0) {
+		if (m_TreasureTime <= 0) {
 			m_Parent->SetOwnerOverride(m_Owner);
 
-			tresure->Smash(m_Parent->GetObjectID());
+			treasure->Smash(m_Parent->GetObjectID());
 
 			m_Interaction = LWOOBJID_EMPTY;
 
-			m_TresureTime = 0;
+			m_TreasureTime = 0;
 		}
 
 		return;
@@ -381,7 +381,7 @@ void PetComponent::Update(float deltaTime) {
 			float distance = Vector3::DistanceSquared(position, switchPosition);
 			if (distance < 3 * 3) {
 				m_Interaction = closestSwitch->GetParentEntity()->GetObjectID();
-				closestSwitch->EntityEnter(m_Parent);
+				closestSwitch->OnUse(m_Parent);
 			} else if (distance < 20 * 20) {
 				haltDistance = 1;
 
@@ -396,30 +396,30 @@ void PetComponent::Update(float deltaTime) {
 	// Determine if the "Lost Tags" mission has been completed and digging has been unlocked
 	const bool digUnlocked = missionComponent->GetMissionState(842) == eMissionState::COMPLETE;
 
-	Entity* closestTresure = PetDigServer::GetClosestTresure(position);
+	Entity* closestTreasure = PetDigServer::GetClosestTreasure(position);
 
-	if (closestTresure != nullptr && digUnlocked) {
+	if (closestTreasure != nullptr && digUnlocked) {
 		// Skeleton Dragon Pat special case for bone digging
-		if (closestTresure->GetLOT() == 12192 && m_Parent->GetLOT() != 13067) {
-			goto skipTresure;
+		if (closestTreasure->GetLOT() == 12192 && m_Parent->GetLOT() != 13067) {
+			goto skipTreasure;
 		}
 
-		NiPoint3 tresurePosition = closestTresure->GetPosition();
-		float distance = Vector3::DistanceSquared(position, tresurePosition);
+		NiPoint3 treasurePosition = closestTreasure->GetPosition();
+		float distance = Vector3::DistanceSquared(position, treasurePosition);
 		if (distance < 5 * 5) {
-			m_Interaction = closestTresure->GetObjectID();
+			m_Interaction = closestTreasure->GetObjectID();
 
 			Command(NiPoint3Constant::ZERO, LWOOBJID_EMPTY, 1, 202, true);
 
-			m_TresureTime = 2;
+			m_TreasureTime = 2;
 		} else if (distance < 10 * 10) {
 			haltDistance = 1;
 
-			destination = tresurePosition;
+			destination = treasurePosition;
 		}
 	}
 
-skipTresure:
+skipTreasure:
 
 	m_MovementAI->SetHaltDistance(haltDistance);
 
@@ -524,7 +524,7 @@ void PetComponent::NotifyTamingBuildSuccess(NiPoint3 position) {
 
 	GameMessages::SendRegisterPetDBID(m_Tamer, petSubKey, tamer->GetSystemAddress());
 
-	inventoryComponent->AddItem(m_Parent->GetLOT(), 1, eLootSourceType::ACTIVITY, eInventoryType::MODELS, {}, LWOOBJID_EMPTY, true, false, petSubKey);
+	inventoryComponent->AddItem(m_Parent->GetLOT(), 1, eLootSourceType::INVENTORY, eInventoryType::MODELS, {}, LWOOBJID_EMPTY, true, false, petSubKey);
 	auto* item = inventoryComponent->FindItemBySubKey(petSubKey, MODELS);
 
 	if (item == nullptr) {
@@ -795,8 +795,6 @@ void PetComponent::Wander() {
 }
 
 void PetComponent::Activate(Item* item, bool registerPet, bool fromTaming) {
-	AddDrainImaginationTimer(item, fromTaming);
-
 	m_ItemId = item->GetId();
 	m_DatabaseId = item->GetSubKey();
 
@@ -807,6 +805,7 @@ void PetComponent::Activate(Item* item, bool registerPet, bool fromTaming) {
 	inventoryComponent->DespawnPet();
 
 	m_Owner = inventoryComponent->GetParent()->GetObjectID();
+	AddDrainImaginationTimer(fromTaming);
 
 	auto* owner = GetOwner();
 
@@ -859,17 +858,14 @@ void PetComponent::Activate(Item* item, bool registerPet, bool fromTaming) {
 	}
 }
 
-void PetComponent::AddDrainImaginationTimer(Item* item, bool fromTaming) {
+void PetComponent::AddDrainImaginationTimer(bool fromTaming) {
 	if (Game::config->GetValue("pets_take_imagination") != "1") return;
 
-	auto playerInventory = item->GetInventory();
-	if (!playerInventory) return;
-
-	auto playerInventoryComponent = playerInventory->GetComponent();
-	if (!playerInventoryComponent) return;
-
-	auto playerEntity = playerInventoryComponent->GetParent();
-	if (!playerEntity) return;
+	auto* playerEntity = Game::entityManager->GetEntity(m_Owner);
+	if (!playerEntity) {
+		LOG("owner was null or didnt exist!");
+		return;
+	}
 
 	auto playerDestroyableComponent = playerEntity->GetComponent<DestroyableComponent>();
 	if (!playerDestroyableComponent) return;
@@ -878,12 +874,16 @@ void PetComponent::AddDrainImaginationTimer(Item* item, bool fromTaming) {
 	if (!fromTaming) playerDestroyableComponent->Imagine(-1);
 
 	// Set this to a variable so when this is called back from the player the timer doesn't fire off.
-	m_Parent->AddCallbackTimer(m_PetInfo.imaginationDrainRate, [playerDestroyableComponent, this, item]() {
-		if (!playerDestroyableComponent) {
-			LOG("No petComponent and/or no playerDestroyableComponent");
+	m_Parent->AddCallbackTimer(m_PetInfo.imaginationDrainRate, [this]() {
+		const auto* owner = Game::entityManager->GetEntity(m_Owner);
+		if (!owner) {
+			LOG("owner was null or didnt exist!");
 			return;
 		}
 
+		const auto* playerDestroyableComponent = owner->GetComponent<DestroyableComponent>();
+		if (!playerDestroyableComponent) return;
+
 		// If we are out of imagination despawn the pet.
 		if (playerDestroyableComponent->GetImagination() == 0) {
 			this->Deactivate();
@@ -893,15 +893,13 @@ void PetComponent::AddDrainImaginationTimer(Item* item, bool fromTaming) {
 			GameMessages::SendUseItemRequirementsResponse(playerEntity->GetObjectID(), playerEntity->GetSystemAddress(), eUseItemResponse::NoImaginationForPet);
 		}
 
-		this->AddDrainImaginationTimer(item);
+		this->AddDrainImaginationTimer();
 		});
 }
 
 void PetComponent::Deactivate() {
 	GameMessages::SendPlayFXEffect(m_Parent->GetObjectID(), -1, u"despawn", "", LWOOBJID_EMPTY, 1, 1, true);
 
-	GameMessages::SendMarkInventoryItemAsActive(m_Owner, false, eUnequippableActiveType::PET, m_ItemId, GetOwner()->GetSystemAddress());
-
 	activePets.erase(m_Owner);
 
 	m_Parent->Kill();
@@ -910,6 +908,8 @@ void PetComponent::Deactivate() {
 
 	if (owner == nullptr) return;
 
+	GameMessages::SendMarkInventoryItemAsActive(m_Owner, false, eUnequippableActiveType::PET, m_ItemId, owner->GetSystemAddress());
+
 	GameMessages::SendAddPetToPlayer(m_Owner, 0, u"", LWOOBJID_EMPTY, LOT_NULL, owner->GetSystemAddress());
 
 	GameMessages::SendRegisterPetID(m_Owner, LWOOBJID_EMPTY, owner->GetSystemAddress());
@@ -1034,6 +1034,7 @@ Entity* PetComponent::GetParentEntity() const {
 }
 
 PetComponent::~PetComponent() {
+	m_Owner = LWOOBJID_EMPTY;
 }
 
 void PetComponent::SetPetNameForModeration(const std::string& petName) {

dGame/dComponents/PetComponent.h

@@ -205,7 +205,7 @@ public:
 	 *
 	 * @param item The item that represents this pet in the inventory.
 	 */
-	void AddDrainImaginationTimer(Item* item, bool fromTaming = false);
+	void AddDrainImaginationTimer(bool fromTaming = false);
 
 private:
 
@@ -329,7 +329,7 @@ private:
 	 * Timer that tracks how long a pet has been digging up some treasure, required to spawn the treasure contents
 	 * on time
 	 */
-	float m_TresureTime;
+	float m_TreasureTime;
 
 	/**
 	 * The position that this pet was spawned at

dGame/dComponents/PhantomPhysicsComponent.cpp

@@ -27,7 +27,7 @@
 #include "dpShapeBox.h"
 #include "dpShapeSphere.h"
 
-PhantomPhysicsComponent::PhantomPhysicsComponent(Entity* parent) : PhysicsComponent(parent) {
+PhantomPhysicsComponent::PhantomPhysicsComponent(Entity* parent, int32_t componentId) : PhysicsComponent(parent, componentId) {
 	m_Position = m_Parent->GetDefaultPosition();
 	m_Rotation = m_Parent->GetDefaultRotation();
 	m_Scale = m_Parent->GetDefaultScale();

dGame/dComponents/PhantomPhysicsComponent.h

@@ -30,7 +30,7 @@ class PhantomPhysicsComponent final : public PhysicsComponent {
 public:
 	static constexpr eReplicaComponentType ComponentType = eReplicaComponentType::PHANTOM_PHYSICS;
 
-	PhantomPhysicsComponent(Entity* parent);
+	PhantomPhysicsComponent(Entity* parent, int32_t componentId);
 	~PhantomPhysicsComponent() override;
 	void Update(float deltaTime) override;
 	void Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) override;

dGame/dComponents/PhysicsComponent.cpp

@@ -14,10 +14,21 @@
 
 #include "EntityInfo.h"
 
-PhysicsComponent::PhysicsComponent(Entity* parent) : Component(parent) {
+PhysicsComponent::PhysicsComponent(Entity* parent, int32_t componentId) : Component(parent) {
 	m_Position = NiPoint3Constant::ZERO;
 	m_Rotation = NiQuaternionConstant::IDENTITY;
 	m_DirtyPosition = false;
+
+	CDPhysicsComponentTable* physicsComponentTable = CDClientManager::GetTable<CDPhysicsComponentTable>();
+
+	if (physicsComponentTable) {
+		auto* info = physicsComponentTable->GetByID(componentId);
+		if (info) {
+			m_CollisionGroup = info->collisionGroup;
+		}
+	}
+
+	if (m_Parent->HasVar(u"CollisionGroupID")) m_CollisionGroup = m_Parent->GetVar<int32_t>(u"CollisionGroupID");
 }
 
 void PhysicsComponent::Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) {
@@ -73,7 +84,12 @@ dpEntity* PhysicsComponent::CreatePhysicsEntity(eReplicaComponentType type) {
 	} else if (info->physicsAsset == "env\\env_won_fv_gas-blocking-volume.hkx") {
 		toReturn = new dpEntity(m_Parent->GetObjectID(), 390.496826f, 111.467964f, 600.821534f, true);
 		m_Position.y -= (111.467964f * m_Parent->GetDefaultScale()) / 2;
-	} else {
+		// Leaving these out for now since they cause more issues than they solve in racing tracks without proper OBB checks.
+	} /* else if (info->physicsAsset == "env\\GFTrack_DeathVolume1_CaveExit.hkx") {
+		toReturn = new dpEntity(m_Parent->GetObjectID(), 112.416870f, 50.363434f, 87.679268f);
+	} else if (info->physicsAsset == "env\\GFTrack_DeathVolume2_RoadGaps.hkx") {
+		toReturn = new dpEntity(m_Parent->GetObjectID(), 48.386536f, 50.363434f, 259.361755f);
+	} */ else {
 		// LOG_DEBUG("This one is supposed to have %s", info->physicsAsset.c_str());
 
 		//add fallback cube:

dGame/dComponents/PhysicsComponent.h

@@ -15,7 +15,7 @@ class dpEntity;
 
 class PhysicsComponent : public Component {
 public:
-	PhysicsComponent(Entity* parent);
+	PhysicsComponent(Entity* parent, int32_t componentId);
 	virtual ~PhysicsComponent() = default;
 
 	void Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) override;
@@ -25,6 +25,9 @@ public:
 
 	const NiQuaternion& GetRotation() const { return m_Rotation; }
 	virtual void SetRotation(const NiQuaternion& rot) { if (m_Rotation == rot) return; m_Rotation = rot; m_DirtyPosition = true; }
+
+	int32_t GetCollisionGroup() const noexcept { return m_CollisionGroup; }
+	void SetCollisionGroup(int32_t group) noexcept { m_CollisionGroup = group; }
 protected:
 	dpEntity* CreatePhysicsEntity(eReplicaComponentType type);
 
@@ -37,6 +40,8 @@ protected:
 	NiQuaternion m_Rotation;
 
 	bool m_DirtyPosition;
+
+	int32_t m_CollisionGroup{};
 };
 
 #endif  //!__PHYSICSCOMPONENT__H__

dGame/dComponents/PossessableComponent.h

@@ -5,7 +5,7 @@
 #include "Component.h"
 #include "Item.h"
 #include "PossessorComponent.h"
-#include "eAninmationFlags.h"
+#include "eAnimationFlags.h"
 #include "eReplicaComponentType.h"
 
 /**

dGame/dComponents/PropertyEntranceComponent.cpp

@@ -14,6 +14,8 @@
 #include "Amf3.h"
 #include "eObjectBits.h"
 #include "eGameMasterLevel.h"
+#include "ePropertySortType.h"
+#include "User.h"
 
 PropertyEntranceComponent::PropertyEntranceComponent(Entity* parent, uint32_t componentID) : Component(parent) {
 	this->propertyQueries = {};
@@ -74,261 +76,103 @@ void PropertyEntranceComponent::OnEnterProperty(Entity* entity, uint32_t index,
 	launcher->Launch(entity, launcher->GetTargetZone(), cloneId);
 }
 
-PropertySelectQueryProperty PropertyEntranceComponent::SetPropertyValues(PropertySelectQueryProperty property, LWOCLONEID cloneId, std::string ownerName, std::string propertyName, std::string propertyDescription, float reputation, bool isBFF, bool isFriend, bool isModeratorApproved, bool isAlt, bool isOwned, uint32_t privacyOption, uint32_t timeLastUpdated, float performanceCost) {
-	property.CloneId = cloneId;
-	property.OwnerName = ownerName;
-	property.Name = propertyName;
-	property.Description = propertyDescription;
-	property.Reputation = reputation;
-	property.IsBestFriend = isBFF;
-	property.IsFriend = isFriend;
-	property.IsModeratorApproved = isModeratorApproved;
-	property.IsAlt = isAlt;
-	property.IsOwned = isOwned;
-	property.AccessType = privacyOption;
-	property.DateLastPublished = timeLastUpdated;
-	property.PerformanceCost = performanceCost;
-
-	return property;
-}
-
-std::string PropertyEntranceComponent::BuildQuery(Entity* entity, int32_t sortMethod, Character* character, std::string customQuery, bool wantLimits) {
-	std::string base;
-	if (customQuery == "") {
-		base = baseQueryForProperties;
-	} else {
-		base = customQuery;
-	}
-	std::string orderBy = "";
-	if (sortMethod == SORT_TYPE_FEATURED || sortMethod == SORT_TYPE_FRIENDS) {
-		std::string friendsList = " AND p.owner_id IN (";
-
-		auto friendsListQuery = Database::Get()->CreatePreppedStmt("SELECT * FROM (SELECT CASE WHEN player_id = ? THEN friend_id WHEN friend_id = ? THEN player_id END AS requested_player FROM friends ) AS fr WHERE requested_player IS NOT NULL ORDER BY requested_player DESC;");
-
-		friendsListQuery->setUInt(1, character->GetID());
-		friendsListQuery->setUInt(2, character->GetID());
-
-		auto friendsListQueryResult = friendsListQuery->executeQuery();
-
-		while (friendsListQueryResult->next()) {
-			auto playerIDToConvert = friendsListQueryResult->getInt(1);
-			friendsList = friendsList + std::to_string(playerIDToConvert) + ",";
-		}
-		// Replace trailing comma with the closing parenthesis.
-		if (friendsList.at(friendsList.size() - 1) == ',') friendsList.erase(friendsList.size() - 1, 1);
-		friendsList += ") ";
-
-		// If we have no friends then use a -1 for the query.
-		if (friendsList.find("()") != std::string::npos) friendsList = " AND p.owner_id IN (-1) ";
-
-		orderBy += friendsList + "ORDER BY ci.name ASC ";
-
-		delete friendsListQueryResult;
-		friendsListQueryResult = nullptr;
-
-		delete friendsListQuery;
-		friendsListQuery = nullptr;
-	} else if (sortMethod == SORT_TYPE_RECENT) {
-		orderBy = "ORDER BY p.last_updated DESC ";
-	} else if (sortMethod == SORT_TYPE_REPUTATION) {
-		orderBy = "ORDER BY p.reputation DESC, p.last_updated DESC ";
-	} else {
-		orderBy = "ORDER BY p.last_updated DESC ";
-	}
-	return base + orderBy + (wantLimits ? "LIMIT ? OFFSET ?;" : ";");
-}
-
 void PropertyEntranceComponent::OnPropertyEntranceSync(Entity* entity, bool includeNullAddress, bool includeNullDescription, bool playerOwn, bool updateUi, int32_t numResults, int32_t lReputationTime, int32_t sortMethod, int32_t startIndex, std::string filterText, const SystemAddress& sysAddr) {
-
-	std::vector<PropertySelectQueryProperty> entries{};
-	PropertySelectQueryProperty playerEntry{};
-
-	auto character = entity->GetCharacter();
+	const auto* const character = entity->GetCharacter();
 	if (!character) return;
+	const auto* const user = character->GetParentUser();
+	if (!user) return;
 
+	auto& entries = propertyQueries[entity->GetObjectID()];
+	entries.clear();
 	// Player property goes in index 1 of the vector.  This is how the client expects it.
-	auto playerPropertyLookup = Database::Get()->CreatePreppedStmt("SELECT * FROM properties WHERE owner_id = ? AND zone_id = ?");
-
-	playerPropertyLookup->setInt(1, character->GetID());
-	playerPropertyLookup->setInt(2, this->m_MapID);
-
-	auto playerPropertyLookupResults = playerPropertyLookup->executeQuery();
+	const auto playerProperty = Database::Get()->GetPropertyInfo(m_MapID, character->GetPropertyCloneID());
 
 	// If the player has a property this query will have a single result.
-	if (playerPropertyLookupResults->next()) {
-		const auto cloneId = playerPropertyLookupResults->getUInt64(4);
-		const auto propertyName = std::string(playerPropertyLookupResults->getString(5).c_str());
-		const auto propertyDescription = std::string(playerPropertyLookupResults->getString(6).c_str());
-		const auto privacyOption = playerPropertyLookupResults->getInt(9);
-		const auto modApproved = playerPropertyLookupResults->getBoolean(10);
-		const auto dateLastUpdated = playerPropertyLookupResults->getInt64(11);
-		const auto reputation = playerPropertyLookupResults->getUInt(14);
-		const auto performanceCost = playerPropertyLookupResults->getFloat(16);
-
-		playerEntry = SetPropertyValues(playerEntry, cloneId, character->GetName(), propertyName, propertyDescription, reputation, true, true, modApproved, true, true, privacyOption, dateLastUpdated, performanceCost);
+	auto& playerEntry = entries.emplace_back();
+	if (playerProperty.has_value()) {
+		playerEntry.OwnerName = character->GetName();
+		playerEntry.IsBestFriend = true;
+		playerEntry.IsFriend = true;
+		playerEntry.IsAlt = true;
+		playerEntry.IsOwned = true;
+		playerEntry.CloneId = playerProperty->cloneId;
+		playerEntry.Name = playerProperty->name;
+		playerEntry.Description = playerProperty->description;
+		playerEntry.AccessType = playerProperty->privacyOption;
+		playerEntry.IsModeratorApproved = playerProperty->modApproved;
+		playerEntry.DateLastPublished = playerProperty->lastUpdatedTime;
+		playerEntry.Reputation = playerProperty->reputation;
+		playerEntry.PerformanceCost = playerProperty->performanceCost;
+		auto& entry = playerEntry;
 	} else {
-		playerEntry = SetPropertyValues(playerEntry, character->GetPropertyCloneID(), character->GetName(), "", "", 0, true, true);
+		playerEntry.OwnerName = character->GetName();
+		playerEntry.IsBestFriend = true;
+		playerEntry.IsFriend = true;
+		playerEntry.IsAlt = false;
+		playerEntry.IsOwned = false;
+		playerEntry.CloneId = character->GetPropertyCloneID();
+		playerEntry.Name = "";
+		playerEntry.Description = "";
+		playerEntry.AccessType = 0;
+		playerEntry.IsModeratorApproved = false;
+		playerEntry.DateLastPublished = 0;
+		playerEntry.Reputation = 0;
+		playerEntry.PerformanceCost = 0.0f;
 	}
 
-	delete playerPropertyLookupResults;
-	playerPropertyLookupResults = nullptr;
+	IProperty::PropertyLookup propertyLookup;
+	propertyLookup.mapId = m_MapID;
+	propertyLookup.searchString = filterText;
+	propertyLookup.sortChoice = static_cast<ePropertySortType>(sortMethod);
+	propertyLookup.playerSort = static_cast<uint32_t>(sortMethod == SORT_TYPE_FEATURED || sortMethod == SORT_TYPE_FRIENDS ? PropertyPrivacyOption::Friends : PropertyPrivacyOption::Public);
+	propertyLookup.playerId = character->GetID();
+	propertyLookup.numResults = numResults;
+	propertyLookup.startIndex = startIndex;
 
-	delete playerPropertyLookup;
-	playerPropertyLookup = nullptr;
-
-	entries.push_back(playerEntry);
-
-	const auto query = BuildQuery(entity, sortMethod, character);
-
-	auto propertyLookup = Database::Get()->CreatePreppedStmt(query);
-
-	const auto searchString = "%" + filterText + "%";
-	propertyLookup->setUInt(1, this->m_MapID);
-	propertyLookup->setString(2, searchString.c_str());
-	propertyLookup->setString(3, searchString.c_str());
-	propertyLookup->setString(4, searchString.c_str());
-	propertyLookup->setInt(5, sortMethod == SORT_TYPE_FEATURED || sortMethod == SORT_TYPE_FRIENDS ? static_cast<uint32_t>(PropertyPrivacyOption::Friends) : static_cast<uint32_t>(PropertyPrivacyOption::Public));
-	propertyLookup->setInt(6, numResults);
-	propertyLookup->setInt(7, startIndex);
-
-	auto propertyEntry = propertyLookup->executeQuery();
-
-	while (propertyEntry->next()) {
-		const auto propertyId = propertyEntry->getUInt64(1);
-		const auto owner = propertyEntry->getInt(2);
-		const auto cloneId = propertyEntry->getUInt64(4);
-		const auto propertyNameFromDb = std::string(propertyEntry->getString(5).c_str());
-		const auto propertyDescriptionFromDb = std::string(propertyEntry->getString(6).c_str());
-		const auto privacyOption = propertyEntry->getInt(9);
-		const auto modApproved = propertyEntry->getBoolean(10);
-		const auto dateLastUpdated = propertyEntry->getInt(11);
-		const float reputation = propertyEntry->getInt(14);
-		const auto performanceCost = propertyEntry->getFloat(16);
-
-		PropertySelectQueryProperty entry{};
-
-		std::string ownerName = "";
-		bool isOwned = true;
-		auto nameLookup = Database::Get()->CreatePreppedStmt("SELECT name FROM charinfo WHERE prop_clone_id = ?;");
-
-		nameLookup->setUInt64(1, cloneId);
-
-		auto nameResult = nameLookup->executeQuery();
-
-		if (!nameResult->next()) {
-			delete nameLookup;
-			nameLookup = nullptr;
-
-			LOG("Failed to find property owner name for %llu!", cloneId);
+	const auto lookupResult = Database::Get()->GetProperties(propertyLookup);
 
+	for (const auto& propertyEntry : lookupResult->entries) {
+		const auto owner = propertyEntry.ownerId;
+		const auto otherCharacter = Database::Get()->GetCharacterInfo(owner);
+		if (!otherCharacter.has_value()) {
+			LOG("Failed to find property owner name for %u!", owner);
 			continue;
-		} else {
-			isOwned = cloneId == character->GetPropertyCloneID();
-			ownerName = std::string(nameResult->getString(1).c_str());
 		}
+		auto& entry = entries.emplace_back();
 
-		delete nameResult;
-		nameResult = nullptr;
-
-		delete nameLookup;
-		nameLookup = nullptr;
-
-		std::string propertyName = propertyNameFromDb;
-		std::string propertyDescription = propertyDescriptionFromDb;
-
-		bool isBestFriend = false;
-		bool isFriend = false;
-
-		// Convert owner char id to LWOOBJID
-		LWOOBJID ownerObjId = owner;
-		GeneralUtils::SetBit(ownerObjId, eObjectBits::CHARACTER);
-		GeneralUtils::SetBit(ownerObjId, eObjectBits::PERSISTENT);
-
+		entry.IsOwned = entry.CloneId == otherCharacter->cloneId;
+		entry.OwnerName = otherCharacter->name;
+		entry.CloneId = propertyEntry.cloneId;
+		entry.Name = propertyEntry.name;
+		entry.Description = propertyEntry.description;
+		entry.AccessType = propertyEntry.privacyOption;
+		entry.IsModeratorApproved = propertyEntry.modApproved;
+		entry.DateLastPublished = propertyEntry.lastUpdatedTime;
+		entry.Reputation = propertyEntry.reputation;
+		entry.PerformanceCost = propertyEntry.performanceCost;
+		entry.IsBestFriend = false;
+		entry.IsFriend = false;
 		// Query to get friend and best friend fields
-		auto friendCheck = Database::Get()->CreatePreppedStmt("SELECT best_friend FROM friends WHERE (player_id = ? AND friend_id = ?) OR (player_id = ? AND friend_id = ?)");
-
-		friendCheck->setUInt(1, character->GetID());
-		friendCheck->setUInt(2, ownerObjId);
-		friendCheck->setUInt(3, ownerObjId);
-		friendCheck->setUInt(4, character->GetID());
-
-		auto friendResult = friendCheck->executeQuery();
-
+		const auto friendCheck = Database::Get()->GetBestFriendStatus(character->GetID(), owner);
 		// If we got a result than the two players are friends.
-		if (friendResult->next()) {
-			isFriend = true;
-			if (friendResult->getInt(1) == 3) {
-				isBestFriend = true;
-			}
+		if (friendCheck.has_value()) {
+			entry.IsFriend = true;
+			entry.IsBestFriend = friendCheck->bestFriendStatus == 3;
 		}
 
-		delete friendCheck;
-		friendCheck = nullptr;
-
-		delete friendResult;
-		friendResult = nullptr;
-
-		bool isModeratorApproved = propertyEntry->getBoolean(10);
-
-		if (!isModeratorApproved && entity->GetGMLevel() >= eGameMasterLevel::LEAD_MODERATOR) {
-			propertyName = "[AWAITING APPROVAL]";
-			propertyDescription = "[AWAITING APPROVAL]";
-			isModeratorApproved = true;
+		if (!entry.IsModeratorApproved && entity->GetGMLevel() >= eGameMasterLevel::LEAD_MODERATOR) {
+			entry.Name = "[AWAITING APPROVAL]";
+			entry.Description = "[AWAITING APPROVAL]";
+			entry.IsModeratorApproved = true;
 		}
 
-		bool isAlt = false;
 		// Query to determine whether this property is an alt character of the entity.
-		auto isAltQuery = Database::Get()->CreatePreppedStmt("SELECT id FROM charinfo where account_id in (SELECT account_id from charinfo WHERE id = ?) AND id = ?;");
-
-		isAltQuery->setInt(1, character->GetID());
-		isAltQuery->setInt(2, owner);
-
-		auto isAltQueryResults = isAltQuery->executeQuery();
-
-		if (isAltQueryResults->next()) {
-			isAlt = true;
+		for (const auto charid : Database::Get()->GetAccountCharacterIds(user->GetAccountID())) {
+			entry.IsAlt = charid == owner;
+			if (entry.IsAlt) break;
 		}
-
-		delete isAltQueryResults;
-		isAltQueryResults = nullptr;
-
-		delete isAltQuery;
-		isAltQuery = nullptr;
-
-		entry = SetPropertyValues(entry, cloneId, ownerName, propertyName, propertyDescription, reputation, isBestFriend, isFriend, isModeratorApproved, isAlt, isOwned, privacyOption, dateLastUpdated, performanceCost);
-
-		entries.push_back(entry);
 	}
 
-	delete propertyEntry;
-	propertyEntry = nullptr;
-
-	delete propertyLookup;
-	propertyLookup = nullptr;
-
-	propertyQueries[entity->GetObjectID()] = entries;
-
 	// Query here is to figure out whether or not to display the button to go to the next page or not.
-	int32_t numberOfProperties = 0;
-
-	auto buttonQuery = BuildQuery(entity, sortMethod, character, "SELECT COUNT(*) FROM properties as p JOIN charinfo as ci ON ci.prop_clone_id = p.clone_id where p.zone_id = ? AND (p.description LIKE ? OR p.name LIKE ? OR ci.name LIKE ?) AND p.privacy_option >= ? ", false);
-	auto propertiesLeft = Database::Get()->CreatePreppedStmt(buttonQuery);
-
-	propertiesLeft->setUInt(1, this->m_MapID);
-	propertiesLeft->setString(2, searchString.c_str());
-	propertiesLeft->setString(3, searchString.c_str());
-	propertiesLeft->setString(4, searchString.c_str());
-	propertiesLeft->setInt(5, sortMethod == SORT_TYPE_FEATURED || sortMethod == SORT_TYPE_FRIENDS ? 1 : 2);
-
-	auto result = propertiesLeft->executeQuery();
-	result->next();
-	numberOfProperties = result->getInt(1);
-
-	delete result;
-	result = nullptr;
-
-	delete propertiesLeft;
-	propertiesLeft = nullptr;
-
-	GameMessages::SendPropertySelectQuery(m_Parent->GetObjectID(), startIndex, numberOfProperties - (startIndex + numResults) > 0, character->GetPropertyCloneID(), false, true, entries, sysAddr);
+	GameMessages::SendPropertySelectQuery(m_Parent->GetObjectID(), startIndex, lookupResult->totalEntriesMatchingQuery - (startIndex + numResults) > 0, character->GetPropertyCloneID(), false, true, entries, sysAddr);
 }

dGame/dComponents/PropertyEntranceComponent.h

@@ -57,11 +57,7 @@ public:
 	 * Returns the map ID for this property
 	 * @return the map ID for this property
 	 */
-	[[nodiscard]] LWOMAPID GetMapID() const { return m_MapID; };
-
-	PropertySelectQueryProperty SetPropertyValues(PropertySelectQueryProperty property, LWOCLONEID cloneId = LWOCLONEID_INVALID, std::string ownerName = "", std::string propertyName = "", std::string propertyDescription = "", float reputation = 0, bool isBFF = false, bool isFriend = false, bool isModeratorApproved = false, bool isAlt = false, bool isOwned = false, uint32_t privacyOption = 0, uint32_t timeLastUpdated = 0, float performanceCost = 0.0f);
-
-	std::string BuildQuery(Entity* entity, int32_t sortMethod, Character* character, std::string customQuery = "", bool wantLimits = true);
+	[[nodiscard]] LWOMAPID GetMapID() const noexcept { return m_MapID; };
 
 private:
 	/**
@@ -78,13 +74,4 @@ private:
 	 * The base map ID for this property (Avant Grove, etc).
 	 */
 	LWOMAPID m_MapID;
-
-	enum ePropertySortType : int32_t {
-		SORT_TYPE_FRIENDS = 0,
-		SORT_TYPE_REPUTATION = 1,
-		SORT_TYPE_RECENT = 3,
-		SORT_TYPE_FEATURED = 5
-	};
-
-	std::string baseQueryForProperties = "SELECT p.* FROM properties as p JOIN charinfo as ci ON ci.prop_clone_id = p.clone_id where p.zone_id = ? AND (p.description LIKE ? OR p.name LIKE ? OR ci.name LIKE ?) AND p.privacy_option >= ? ";
 };

dGame/dComponents/ProximityMonitorComponent.cpp

@@ -38,7 +38,7 @@ void ProximityMonitorComponent::SetProximityRadius(dpEntity* entity, const std::
 	m_ProximitiesData.insert(std::make_pair(name, entity));
 }
 
-const std::unordered_set<LWOOBJID>& ProximityMonitorComponent::GetProximityObjects(const std::string& name) {
+const std::unordered_set<LWOOBJID>& ProximityMonitorComponent::GetProximityObjects(const std::string& name) const {
 	const auto iter = m_ProximitiesData.find(name);
 
 	if (iter == m_ProximitiesData.cend()) {

dGame/dComponents/ProximityMonitorComponent.h

@@ -46,7 +46,7 @@ public:
 	 * @param name the proximity name to retrieve physics objects for
 	 * @return a set of physics entity object IDs for this name
 	 */
-	const std::unordered_set<LWOOBJID>& GetProximityObjects(const std::string& name);
+	const std::unordered_set<LWOOBJID>& GetProximityObjects(const std::string& name) const;
 
 	/**
 	 * Checks if the passed object is in proximity of the named proximity sensor

dGame/dComponents/QuickBuildComponent.cpp

@@ -65,14 +65,7 @@ void QuickBuildComponent::Serialize(RakNet::BitStream& outBitStream, bool bIsIni
 
 		outBitStream.Write(false);
 	}
-	// If build state is completed and we've already serialized once in the completed state,
-	// don't serializing this component anymore as this will cause the build to jump again.
-	// If state changes, serialization will begin again.
-	if (!m_StateDirty && m_State == eQuickBuildState::COMPLETED) {
-		outBitStream.Write0();
-		outBitStream.Write0();
-		return;
-	}
+
 	// BEGIN Scripted Activity
 	outBitStream.Write1();
 
@@ -90,36 +83,27 @@ void QuickBuildComponent::Serialize(RakNet::BitStream& outBitStream, bool bIsIni
 	}
 	// END Scripted Activity
 
-	outBitStream.Write1();
+	outBitStream.Write(m_StateDirty || bIsInitialUpdate);
+	if (m_StateDirty || bIsInitialUpdate) {
+		outBitStream.Write(m_State);
 
-	outBitStream.Write(m_State);
+		outBitStream.Write(m_ShowResetEffect);
+		outBitStream.Write(m_Activator != nullptr);
 
-	outBitStream.Write(m_ShowResetEffect);
-	outBitStream.Write(m_Activator != nullptr);
+		outBitStream.Write(m_Timer);
+		outBitStream.Write(m_TimerIncomplete);
 
-	outBitStream.Write(m_Timer);
-	outBitStream.Write(m_TimerIncomplete);
-
-	if (bIsInitialUpdate) {
-		outBitStream.Write(false);
-		outBitStream.Write(m_ActivatorPosition);
-		outBitStream.Write(m_RepositionPlayer);
+		if (bIsInitialUpdate) {
+			outBitStream.Write(false); // IsChoiceBuild
+			outBitStream.Write(m_ActivatorPosition);
+			outBitStream.Write(m_RepositionPlayer);
+		}
+		m_StateDirty = false;
 	}
-	m_StateDirty = false;
 }
 
 void QuickBuildComponent::Update(float deltaTime) {
-	m_Activator = GetActivator();
-
-	// Serialize the quickbuild every so often, fixes the odd bug where the quickbuild is not buildable
-	/*if (m_SoftTimer > 0.0f) {
-		m_SoftTimer -= deltaTime;
-	}
-	else {
-		m_SoftTimer = 5.0f;
-
-		Game::entityManager->SerializeEntity(m_Parent);
-	}*/
+	SetActivator(GetActivator());
 
 	switch (m_State) {
 	case eQuickBuildState::OPEN: {
@@ -130,12 +114,12 @@ void QuickBuildComponent::Update(float deltaTime) {
 		const bool isSmashGroup = spawner != nullptr ? spawner->GetIsSpawnSmashGroup() : false;
 
 		if (isSmashGroup) {
-			m_TimerIncomplete += deltaTime;
+			ModifyIncompleteTimer(deltaTime);
 
 			// For reset times < 0 this has to be handled manually
 			if (m_TimeBeforeSmash > 0) {
-				if (m_TimerIncomplete >= m_TimeBeforeSmash - 4.0f) {
-					m_ShowResetEffect = true;
+				if (m_TimerIncomplete >= m_TimeBeforeSmash - 4.0f && !m_ShowResetEffect) {
+					SetShowResetEffect(true);
 
 					Game::entityManager->SerializeEntity(m_Parent);
 				}
@@ -153,21 +137,19 @@ void QuickBuildComponent::Update(float deltaTime) {
 		break;
 	}
 	case eQuickBuildState::COMPLETED: {
-		m_Timer += deltaTime;
+		ModifyTimer(deltaTime);
 
 		// For reset times < 0 this has to be handled manually
 		if (m_ResetTime > 0) {
-			if (m_Timer >= m_ResetTime - 4.0f) {
-				if (!m_ShowResetEffect) {
-					m_ShowResetEffect = true;
+			if (m_Timer >= m_ResetTime - 4.0f && !m_ShowResetEffect) {
+				SetShowResetEffect(true);
 
-					Game::entityManager->SerializeEntity(m_Parent);
-				}
+				Game::entityManager->SerializeEntity(m_Parent);
 			}
 
 			if (m_Timer >= m_ResetTime) {
 
-				GameMessages::SendDieNoImplCode(m_Parent, LWOOBJID_EMPTY, LWOOBJID_EMPTY, eKillType::VIOLENT, u"", 0.0f, 0.0f, 0.0f, false, true);
+				GameMessages::SendDieNoImplCode(m_Parent, LWOOBJID_EMPTY, LWOOBJID_EMPTY, eKillType::VIOLENT, u"", 0.0f, 0.0f, 7.0f, false, true);
 
 				ResetQuickBuild(false);
 			}
@@ -185,9 +167,9 @@ void QuickBuildComponent::Update(float deltaTime) {
 		}
 
 		m_TimeBeforeDrain -= deltaTime;
-		m_Timer += deltaTime;
-		m_TimerIncomplete = 0;
-		m_ShowResetEffect = false;
+		ModifyTimer(deltaTime);
+		SetIncompleteTimer(0.0f);
+		SetShowResetEffect(false);
 
 		if (m_TimeBeforeDrain <= 0.0f) {
 			m_TimeBeforeDrain = m_CompleteTime / static_cast<float>(m_TakeImagination);
@@ -215,12 +197,12 @@ void QuickBuildComponent::Update(float deltaTime) {
 		break;
 	}
 	case eQuickBuildState::INCOMPLETE: {
-		m_TimerIncomplete += deltaTime;
+		ModifyIncompleteTimer(deltaTime);
 
 		// For reset times < 0 this has to be handled manually
 		if (m_TimeBeforeSmash > 0) {
-			if (m_TimerIncomplete >= m_TimeBeforeSmash - 4.0f) {
-				m_ShowResetEffect = true;
+			if (m_TimerIncomplete >= m_TimeBeforeSmash - 4.0f && !m_ShowResetEffect) {
+				SetShowResetEffect(true);
 
 				Game::entityManager->SerializeEntity(m_Parent);
 			}
@@ -260,7 +242,7 @@ void QuickBuildComponent::SpawnActivator() {
 			info.spawnerID = m_Parent->GetObjectID();
 			info.pos = m_ActivatorPosition == NiPoint3Constant::ZERO ? m_Parent->GetPosition() : m_ActivatorPosition;
 
-			m_Activator = Game::entityManager->CreateEntity(info, nullptr, m_Parent);
+			SetActivator(Game::entityManager->CreateEntity(info, nullptr, m_Parent));
 			if (m_Activator) {
 				m_ActivatorId = m_Activator->GetObjectID();
 				Game::entityManager->ConstructEntity(m_Activator);
@@ -277,7 +259,7 @@ void QuickBuildComponent::DespawnActivator() {
 
 		m_Activator->ScheduleKillAfterUpdate();
 
-		m_Activator = nullptr;
+		SetActivator(nullptr);
 
 		m_ActivatorId = LWOOBJID_EMPTY;
 	}
@@ -405,8 +387,7 @@ void QuickBuildComponent::StartQuickBuild(Entity* const user) {
 		GameMessages::SendQuickBuildNotifyState(m_Parent, m_State, eQuickBuildState::BUILDING, user->GetObjectID());
 		GameMessages::SendEnableQuickBuild(m_Parent, true, false, false, eQuickBuildFailReason::NOT_GIVEN, 0.0f, user->GetObjectID());
 
-		m_State = eQuickBuildState::BUILDING;
-		m_StateDirty = true;
+		SetState(eQuickBuildState::BUILDING);
 		Game::entityManager->SerializeEntity(m_Parent);
 
 		auto* movingPlatform = m_Parent->GetComponent<MovingPlatformComponent>();
@@ -444,9 +425,8 @@ void QuickBuildComponent::CompleteQuickBuild(Entity* const user) {
 	GameMessages::SendTerminateInteraction(user->GetObjectID(), eTerminateType::FROM_INTERACTION, m_Parent->GetObjectID());
 
 
-	m_State = eQuickBuildState::COMPLETED;
-	m_StateDirty = true;
-	m_Timer = 0.0f;
+	SetState(eQuickBuildState::COMPLETED);
+	SetTimer(0.0f);
 	m_DrainedImagination = 0;
 
 	Game::entityManager->SerializeEntity(m_Parent);
@@ -526,11 +506,10 @@ void QuickBuildComponent::ResetQuickBuild(const bool failed) {
 
 	GameMessages::SendQuickBuildNotifyState(m_Parent, m_State, eQuickBuildState::RESETTING, LWOOBJID_EMPTY);
 
-	m_State = eQuickBuildState::RESETTING;
-	m_StateDirty = true;
-	m_Timer = 0.0f;
-	m_TimerIncomplete = 0.0f;
-	m_ShowResetEffect = false;
+	SetState(eQuickBuildState::RESETTING);
+	SetTimer(0.0f);
+	SetIncompleteTimer(0.0f);
+	SetShowResetEffect(false);
 	m_DrainedImagination = 0;
 
 	Game::entityManager->SerializeEntity(m_Parent);
@@ -563,8 +542,7 @@ void QuickBuildComponent::CancelQuickBuild(Entity* const entity, const eQuickBui
 		GameMessages::SendTerminateInteraction(m_Parent->GetObjectID(), eTerminateType::FROM_INTERACTION, m_Parent->GetObjectID());
 
 		// Now update the component itself
-		m_State = eQuickBuildState::INCOMPLETE;
-		m_StateDirty = true;
+		SetState(eQuickBuildState::INCOMPLETE);
 
 		// Notify scripts and possible subscribers
 		m_Parent->GetScript()->OnQuickBuildNotifyState(m_Parent, m_State);

dGame/dComponents/QuickBuildComponent.h

@@ -218,6 +218,48 @@ public:
 	 * @param skipChecks whether or not to skip the check for the quickbuild not being completed
 	 */
 	void CancelQuickBuild(Entity* const builder, const eQuickBuildFailReason failReason, const bool skipChecks = false);
+
+	void SetState(const eQuickBuildState state) {
+		if (m_State == state) return;
+		m_State = state;
+		m_StateDirty = true;
+	}
+
+	void SetShowResetEffect(const bool value) {
+		if (m_ShowResetEffect == value) return;
+		m_ShowResetEffect = value;
+		m_StateDirty = true;
+	}
+
+	void SetActivator(Entity* const activator) {
+		if (m_Activator == activator) return;
+		m_Activator = activator;
+		m_StateDirty = true;
+	}
+
+	void SetTimer(const float value) {
+		if (m_Timer == value) return;
+		m_Timer = value;
+		m_StateDirty = true;
+	}
+
+	void ModifyTimer(const float value) {
+		if (value == 0.0f) return;
+		m_Timer += value;
+		m_StateDirty = true;
+	}
+
+	void SetIncompleteTimer(const float value) {
+		if (m_TimerIncomplete == value) return;
+		m_TimerIncomplete = value;
+		m_StateDirty = true;
+	}
+
+	void ModifyIncompleteTimer(const float value) {
+		if (value == 0.0f) return;
+		m_TimerIncomplete += value;
+		m_StateDirty = true;
+	}
 private:
 	/**
 	 * Whether or not the quickbuild state has been changed since we last serialized it.

dGame/dComponents/RacingControlComponent.cpp

@@ -35,7 +35,8 @@
 RacingControlComponent::RacingControlComponent(Entity* parent)
 	: Component(parent) {
 	m_PathName = u"MainPath";
-	m_RemainingLaps = 3;
+	m_NumberOfLaps = 3;
+	m_RemainingLaps = m_NumberOfLaps;
 	m_LeadingPlayer = LWOOBJID_EMPTY;
 	m_RaceBestTime = 0;
 	m_RaceBestLap = 0;
@@ -45,7 +46,6 @@ RacingControlComponent::RacingControlComponent(Entity* parent)
 	m_LoadedPlayers = 0;
 	m_LoadTimer = 0;
 	m_Finished = 0;
-	m_StartTime = 0;
 	m_EmptyTimer = 0;
 	m_SoloRacing = Game::config->GetValue("solo_racing") == "1";
 
@@ -285,7 +285,7 @@ void RacingControlComponent::OnRacingClientReady(Entity* player) {
 	Game::entityManager->SerializeEntity(m_Parent);
 }
 
-void RacingControlComponent::OnRequestDie(Entity* player) {
+void RacingControlComponent::OnRequestDie(Entity* player, const std::u16string& deathType) {
 	// Sent by the client when they collide with something which should smash
 	// them.
 
@@ -301,8 +301,9 @@ void RacingControlComponent::OnRequestDie(Entity* player) {
 
 		if (!racingPlayer.noSmashOnReload) {
 			racingPlayer.smashedTimes++;
+			LOG("Death type %s", GeneralUtils::UTF16ToWTF8(deathType).c_str());
 			GameMessages::SendDie(vehicle, vehicle->GetObjectID(), LWOOBJID_EMPTY, true,
-				eKillType::VIOLENT, u"", 0, 0, 90.0f, false, true, 0);
+				eKillType::VIOLENT, deathType, 0, 0, 90.0f, false, true, 0);
 
 			auto* destroyableComponent = vehicle->GetComponent<DestroyableComponent>();
 			uint32_t respawnImagination = 0;
@@ -427,9 +428,9 @@ void RacingControlComponent::Serialize(RakNet::BitStream& outBitStream, bool bIs
 		outBitStream.Write(player.playerID);
 
 		outBitStream.Write(player.data[0]);
-		if (player.finished != 0) outBitStream.Write<float>(player.raceTime);
+		if (player.finished != 0) outBitStream.Write<float>(player.raceTime.count() / 1000.0f);
 		else outBitStream.Write(player.data[1]);
-		if (player.finished != 0) outBitStream.Write<float>(player.bestLapTime);
+		if (player.finished != 0) outBitStream.Write<float>(player.bestLapTime.count() / 1000.0f);
 		else outBitStream.Write(player.data[2]);
 		if (player.finished == 1) outBitStream.Write<float>(1.0f);
 		else outBitStream.Write(player.data[3]);
@@ -490,8 +491,8 @@ void RacingControlComponent::Serialize(RakNet::BitStream& outBitStream, bool bIs
 			if (player.finished == 0) continue;
 			outBitStream.Write1(); // Has more data
 			outBitStream.Write(player.playerID);
-			outBitStream.Write<float>(player.bestLapTime);
-			outBitStream.Write<float>(player.raceTime);
+			outBitStream.Write<float>(player.bestLapTime.count() / 1000.0f);
+			outBitStream.Write<float>(player.raceTime.count() / 1000.0f);
 		}
 
 		outBitStream.Write0(); // No more data
@@ -659,23 +660,9 @@ void RacingControlComponent::Update(float deltaTime) {
 					}
 				}
 
-				// Spawn imagination pickups
-				auto* minSpawner = Game::zoneManager->GetSpawnersByName(
-					"ImaginationSpawn_Min")[0];
-				auto* medSpawner = Game::zoneManager->GetSpawnersByName(
-					"ImaginationSpawn_Med")[0];
-				auto* maxSpawner = Game::zoneManager->GetSpawnersByName(
-					"ImaginationSpawn_Max")[0];
-
-				minSpawner->Activate();
-
-				if (m_LoadedPlayers > 2) {
-					medSpawner->Activate();
-				}
-
-				if (m_LoadedPlayers > 4) {
-					maxSpawner->Activate();
-				}
+				GameMessages::ZoneLoadedInfo zoneLoadInfo{};
+				zoneLoadInfo.maxPlayers = m_LoadedPlayers;
+				m_Parent->GetScript()->OnZoneLoadedInfo(m_Parent, zoneLoadInfo);
 
 				// Reset players to their start location, without smashing them
 				for (auto& player : m_RacingPlayers) {
@@ -721,7 +708,7 @@ void RacingControlComponent::Update(float deltaTime) {
 
 				Game::entityManager->SerializeEntity(m_Parent);
 
-				m_StartTime = std::time(nullptr);
+				m_StartTime = std::chrono::high_resolution_clock::now();
 			}
 
 			m_StartTimer += deltaTime;
@@ -765,7 +752,7 @@ void RacingControlComponent::Update(float deltaTime) {
 		// new checkpoint
 		uint32_t respawnIndex = 0;
 		for (const auto& waypoint : path->pathWaypoints) {
-			if (player.lap == 3) {
+			if (player.lap == m_NumberOfLaps) {
 				break;
 			}
 
@@ -810,46 +797,45 @@ void RacingControlComponent::Update(float deltaTime) {
 
 			// Reached the start point, lapped
 			if (respawnIndex == 0) {
-				time_t lapTime = std::time(nullptr) - (player.lap == 0 ? m_StartTime : player.lapTime);
+				const auto now = std::chrono::high_resolution_clock::now();
+				const auto lapTime = std::chrono::duration_cast<std::chrono::milliseconds>(now - (player.lap == 0 ? m_StartTime : player.lapTime));
 
 				// Cheating check
-				if (lapTime < 40) {
+				if (lapTime.count() < 40000) {
 					continue;
 				}
 
-				player.lap++;
+				player.lapTime = now;
 
-				player.lapTime = std::time(nullptr);
-
-				if (player.bestLapTime == 0 || player.bestLapTime > lapTime) {
+				if (player.bestLapTime > lapTime || player.lap == 0) {
 					player.bestLapTime = lapTime;
 
 					LOG("Best lap time (%llu)", lapTime);
 				}
 
+				player.lap++;
+
 				auto* missionComponent =
 					playerEntity->GetComponent<MissionComponent>();
 
 				if (missionComponent != nullptr) {
 
 					// Progress lap time tasks
-					missionComponent->Progress(eMissionTaskType::RACING, (lapTime) * 1000, static_cast<LWOOBJID>(eRacingTaskParam::LAP_TIME));
+					missionComponent->Progress(eMissionTaskType::RACING, lapTime.count(), static_cast<LWOOBJID>(eRacingTaskParam::LAP_TIME));
 
-					if (player.lap == 3) {
+					if (player.lap == m_NumberOfLaps) {
 						m_Finished++;
 						player.finished = m_Finished;
 
-						const auto raceTime =
-							(std::time(nullptr) - m_StartTime);
+						const auto raceTime = std::chrono::duration_cast<std::chrono::milliseconds>(now - m_StartTime);
 
 						player.raceTime = raceTime;
 
-						LOG("Completed time %llu, %llu",
-							raceTime, raceTime * 1000);
+						LOG("Completed time %llums %fs", raceTime.count(), raceTime.count() / 1000.0f);
 
-						LeaderboardManager::SaveScore(playerEntity->GetObjectID(), m_ActivityID, static_cast<float>(player.raceTime), static_cast<float>(player.bestLapTime), static_cast<float>(player.finished == 1));
+						LeaderboardManager::SaveScore(playerEntity->GetObjectID(), m_ActivityID, static_cast<float>(player.raceTime.count()) / 1000, static_cast<float>(player.bestLapTime.count()) / 1000, static_cast<float>(player.finished == 1));
 						// Entire race time
-						missionComponent->Progress(eMissionTaskType::RACING, (raceTime) * 1000, static_cast<LWOOBJID>(eRacingTaskParam::TOTAL_TRACK_TIME));
+						missionComponent->Progress(eMissionTaskType::RACING, player.raceTime.count(), static_cast<LWOOBJID>(eRacingTaskParam::TOTAL_TRACK_TIME));
 
 						missionComponent->Progress(eMissionTaskType::RACING, 0, static_cast<LWOOBJID>(eRacingTaskParam::COMPETED_IN_RACE)); // Progress task for competing in a race
 						missionComponent->Progress(eMissionTaskType::RACING, player.smashedTimes, static_cast<LWOOBJID>(eRacingTaskParam::SAFE_DRIVER)); // Finish a race without being smashed.
@@ -873,8 +859,8 @@ void RacingControlComponent::Update(float deltaTime) {
 					}
 				}
 
-				LOG("Lapped (%i) in (%llu)", player.lap,
-					lapTime);
+				LOG("Lapped (%i) in (%llums %fs)", player.lap,
+					lapTime.count(), lapTime.count() / 1000.0f);
 			}
 
 			LOG("Reached point (%i)/(%i)", player.respawnIndex,
@@ -884,3 +870,20 @@ void RacingControlComponent::Update(float deltaTime) {
 		}
 	}
 }
+
+void RacingControlComponent::MsgConfigureRacingControl(const GameMessages::ConfigureRacingControl& msg) {
+	for (const auto& dataUnique : msg.racingSettings) {
+		if (!dataUnique) continue;
+		const auto* const data = dataUnique.get(); 
+		if (data->GetKey() == u"Race_PathName" && data->GetValueType() == LDF_TYPE_UTF_16) {
+			m_PathName = static_cast<const LDFData<std::u16string>*>(data)->GetValue();
+		} else if (data->GetKey() == u"activityID" && data->GetValueType() == LDF_TYPE_S32) {
+			m_ActivityID = static_cast<const LDFData<int32_t>*>(data)->GetValue();
+		} else if (data->GetKey() == u"Number_of_Laps" && data->GetValueType() == LDF_TYPE_S32) {
+			m_NumberOfLaps = static_cast<const LDFData<int32_t>*>(data)->GetValue();
+			m_RemainingLaps = m_NumberOfLaps;
+		} else if (data->GetKey() == u"Minimum_Players_for_Group_Achievements" && data->GetValueType() == LDF_TYPE_S32) {
+			m_MinimumPlayersForGroupAchievements = static_cast<const LDFData<int32_t>*>(data)->GetValue();
+		}
+	}
+}

dGame/dComponents/RacingControlComponent.h

@@ -8,6 +8,7 @@
 #include "Entity.h"
 #include "Component.h"
 #include "eReplicaComponentType.h"
+#include <chrono>
 
  /**
   * Information for each player in the race
@@ -72,12 +73,12 @@ struct RacingPlayerInfo {
 	/**
 	 * The fastest lap time of the player
 	 */
-	time_t bestLapTime = 0;
+	std::chrono::milliseconds bestLapTime;
 
 	/**
 	 * The current lap time of the player
 	 */
-	time_t lapTime = 0;
+	std::chrono::high_resolution_clock::time_point lapTime;
 
 	/**
 	 * The number of times this player smashed their car
@@ -97,7 +98,7 @@ struct RacingPlayerInfo {
 	/**
 	 * Unused
 	 */
-	time_t raceTime = 0;
+	std::chrono::milliseconds raceTime;
 };
 
 /**
@@ -134,7 +135,7 @@ public:
 	/**
 	 * Invoked when the client says it should be smashed.
 	 */
-	void OnRequestDie(Entity* player);
+	void OnRequestDie(Entity* player, const std::u16string& deathType = u"");
 
 	/**
 	 * Invoked when the player has finished respawning.
@@ -151,6 +152,8 @@ public:
 	 */
 	RacingPlayerInfo* GetPlayerData(LWOOBJID playerID);
 
+	void MsgConfigureRacingControl(const GameMessages::ConfigureRacingControl& msg);
+
 private:
 
 	/**
@@ -160,11 +163,13 @@ private:
 
 	/**
 	 * The paths that are followed for the camera scenes
+	 * Configurable in the ConfigureRacingControl msg with the key `Race_PathName`.
 	 */
 	std::u16string m_PathName;
 
 	/**
 	 * The ID of the activity for participating in this race
+	 * Configurable in the ConfigureRacingControl msg with the key `activityID`.
 	 */
 	uint32_t m_ActivityID;
 
@@ -231,7 +236,7 @@ private:
 	/**
 	 * The time the race was started
 	 */
-	time_t m_StartTime;
+	std::chrono::high_resolution_clock::time_point m_StartTime;
 
 	/**
 	 * Timer for tracking how long a player was alone in this race
@@ -244,5 +249,20 @@ private:
 	 * Value for message box response to know if we are exiting the race via the activity dialogue
 	 */
 	const int32_t m_ActivityExitConfirm = 1;
+
 	bool m_AllPlayersReady = false;
+
+	/**
+	 * @brief The number of laps in this race. Configurable in the ConfigureRacingControl msg
+	 * with the key `Number_of_Laps`.
+	 * 
+	 */
+	int32_t m_NumberOfLaps{ 3 };
+
+	/**
+	 * @brief The minimum number of players required to progress group achievements.
+	 * Configurable with the ConfigureRacingControl msg with the key `Minimum_Players_for_Group_Achievements`.
+	 * 
+	 */
+	int32_t m_MinimumPlayersForGroupAchievements{ 2 };
 };

dGame/dComponents/RigidbodyPhantomPhysicsComponent.cpp

@@ -12,7 +12,7 @@
 #include "dpShapeSphere.h"
 #include"EntityInfo.h"
 
-RigidbodyPhantomPhysicsComponent::RigidbodyPhantomPhysicsComponent(Entity* parent) : PhysicsComponent(parent) {
+RigidbodyPhantomPhysicsComponent::RigidbodyPhantomPhysicsComponent(Entity* parent, int32_t componentId) : PhysicsComponent(parent, componentId) {
 	m_Position = m_Parent->GetDefaultPosition();
 	m_Rotation = m_Parent->GetDefaultRotation();
 	m_Scale = m_Parent->GetDefaultScale();

dGame/dComponents/RigidbodyPhantomPhysicsComponent.h

@@ -21,7 +21,7 @@ class RigidbodyPhantomPhysicsComponent : public PhysicsComponent {
 public:
 	static constexpr eReplicaComponentType ComponentType = eReplicaComponentType::RIGID_BODY_PHANTOM_PHYSICS;
 
-	RigidbodyPhantomPhysicsComponent(Entity* parent);
+	RigidbodyPhantomPhysicsComponent(Entity* parent, int32_t componentId);
 
 	void Update(const float deltaTime) override;
 

dGame/dComponents/RocketLaunchpadControlComponent.cpp

@@ -18,7 +18,7 @@
 #include "BitStreamUtils.h"
 #include "eObjectWorldState.h"
 #include "eConnectionType.h"
-#include "eMasterMessageType.h"
+#include "MessageType/Master.h"
 
 RocketLaunchpadControlComponent::RocketLaunchpadControlComponent(Entity* parent, int rocketId) : Component(parent) {
 	auto query = CDClientDatabase::CreatePreppedStmt(
@@ -137,7 +137,7 @@ LWOCLONEID RocketLaunchpadControlComponent::GetSelectedCloneId(LWOOBJID player)
 
 void RocketLaunchpadControlComponent::TellMasterToPrepZone(int zoneID) {
 	CBITSTREAM;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::PREP_ZONE);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::MASTER, MessageType::Master::PREP_ZONE);
 	bitStream.Write(zoneID);
 	Game::server->SendToMaster(bitStream);
 }

dGame/dComponents/SimplePhysicsComponent.cpp

@@ -13,7 +13,7 @@
 
 #include "Entity.h"
 
-SimplePhysicsComponent::SimplePhysicsComponent(Entity* parent, uint32_t componentID) : PhysicsComponent(parent) {
+SimplePhysicsComponent::SimplePhysicsComponent(Entity* parent, int32_t componentID) : PhysicsComponent(parent, componentID) {
 	m_Position = m_Parent->GetDefaultPosition();
 	m_Rotation = m_Parent->GetDefaultRotation();
 
@@ -27,6 +27,7 @@ SimplePhysicsComponent::SimplePhysicsComponent(Entity* parent, uint32_t componen
 	} else {
 		SetClimbableType(eClimbableType::CLIMBABLE_TYPE_NOT);
 	}
+	m_PhysicsMotionState = m_Parent->GetVarAs<uint32_t>(u"motionType");
 }
 
 SimplePhysicsComponent::~SimplePhysicsComponent() {
@@ -47,11 +48,10 @@ void SimplePhysicsComponent::Serialize(RakNet::BitStream& outBitStream, bool bIs
 	}
 
 	// Physics motion state
-	if (m_PhysicsMotionState != 0) {
-		outBitStream.Write1();
+	outBitStream.Write(m_DirtyPhysicsMotionState || bIsInitialUpdate);
+	if (m_DirtyPhysicsMotionState || bIsInitialUpdate) {
 		outBitStream.Write<uint32_t>(m_PhysicsMotionState);
-	} else {
-		outBitStream.Write0();
+		m_DirtyPhysicsMotionState = false;
 	}
 	PhysicsComponent::Serialize(outBitStream, bIsInitialUpdate);
 }
@@ -61,5 +61,6 @@ uint32_t SimplePhysicsComponent::GetPhysicsMotionState() const {
 }
 
 void SimplePhysicsComponent::SetPhysicsMotionState(uint32_t value) {
+	m_DirtyPhysicsMotionState = m_PhysicsMotionState != value;
 	m_PhysicsMotionState = value;
 }

dGame/dComponents/SimplePhysicsComponent.h

@@ -30,7 +30,7 @@ class SimplePhysicsComponent : public PhysicsComponent {
 public:
 	static constexpr eReplicaComponentType ComponentType = eReplicaComponentType::SIMPLE_PHYSICS;
 
-	SimplePhysicsComponent(Entity* parent, uint32_t componentID);
+	SimplePhysicsComponent(Entity* parent, int32_t componentID);
 	~SimplePhysicsComponent() override;
 
 	void Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) override;
@@ -102,7 +102,9 @@ private:
 	/**
 	 * The current physics motion state
 	 */
-	uint32_t m_PhysicsMotionState = 0;
+	uint32_t m_PhysicsMotionState = 5;
+
+	bool m_DirtyPhysicsMotionState = true;
 
 	/**
 	 * Whether or not the entity is climbable

dGame/dComponents/SkillComponent.cpp

@@ -24,7 +24,7 @@
 #include "CDClientManager.h"
 #include "CDSkillBehaviorTable.h"
 #include "eConnectionType.h"
-#include "eClientMessageType.h"
+#include "MessageType/Client.h"
 
 ProjectileSyncEntry::ProjectileSyncEntry() {
 }
@@ -123,6 +123,11 @@ void SkillComponent::SyncPlayerProjectile(const LWOOBJID projectileId, RakNet::B
 	behavior->Handle(sync_entry.context, bitStream, branch);
 
 	this->m_managedProjectiles.erase(this->m_managedProjectiles.begin() + index);
+
+	GameMessages::ActivityNotify notify;
+	notify.notification.push_back( std::make_unique<LDFData<int32_t>>(u"shot_done", sync_entry.skillId));
+
+	m_Parent->OnActivityNotify(notify);
 }
 
 void SkillComponent::RegisterPlayerProjectile(const LWOOBJID projectileId, BehaviorContext* context, const BehaviorBranchContext& branch, const LOT lot) {
@@ -132,6 +137,7 @@ void SkillComponent::RegisterPlayerProjectile(const LWOOBJID projectileId, Behav
 	entry.branchContext = branch;
 	entry.lot = lot;
 	entry.id = projectileId;
+	entry.skillId = context->skillID;
 
 	this->m_managedProjectiles.push_back(entry);
 }
@@ -320,7 +326,7 @@ SkillExecutionResult SkillComponent::CalculateBehavior(
 		// Write message
 		RakNet::BitStream message;
 
-		BitStreamUtils::WriteHeader(message, eConnectionType::CLIENT, eClientMessageType::GAME_MSG);
+		BitStreamUtils::WriteHeader(message, eConnectionType::CLIENT, MessageType::Client::GAME_MSG);
 		message.Write(this->m_Parent->GetObjectID());
 		start.Serialize(message);
 
@@ -451,7 +457,7 @@ void SkillComponent::SyncProjectileCalculation(const ProjectileSyncEntry& entry)
 
 	RakNet::BitStream message;
 
-	BitStreamUtils::WriteHeader(message, eConnectionType::CLIENT, eClientMessageType::GAME_MSG);
+	BitStreamUtils::WriteHeader(message, eConnectionType::CLIENT, MessageType::Client::GAME_MSG);
 	message.Write(this->m_Parent->GetObjectID());
 	projectileImpact.Serialize(message);
 

dGame/dComponents/SkillComponent.h

@@ -40,6 +40,8 @@ struct ProjectileSyncEntry {
 
 	BehaviorBranchContext branchContext{ 0, 0 };
 
+	int32_t skillId{ 0 };
+
 	explicit ProjectileSyncEntry();
 };
 

dGame/dComponents/SwitchComponent.cpp

@@ -2,6 +2,7 @@
 #include "EntityManager.h"
 #include "eTriggerEventType.h"
 #include "RenderComponent.h"
+#include "DestroyableComponent.h"
 
 std::vector<SwitchComponent*> SwitchComponent::petSwitches;
 
@@ -11,6 +12,13 @@ SwitchComponent::SwitchComponent(Entity* parent) : Component(parent) {
 	m_ResetTime = m_Parent->GetVarAs<int32_t>(u"switch_reset_time");
 
 	m_QuickBuild = m_Parent->GetComponent<QuickBuildComponent>();
+
+	const auto factions = GeneralUtils::SplitString(m_Parent->GetVar<std::u16string>(u"respond_to_faction"), u':');
+	for (const auto& faction : factions) {
+		auto factionID = GeneralUtils::TryParse<int32_t>(GeneralUtils::UTF16ToWTF8(faction));
+		if (!factionID) continue;
+		m_FactionsToRespondTo.push_back(factionID.value());
+	}
 }
 
 SwitchComponent::~SwitchComponent() {
@@ -25,6 +33,17 @@ void SwitchComponent::Serialize(RakNet::BitStream& outBitStream, bool bIsInitial
 	outBitStream.Write(m_Active);
 }
 
+void SwitchComponent::OnUse(Entity* originator) {
+	const auto* const destroyableComponent = originator->GetComponent<DestroyableComponent>();
+	if (!destroyableComponent) return;
+	for (const auto faction : m_FactionsToRespondTo) {
+		if (destroyableComponent->HasFaction(faction)) {
+			EntityEnter(originator);
+			break;
+		}
+	}
+}
+
 void SwitchComponent::SetActive(bool active) {
 	m_Active = active;
 

dGame/dComponents/SwitchComponent.h

@@ -22,6 +22,7 @@ public:
 	~SwitchComponent() override;
 
 	void Update(float deltaTime) override;
+	void OnUse(Entity* originator) override;
 
 	Entity* GetParentEntity() const;
 
@@ -101,6 +102,8 @@ private:
 	 * Attached pet bouncer
 	 */
 	BouncerComponent* m_PetBouncer = nullptr;
+
+	std::vector<int32_t> m_FactionsToRespondTo{};
 };
 
 #endif // SWITCHCOMPONENT_H