Merge remote-tracking branch 'refs/remotes/origin/main'

Conflicts:
	CMakeLists.txt
	dGame/CMakeLists.txt
	dGame/Entity.cpp
	dGame/dBehaviors/AttackDelayBehavior.cpp
	dGame/dBehaviors/PlayEffectBehavior.cpp

dGame/dComponents/AchievementVendorComponent.cpp

@@ -0,0 +1,81 @@
+#include "AchievementVendorComponent.h"
+#include "MissionComponent.h"
+#include "InventoryComponent.h"
+#include "eMissionState.h"
+#include "CDComponentsRegistryTable.h"
+#include "CDItemComponentTable.h"
+#include "eVendorTransactionResult.h"
+#include "CheatDetection.h"
+#include "UserManager.h"
+#include "CDMissionsTable.h"
+
+AchievementVendorComponent::AchievementVendorComponent(Entity* parent) : VendorComponent(parent) {
+	RefreshInventory(true);
+};
+
+bool AchievementVendorComponent::SellsItem(Entity* buyer, const LOT lot) {
+	auto* missionComponent = buyer->GetComponent<MissionComponent>();
+	if (!missionComponent) return false;
+
+	if (m_PlayerPurchasableItems[buyer->GetObjectID()].contains(lot)) {
+		return true;
+	}
+
+	CDMissionsTable* missionsTable = CDClientManager::GetTable<CDMissionsTable>();
+	const auto missions = missionsTable->GetMissionsForReward(lot);
+	for (const auto mission : missions) {
+		if (missionComponent->GetMissionState(mission) == eMissionState::COMPLETE) {
+			m_PlayerPurchasableItems[buyer->GetObjectID()].insert(lot);
+			return true;
+		}
+	}
+	return false;
+}
+
+void AchievementVendorComponent::Buy(Entity* buyer, LOT lot, uint32_t count) {
+	// get the item Comp from the item LOT
+	CDComponentsRegistryTable* compRegistryTable = CDClientManager::GetTable<CDComponentsRegistryTable>();
+	CDItemComponentTable* itemComponentTable = CDClientManager::GetTable<CDItemComponentTable>();
+	int itemCompID = compRegistryTable->GetByIDAndType(lot, eReplicaComponentType::ITEM);
+	CDItemComponent itemComp = itemComponentTable->GetItemComponentByID(itemCompID);
+	uint32_t costLOT = itemComp.commendationLOT;
+
+	if (costLOT == -1 || !SellsItem(buyer, lot)) {
+		auto* user = UserManager::Instance()->GetUser(buyer->GetSystemAddress());
+		CheatDetection::ReportCheat(user, buyer->GetSystemAddress(), "Attempted to buy item %i from achievement vendor %i that is not purchasable", lot, m_Parent->GetLOT());
+		GameMessages::SendVendorTransactionResult(buyer, buyer->GetSystemAddress(), eVendorTransactionResult::PURCHASE_FAIL);
+		return;
+	}
+
+	auto* inventoryComponent = buyer->GetComponent<InventoryComponent>();
+	if (!inventoryComponent) {
+		GameMessages::SendVendorTransactionResult(buyer, buyer->GetSystemAddress(), eVendorTransactionResult::PURCHASE_FAIL);
+		return;
+	}
+
+	if (costLOT == 13763) { // Faction Token Proxy
+		auto* missionComponent = buyer->GetComponent<MissionComponent>();
+		if (!missionComponent) return;
+
+		if (missionComponent->GetMissionState(545) == eMissionState::COMPLETE) costLOT = 8318; // "Assembly Token"
+		if (missionComponent->GetMissionState(556) == eMissionState::COMPLETE) costLOT = 8321; // "Venture League Token"
+		if (missionComponent->GetMissionState(567) == eMissionState::COMPLETE) costLOT = 8319; // "Sentinels Token"
+		if (missionComponent->GetMissionState(578) == eMissionState::COMPLETE) costLOT = 8320; // "Paradox Token"
+	}
+
+	const uint32_t altCurrencyCost = itemComp.commendationCost * count;
+	if (inventoryComponent->GetLotCount(costLOT) < altCurrencyCost) {
+		GameMessages::SendVendorTransactionResult(buyer, buyer->GetSystemAddress(), eVendorTransactionResult::PURCHASE_FAIL);
+		return;
+	}
+
+	inventoryComponent->RemoveItem(costLOT, altCurrencyCost);
+	inventoryComponent->AddItem(lot, count, eLootSourceType::VENDOR);
+	GameMessages::SendVendorTransactionResult(buyer, buyer->GetSystemAddress(), eVendorTransactionResult::PURCHASE_SUCCESS);
+
+}
+
+void AchievementVendorComponent::RefreshInventory(bool isCreation) {
+	SetHasStandardCostItems(true);
+	Game::entityManager->SerializeEntity(m_Parent);
+}

dGame/dComponents/AchievementVendorComponent.h

@@ -0,0 +1,25 @@
+#ifndef __ACHIEVEMENTVENDORCOMPONENT__H__
+#define __ACHIEVEMENTVENDORCOMPONENT__H__
+
+#include "VendorComponent.h"
+#include "eReplicaComponentType.h"
+#include <set>
+#include <map>
+
+class Entity;
+
+class AchievementVendorComponent final : public VendorComponent {
+public:
+	static constexpr eReplicaComponentType ComponentType = eReplicaComponentType::ACHIEVEMENT_VENDOR;
+	AchievementVendorComponent(Entity* parent);
+	
+	void RefreshInventory(bool isCreation = false) override;
+	bool SellsItem(Entity* buyer, const LOT lot);
+	void Buy(Entity* buyer, LOT lot, uint32_t count);
+
+private:
+	std::map<LWOOBJID,std::set<LOT>> m_PlayerPurchasableItems;
+};
+
+
+#endif  //!__ACHIEVEMENTVENDORCOMPONENT__H__

dGame/dComponents/ActivityComponent.cpp

@@ -21,7 +21,7 @@
 #include "eMissionTaskType.h"
 #include "eMatchUpdate.h"
 #include "eConnectionType.h"
-#include "eChatInternalMessageType.h"
+#include "eChatMessageType.h"
 
 #include "CDCurrencyTableTable.h"
 #include "CDActivityRewardsTable.h"
@@ -90,15 +90,15 @@ void ActivityComponent::LoadActivityData(const int32_t activityId) {
 	}
 }
 
-void ActivityComponent::Serialize(RakNet::BitStream* outBitStream, bool bIsInitialUpdate) {
-	outBitStream->Write(m_DirtyActivityInfo);
+void ActivityComponent::Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) {
+	outBitStream.Write(m_DirtyActivityInfo);
 	if (m_DirtyActivityInfo) {
-		outBitStream->Write<uint32_t>(m_ActivityPlayers.size());
+		outBitStream.Write<uint32_t>(m_ActivityPlayers.size());
 		if (!m_ActivityPlayers.empty()) {
 			for (const auto& activityPlayer : m_ActivityPlayers) {
-				outBitStream->Write<LWOOBJID>(activityPlayer->playerID);
+				outBitStream.Write<LWOOBJID>(activityPlayer->playerID);
 				for (const auto& activityValue : activityPlayer->values) {
-					outBitStream->Write<float_t>(activityValue);
+					outBitStream.Write<float_t>(activityValue);
 				}
 			}
 		}
@@ -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_INTERNAL, eChatInternalMessageType::CREATE_TEAM);
+		BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::CREATE_TEAM);
 
 		bitStream.Write(leader->GetObjectID());
 		bitStream.Write(m_Participants.size());

dGame/dComponents/ActivityComponent.h

@@ -155,7 +155,7 @@ public:
 	void LoadActivityData(const int32_t activityId);
 
 	void Update(float deltaTime) override;
-	void Serialize(RakNet::BitStream* outBitStream, bool bIsInitialUpdate) override;
+	void Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) override;
 
 	/**
 	 * Makes some entity join the minigame, if it's a lobbied one, the entity will be placed in the lobby

dGame/dComponents/BaseCombatAIComponent.cpp

@@ -162,7 +162,6 @@ void BaseCombatAIComponent::Update(const float deltaTime) {
 	// Check if we should stop the tether effect
 	if (m_TetherEffectActive) {
 		m_TetherTime -= deltaTime;
-		const auto& info = m_MovementAI->GetInfo();
 		if (m_Target != LWOOBJID_EMPTY || (NiPoint3::DistanceSquared(
 			m_StartPosition,
 			m_Parent->GetPosition()) < 20 * 20 && m_TetherTime <= 0)
@@ -520,11 +519,11 @@ bool BaseCombatAIComponent::IsMech() {
 }
 
 
-void BaseCombatAIComponent::Serialize(RakNet::BitStream* outBitStream, bool bIsInitialUpdate) {
-	outBitStream->Write(m_DirtyStateOrTarget || bIsInitialUpdate);
+void BaseCombatAIComponent::Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) {
+	outBitStream.Write(m_DirtyStateOrTarget || bIsInitialUpdate);
 	if (m_DirtyStateOrTarget || bIsInitialUpdate) {
-		outBitStream->Write(m_State);
-		outBitStream->Write(m_Target);
+		outBitStream.Write(m_State);
+		outBitStream.Write(m_Target);
 		m_DirtyStateOrTarget = false;
 	}
 }

dGame/dComponents/BaseCombatAIComponent.h

@@ -53,7 +53,7 @@ public:
 	~BaseCombatAIComponent() override;
 
 	void Update(float deltaTime) override;
-	void Serialize(RakNet::BitStream* outBitStream, bool bIsInitialUpdate) override;
+	void Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) override;
 
 	/**
 	 * Get the current behavioral state of the enemy

dGame/dComponents/BouncerComponent.cpp

@@ -22,10 +22,10 @@ BouncerComponent::BouncerComponent(Entity* parent) : Component(parent) {
 BouncerComponent::~BouncerComponent() {
 }
 
-void BouncerComponent::Serialize(RakNet::BitStream* outBitStream, bool bIsInitialUpdate) {
-	outBitStream->Write(m_PetEnabled);
+void BouncerComponent::Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) {
+	outBitStream.Write(m_PetEnabled);
 	if (m_PetEnabled) {
-		outBitStream->Write(m_PetBouncerEnabled);
+		outBitStream.Write(m_PetBouncerEnabled);
 	}
 }
 

dGame/dComponents/BouncerComponent.h

@@ -17,7 +17,7 @@ public:
 	BouncerComponent(Entity* parentEntity);
 	~BouncerComponent() override;
 
-	void Serialize(RakNet::BitStream* outBitStream, bool bIsInitialUpdate) override;
+	void Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) override;
 
 	Entity* GetParentEntity() const;
 

dGame/dComponents/BuffComponent.cpp

@@ -32,24 +32,24 @@ BuffComponent::BuffComponent(Entity* parent) : Component(parent) {
 BuffComponent::~BuffComponent() {
 }
 
-void BuffComponent::Serialize(RakNet::BitStream* outBitStream, bool bIsInitialUpdate) {
+void BuffComponent::Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) {
 	if (!bIsInitialUpdate) return;
-	outBitStream->Write(!m_Buffs.empty());
+	outBitStream.Write(!m_Buffs.empty());
 	if (!m_Buffs.empty()) {
-		outBitStream->Write<uint32_t>(m_Buffs.size());
+		outBitStream.Write<uint32_t>(m_Buffs.size());
 
 		for (const auto& [id, buff] : m_Buffs) {
-			outBitStream->Write<uint32_t>(id);
-			outBitStream->Write(buff.time != 0.0f);
-			if (buff.time != 0.0f) outBitStream->Write<uint32_t>(buff.time * 1000.0f);
-			outBitStream->Write(buff.cancelOnDeath);
-			outBitStream->Write(buff.cancelOnZone);
-			outBitStream->Write(buff.cancelOnDamaged);
-			outBitStream->Write(buff.cancelOnRemoveBuff);
-			outBitStream->Write(buff.cancelOnUi);
-			outBitStream->Write(buff.cancelOnLogout);
-			outBitStream->Write(buff.cancelOnUnequip);
-			outBitStream->Write0(); // Cancel on Damage Absorb Ran Out. Generally false from what I can tell
+			outBitStream.Write<uint32_t>(id);
+			outBitStream.Write(buff.time != 0.0f);
+			if (buff.time != 0.0f) outBitStream.Write<uint32_t>(buff.time * 1000.0f);
+			outBitStream.Write(buff.cancelOnDeath);
+			outBitStream.Write(buff.cancelOnZone);
+			outBitStream.Write(buff.cancelOnDamaged);
+			outBitStream.Write(buff.cancelOnRemoveBuff);
+			outBitStream.Write(buff.cancelOnUi);
+			outBitStream.Write(buff.cancelOnLogout);
+			outBitStream.Write(buff.cancelOnUnequip);
+			outBitStream.Write0(); // Cancel on Damage Absorb Ran Out. Generally false from what I can tell
 
 			auto* team = TeamManager::Instance()->GetTeam(buff.source);
 			bool addedByTeammate = false;
@@ -57,15 +57,15 @@ void BuffComponent::Serialize(RakNet::BitStream* outBitStream, bool bIsInitialUp
 				addedByTeammate = std::count(team->members.begin(), team->members.end(), m_Parent->GetObjectID()) > 0;
 			}
 
-			outBitStream->Write(addedByTeammate); // Added by teammate. If source is in the same team as the target, this is true. Otherwise, false.
-			outBitStream->Write(buff.applyOnTeammates);
-			if (addedByTeammate) outBitStream->Write(buff.source);
+			outBitStream.Write(addedByTeammate); // Added by teammate. If source is in the same team as the target, this is true. Otherwise, false.
+			outBitStream.Write(buff.applyOnTeammates);
+			if (addedByTeammate) outBitStream.Write(buff.source);
 
-			outBitStream->Write<uint32_t>(buff.refCount);
+			outBitStream.Write<uint32_t>(buff.refCount);
 		}
 	}
 
-	outBitStream->Write0(); // something to do with immunity buffs?
+	outBitStream.Write0(); // something to do with immunity buffs?
 }
 
 void BuffComponent::Update(float deltaTime) {
@@ -208,9 +208,8 @@ void BuffComponent::ApplyBuff(const int32_t id, const float duration, const LWOO
 void BuffComponent::RemoveBuff(int32_t id, bool fromUnEquip, bool removeImmunity, bool ignoreRefCount) {
 	const auto& iter = m_Buffs.find(id);
 
-	if (iter == m_Buffs.end()) {
-		return;
-	}
+	// If the buff is already scheduled to be removed, don't do it again
+	if (iter == m_Buffs.end() || m_BuffsToRemove.contains(id)) return;
 
 	if (!ignoreRefCount && !iter->second.cancelOnRemoveBuff) {
 		iter->second.refCount--;
@@ -222,7 +221,7 @@ void BuffComponent::RemoveBuff(int32_t id, bool fromUnEquip, bool removeImmunity
 
 	GameMessages::SendRemoveBuff(m_Parent, fromUnEquip, removeImmunity, id);
 
-	m_BuffsToRemove.push_back(id);
+	m_BuffsToRemove.insert(id);
 
 	RemoveBuffEffect(id);
 }

dGame/dComponents/BuffComponent.h

@@ -61,7 +61,7 @@ public:
 
 	void UpdateXml(tinyxml2::XMLDocument* doc) override;
 
-	void Serialize(RakNet::BitStream* outBitStream, bool bIsInitialUpdate) override;
+	void Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) override;
 
 	void Update(float deltaTime) override;
 
@@ -141,7 +141,7 @@ private:
 	std::map<int32_t, Buff> m_Buffs;
 
 	// Buffs to remove at the end of the update frame.
-	std::vector<int32_t> m_BuffsToRemove;
+	std::set<int32_t> m_BuffsToRemove;
 
 	/**
 	 * Parameters (=effects) for each buff

dGame/dComponents/CMakeLists.txt

@@ -1,4 +1,5 @@
 set(DGAME_DCOMPONENTS_SOURCES
+	"AchievementVendorComponent.cpp"
 	"ActivityComponent.cpp"
 	"BaseCombatAIComponent.cpp"
 	"BouncerComponent.cpp"
@@ -47,11 +48,35 @@ set(DGAME_DCOMPONENTS_SOURCES
 	"HavokVehiclePhysicsComponent.cpp"
 	"VendorComponent.cpp"
 	"MiniGameControlComponent.cpp"
+	"ScriptComponent.cpp"
 )
 
-add_library(dComponents STATIC ${DGAME_DCOMPONENTS_SOURCES})
-target_include_directories(dComponents PRIVATE ${PROJECT_SOURCE_DIR}/dScripts/02_server/Map/General) # PetDigServer.h
+add_library(dComponents OBJECT ${DGAME_DCOMPONENTS_SOURCES})
+target_include_directories(dComponents PUBLIC "."
+	"${PROJECT_SOURCE_DIR}/dGame/dPropertyBehaviors" # via ModelComponent.h
+	"${PROJECT_SOURCE_DIR}/dGame/dPropertyBehaviors/ControlBehaviorMessages"
+	"${PROJECT_SOURCE_DIR}/dGame/dMission" # via MissionComponent.h
+	"${PROJECT_SOURCE_DIR}/dGame/dBehaviors" # via InventoryComponent.h
+	"${PROJECT_SOURCE_DIR}/dGame/dInventory" # via InventoryComponent.h
+	PRIVATE
+	"${PROJECT_SOURCE_DIR}/dCommon"
+	"${PROJECT_SOURCE_DIR}/dCommon/dEnums"
+	"${PROJECT_SOURCE_DIR}/dDatabase/CDClientDatabase"
+	"${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"
+
+	"${PROJECT_SOURCE_DIR}/dScripts/02_server/Map/General" # PetDigServer.h
+	"${PROJECT_SOURCE_DIR}/dGame/dGameMessages" # direct
+	"${PROJECT_SOURCE_DIR}/dGame/dUtilities" # direct Loot.h
+	"${PROJECT_SOURCE_DIR}/dGame/dEntity" # via dZoneManager/Spawner.h
+	"${PROJECT_SOURCE_DIR}/dZoneManager" # via BouncerComponent.cpp, ActivityComponent.cpp
+	"${PROJECT_SOURCE_DIR}/dChatFilter" # via PetComponent.cpp
+)
 target_precompile_headers(dComponents REUSE_FROM dGameBase)
-target_link_libraries(dComponents
-	PUBLIC dPhysics dDatabase
-	INTERFACE dUtilities dCommon dBehaviors dChatFilter dMission dInventory)
+
+target_link_libraries(dComponents INTERFACE dBehaviors)

dGame/dComponents/CharacterComponent.cpp

@@ -78,94 +78,94 @@ bool CharacterComponent::LandingAnimDisabled(int zoneID) {
 CharacterComponent::~CharacterComponent() {
 }
 
-void CharacterComponent::Serialize(RakNet::BitStream* outBitStream, bool bIsInitialUpdate) {
+void CharacterComponent::Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) {
 
 	if (bIsInitialUpdate) {
-		outBitStream->Write(m_ClaimCodes[0] != 0);
-		if (m_ClaimCodes[0] != 0) outBitStream->Write(m_ClaimCodes[0]);
-		outBitStream->Write(m_ClaimCodes[1] != 0);
-		if (m_ClaimCodes[1] != 0) outBitStream->Write(m_ClaimCodes[1]);
-		outBitStream->Write(m_ClaimCodes[2] != 0);
-		if (m_ClaimCodes[2] != 0) outBitStream->Write(m_ClaimCodes[2]);
-		outBitStream->Write(m_ClaimCodes[3] != 0);
-		if (m_ClaimCodes[3] != 0) outBitStream->Write(m_ClaimCodes[3]);
+		outBitStream.Write(m_ClaimCodes[0] != 0);
+		if (m_ClaimCodes[0] != 0) outBitStream.Write(m_ClaimCodes[0]);
+		outBitStream.Write(m_ClaimCodes[1] != 0);
+		if (m_ClaimCodes[1] != 0) outBitStream.Write(m_ClaimCodes[1]);
+		outBitStream.Write(m_ClaimCodes[2] != 0);
+		if (m_ClaimCodes[2] != 0) outBitStream.Write(m_ClaimCodes[2]);
+		outBitStream.Write(m_ClaimCodes[3] != 0);
+		if (m_ClaimCodes[3] != 0) outBitStream.Write(m_ClaimCodes[3]);
 
-		outBitStream->Write(m_Character->GetHairColor());
-		outBitStream->Write(m_Character->GetHairStyle());
-		outBitStream->Write<uint32_t>(0); //Default "head"
-		outBitStream->Write(m_Character->GetShirtColor());
-		outBitStream->Write(m_Character->GetPantsColor());
-		outBitStream->Write(m_Character->GetShirtStyle());
-		outBitStream->Write<uint32_t>(0); //Default "head color"
-		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(m_Character->GetLastLogin()); //Last login
-		outBitStream->Write<uint64_t>(0); //"prop mod last display time"
-		outBitStream->Write<uint64_t>(m_Uscore); //u-score
-		outBitStream->Write0(); //Not free-to-play (disabled in DLU)
+		outBitStream.Write(m_Character->GetHairColor());
+		outBitStream.Write(m_Character->GetHairStyle());
+		outBitStream.Write<uint32_t>(0); //Default "head"
+		outBitStream.Write(m_Character->GetShirtColor());
+		outBitStream.Write(m_Character->GetPantsColor());
+		outBitStream.Write(m_Character->GetShirtStyle());
+		outBitStream.Write<uint32_t>(0); //Default "head color"
+		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(m_Character->GetLastLogin()); //Last login
+		outBitStream.Write<uint64_t>(0); //"prop mod last display time"
+		outBitStream.Write<uint64_t>(m_Uscore); //u-score
+		outBitStream.Write0(); //Not free-to-play (disabled in DLU)
 
 		//Stats:
-		outBitStream->Write(m_CurrencyCollected);
-		outBitStream->Write(m_BricksCollected);
-		outBitStream->Write(m_SmashablesSmashed);
-		outBitStream->Write(m_QuickBuildsCompleted);
-		outBitStream->Write(m_EnemiesSmashed);
-		outBitStream->Write(m_RocketsUsed);
-		outBitStream->Write(m_MissionsCompleted);
-		outBitStream->Write(m_PetsTamed);
-		outBitStream->Write(m_ImaginationPowerUpsCollected);
-		outBitStream->Write(m_LifePowerUpsCollected);
-		outBitStream->Write(m_ArmorPowerUpsCollected);
-		outBitStream->Write(m_MetersTraveled);
-		outBitStream->Write(m_TimesSmashed);
-		outBitStream->Write(m_TotalDamageTaken);
-		outBitStream->Write(m_TotalDamageHealed);
-		outBitStream->Write(m_TotalArmorRepaired);
-		outBitStream->Write(m_TotalImaginationRestored);
-		outBitStream->Write(m_TotalImaginationUsed);
-		outBitStream->Write(m_DistanceDriven);
-		outBitStream->Write(m_TimeAirborneInCar);
-		outBitStream->Write(m_RacingImaginationPowerUpsCollected);
-		outBitStream->Write(m_RacingImaginationCratesSmashed);
-		outBitStream->Write(m_RacingCarBoostsActivated);
-		outBitStream->Write(m_RacingTimesWrecked);
-		outBitStream->Write(m_RacingSmashablesSmashed);
-		outBitStream->Write(m_RacesFinished);
-		outBitStream->Write(m_FirstPlaceRaceFinishes);
+		outBitStream.Write(m_CurrencyCollected);
+		outBitStream.Write(m_BricksCollected);
+		outBitStream.Write(m_SmashablesSmashed);
+		outBitStream.Write(m_QuickBuildsCompleted);
+		outBitStream.Write(m_EnemiesSmashed);
+		outBitStream.Write(m_RocketsUsed);
+		outBitStream.Write(m_MissionsCompleted);
+		outBitStream.Write(m_PetsTamed);
+		outBitStream.Write(m_ImaginationPowerUpsCollected);
+		outBitStream.Write(m_LifePowerUpsCollected);
+		outBitStream.Write(m_ArmorPowerUpsCollected);
+		outBitStream.Write(m_MetersTraveled);
+		outBitStream.Write(m_TimesSmashed);
+		outBitStream.Write(m_TotalDamageTaken);
+		outBitStream.Write(m_TotalDamageHealed);
+		outBitStream.Write(m_TotalArmorRepaired);
+		outBitStream.Write(m_TotalImaginationRestored);
+		outBitStream.Write(m_TotalImaginationUsed);
+		outBitStream.Write(m_DistanceDriven);
+		outBitStream.Write(m_TimeAirborneInCar);
+		outBitStream.Write(m_RacingImaginationPowerUpsCollected);
+		outBitStream.Write(m_RacingImaginationCratesSmashed);
+		outBitStream.Write(m_RacingCarBoostsActivated);
+		outBitStream.Write(m_RacingTimesWrecked);
+		outBitStream.Write(m_RacingSmashablesSmashed);
+		outBitStream.Write(m_RacesFinished);
+		outBitStream.Write(m_FirstPlaceRaceFinishes);
 
-		outBitStream->Write0();
-		outBitStream->Write(m_IsLanding);
+		outBitStream.Write0();
+		outBitStream.Write(m_IsLanding);
 		if (m_IsLanding) {
-			outBitStream->Write<uint16_t>(m_LastRocketConfig.size());
+			outBitStream.Write<uint16_t>(m_LastRocketConfig.size());
 			for (uint16_t character : m_LastRocketConfig) {
-				outBitStream->Write(character);
+				outBitStream.Write(character);
 			}
 		}
 	}
 
-	outBitStream->Write(m_DirtyGMInfo);
+	outBitStream.Write(m_DirtyGMInfo);
 	if (m_DirtyGMInfo) {
-		outBitStream->Write(m_PvpEnabled);
-		outBitStream->Write(m_IsGM);
-		outBitStream->Write(m_GMLevel);
-		outBitStream->Write(m_EditorEnabled);
-		outBitStream->Write(m_EditorLevel);
+		outBitStream.Write(m_PvpEnabled);
+		outBitStream.Write(m_IsGM);
+		outBitStream.Write(m_GMLevel);
+		outBitStream.Write(m_EditorEnabled);
+		outBitStream.Write(m_EditorLevel);
 	}
 
-	outBitStream->Write(m_DirtyCurrentActivity);
-	if (m_DirtyCurrentActivity) outBitStream->Write(m_CurrentActivity);
+	outBitStream.Write(m_DirtyCurrentActivity);
+	if (m_DirtyCurrentActivity) outBitStream.Write(m_CurrentActivity);
 
-	outBitStream->Write(m_DirtySocialInfo);
+	outBitStream.Write(m_DirtySocialInfo);
 	if (m_DirtySocialInfo) {
-		outBitStream->Write(m_GuildID);
-		outBitStream->Write<unsigned char>(m_GuildName.size());
+		outBitStream.Write(m_GuildID);
+		outBitStream.Write<unsigned char>(m_GuildName.size());
 		if (!m_GuildName.empty())
-			outBitStream->WriteBits(reinterpret_cast<const unsigned char*>(m_GuildName.c_str()), static_cast<unsigned char>(m_GuildName.size()) * sizeof(wchar_t) * 8);
+			outBitStream.WriteBits(reinterpret_cast<const unsigned char*>(m_GuildName.c_str()), static_cast<unsigned char>(m_GuildName.size()) * sizeof(wchar_t) * 8);
 
-		outBitStream->Write(m_IsLEGOClubMember);
-		outBitStream->Write(m_CountryCode);
+		outBitStream.Write(m_IsLEGOClubMember);
+		outBitStream.Write(m_CountryCode);
 	}
 }
 

dGame/dComponents/CharacterComponent.h

@@ -5,7 +5,6 @@
 #include "RakNetTypes.h"
 #include "Character.h"
 #include "Component.h"
-#include "Item.h"
 #include <string>
 #include "CDMissionsTable.h"
 #include "tinyxml2.h"
@@ -15,6 +14,8 @@
 
 enum class eGameActivity : uint32_t;
 
+class Item;
+
 /**
  * The statistics that can be achieved per zone
  */
@@ -72,7 +73,7 @@ public:
 	void LoadFromXml(tinyxml2::XMLDocument* doc) override;
 	void UpdateXml(tinyxml2::XMLDocument* doc) override;
 
-	void Serialize(RakNet::BitStream* outBitStream, bool bIsInitialUpdate) override;
+	void Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) override;
 
 	/**
 	 * Updates the rocket configuration using a LOT string separated by commas

dGame/dComponents/CollectibleComponent.cpp

@@ -1,5 +1,5 @@
 #include "CollectibleComponent.h"
 
-void CollectibleComponent::Serialize(RakNet::BitStream* outBitStream, bool isConstruction) {
-	outBitStream->Write(GetCollectibleId());
+void CollectibleComponent::Serialize(RakNet::BitStream& outBitStream, bool isConstruction) {
+	outBitStream.Write(GetCollectibleId());
 }

dGame/dComponents/CollectibleComponent.h

@@ -10,7 +10,7 @@ public:
 	CollectibleComponent(Entity* parentEntity, int32_t collectibleId) : Component(parentEntity), m_CollectibleId(collectibleId) {}
 
 	int16_t GetCollectibleId() const { return m_CollectibleId; }
-	void Serialize(RakNet::BitStream* outBitStream, bool isConstruction) override;
+	void Serialize(RakNet::BitStream& outBitStream, bool isConstruction) override;
 private:
 	int16_t m_CollectibleId = 0;
 };

dGame/dComponents/Component.cpp

@@ -29,6 +29,6 @@ void Component::LoadFromXml(tinyxml2::XMLDocument* doc) {
 
 }
 
-void Component::Serialize(RakNet::BitStream* outBitStream, bool isConstruction) {
+void Component::Serialize(RakNet::BitStream& outBitStream, bool isConstruction) {
 
 }

dGame/dComponents/Component.h

@@ -42,7 +42,7 @@ public:
 	 */
 	virtual void LoadFromXml(tinyxml2::XMLDocument* doc);
 
-	virtual void Serialize(RakNet::BitStream* outBitStream, bool isConstruction);
+	virtual void Serialize(RakNet::BitStream& outBitStream, bool isConstruction);
 
 protected:
 

dGame/dComponents/ControllablePhysicsComponent.cpp

@@ -21,14 +21,11 @@ ControllablePhysicsComponent::ControllablePhysicsComponent(Entity* entity) : Phy
 	m_InJetpackMode = false;
 	m_IsOnGround = true;
 	m_IsOnRail = false;
-	m_DirtyVelocity = true;
-	m_DirtyAngularVelocity = true;
 	m_dpEntity = nullptr;
 	m_Static = false;
 	m_SpeedMultiplier = 1;
 	m_GravityScale = 1;
 	m_DirtyCheats = false;
-	m_IgnoreMultipliers = false;
 
 	m_DirtyEquippedItemInfo = true;
 	m_PickupRadius = 0.0f;
@@ -71,90 +68,93 @@ void ControllablePhysicsComponent::Update(float deltaTime) {
 
 }
 
-void ControllablePhysicsComponent::Serialize(RakNet::BitStream* outBitStream, bool bIsInitialUpdate) {
+void ControllablePhysicsComponent::Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) {
 	//If this is a creation, then we assume the position is dirty, even when it isn't.
 	//This is because new clients will still need to receive the position.
 	//if (bIsInitialUpdate) m_DirtyPosition = true;
 
 	if (bIsInitialUpdate) {
-		outBitStream->Write(m_InJetpackMode);
+		outBitStream.Write(m_InJetpackMode);
 		if (m_InJetpackMode) {
-			outBitStream->Write(m_JetpackEffectID);
-			outBitStream->Write(m_JetpackFlying);
-			outBitStream->Write(m_JetpackBypassChecks);
+			outBitStream.Write(m_JetpackEffectID);
+			outBitStream.Write(m_JetpackFlying);
+			outBitStream.Write(m_JetpackBypassChecks);
 		}
 
-		outBitStream->Write1(); // always write these on construction
-		outBitStream->Write(m_ImmuneToStunMoveCount);
-		outBitStream->Write(m_ImmuneToStunJumpCount);
-		outBitStream->Write(m_ImmuneToStunTurnCount);
-		outBitStream->Write(m_ImmuneToStunAttackCount);
-		outBitStream->Write(m_ImmuneToStunUseItemCount);
-		outBitStream->Write(m_ImmuneToStunEquipCount);
-		outBitStream->Write(m_ImmuneToStunInteractCount);
+		outBitStream.Write1(); // always write these on construction
+		outBitStream.Write(m_ImmuneToStunMoveCount);
+		outBitStream.Write(m_ImmuneToStunJumpCount);
+		outBitStream.Write(m_ImmuneToStunTurnCount);
+		outBitStream.Write(m_ImmuneToStunAttackCount);
+		outBitStream.Write(m_ImmuneToStunUseItemCount);
+		outBitStream.Write(m_ImmuneToStunEquipCount);
+		outBitStream.Write(m_ImmuneToStunInteractCount);
 	}
 
-	if (m_IgnoreMultipliers) m_DirtyCheats = false;
+	outBitStream.Write(m_DirtyCheats || bIsInitialUpdate);
+	if (m_DirtyCheats || bIsInitialUpdate) {
+		outBitStream.Write(m_GravityScale);
+		outBitStream.Write(m_SpeedMultiplier);
 
-	outBitStream->Write(m_DirtyCheats);
-	if (m_DirtyCheats) {
-		outBitStream->Write(m_GravityScale);
-		outBitStream->Write(m_SpeedMultiplier);
-
-		m_DirtyCheats = false;
+		if (!bIsInitialUpdate) m_DirtyCheats = false;
 	}
 
-	outBitStream->Write(m_DirtyEquippedItemInfo);
-	if (m_DirtyEquippedItemInfo) {
-		outBitStream->Write(m_PickupRadius);
-		outBitStream->Write(m_InJetpackMode);
-		m_DirtyEquippedItemInfo = false;
+	outBitStream.Write(m_DirtyEquippedItemInfo || bIsInitialUpdate);
+	if (m_DirtyEquippedItemInfo || bIsInitialUpdate) {
+		outBitStream.Write(m_PickupRadius);
+		outBitStream.Write(m_InJetpackMode);
+
+		if (!bIsInitialUpdate) m_DirtyEquippedItemInfo = false;
 	}
 
-	outBitStream->Write(m_DirtyBubble);
-	if (m_DirtyBubble) {
-		outBitStream->Write(m_IsInBubble);
+	outBitStream.Write(m_DirtyBubble || bIsInitialUpdate);
+	if (m_DirtyBubble || bIsInitialUpdate) {
+		outBitStream.Write(m_IsInBubble);
 		if (m_IsInBubble) {
-			outBitStream->Write(m_BubbleType);
-			outBitStream->Write(m_SpecialAnims);
+			outBitStream.Write(m_BubbleType);
+			outBitStream.Write(m_SpecialAnims);
 		}
-		m_DirtyBubble = false;
+
+		if (!bIsInitialUpdate) m_DirtyBubble = false;
 	}
 
-	outBitStream->Write(m_DirtyPosition || bIsInitialUpdate);
+	outBitStream.Write(m_DirtyPosition || bIsInitialUpdate);
 	if (m_DirtyPosition || bIsInitialUpdate) {
-		outBitStream->Write(m_Position.x);
-		outBitStream->Write(m_Position.y);
-		outBitStream->Write(m_Position.z);
+		outBitStream.Write(m_Position.x);
+		outBitStream.Write(m_Position.y);
+		outBitStream.Write(m_Position.z);
 
-		outBitStream->Write(m_Rotation.x);
-		outBitStream->Write(m_Rotation.y);
-		outBitStream->Write(m_Rotation.z);
-		outBitStream->Write(m_Rotation.w);
+		outBitStream.Write(m_Rotation.x);
+		outBitStream.Write(m_Rotation.y);
+		outBitStream.Write(m_Rotation.z);
+		outBitStream.Write(m_Rotation.w);
 
-		outBitStream->Write(m_IsOnGround);
-		outBitStream->Write(m_IsOnRail);
+		outBitStream.Write(m_IsOnGround);
+		outBitStream.Write(m_IsOnRail);
 
-		outBitStream->Write(m_DirtyVelocity);
-		if (m_DirtyVelocity) {
-			outBitStream->Write(m_Velocity.x);
-			outBitStream->Write(m_Velocity.y);
-			outBitStream->Write(m_Velocity.z);
+		bool isNotZero = m_Velocity != NiPoint3Constant::ZERO;
+		outBitStream.Write(isNotZero);
+		if (isNotZero) {
+			outBitStream.Write(m_Velocity.x);
+			outBitStream.Write(m_Velocity.y);
+			outBitStream.Write(m_Velocity.z);
 		}
 
-		outBitStream->Write(m_DirtyAngularVelocity);
-		if (m_DirtyAngularVelocity) {
-			outBitStream->Write(m_AngularVelocity.x);
-			outBitStream->Write(m_AngularVelocity.y);
-			outBitStream->Write(m_AngularVelocity.z);
+		isNotZero = m_AngularVelocity != NiPoint3Constant::ZERO;
+		outBitStream.Write(isNotZero);
+		if (isNotZero) {
+			outBitStream.Write(m_AngularVelocity.x);
+			outBitStream.Write(m_AngularVelocity.y);
+			outBitStream.Write(m_AngularVelocity.z);
 		}
 
-		outBitStream->Write0();
-	}
+		outBitStream.Write0(); // local_space_info, always zero for now.
 
-	if (!bIsInitialUpdate) {
-		outBitStream->Write(m_IsTeleporting);
-		m_IsTeleporting = false;
+		if (!bIsInitialUpdate) {
+			m_DirtyPosition = false;
+			outBitStream.Write(m_IsTeleporting);
+			m_IsTeleporting = false;
+		}
 	}
 }
 
@@ -211,33 +211,29 @@ void ControllablePhysicsComponent::SetRotation(const NiQuaternion& rot) {
 }
 
 void ControllablePhysicsComponent::SetVelocity(const NiPoint3& vel) {
-	if (m_Static) {
-		return;
-	}
+	if (m_Static || m_Velocity == vel) return;
 
 	m_Velocity = vel;
 	m_DirtyPosition = true;
-	m_DirtyVelocity = true;
 
 	if (m_dpEntity) m_dpEntity->SetVelocity(vel);
 }
 
 void ControllablePhysicsComponent::SetAngularVelocity(const NiPoint3& vel) {
-	if (m_Static) {
-		return;
-	}
+	if (m_Static || m_AngularVelocity == vel) return;
 
 	m_AngularVelocity = vel;
 	m_DirtyPosition = true;
-	m_DirtyAngularVelocity = true;
 }
 
 void ControllablePhysicsComponent::SetIsOnGround(bool val) {
+	if (m_IsOnGround == val) return;
 	m_DirtyPosition = true;
 	m_IsOnGround = val;
 }
 
 void ControllablePhysicsComponent::SetIsOnRail(bool val) {
+	if (m_IsOnRail == val) return;
 	m_DirtyPosition = true;
 	m_IsOnRail = val;
 }
@@ -245,15 +241,6 @@ void ControllablePhysicsComponent::SetIsOnRail(bool val) {
 void ControllablePhysicsComponent::SetDirtyPosition(bool val) {
 	m_DirtyPosition = val;
 }
-
-void ControllablePhysicsComponent::SetDirtyVelocity(bool val) {
-	m_DirtyVelocity = val;
-}
-
-void ControllablePhysicsComponent::SetDirtyAngularVelocity(bool val) {
-	m_DirtyAngularVelocity = val;
-}
-
 void ControllablePhysicsComponent::AddPickupRadiusScale(float value) {
 	m_ActivePickupRadiusScales.push_back(value);
 	if (value > m_PickupRadius) {
@@ -309,7 +296,7 @@ void ControllablePhysicsComponent::RemoveSpeedboost(float value) {
 	Game::entityManager->SerializeEntity(m_Parent);
 }
 
-void ControllablePhysicsComponent::ActivateBubbleBuff(eBubbleType bubbleType, bool specialAnims){
+void ControllablePhysicsComponent::ActivateBubbleBuff(eBubbleType bubbleType, bool specialAnims) {
 	if (m_IsInBubble) {
 		LOG("Already in bubble");
 		return;
@@ -321,7 +308,7 @@ void ControllablePhysicsComponent::ActivateBubbleBuff(eBubbleType bubbleType, bo
 	Game::entityManager->SerializeEntity(m_Parent);
 }
 
-void ControllablePhysicsComponent::DeactivateBubbleBuff(){
+void ControllablePhysicsComponent::DeactivateBubbleBuff() {
 	m_DirtyBubble = true;
 	m_IsInBubble = false;
 	Game::entityManager->SerializeEntity(m_Parent);
@@ -336,9 +323,9 @@ void ControllablePhysicsComponent::SetStunImmunity(
 	const bool bImmuneToStunJump,
 	const bool bImmuneToStunMove,
 	const bool bImmuneToStunTurn,
-	const bool bImmuneToStunUseItem){
+	const bool bImmuneToStunUseItem) {
 
-	if (state == eStateChangeType::POP){
+	if (state == eStateChangeType::POP) {
 		if (bImmuneToStunAttack && m_ImmuneToStunAttackCount > 0) 		m_ImmuneToStunAttackCount -= 1;
 		if (bImmuneToStunEquip && m_ImmuneToStunEquipCount > 0) 		m_ImmuneToStunEquipCount -= 1;
 		if (bImmuneToStunInteract && m_ImmuneToStunInteractCount > 0) 	m_ImmuneToStunInteractCount -= 1;

dGame/dComponents/ControllablePhysicsComponent.h

@@ -27,7 +27,7 @@ public:
 	~ControllablePhysicsComponent() override;
 
 	void Update(float deltaTime) override;
-	void Serialize(RakNet::BitStream* outBitStream, bool bIsInitialUpdate) override;
+	void Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) override;
 	void LoadFromXml(tinyxml2::XMLDocument* doc) override;
 	void UpdateXml(tinyxml2::XMLDocument* doc) override;
 
@@ -104,18 +104,6 @@ public:
 	 */
 	void SetDirtyPosition(bool val);
 
-	/**
-	 * Mark the velocity as dirty, forcing a serializtion update next tick
-	 * @param val whether or not the velocity is dirty
-	 */
-	void SetDirtyVelocity(bool val);
-
-	/**
-	 * Mark the angular velocity as dirty, forcing a serialization update next tick
-	 * @param val whether or not the angular velocity is dirty
-	 */
-	void SetDirtyAngularVelocity(bool val);
-
 	/**
 	 * Sets whether or not the entity is currently wearing a jetpack
 	 * @param val whether or not the entity is currently wearing a jetpack
@@ -186,18 +174,6 @@ public:
 	 */
 	const float GetGravityScale() const { return m_GravityScale; }
 
-	/**
-	 * Sets the ignore multipliers value, allowing you to skip the serialization of speed and gravity multipliers
-	 * @param value whether or not to ignore multipliers
-	 */
-	void SetIgnoreMultipliers(bool value) { m_IgnoreMultipliers = value; }
-
-	/**
-	 * Returns the current ignore multipliers value
-	 * @return the current ignore multipliers value
-	 */
-	const bool GetIgnoreMultipliers() const { return m_IgnoreMultipliers; }
-
 	/**
 	 * Can make an entity static, making it unable to move around
 	 * @param value whether or not the entity is static
@@ -310,21 +286,11 @@ private:
 	 */
 	dpEntity* m_dpEntity;
 
-	/**
-	 * Whether or not the velocity is dirty, forcing a serialization of the velocity
-	 */
-	bool m_DirtyVelocity;
-
 	/**
 	 * The current velocity of the entity
 	 */
 	NiPoint3 m_Velocity;
 
-	/**
-	 * Whether or not the angular velocity is dirty, forcing a serialization
-	 */
-	bool m_DirtyAngularVelocity;
-
 	/**
 	 * The current angular velocity of the entity
 	 */
@@ -375,11 +341,6 @@ private:
 	 */
 	bool m_DirtyCheats;
 
-	/**
-	 * Makes it so that the speed multiplier and gravity scale are no longer serialized if false
-	 */
-	bool m_IgnoreMultipliers;
-
 	/**
 	 * Whether this entity is static, making it unable to move
 	 */

dGame/dComponents/DestroyableComponent.cpp

@@ -122,61 +122,61 @@ void DestroyableComponent::Reinitialize(LOT templateID) {
 	}
 }
 
-void DestroyableComponent::Serialize(RakNet::BitStream* outBitStream, bool bIsInitialUpdate) {
+void DestroyableComponent::Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) {
 	if (bIsInitialUpdate) {
-		outBitStream->Write1(); // always write these on construction
-		outBitStream->Write(m_ImmuneToBasicAttackCount);
-		outBitStream->Write(m_ImmuneToDamageOverTimeCount);
-		outBitStream->Write(m_ImmuneToKnockbackCount);
-		outBitStream->Write(m_ImmuneToInterruptCount);
-		outBitStream->Write(m_ImmuneToSpeedCount);
-		outBitStream->Write(m_ImmuneToImaginationGainCount);
-		outBitStream->Write(m_ImmuneToImaginationLossCount);
-		outBitStream->Write(m_ImmuneToQuickbuildInterruptCount);
-		outBitStream->Write(m_ImmuneToPullToPointCount);
+		outBitStream.Write1(); // always write these on construction
+		outBitStream.Write(m_ImmuneToBasicAttackCount);
+		outBitStream.Write(m_ImmuneToDamageOverTimeCount);
+		outBitStream.Write(m_ImmuneToKnockbackCount);
+		outBitStream.Write(m_ImmuneToInterruptCount);
+		outBitStream.Write(m_ImmuneToSpeedCount);
+		outBitStream.Write(m_ImmuneToImaginationGainCount);
+		outBitStream.Write(m_ImmuneToImaginationLossCount);
+		outBitStream.Write(m_ImmuneToQuickbuildInterruptCount);
+		outBitStream.Write(m_ImmuneToPullToPointCount);
 	}
 
-	outBitStream->Write(m_DirtyHealth || bIsInitialUpdate);
+	outBitStream.Write(m_DirtyHealth || bIsInitialUpdate);
 	if (m_DirtyHealth || bIsInitialUpdate) {
-		outBitStream->Write(m_iHealth);
-		outBitStream->Write(m_fMaxHealth);
-		outBitStream->Write(m_iArmor);
-		outBitStream->Write(m_fMaxArmor);
-		outBitStream->Write(m_iImagination);
-		outBitStream->Write(m_fMaxImagination);
+		outBitStream.Write(m_iHealth);
+		outBitStream.Write(m_fMaxHealth);
+		outBitStream.Write(m_iArmor);
+		outBitStream.Write(m_fMaxArmor);
+		outBitStream.Write(m_iImagination);
+		outBitStream.Write(m_fMaxImagination);
 
-		outBitStream->Write(m_DamageToAbsorb);
-		outBitStream->Write(IsImmune());
-		outBitStream->Write(m_IsGMImmune);
-		outBitStream->Write(m_IsShielded);
+		outBitStream.Write(m_DamageToAbsorb);
+		outBitStream.Write(IsImmune());
+		outBitStream.Write(m_IsGMImmune);
+		outBitStream.Write(m_IsShielded);
 
-		outBitStream->Write(m_fMaxHealth);
-		outBitStream->Write(m_fMaxArmor);
-		outBitStream->Write(m_fMaxImagination);
+		outBitStream.Write(m_fMaxHealth);
+		outBitStream.Write(m_fMaxArmor);
+		outBitStream.Write(m_fMaxImagination);
 
-		outBitStream->Write<uint32_t>(m_FactionIDs.size());
+		outBitStream.Write<uint32_t>(m_FactionIDs.size());
 		for (size_t i = 0; i < m_FactionIDs.size(); ++i) {
-			outBitStream->Write(m_FactionIDs[i]);
+			outBitStream.Write(m_FactionIDs[i]);
 		}
 
-		outBitStream->Write(m_IsSmashable);
+		outBitStream.Write(m_IsSmashable);
 
 		if (bIsInitialUpdate) {
-			outBitStream->Write(m_IsDead);
-			outBitStream->Write(m_IsSmashed);
+			outBitStream.Write(m_IsDead);
+			outBitStream.Write(m_IsSmashed);
 
 			if (m_IsSmashable) {
-				outBitStream->Write(m_IsModuleAssembly);
-				outBitStream->Write(m_ExplodeFactor != 1.0f);
-				if (m_ExplodeFactor != 1.0f) outBitStream->Write(m_ExplodeFactor);
+				outBitStream.Write(m_IsModuleAssembly);
+				outBitStream.Write(m_ExplodeFactor != 1.0f);
+				if (m_ExplodeFactor != 1.0f) outBitStream.Write(m_ExplodeFactor);
 			}
 		}
 		m_DirtyHealth = false;
 	}
 
-	outBitStream->Write(m_DirtyThreatList || bIsInitialUpdate);
+	outBitStream.Write(m_DirtyThreatList || bIsInitialUpdate);
 	if (m_DirtyThreatList || bIsInitialUpdate) {
-		outBitStream->Write(m_HasThreats);
+		outBitStream.Write(m_HasThreats);
 		m_DirtyThreatList = false;
 	}
 }
@@ -785,16 +785,12 @@ void DestroyableComponent::Smash(const LWOOBJID source, const eKillType killType
 		}
 
 		Entity* zoneControl = Game::entityManager->GetZoneControlEntity();
-		for (CppScripts::Script* script : CppScripts::GetEntityScripts(zoneControl)) {
-			script->OnPlayerDied(zoneControl, m_Parent);
-		}
+		if (zoneControl) zoneControl->GetScript()->OnPlayerDied(zoneControl, m_Parent);
 
 		std::vector<Entity*> scriptedActs = Game::entityManager->GetEntitiesByComponent(eReplicaComponentType::SCRIPTED_ACTIVITY);
 		for (Entity* scriptEntity : scriptedActs) {
 			if (scriptEntity->GetObjectID() != zoneControl->GetObjectID()) { // Don't want to trigger twice on instance worlds
-				for (CppScripts::Script* script : CppScripts::GetEntityScripts(scriptEntity)) {
-					script->OnPlayerDied(scriptEntity, m_Parent);
-				}
+				scriptEntity->GetScript()->OnPlayerDied(scriptEntity, m_Parent);
 			}
 		}
 	}

dGame/dComponents/DestroyableComponent.h

@@ -25,7 +25,7 @@ public:
 	~DestroyableComponent() override;
 
 	void Update(float deltaTime) override;
-	void Serialize(RakNet::BitStream* outBitStream, bool bIsInitialUpdate) override;
+	void Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) override;
 	void LoadFromXml(tinyxml2::XMLDocument* doc) override;
 	void UpdateXml(tinyxml2::XMLDocument* doc) override;
 

dGame/dComponents/DonationVendorComponent.cpp

@@ -36,13 +36,13 @@ void DonationVendorComponent::SubmitDonation(uint32_t count) {
 	m_DirtyDonationVendor = true;
 }
 
-void DonationVendorComponent::Serialize(RakNet::BitStream* outBitStream, bool bIsInitialUpdate) {
+void DonationVendorComponent::Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) {
 	VendorComponent::Serialize(outBitStream, bIsInitialUpdate);
-	outBitStream->Write(bIsInitialUpdate || m_DirtyDonationVendor);
+	outBitStream.Write(bIsInitialUpdate || m_DirtyDonationVendor);
 	if (bIsInitialUpdate || m_DirtyDonationVendor) {
-		outBitStream->Write(m_PercentComplete);
-		outBitStream->Write(m_TotalDonated);
-		outBitStream->Write(m_TotalRemaining);
+		outBitStream.Write(m_PercentComplete);
+		outBitStream.Write(m_TotalDonated);
+		outBitStream.Write(m_TotalRemaining);
 		if (!bIsInitialUpdate) m_DirtyDonationVendor = false;
 	}
 }

dGame/dComponents/DonationVendorComponent.h

@@ -10,7 +10,7 @@ class DonationVendorComponent final : public VendorComponent {
 public:
 	static constexpr eReplicaComponentType ComponentType = eReplicaComponentType::DONATION_VENDOR;
 	DonationVendorComponent(Entity* parent);
-	void Serialize(RakNet::BitStream* outBitStream, bool bIsInitialUpdate) override;
+	void Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) override;
 	uint32_t GetActivityID() {return m_ActivityId;};
 	void SubmitDonation(uint32_t count);
 

dGame/dComponents/HavokVehiclePhysicsComponent.cpp

@@ -7,8 +7,6 @@ HavokVehiclePhysicsComponent::HavokVehiclePhysicsComponent(Entity* parent) : Phy
 	m_IsOnGround = true;
 	m_IsOnRail = false;
 	m_DirtyPosition = true;
-	m_DirtyVelocity = true;
-	m_DirtyAngularVelocity = true;
 	m_EndBehavior = GeneralUtils::GenerateRandomNumber<uint32_t>(0, 7);
 }
 
@@ -37,85 +35,66 @@ void HavokVehiclePhysicsComponent::SetIsOnRail(bool val) {
 }
 
 void HavokVehiclePhysicsComponent::SetRemoteInputInfo(const RemoteInputInfo& remoteInputInfo) {
-	if (m_RemoteInputInfo == remoteInputInfo) return;
+	if (remoteInputInfo == m_RemoteInputInfo) return;
 	this->m_RemoteInputInfo = remoteInputInfo;
-	m_DirtyRemoteInput = true;
+	m_DirtyPosition = true;
 }
 
-void HavokVehiclePhysicsComponent::SetDirtyVelocity(bool val) {
-	m_DirtyVelocity = val;
-}
-
-void HavokVehiclePhysicsComponent::SetDirtyAngularVelocity(bool val) {
-	m_DirtyAngularVelocity = val;
-}
-
-void HavokVehiclePhysicsComponent::Serialize(RakNet::BitStream* outBitStream, bool bIsInitialUpdate) {
-	outBitStream->Write(bIsInitialUpdate || m_DirtyPosition);
+void HavokVehiclePhysicsComponent::Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) {
+	outBitStream.Write(bIsInitialUpdate || m_DirtyPosition);
 
 	if (bIsInitialUpdate || m_DirtyPosition) {
 		m_DirtyPosition = false;
-		outBitStream->Write(m_Position.x);
-		outBitStream->Write(m_Position.y);
-		outBitStream->Write(m_Position.z);
+		outBitStream.Write(m_Position.x);
+		outBitStream.Write(m_Position.y);
+		outBitStream.Write(m_Position.z);
 
-		outBitStream->Write(m_Rotation.x);
-		outBitStream->Write(m_Rotation.y);
-		outBitStream->Write(m_Rotation.z);
-		outBitStream->Write(m_Rotation.w);
+		outBitStream.Write(m_Rotation.x);
+		outBitStream.Write(m_Rotation.y);
+		outBitStream.Write(m_Rotation.z);
+		outBitStream.Write(m_Rotation.w);
 
-		outBitStream->Write(m_IsOnGround);
-		outBitStream->Write(m_IsOnRail);
+		outBitStream.Write(m_IsOnGround);
+		outBitStream.Write(m_IsOnRail);
 
-		outBitStream->Write(bIsInitialUpdate || m_DirtyVelocity);
-
-		if (bIsInitialUpdate || m_DirtyVelocity) {
-			outBitStream->Write(m_Velocity.x);
-			outBitStream->Write(m_Velocity.y);
-			outBitStream->Write(m_Velocity.z);
-			m_DirtyVelocity = false;
+		bool isNotZero = m_Velocity != NiPoint3Constant::ZERO;
+		outBitStream.Write(isNotZero);
+		if (isNotZero) {
+			outBitStream.Write(m_Velocity.x);
+			outBitStream.Write(m_Velocity.y);
+			outBitStream.Write(m_Velocity.z);
 		}
 
-		outBitStream->Write(bIsInitialUpdate || m_DirtyAngularVelocity);
-
-		if (bIsInitialUpdate || m_DirtyAngularVelocity) {
-			outBitStream->Write(m_AngularVelocity.x);
-			outBitStream->Write(m_AngularVelocity.y);
-			outBitStream->Write(m_AngularVelocity.z);
-			m_DirtyAngularVelocity = false;
+		isNotZero = m_AngularVelocity != NiPoint3Constant::ZERO;
+		outBitStream.Write(isNotZero);
+		if (isNotZero) {
+			outBitStream.Write(m_AngularVelocity.x);
+			outBitStream.Write(m_AngularVelocity.y);
+			outBitStream.Write(m_AngularVelocity.z);
 		}
 
-		outBitStream->Write0(); // local_space_info. TODO: Implement this
+		outBitStream.Write0(); // local_space_info. TODO: Implement this
 
-		outBitStream->Write(m_DirtyRemoteInput || bIsInitialUpdate); // remote_input_info
-		if (m_DirtyRemoteInput || bIsInitialUpdate) {
-			outBitStream->Write(m_RemoteInputInfo.m_RemoteInputX);
-			outBitStream->Write(m_RemoteInputInfo.m_RemoteInputY);
-			outBitStream->Write(m_RemoteInputInfo.m_IsPowersliding);
-			outBitStream->Write(m_RemoteInputInfo.m_IsModified);
-			m_DirtyRemoteInput = false;
-		}
+		// This structure only has this bool flag set to false if a ptr to the peVehicle is null, which we don't have
+		// therefore, this will always be 1, even if all the values in the structure are 0.
+		outBitStream.Write1(); // has remote_input_info
+		outBitStream.Write(m_RemoteInputInfo.m_RemoteInputX);
+		outBitStream.Write(m_RemoteInputInfo.m_RemoteInputY);
+		outBitStream.Write(m_RemoteInputInfo.m_IsPowersliding);
+		outBitStream.Write(m_RemoteInputInfo.m_IsModified);
 
-		outBitStream->Write(125.0f); // remote_input_ping TODO: Figure out how this should be calculated as it seems to be constant through the whole race.
+
+		outBitStream.Write(125.0f); // remote_input_ping TODO: Figure out how this should be calculated as it seems to be constant through the whole race.
 
 		if (!bIsInitialUpdate) {
-			outBitStream->Write0();
+			outBitStream.Write0();
 		}
 	}
 
 	if (bIsInitialUpdate) {
-		outBitStream->Write<uint8_t>(m_EndBehavior);
-		outBitStream->Write1(); // is input locked?
+		outBitStream.Write<uint8_t>(m_EndBehavior);
+		outBitStream.Write1(); // is input locked?
 	}
 
-	outBitStream->Write0();
-}
-
-void HavokVehiclePhysicsComponent::Update(float deltaTime) {
-	if (m_SoftUpdate > 5) {
-		Game::entityManager->SerializeEntity(m_Parent);
-		m_SoftUpdate = 0;
-	} else {
-		m_SoftUpdate += deltaTime;
-	}
+	outBitStream.Write0();
 }

dGame/dComponents/HavokVehiclePhysicsComponent.h

@@ -15,9 +15,7 @@ public:
 
 	HavokVehiclePhysicsComponent(Entity* parentEntity);
 
-	void Serialize(RakNet::BitStream* outBitStream, bool bIsInitialUpdate) override;
-
-	void Update(float deltaTime) override;
+	void Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) override;
 
 	/**
 	 * Sets the velocity
@@ -67,22 +65,16 @@ public:
 	 */
 	const bool GetIsOnRail() const { return m_IsOnRail; }
 
-	void SetDirtyPosition(bool val);
-	void SetDirtyVelocity(bool val);
-	void SetDirtyAngularVelocity(bool val);
 	void SetRemoteInputInfo(const RemoteInputInfo&);
 
 private:
-	bool m_DirtyVelocity;
 	NiPoint3 m_Velocity;
-
-	bool m_DirtyAngularVelocity;
 	NiPoint3 m_AngularVelocity;
+
 	bool m_IsOnGround;
 	bool m_IsOnRail;
 
 	float m_SoftUpdate = 0;
 	uint32_t m_EndBehavior;
 	RemoteInputInfo m_RemoteInputInfo;
-	bool m_DirtyRemoteInput;
 };

dGame/dComponents/InventoryComponent.cpp

@@ -694,11 +694,11 @@ void InventoryComponent::UpdateXml(tinyxml2::XMLDocument* document) {
 	}
 }
 
-void InventoryComponent::Serialize(RakNet::BitStream* outBitStream, const bool bIsInitialUpdate) {
+void InventoryComponent::Serialize(RakNet::BitStream& outBitStream, const bool bIsInitialUpdate) {
 	if (bIsInitialUpdate || m_Dirty) {
-		outBitStream->Write(true);
+		outBitStream.Write(true);
 
-		outBitStream->Write<uint32_t>(m_Equipped.size());
+		outBitStream.Write<uint32_t>(m_Equipped.size());
 
 		for (const auto& pair : m_Equipped) {
 			const auto item = pair.second;
@@ -707,21 +707,21 @@ void InventoryComponent::Serialize(RakNet::BitStream* outBitStream, const bool b
 				AddItemSkills(item.lot);
 			}
 
-			outBitStream->Write(item.id);
-			outBitStream->Write(item.lot);
+			outBitStream.Write(item.id);
+			outBitStream.Write(item.lot);
 
-			outBitStream->Write0();
+			outBitStream.Write0();
 
-			outBitStream->Write(item.count > 0);
-			if (item.count > 0) outBitStream->Write(item.count);
+			outBitStream.Write(item.count > 0);
+			if (item.count > 0) outBitStream.Write(item.count);
 
-			outBitStream->Write(item.slot != 0);
-			if (item.slot != 0) outBitStream->Write<uint16_t>(item.slot);
+			outBitStream.Write(item.slot != 0);
+			if (item.slot != 0) outBitStream.Write<uint16_t>(item.slot);
 
-			outBitStream->Write0();
+			outBitStream.Write0();
 
 			bool flag = !item.config.empty();
-			outBitStream->Write(flag);
+			outBitStream.Write(flag);
 			if (flag) {
 				RakNet::BitStream ldfStream;
 				ldfStream.Write<int32_t>(item.config.size()); // Key count
@@ -730,26 +730,26 @@ void InventoryComponent::Serialize(RakNet::BitStream* outBitStream, const bool b
 						std::string newRocketStr = data->GetValueAsString() + ";";
 						GeneralUtils::ReplaceInString(newRocketStr, "+", ";");
 						LDFData<std::u16string>* ldf_data = new LDFData<std::u16string>(u"assemblyPartLOTs", GeneralUtils::ASCIIToUTF16(newRocketStr));
-						ldf_data->WriteToPacket(&ldfStream);
+						ldf_data->WriteToPacket(ldfStream);
 						delete ldf_data;
 					} else {
-						data->WriteToPacket(&ldfStream);
+						data->WriteToPacket(ldfStream);
 					}
 				}
-				outBitStream->Write(ldfStream.GetNumberOfBytesUsed() + 1);
-				outBitStream->Write<uint8_t>(0); // Don't compress
-				outBitStream->Write(ldfStream);
+				outBitStream.Write(ldfStream.GetNumberOfBytesUsed() + 1);
+				outBitStream.Write<uint8_t>(0); // Don't compress
+				outBitStream.Write(ldfStream);
 			}
 
-			outBitStream->Write1();
+			outBitStream.Write1();
 		}
 
 		m_Dirty = false;
 	} else {
-		outBitStream->Write(false);
+		outBitStream.Write(false);
 	}
 
-	outBitStream->Write(false);
+	outBitStream.Write(false);
 }
 
 void InventoryComponent::Update(float deltaTime) {

dGame/dComponents/InventoryComponent.h

@@ -41,7 +41,7 @@ public:
 	explicit InventoryComponent(Entity* parent, tinyxml2::XMLDocument* document = nullptr);
 
 	void Update(float deltaTime) override;
-	void Serialize(RakNet::BitStream* outBitStream, bool bIsInitialUpdate) override;
+	void Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) override;
 	void LoadXml(tinyxml2::XMLDocument* document);
 	void UpdateXml(tinyxml2::XMLDocument* document) override;
 

dGame/dComponents/ItemComponent.cpp

@@ -1,5 +1,5 @@
 #include "ItemComponent.h"
 
-void ItemComponent::Serialize(RakNet::BitStream* outBitStream, bool isConstruction) {
-	outBitStream->Write0();
+void ItemComponent::Serialize(RakNet::BitStream& outBitStream, bool isConstruction) {
+	outBitStream.Write0();
 }

dGame/dComponents/ItemComponent.h

@@ -10,7 +10,7 @@ public:
 
 	ItemComponent(Entity* entity) : Component(entity) {}
 
-	void Serialize(RakNet::BitStream* bitStream, bool isConstruction) override;
+	void Serialize(RakNet::BitStream& bitStream, bool isConstruction) override;
 };
 
 #endif  //!__ITEMCOMPONENT__H__

dGame/dComponents/LUPExhibitComponent.cpp

@@ -15,10 +15,10 @@ void LUPExhibitComponent::NextLUPExhibit() {
 	Game::entityManager->SerializeEntity(m_Parent);
 }
 
-void LUPExhibitComponent::Serialize(RakNet::BitStream* outBitStream, bool bIsInitialUpdate) {
-	outBitStream->Write(m_DirtyLUPExhibit);
+void LUPExhibitComponent::Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) {
+	outBitStream.Write(m_DirtyLUPExhibit);
 	if (m_DirtyLUPExhibit) {
-		outBitStream->Write(m_LUPExhibits[m_LUPExhibitIndex % m_LUPExhibits.size()]);
+		outBitStream.Write(m_LUPExhibits[m_LUPExhibitIndex % m_LUPExhibits.size()]);
 		if (!bIsInitialUpdate) m_DirtyLUPExhibit = false;
 	}
 }

dGame/dComponents/LUPExhibitComponent.h

@@ -18,7 +18,7 @@ public:
 
 	LUPExhibitComponent(Entity* parent) : Component(parent) {};
 	void Update(float deltaTime) override;
-	void Serialize(RakNet::BitStream* outBitStream, bool bIsInitialUpdate) override;
+	void Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) override;
 	void NextLUPExhibit();
 private:
 	float m_UpdateTimer = 0.0f;

dGame/dComponents/LevelProgressionComponent.cpp

@@ -37,9 +37,9 @@ void LevelProgressionComponent::LoadFromXml(tinyxml2::XMLDocument* doc) {
 	m_CharacterVersion = static_cast<eCharacterVersion>(characterVersion);
 }
 
-void LevelProgressionComponent::Serialize(RakNet::BitStream* outBitStream, bool bIsInitialUpdate) {
-	outBitStream->Write(bIsInitialUpdate || m_DirtyLevelInfo);
-	if (bIsInitialUpdate || m_DirtyLevelInfo) outBitStream->Write(m_Level);
+void LevelProgressionComponent::Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) {
+	outBitStream.Write(bIsInitialUpdate || m_DirtyLevelInfo);
+	if (bIsInitialUpdate || m_DirtyLevelInfo) outBitStream.Write(m_Level);
 	m_DirtyLevelInfo = false;
 }
 

dGame/dComponents/LevelProgressionComponent.h

@@ -21,7 +21,7 @@ public:
 	 */
 	LevelProgressionComponent(Entity* parent);
 
-	void Serialize(RakNet::BitStream* outBitStream, bool bIsInitialUpdate) override;
+	void Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) override;
 
 	/**
 	 * Save data from this componennt to character XML

dGame/dComponents/MiniGameControlComponent.cpp

@@ -1,5 +1,5 @@
 #include "MiniGameControlComponent.h"
 
-void MiniGameControlComponent::Serialize(RakNet::BitStream* outBitStream, bool isConstruction) {
-	outBitStream->Write<uint32_t>(0x40000000);
+void MiniGameControlComponent::Serialize(RakNet::BitStream& outBitStream, bool isConstruction) {
+	outBitStream.Write<uint32_t>(0x40000000);
 }

dGame/dComponents/MiniGameControlComponent.h

@@ -9,7 +9,7 @@ public:
 	static constexpr eReplicaComponentType ComponentType = eReplicaComponentType::MINI_GAME_CONTROL;
 
 	MiniGameControlComponent(Entity* parent) : Component(parent) {}
-	void Serialize(RakNet::BitStream* outBitStream, bool isConstruction);
+	void Serialize(RakNet::BitStream& outBitStream, bool isConstruction);
 };
 
 #endif  //!__MINIGAMECONTROLCOMPONENT__H__

dGame/dComponents/MinigameComponent.cpp

@@ -1,5 +1,5 @@
 #include "MinigameComponent.h"
 
-void MinigameComponent::Serialize(RakNet::BitStream* outBitStream, bool isConstruction) {
-	outBitStream->Write<uint32_t>(0x40000000);
+void MinigameComponent::Serialize(RakNet::BitStream& outBitStream, bool isConstruction) {
+	outBitStream.Write<uint32_t>(0x40000000);
 }

dGame/dComponents/MissionComponent.h

@@ -30,7 +30,7 @@ public:
 
 	explicit MissionComponent(Entity* parent);
 	~MissionComponent() override;
-	void Serialize(RakNet::BitStream* outBitStream, bool bIsInitialUpdate, unsigned int& flags);
+	void Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate, unsigned int& flags);
 	void LoadFromXml(tinyxml2::XMLDocument* doc) override;
 	void UpdateXml(tinyxml2::XMLDocument* doc) override;
 

dGame/dComponents/ModelComponent.cpp

@@ -14,26 +14,26 @@ ModelComponent::ModelComponent(Entity* parent) : Component(parent) {
 	m_userModelID = m_Parent->GetVarAs<LWOOBJID>(u"userModelID");
 }
 
-void ModelComponent::Serialize(RakNet::BitStream* outBitStream, bool bIsInitialUpdate) {
+void ModelComponent::Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) {
 	// ItemComponent Serialization.  Pets do not get this serialization.
 	if (!m_Parent->HasComponent(eReplicaComponentType::PET)) {
-		outBitStream->Write1();
-		outBitStream->Write<LWOOBJID>(m_userModelID != LWOOBJID_EMPTY ? m_userModelID : m_Parent->GetObjectID());
-		outBitStream->Write<int>(0);
-		outBitStream->Write0();
+		outBitStream.Write1();
+		outBitStream.Write<LWOOBJID>(m_userModelID != LWOOBJID_EMPTY ? m_userModelID : m_Parent->GetObjectID());
+		outBitStream.Write<int>(0);
+		outBitStream.Write0();
 	}
 
 	//actual model component:
-	outBitStream->Write1(); // Yes we are writing model info
-	outBitStream->Write0(); // Is pickable
-	outBitStream->Write<uint32_t>(2); // Physics type
-	outBitStream->Write(m_OriginalPosition); // Original position
-	outBitStream->Write(m_OriginalRotation); // Original rotation
+	outBitStream.Write1(); // Yes we are writing model info
+	outBitStream.Write0(); // Is pickable
+	outBitStream.Write<uint32_t>(2); // Physics type
+	outBitStream.Write(m_OriginalPosition); // Original position
+	outBitStream.Write(m_OriginalRotation); // Original rotation
 
-	outBitStream->Write1(); // We are writing behavior info
-	outBitStream->Write<uint32_t>(0); // Number of behaviors
-	outBitStream->Write1(); // Is this model paused
-	if (bIsInitialUpdate) outBitStream->Write0(); // We are not writing model editing info
+	outBitStream.Write1(); // We are writing behavior info
+	outBitStream.Write<uint32_t>(0); // Number of behaviors
+	outBitStream.Write1(); // Is this model paused
+	if (bIsInitialUpdate) outBitStream.Write0(); // We are not writing model editing info
 }
 
 void ModelComponent::UpdatePendingBehaviorId(const int32_t newId) {

dGame/dComponents/ModelComponent.h

@@ -28,7 +28,7 @@ public:
 
 	ModelComponent(Entity* parent);
 
-	void Serialize(RakNet::BitStream* outBitStream, bool bIsInitialUpdate) override;
+	void Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) override;
 
 	/**
 	 * Returns the original position of the model
@@ -61,7 +61,7 @@ public:
 	 * @param args the arguments of the message to be deserialized
 	 */
 	template<typename Msg>
-	void HandleControlBehaviorsMsg(AMFArrayValue* args) {
+	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) {

dGame/dComponents/ModuleAssemblyComponent.cpp

@@ -46,20 +46,20 @@ const std::u16string& ModuleAssemblyComponent::GetAssemblyPartsLOTs() const {
 	return m_AssemblyPartsLOTs;
 }
 
-void ModuleAssemblyComponent::Serialize(RakNet::BitStream* outBitStream, bool bIsInitialUpdate) {
+void ModuleAssemblyComponent::Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) {
 	if (bIsInitialUpdate) {
-		outBitStream->Write1();
+		outBitStream.Write1();
 
-		outBitStream->Write(m_SubKey != LWOOBJID_EMPTY);
+		outBitStream.Write(m_SubKey != LWOOBJID_EMPTY);
 		if (m_SubKey != LWOOBJID_EMPTY) {
-			outBitStream->Write(m_SubKey);
+			outBitStream.Write(m_SubKey);
 		}
 
-		outBitStream->Write(m_UseOptionalParts);
+		outBitStream.Write(m_UseOptionalParts);
 
-		outBitStream->Write<uint16_t>(m_AssemblyPartsLOTs.size());
+		outBitStream.Write<uint16_t>(m_AssemblyPartsLOTs.size());
 		for (char16_t character : m_AssemblyPartsLOTs) {
-			outBitStream->Write(character);
+			outBitStream.Write(character);
 		}
 	}
 }

dGame/dComponents/ModuleAssemblyComponent.h

@@ -17,7 +17,7 @@ public:
 	ModuleAssemblyComponent(Entity* parent);
 	~ModuleAssemblyComponent() override;
 
-	void Serialize(RakNet::BitStream* outBitStream, bool bIsInitialUpdate) override;
+	void Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) override;
 	void Update(float deltaTime) override;
 
 	/**

dGame/dComponents/MovementAIComponent.cpp

@@ -50,9 +50,44 @@ MovementAIComponent::MovementAIComponent(Entity* parent, MovementAIInfo info) :
 	m_CurrentSpeed = 0;
 	m_MaxSpeed = 0;
 	m_LockRotation = false;
+	m_Path = nullptr;
+	m_SourcePosition = m_Parent->GetPosition();
+	m_Paused = false;
+	m_SavedVelocity = NiPoint3Constant::ZERO;
+
+	if (!m_Parent->GetComponent<BaseCombatAIComponent>()) SetPath(m_Parent->GetVarAsString(u"attached_path"));
+}
+
+void MovementAIComponent::SetPath(const std::string pathName) {
+	m_Path = Game::zoneManager->GetZone()->GetPath(pathName);
+	if (!pathName.empty()) LOG("WARNING: %s path %s", m_Path ? "Found" : "Failed to find", pathName.c_str());
+	if (!m_Path) return;
+	SetMaxSpeed(1);
+	SetCurrentSpeed(m_BaseSpeed);
+	SetPath(m_Path->pathWaypoints);
+}
+
+void MovementAIComponent::Pause() {
+	if (m_Paused) return;
+	m_Paused = true;
+	SetPosition(ApproximateLocation());
+	m_SavedVelocity = GetVelocity();
+	SetVelocity(NiPoint3Constant::ZERO);
+	Game::entityManager->SerializeEntity(m_Parent);
+}
+
+void MovementAIComponent::Resume() {
+	if (!m_Paused) return;
+	m_Paused = false;
+	SetVelocity(m_SavedVelocity);
+	m_SavedVelocity = NiPoint3Constant::ZERO;
+	SetRotation(NiQuaternion::LookAt(m_Parent->GetPosition(), m_NextWaypoint));
+	Game::entityManager->SerializeEntity(m_Parent);
 }
 
 void MovementAIComponent::Update(const float deltaTime) {
+	if (m_Paused) return;
+
 	if (m_PullingToPoint) {
 		const auto source = GetCurrentWaypoint();
 
@@ -81,64 +116,65 @@ void MovementAIComponent::Update(const float deltaTime) {
 	}
 
 	m_TimeTravelled += deltaTime;
+
+	SetPosition(ApproximateLocation());
+
 	if (m_TimeTravelled < m_TimeToTravel) return;
 	m_TimeTravelled = 0.0f;
 
 	const auto source = GetCurrentWaypoint();
 
 	SetPosition(source);
-
-	NiPoint3 velocity = NiPoint3Constant::ZERO;
+	m_SourcePosition = source;
 
 	if (m_Acceleration > 0 && m_BaseSpeed > 0 && AdvanceWaypointIndex()) // Do we have another waypoint to seek?
 	{
 		m_NextWaypoint = GetCurrentWaypoint();
-
 		if (m_NextWaypoint == source) {
 			m_TimeToTravel = 0.0f;
+		} else {
+			m_CurrentSpeed = std::min(m_CurrentSpeed + m_Acceleration, m_MaxSpeed);
 
-			goto nextAction;
+			const auto speed = m_CurrentSpeed * m_BaseSpeed; // scale speed based on base speed
+
+			const auto delta = m_NextWaypoint - source;
+
+			// Normalize the vector
+			const auto length = delta.Length();
+			if (length > 0.0f) {
+				SetVelocity((delta / length) * speed);
+			}
+
+			// Calclute the time it will take to reach the next waypoint with the current speed
+			m_TimeTravelled = 0.0f;
+			m_TimeToTravel = length / speed;
+
+			SetRotation(NiQuaternion::LookAt(source, m_NextWaypoint));
 		}
-
-		if (m_CurrentSpeed < m_MaxSpeed) {
-			m_CurrentSpeed += m_Acceleration;
-		}
-
-		if (m_CurrentSpeed > m_MaxSpeed) {
-			m_CurrentSpeed = m_MaxSpeed;
-		}
-
-		const auto speed = m_CurrentSpeed * m_BaseSpeed; // scale speed based on base speed
-
-		const auto delta = m_NextWaypoint - source;
-
-		// Normalize the vector
-		const auto length = delta.Length();
-		if (length > 0) {
-			velocity = (delta / length) * speed;
-		}
-
-		// Calclute the time it will take to reach the next waypoint with the current speed
-		m_TimeTravelled = 0.0f;
-		m_TimeToTravel = length / speed;
-
-		SetRotation(NiQuaternion::LookAt(source, m_NextWaypoint));
 	} else {
 		// Check if there are more waypoints in the queue, if so set our next destination to the next waypoint
 		if (m_CurrentPath.empty()) {
-			Stop();
-
-			return;
+			if (m_Path) {
+				if (m_Path->pathBehavior == PathBehavior::Loop) {
+					SetPath(m_Path->pathWaypoints);
+				} else if (m_Path->pathBehavior == PathBehavior::Bounce) {
+					std::vector<PathWaypoint> waypoints = m_Path->pathWaypoints;
+					std::reverse(waypoints.begin(), waypoints.end());
+					SetPath(waypoints);
+				} else if (m_Path->pathBehavior == PathBehavior::Once) {
+					Stop();
+					return;
+				}
+			} else {
+				Stop();
+				return;
+			}
 		}
-		SetDestination(m_CurrentPath.top());
+		SetDestination(m_CurrentPath.top().position);
 
 		m_CurrentPath.pop();
 	}
 
-nextAction:
-
-	SetVelocity(velocity);
-
 	Game::entityManager->SerializeEntity(m_Parent);
 }
 
@@ -161,7 +197,7 @@ NiPoint3 MovementAIComponent::GetCurrentWaypoint() const {
 }
 
 NiPoint3 MovementAIComponent::ApproximateLocation() const {
-	auto source = m_Parent->GetPosition();
+	auto source = m_SourcePosition;
 
 	if (AtFinalWaypoint()) return source;
 
@@ -227,13 +263,13 @@ void MovementAIComponent::PullToPoint(const NiPoint3& point) {
 	m_PullPoint = point;
 }
 
-void MovementAIComponent::SetPath(std::vector<NiPoint3> path) {
+void MovementAIComponent::SetPath(std::vector<PathWaypoint> path) {
 	if (path.empty()) return;
-	std::for_each(path.rbegin(), path.rend() - 1, [this](const NiPoint3& point) {
+	std::for_each(path.rbegin(), path.rend() - 1, [this](const PathWaypoint& point) {
 		this->m_CurrentPath.push(point);
 		});
 
-	SetDestination(path.front());
+	SetDestination(path.front().position);
 }
 
 float MovementAIComponent::GetBaseSpeed(LOT lot) {
@@ -278,6 +314,23 @@ void MovementAIComponent::SetRotation(const NiQuaternion& value) {
 	if (!m_LockRotation) m_Parent->SetRotation(value);
 }
 
+NiPoint3 MovementAIComponent::GetVelocity() const {
+	auto* controllablePhysicsComponent = m_Parent->GetComponent<ControllablePhysicsComponent>();
+
+	if (controllablePhysicsComponent != nullptr) {
+		return controllablePhysicsComponent->GetVelocity();
+	}
+
+	auto* simplePhysicsComponent = m_Parent->GetComponent<SimplePhysicsComponent>();
+
+	if (simplePhysicsComponent != nullptr) {
+		return simplePhysicsComponent->GetVelocity();
+	}
+
+	return NiPoint3Constant::ZERO;
+
+}
+
 void MovementAIComponent::SetVelocity(const NiPoint3& value) {
 	auto* controllablePhysicsComponent = m_Parent->GetComponent<ControllablePhysicsComponent>();
 
@@ -294,7 +347,7 @@ void MovementAIComponent::SetVelocity(const NiPoint3& value) {
 	}
 }
 
-void MovementAIComponent::SetDestination(const NiPoint3& destination) {
+void MovementAIComponent::SetDestination(const NiPoint3 destination) {
 	if (m_PullingToPoint) return;
 
 	const auto location = ApproximateLocation();
@@ -303,6 +356,8 @@ void MovementAIComponent::SetDestination(const NiPoint3& destination) {
 		SetPosition(location);
 	}
 
+	m_SourcePosition = location;
+
 	std::vector<NiPoint3> computedPath;
 	if (dpWorld::IsLoaded()) {
 		computedPath = dpWorld::GetNavMesh()->GetPath(m_Parent->GetPosition(), destination, m_Info.wanderSpeed);
@@ -319,8 +374,7 @@ void MovementAIComponent::SetDestination(const NiPoint3& destination) {
 		auto step = delta / 10.0f;
 
 		for (int i = 0; i < 10; i++) {
-			// TODO: Replace this with += when the NiPoint3::operator+= is fixed
-			start = start + step;
+			start += step;
 
 			computedPath.push_back(start);
 		}

dGame/dComponents/MovementAIComponent.h

@@ -14,11 +14,14 @@
 #include "Logger.h"
 #include "Component.h"
 #include "eReplicaComponentType.h"
+#include "Zone.h"
 #include <vector>
 
 class ControllablePhysicsComponent;
 class BaseCombatAIComponent;
 
+struct Path;
+
 /**
  * Information that describes the different variables used to make an entity move around
  */
@@ -61,6 +64,8 @@ public:
 
 	MovementAIComponent(Entity* parentEntity, MovementAIInfo info);
 
+	void SetPath(const std::string pathName);
+
 	void Update(float deltaTime) override;
 
 	/**
@@ -73,7 +78,7 @@ public:
 	 * Set a destination point for the entity to move towards
 	 * @param value the destination point to move towards
 	 */
-	void SetDestination(const NiPoint3& value);
+	void SetDestination(const NiPoint3 value);
 
 	/**
 	 * Returns the current rotation this entity is moving towards
@@ -189,7 +194,13 @@ public:
 	 * Sets a path to follow for the AI
 	 * @param path the path to follow
 	 */
-	void SetPath(std::vector<NiPoint3> path);
+	void SetPath(std::vector<PathWaypoint> path);
+
+	void Pause();
+
+	void Resume();
+
+	NiPoint3 GetVelocity() const;
 
 	/**
 	 * Returns the base speed from the DB for a given LOT
@@ -301,7 +312,15 @@ private:
 	/**
 	 * The path from the current position to the destination.
 	 */
-	std::stack<NiPoint3> m_CurrentPath;
+	std::stack<PathWaypoint> m_CurrentPath;
+
+	const Path* m_Path = nullptr;
+
+	NiPoint3 m_SourcePosition;
+
+	bool m_Paused;
+
+	NiPoint3 m_SavedVelocity;
 };
 
 #endif // MOVEMENTAICOMPONENT_H

dGame/dComponents/MovingPlatformComponent.cpp

@@ -32,25 +32,25 @@ MoverSubComponent::MoverSubComponent(const NiPoint3& startPos) {
 
 MoverSubComponent::~MoverSubComponent() = default;
 
-void MoverSubComponent::Serialize(RakNet::BitStream* outBitStream, bool bIsInitialUpdate) {
-	outBitStream->Write<bool>(true);
+void MoverSubComponent::Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) {
+	outBitStream.Write<bool>(true);
 
-	outBitStream->Write(mState);
-	outBitStream->Write<int32_t>(mDesiredWaypointIndex);
-	outBitStream->Write(mShouldStopAtDesiredWaypoint);
-	outBitStream->Write(mInReverse);
+	outBitStream.Write(mState);
+	outBitStream.Write<int32_t>(mDesiredWaypointIndex);
+	outBitStream.Write(mShouldStopAtDesiredWaypoint);
+	outBitStream.Write(mInReverse);
 
-	outBitStream->Write<float_t>(mPercentBetweenPoints);
+	outBitStream.Write<float_t>(mPercentBetweenPoints);
 
-	outBitStream->Write<float_t>(mPosition.x);
-	outBitStream->Write<float_t>(mPosition.y);
-	outBitStream->Write<float_t>(mPosition.z);
+	outBitStream.Write<float_t>(mPosition.x);
+	outBitStream.Write<float_t>(mPosition.y);
+	outBitStream.Write<float_t>(mPosition.z);
 
-	outBitStream->Write<uint32_t>(mCurrentWaypointIndex);
-	outBitStream->Write<uint32_t>(mNextWaypointIndex);
+	outBitStream.Write<uint32_t>(mCurrentWaypointIndex);
+	outBitStream.Write<uint32_t>(mNextWaypointIndex);
 
-	outBitStream->Write<float_t>(mIdleTimeElapsed);
-	outBitStream->Write<float_t>(0.0f); // Move time elapsed
+	outBitStream.Write<float_t>(mIdleTimeElapsed);
+	outBitStream.Write<float_t>(0.0f); // Move time elapsed
 }
 
 //------------- MovingPlatformComponent below --------------
@@ -71,43 +71,43 @@ MovingPlatformComponent::~MovingPlatformComponent() {
 	delete static_cast<MoverSubComponent*>(m_MoverSubComponent);
 }
 
-void MovingPlatformComponent::Serialize(RakNet::BitStream* outBitStream, bool bIsInitialUpdate) {
+void MovingPlatformComponent::Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) {
 	// Here we don't serialize the moving platform to let the client simulate the movement
 
 	if (!m_Serialize) {
-		outBitStream->Write<bool>(false);
-		outBitStream->Write<bool>(false);
+		outBitStream.Write<bool>(false);
+		outBitStream.Write<bool>(false);
 
 		return;
 	}
 
-	outBitStream->Write<bool>(true);
+	outBitStream.Write<bool>(true);
 
 	auto hasPath = !m_PathingStopped && !m_PathName.empty();
-	outBitStream->Write(hasPath);
+	outBitStream.Write(hasPath);
 
 	if (hasPath) {
 		// Is on rail
-		outBitStream->Write1();
+		outBitStream.Write1();
 
-		outBitStream->Write<uint16_t>(m_PathName.size());
+		outBitStream.Write<uint16_t>(m_PathName.size());
 		for (const auto& c : m_PathName) {
-			outBitStream->Write<uint16_t>(c);
+			outBitStream.Write<uint16_t>(c);
 		}
 
 		// Starting point
-		outBitStream->Write<uint32_t>(0);
+		outBitStream.Write<uint32_t>(0);
 
 		// Reverse
-		outBitStream->Write<bool>(false);
+		outBitStream.Write<bool>(false);
 	}
 
 	const auto hasPlatform = m_MoverSubComponent != nullptr;
-	outBitStream->Write<bool>(hasPlatform);
+	outBitStream.Write<bool>(hasPlatform);
 
 	if (hasPlatform) {
 		auto* mover = static_cast<MoverSubComponent*>(m_MoverSubComponent);
-		outBitStream->Write(m_MoverSubComponentType);
+		outBitStream.Write(m_MoverSubComponentType);
 
 		if (m_MoverSubComponentType == eMoverSubComponentType::simpleMover) {
 			// TODO
@@ -162,7 +162,7 @@ void MovingPlatformComponent::StartPathing() {
 		const auto& nextWaypoint = m_Path->pathWaypoints[subComponent->mNextWaypointIndex];
 
 		subComponent->mPosition = currentWaypoint.position;
-		subComponent->mSpeed = currentWaypoint.movingPlatform.speed;
+		subComponent->mSpeed = currentWaypoint.speed;
 		subComponent->mWaitTime = currentWaypoint.movingPlatform.wait;
 
 		targetPosition = nextWaypoint.position;
@@ -183,9 +183,7 @@ void MovingPlatformComponent::StartPathing() {
 	const auto travelNext = subComponent->mWaitTime + travelTime;
 
 	m_Parent->AddCallbackTimer(travelTime, [subComponent, this] {
-		for (CppScripts::Script* script : CppScripts::GetEntityScripts(m_Parent)) {
-			script->OnWaypointReached(m_Parent, subComponent->mNextWaypointIndex);
-		}
+		this->m_Parent->GetScript()->OnWaypointReached(m_Parent, subComponent->mNextWaypointIndex);
 		});
 
 	m_Parent->AddCallbackTimer(travelNext, [this] {
@@ -213,7 +211,7 @@ void MovingPlatformComponent::ContinuePathing() {
 		const auto& nextWaypoint = m_Path->pathWaypoints[subComponent->mNextWaypointIndex];
 
 		subComponent->mPosition = currentWaypoint.position;
-		subComponent->mSpeed = currentWaypoint.movingPlatform.speed;
+		subComponent->mSpeed = currentWaypoint.speed;
 		subComponent->mWaitTime = currentWaypoint.movingPlatform.wait; // + 2;
 
 		pathSize = m_Path->pathWaypoints.size() - 1;
@@ -295,9 +293,7 @@ void MovingPlatformComponent::ContinuePathing() {
 	const auto travelNext = subComponent->mWaitTime + travelTime;
 
 	m_Parent->AddCallbackTimer(travelTime, [subComponent, this] {
-		for (CppScripts::Script* script : CppScripts::GetEntityScripts(m_Parent)) {
-			script->OnWaypointReached(m_Parent, subComponent->mNextWaypointIndex);
-		}
+		this->m_Parent->GetScript()->OnWaypointReached(m_Parent, subComponent->mNextWaypointIndex);
 		});
 
 	m_Parent->AddCallbackTimer(travelNext, [this] {

dGame/dComponents/MovingPlatformComponent.h

@@ -38,7 +38,7 @@ public:
 	MoverSubComponent(const NiPoint3& startPos);
 	~MoverSubComponent();
 
-	void Serialize(RakNet::BitStream* outBitStream, bool bIsInitialUpdate);
+	void Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate);
 
 	/**
 	 * The state the platform is currently in
@@ -111,7 +111,7 @@ public:
 	MovingPlatformComponent(Entity* parent, const std::string& pathName);
 	~MovingPlatformComponent() override;
 
-	void Serialize(RakNet::BitStream* outBitStream, bool bIsInitialUpdate) override;
+	void Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) override;
 
 	/**
 	 * Stops all pathing, called when an entity starts a quick build associated with this platform

dGame/dComponents/PetComponent.cpp

@@ -96,42 +96,42 @@ PetComponent::PetComponent(Entity* parentEntity, uint32_t componentId) : Compone
 	}
 }
 
-void PetComponent::Serialize(RakNet::BitStream* outBitStream, bool bIsInitialUpdate) {
+void PetComponent::Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) {
 	const bool tamed = m_Owner != LWOOBJID_EMPTY;
 
-	outBitStream->Write1(); // Always serialize as dirty for now
+	outBitStream.Write1(); // Always serialize as dirty for now
 
-	outBitStream->Write<uint32_t>(m_Status);
-	outBitStream->Write(tamed ? m_Ability : ePetAbilityType::Invalid); // Something with the overhead icon?
+	outBitStream.Write<uint32_t>(m_Status);
+	outBitStream.Write(tamed ? m_Ability : ePetAbilityType::Invalid); // Something with the overhead icon?
 
 	const bool interacting = m_Interaction != LWOOBJID_EMPTY;
 
-	outBitStream->Write(interacting);
+	outBitStream.Write(interacting);
 	if (interacting) {
-		outBitStream->Write(m_Interaction);
+		outBitStream.Write(m_Interaction);
 	}
 
-	outBitStream->Write(tamed);
+	outBitStream.Write(tamed);
 	if (tamed) {
-		outBitStream->Write(m_Owner);
+		outBitStream.Write(m_Owner);
 	}
 
 	if (bIsInitialUpdate) {
-		outBitStream->Write(tamed);
+		outBitStream.Write(tamed);
 		if (tamed) {
-			outBitStream->Write(m_ModerationStatus);
+			outBitStream.Write(m_ModerationStatus);
 
 			const auto nameData = GeneralUtils::UTF8ToUTF16(m_Name);
 			const auto ownerNameData = GeneralUtils::UTF8ToUTF16(m_OwnerName);
 
-			outBitStream->Write<uint8_t>(nameData.size());
+			outBitStream.Write<uint8_t>(nameData.size());
 			for (const auto c : nameData) {
-				outBitStream->Write(c);
+				outBitStream.Write(c);
 			}
 
-			outBitStream->Write<uint8_t>(ownerNameData.size());
+			outBitStream.Write<uint8_t>(ownerNameData.size());
 			for (const auto c : ownerNameData) {
-				outBitStream->Write(c);
+				outBitStream.Write(c);
 			}
 		}
 	}
@@ -306,9 +306,7 @@ void PetComponent::OnUse(Entity* originator) {
 	currentActivities.insert_or_assign(m_Tamer, m_Parent->GetObjectID());
 
 	// Notify the start of a pet taming minigame
-	for (CppScripts::Script* script : CppScripts::GetEntityScripts(m_Parent)) {
-		script->OnNotifyPetTamingMinigame(m_Parent, originator, ePetTamingNotifyType::BEGIN);
-	}
+	m_Parent->GetScript()->OnNotifyPetTamingMinigame(m_Parent, originator, ePetTamingNotifyType::BEGIN);
 }
 
 void PetComponent::Update(float deltaTime) {
@@ -690,9 +688,7 @@ void PetComponent::RequestSetPetName(std::u16string name) {
 	m_Tamer = LWOOBJID_EMPTY;
 
 	// Notify the end of a pet taming minigame
-	for (CppScripts::Script* script : CppScripts::GetEntityScripts(m_Parent)) {
-		script->OnNotifyPetTamingMinigame(m_Parent, tamer, ePetTamingNotifyType::SUCCESS);
-	}
+	m_Parent->GetScript()->OnNotifyPetTamingMinigame(m_Parent, tamer, ePetTamingNotifyType::SUCCESS);
 }
 
 void PetComponent::ClientExitTamingMinigame(bool voluntaryExit) {
@@ -731,9 +727,7 @@ void PetComponent::ClientExitTamingMinigame(bool voluntaryExit) {
 	Game::entityManager->SerializeEntity(m_Parent);
 
 	// Notify the end of a pet taming minigame
-	for (CppScripts::Script* script : CppScripts::GetEntityScripts(m_Parent)) {
-		script->OnNotifyPetTamingMinigame(m_Parent, tamer, ePetTamingNotifyType::QUIT);
-	}
+	m_Parent->GetScript()->OnNotifyPetTamingMinigame(m_Parent, tamer, ePetTamingNotifyType::QUIT);
 }
 
 void PetComponent::StartTimer() {
@@ -782,9 +776,7 @@ void PetComponent::ClientFailTamingMinigame() {
 	Game::entityManager->SerializeEntity(m_Parent);
 
 	// Notify the end of a pet taming minigame
-	for (CppScripts::Script* script : CppScripts::GetEntityScripts(m_Parent)) {
-		script->OnNotifyPetTamingMinigame(m_Parent, tamer, ePetTamingNotifyType::FAILED);
-	}
+	m_Parent->GetScript()->OnNotifyPetTamingMinigame(m_Parent, tamer, ePetTamingNotifyType::FAILED);
 }
 
 void PetComponent::Wander() {

dGame/dComponents/PetComponent.h

@@ -21,7 +21,7 @@ public:
 	explicit PetComponent(Entity* parentEntity, uint32_t componentId);
 	~PetComponent() override;
 
-	void Serialize(RakNet::BitStream* outBitStream, bool bIsInitialUpdate) override;
+	void Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) override;
 	void Update(float deltaTime) override;
 
 	/**
@@ -353,7 +353,6 @@ private:
 
 	/**
 	 * Pet information loaded from the CDClientDatabase
-	 * TODO: Switch to a reference when safe to do so
 	 */
 	CDPetComponent m_PetInfo;
 };

dGame/dComponents/PhantomPhysicsComponent.cpp

@@ -264,30 +264,30 @@ void PhantomPhysicsComponent::CreatePhysics() {
 	m_HasCreatedPhysics = true;
 }
 
-void PhantomPhysicsComponent::Serialize(RakNet::BitStream* outBitStream, bool bIsInitialUpdate) {
+void PhantomPhysicsComponent::Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) {
 	PhysicsComponent::Serialize(outBitStream, bIsInitialUpdate);
 
-	outBitStream->Write(m_EffectInfoDirty || bIsInitialUpdate);
+	outBitStream.Write(m_EffectInfoDirty || bIsInitialUpdate);
 	if (m_EffectInfoDirty || bIsInitialUpdate) {
-		outBitStream->Write(m_IsPhysicsEffectActive);
+		outBitStream.Write(m_IsPhysicsEffectActive);
 
 		if (m_IsPhysicsEffectActive) {
-			outBitStream->Write(m_EffectType);
-			outBitStream->Write(m_DirectionalMultiplier);
+			outBitStream.Write(m_EffectType);
+			outBitStream.Write(m_DirectionalMultiplier);
 
 			// forgive me father for i have sinned
-			outBitStream->Write0();
-			//outBitStream->Write(m_MinMax);
+			outBitStream.Write0();
+			//outBitStream.Write(m_MinMax);
 			//if (m_MinMax) {
-				//outBitStream->Write(m_Min);
-				//outBitStream->Write(m_Max);
+				//outBitStream.Write(m_Min);
+				//outBitStream.Write(m_Max);
 			//}
 
-			outBitStream->Write(m_IsDirectional);
+			outBitStream.Write(m_IsDirectional);
 			if (m_IsDirectional) {
-				outBitStream->Write(m_Direction.x);
-				outBitStream->Write(m_Direction.y);
-				outBitStream->Write(m_Direction.z);
+				outBitStream.Write(m_Direction.x);
+				outBitStream.Write(m_Direction.y);
+				outBitStream.Write(m_Direction.z);
 			}
 		}
 

dGame/dComponents/PhantomPhysicsComponent.h

@@ -32,7 +32,7 @@ public:
 	PhantomPhysicsComponent(Entity* parent);
 	~PhantomPhysicsComponent() override;
 	void Update(float deltaTime) override;
-	void Serialize(RakNet::BitStream* outBitStream, bool bIsInitialUpdate) override;
+	void Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) override;
 
 	/**
 	 * Creates the physics shape for this entity based on LDF data

dGame/dComponents/PhysicsComponent.cpp

@@ -6,16 +6,16 @@ PhysicsComponent::PhysicsComponent(Entity* parent) : Component(parent) {
 	m_DirtyPosition = false;
 }
 
-void PhysicsComponent::Serialize(RakNet::BitStream* outBitStream, bool bIsInitialUpdate) {
-	outBitStream->Write(bIsInitialUpdate || m_DirtyPosition);
+void PhysicsComponent::Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) {
+	outBitStream.Write(bIsInitialUpdate || m_DirtyPosition);
 	if (bIsInitialUpdate || m_DirtyPosition) {
-		outBitStream->Write(m_Position.x);
-		outBitStream->Write(m_Position.y);
-		outBitStream->Write(m_Position.z);
-		outBitStream->Write(m_Rotation.x);
-		outBitStream->Write(m_Rotation.y);
-		outBitStream->Write(m_Rotation.z);
-		outBitStream->Write(m_Rotation.w);
+		outBitStream.Write(m_Position.x);
+		outBitStream.Write(m_Position.y);
+		outBitStream.Write(m_Position.z);
+		outBitStream.Write(m_Rotation.x);
+		outBitStream.Write(m_Rotation.y);
+		outBitStream.Write(m_Rotation.z);
+		outBitStream.Write(m_Rotation.w);
 		if (!bIsInitialUpdate) m_DirtyPosition = false;
 	}
 }

dGame/dComponents/PhysicsComponent.h

@@ -14,7 +14,7 @@ public:
 	PhysicsComponent(Entity* parent);
 	virtual ~PhysicsComponent() = default;
 
-	void Serialize(RakNet::BitStream* outBitStream, bool bIsInitialUpdate) override;
+	void Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) override;
 
 	const NiPoint3& GetPosition() const { return m_Position; }
 	virtual void SetPosition(const NiPoint3& pos) { if (m_Position == pos) return; m_Position = pos; m_DirtyPosition = true; }

dGame/dComponents/PlayerForcedMovementComponent.cpp

@@ -6,11 +6,11 @@ PlayerForcedMovementComponent::PlayerForcedMovementComponent(Entity* parent) : C
 
 PlayerForcedMovementComponent::~PlayerForcedMovementComponent() {}
 
-void PlayerForcedMovementComponent::Serialize(RakNet::BitStream* outBitStream, bool bIsInitialUpdate) {
-	outBitStream->Write(m_DirtyInfo || bIsInitialUpdate);
+void PlayerForcedMovementComponent::Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) {
+	outBitStream.Write(m_DirtyInfo || bIsInitialUpdate);
 	if (m_DirtyInfo || bIsInitialUpdate) {
-		outBitStream->Write(m_PlayerOnRail);
-		outBitStream->Write(m_ShowBillboard);
+		outBitStream.Write(m_PlayerOnRail);
+		outBitStream.Write(m_ShowBillboard);
 	}
 	m_DirtyInfo = false;
 }

dGame/dComponents/PlayerForcedMovementComponent.h

@@ -19,7 +19,7 @@ public:
 	PlayerForcedMovementComponent(Entity* parent);
 	~PlayerForcedMovementComponent() override;
 
-	void Serialize(RakNet::BitStream* outBitStream, bool bIsInitialUpdate) override;
+	void Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) override;
 
 	/**
 	 * @brief Set the Player On Rail object

dGame/dComponents/PossessableComponent.cpp

@@ -27,17 +27,17 @@ PossessableComponent::PossessableComponent(Entity* parent, uint32_t componentId)
 	result.finalize();
 }
 
-void PossessableComponent::Serialize(RakNet::BitStream* outBitStream, bool bIsInitialUpdate) {
-	outBitStream->Write(m_DirtyPossessable || bIsInitialUpdate);
+void PossessableComponent::Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) {
+	outBitStream.Write(m_DirtyPossessable || bIsInitialUpdate);
 	if (m_DirtyPossessable || bIsInitialUpdate) {
 		m_DirtyPossessable = false; // reset flag
-		outBitStream->Write(m_Possessor != LWOOBJID_EMPTY);
-		if (m_Possessor != LWOOBJID_EMPTY) outBitStream->Write(m_Possessor);
+		outBitStream.Write(m_Possessor != LWOOBJID_EMPTY);
+		if (m_Possessor != LWOOBJID_EMPTY) outBitStream.Write(m_Possessor);
 
-		outBitStream->Write(m_AnimationFlag != eAnimationFlags::IDLE_NONE);
-		if (m_AnimationFlag != eAnimationFlags::IDLE_NONE) outBitStream->Write(m_AnimationFlag);
+		outBitStream.Write(m_AnimationFlag != eAnimationFlags::IDLE_NONE);
+		if (m_AnimationFlag != eAnimationFlags::IDLE_NONE) outBitStream.Write(m_AnimationFlag);
 
-		outBitStream->Write(m_ImmediatelyDepossess);
+		outBitStream.Write(m_ImmediatelyDepossess);
 		m_ImmediatelyDepossess = false; // reset flag
 	}
 }

dGame/dComponents/PossessableComponent.h

@@ -18,7 +18,7 @@ public:
 
 	PossessableComponent(Entity* parentEntity, uint32_t componentId);
 
-	void Serialize(RakNet::BitStream* outBitStream, bool bIsInitialUpdate) override;
+	void Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) override;
 
 	/**
 	 * @brief mounts the Entity

dGame/dComponents/PossessorComponent.cpp

@@ -26,15 +26,15 @@ PossessorComponent::~PossessorComponent() {
 	}
 }
 
-void PossessorComponent::Serialize(RakNet::BitStream* outBitStream, bool bIsInitialUpdate) {
-	outBitStream->Write(m_DirtyPossesor || bIsInitialUpdate);
+void PossessorComponent::Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) {
+	outBitStream.Write(m_DirtyPossesor || bIsInitialUpdate);
 	if (m_DirtyPossesor || bIsInitialUpdate) {
 		m_DirtyPossesor = false;
-		outBitStream->Write(m_Possessable != LWOOBJID_EMPTY);
+		outBitStream.Write(m_Possessable != LWOOBJID_EMPTY);
 		if (m_Possessable != LWOOBJID_EMPTY) {
-			outBitStream->Write(m_Possessable);
+			outBitStream.Write(m_Possessable);
 		}
-		outBitStream->Write(m_PossessableType);
+		outBitStream.Write(m_PossessableType);
 	}
 }
 

dGame/dComponents/PossessorComponent.h

@@ -23,7 +23,7 @@ public:
 	PossessorComponent(Entity* parent);
 	~PossessorComponent() override;
 
-	void Serialize(RakNet::BitStream* outBitStream, bool bIsInitialUpdate) override;
+	void Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) override;
 
 	/**
 	 * @brief Mounts the entity

dGame/dComponents/PropertyManagementComponent.cpp

@@ -214,9 +214,7 @@ bool PropertyManagementComponent::Claim(const LWOOBJID playerId) {
 	Database::Get()->InsertNewProperty(info, templateId, worldId);
 
 	auto* zoneControlObject = Game::zoneManager->GetZoneControlObject();
-	for (CppScripts::Script* script : CppScripts::GetEntityScripts(zoneControlObject)) {
-		script->OnZonePropertyRented(zoneControlObject, entity);
-	}
+	if (zoneControlObject) zoneControlObject->GetScript()->OnZonePropertyRented(zoneControlObject, entity);
 	return true;
 }
 

dGame/dComponents/ProximityMonitorComponent.cpp

@@ -64,6 +64,7 @@ void ProximityMonitorComponent::Update(float deltaTime) {
 	for (const auto& prox : m_ProximitiesData) {
 		if (!prox.second) continue;
 
+		prox.second->SetPosition(m_Parent->GetPosition());
 		//Process enter events
 		for (auto* en : prox.second->GetNewObjects()) {
 			m_Parent->OnCollisionProximity(en->GetObjectID(), prox.first, "ENTER");

dGame/dComponents/QuickBuildComponent.cpp

@@ -55,55 +55,55 @@ QuickBuildComponent::~QuickBuildComponent() {
 	DespawnActivator();
 }
 
-void QuickBuildComponent::Serialize(RakNet::BitStream* outBitStream, bool bIsInitialUpdate) {
+void QuickBuildComponent::Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) {
 	if (m_Parent->GetComponent(eReplicaComponentType::DESTROYABLE) == nullptr) {
 		if (bIsInitialUpdate) {
-			outBitStream->Write(false);
+			outBitStream.Write(false);
 		}
 
-		outBitStream->Write(false);
+		outBitStream.Write(false);
 
-		outBitStream->Write(false);
+		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();
+		outBitStream.Write0();
+		outBitStream.Write0();
 		return;
 	}
 	// BEGIN Scripted Activity
-	outBitStream->Write1();
+	outBitStream.Write1();
 
 	Entity* builder = GetBuilder();
 
 	if (builder) {
-		outBitStream->Write<uint32_t>(1);
-		outBitStream->Write(builder->GetObjectID());
+		outBitStream.Write<uint32_t>(1);
+		outBitStream.Write(builder->GetObjectID());
 
 		for (int i = 0; i < 10; i++) {
-			outBitStream->Write(0.0f);
+			outBitStream.Write(0.0f);
 		}
 	} else {
-		outBitStream->Write<uint32_t>(0);
+		outBitStream.Write<uint32_t>(0);
 	}
 	// END Scripted Activity
 
-	outBitStream->Write1();
+	outBitStream.Write1();
 
-	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);
+		outBitStream.Write(false);
+		outBitStream.Write(m_ActivatorPosition);
+		outBitStream.Write(m_RepositionPlayer);
 	}
 	m_StateDirty = false;
 }
@@ -414,13 +414,11 @@ void QuickBuildComponent::StartQuickBuild(Entity* const user) {
 			movingPlatform->OnQuickBuildInitilized();
 		}
 
-		for (auto* script : CppScripts::GetEntityScripts(m_Parent)) {
-			script->OnQuickBuildStart(m_Parent, user);
-		}
+		auto* script = m_Parent->GetScript();
+		script->OnQuickBuildStart(m_Parent, user);
 
 		// Notify scripts and possible subscribers
-		for (auto* script : CppScripts::GetEntityScripts(m_Parent))
-			script->OnQuickBuildNotifyState(m_Parent, m_State);
+		script->OnQuickBuildNotifyState(m_Parent, m_State);
 		for (const auto& cb : m_QuickBuildStateCallbacks)
 			cb(m_State);
 	}
@@ -485,10 +483,9 @@ void QuickBuildComponent::CompleteQuickBuild(Entity* const user) {
 	}
 
 	// Notify scripts
-	for (auto* script : CppScripts::GetEntityScripts(m_Parent)) {
-		script->OnQuickBuildComplete(m_Parent, user);
-		script->OnQuickBuildNotifyState(m_Parent, m_State);
-	}
+	auto* script = m_Parent->GetScript();
+	script->OnQuickBuildComplete(m_Parent, user);
+	script->OnQuickBuildNotifyState(m_Parent, m_State);
 
 	// Notify subscribers
 	for (const auto& callback : m_QuickBuildStateCallbacks)
@@ -539,8 +536,7 @@ void QuickBuildComponent::ResetQuickBuild(const bool failed) {
 	Game::entityManager->SerializeEntity(m_Parent);
 
 	// Notify scripts and possible subscribers
-	for (auto* script : CppScripts::GetEntityScripts(m_Parent))
-		script->OnQuickBuildNotifyState(m_Parent, m_State);
+	m_Parent->GetScript()->OnQuickBuildNotifyState(m_Parent, m_State);
 	for (const auto& cb : m_QuickBuildStateCallbacks)
 		cb(m_State);
 
@@ -571,8 +567,7 @@ void QuickBuildComponent::CancelQuickBuild(Entity* const entity, const eQuickBui
 		m_StateDirty = true;
 
 		// Notify scripts and possible subscribers
-		for (auto* script : CppScripts::GetEntityScripts(m_Parent))
-			script->OnQuickBuildNotifyState(m_Parent, m_State);
+		m_Parent->GetScript()->OnQuickBuildNotifyState(m_Parent, m_State);
 		for (const auto& cb : m_QuickBuildStateCallbacks)
 			cb(m_State);
 

dGame/dComponents/QuickBuildComponent.h

@@ -27,7 +27,7 @@ public:
 	QuickBuildComponent(Entity* const entity);
 	~QuickBuildComponent() override;
 
-	void Serialize(RakNet::BitStream* outBitStream, bool bIsInitialUpdate) override;
+	void Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) override;
 	void Update(float deltaTime) override;
 
 	/**

dGame/dComponents/RacingControlComponent.cpp

@@ -433,83 +433,83 @@ void RacingControlComponent::HandleMessageBoxResponse(Entity* player, int32_t bu
 	}
 }
 
-void RacingControlComponent::Serialize(RakNet::BitStream* outBitStream, bool bIsInitialUpdate) {
+void RacingControlComponent::Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) {
 	// BEGIN Scripted Activity
-	outBitStream->Write1();
+	outBitStream.Write1();
 
-	outBitStream->Write<uint32_t>(m_RacingPlayers.size());
+	outBitStream.Write<uint32_t>(m_RacingPlayers.size());
 	for (const auto& player : m_RacingPlayers) {
-		outBitStream->Write(player.playerID);
+		outBitStream.Write(player.playerID);
 
-		outBitStream->Write(player.data[0]);
-		if (player.finished != 0) outBitStream->Write<float>(player.raceTime);
-		else outBitStream->Write(player.data[1]);
-		if (player.finished != 0) outBitStream->Write<float>(player.bestLapTime);
-		else outBitStream->Write(player.data[2]);
-		if (player.finished == 1) outBitStream->Write<float>(1.0f);
-		else outBitStream->Write(player.data[3]);
-		outBitStream->Write(player.data[4]);
-		outBitStream->Write(player.data[5]);
-		outBitStream->Write(player.data[6]);
-		outBitStream->Write(player.data[7]);
-		outBitStream->Write(player.data[8]);
-		outBitStream->Write(player.data[9]);
+		outBitStream.Write(player.data[0]);
+		if (player.finished != 0) outBitStream.Write<float>(player.raceTime);
+		else outBitStream.Write(player.data[1]);
+		if (player.finished != 0) outBitStream.Write<float>(player.bestLapTime);
+		else outBitStream.Write(player.data[2]);
+		if (player.finished == 1) outBitStream.Write<float>(1.0f);
+		else outBitStream.Write(player.data[3]);
+		outBitStream.Write(player.data[4]);
+		outBitStream.Write(player.data[5]);
+		outBitStream.Write(player.data[6]);
+		outBitStream.Write(player.data[7]);
+		outBitStream.Write(player.data[8]);
+		outBitStream.Write(player.data[9]);
 	}
 
 	// END Scripted Activity
 
-	outBitStream->Write1();
-	outBitStream->Write<uint16_t>(m_RacingPlayers.size());
+	outBitStream.Write1();
+	outBitStream.Write<uint16_t>(m_RacingPlayers.size());
 
-	outBitStream->Write(!m_AllPlayersReady);
+	outBitStream.Write(!m_AllPlayersReady);
 	if (!m_AllPlayersReady) {
 		int32_t numReady = 0;
 		for (const auto& player : m_RacingPlayers) {
-			outBitStream->Write1(); // Has more player data
-			outBitStream->Write(player.playerID);
-			outBitStream->Write(player.vehicleID);
-			outBitStream->Write(player.playerIndex);
-			outBitStream->Write(player.playerLoaded);
+			outBitStream.Write1(); // Has more player data
+			outBitStream.Write(player.playerID);
+			outBitStream.Write(player.vehicleID);
+			outBitStream.Write(player.playerIndex);
+			outBitStream.Write(player.playerLoaded);
 			if (player.playerLoaded) numReady++;
 		}
 
-		outBitStream->Write0(); // No more data
+		outBitStream.Write0(); // No more data
 		if (numReady == m_RacingPlayers.size()) m_AllPlayersReady = true;
 	}
 
-	outBitStream->Write(!m_RacingPlayers.empty());
+	outBitStream.Write(!m_RacingPlayers.empty());
 	if (!m_RacingPlayers.empty()) {
 		for (const auto& player : m_RacingPlayers) {
 			if (player.finished == 0) continue;
-			outBitStream->Write1(); // Has more date
+			outBitStream.Write1(); // Has more date
 
-			outBitStream->Write(player.playerID);
-			outBitStream->Write(player.finished);
+			outBitStream.Write(player.playerID);
+			outBitStream.Write(player.finished);
 		}
 
-		outBitStream->Write0(); // No more data
+		outBitStream.Write0(); // No more data
 	}
 
-	outBitStream->Write(bIsInitialUpdate);
+	outBitStream.Write(bIsInitialUpdate);
 	if (bIsInitialUpdate) {
-		outBitStream->Write(m_RemainingLaps);
-		outBitStream->Write<uint16_t>(m_PathName.size());
+		outBitStream.Write(m_RemainingLaps);
+		outBitStream.Write<uint16_t>(m_PathName.size());
 		for (const auto character : m_PathName) {
-			outBitStream->Write(character);
+			outBitStream.Write(character);
 		}
 	}
 
-	outBitStream->Write(!m_RacingPlayers.empty());
+	outBitStream.Write(!m_RacingPlayers.empty());
 	if (!m_RacingPlayers.empty()) {
 		for (const auto& player : m_RacingPlayers) {
 			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.Write1(); // Has more data
+			outBitStream.Write(player.playerID);
+			outBitStream.Write<float>(player.bestLapTime);
+			outBitStream.Write<float>(player.raceTime);
 		}
 
-		outBitStream->Write0(); // No more data
+		outBitStream.Write0(); // No more data
 	}
 }
 

dGame/dComponents/RacingControlComponent.h

@@ -110,7 +110,7 @@ public:
 	RacingControlComponent(Entity* parentEntity);
 	~RacingControlComponent();
 
-	void Serialize(RakNet::BitStream* outBitStream, bool bIsInitialUpdate) override;
+	void Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) override;
 	void Update(float deltaTime) override;
 
 	/**

dGame/dComponents/RenderComponent.cpp

@@ -57,25 +57,25 @@ RenderComponent::RenderComponent(Entity* const parentEntity, const int32_t compo
 	m_AnimationGroupCache[componentId] = m_animationGroupIds;
 }
 
-void RenderComponent::Serialize(RakNet::BitStream* outBitStream, bool bIsInitialUpdate) {
+void RenderComponent::Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) {
 	if (!bIsInitialUpdate) return;
 
-	outBitStream->Write<uint32_t>(m_Effects.size());
+	outBitStream.Write<uint32_t>(m_Effects.size());
 
 	for (auto& eff : m_Effects) {
-		outBitStream->Write<uint8_t>(eff.name.size());
+		outBitStream.Write<uint8_t>(eff.name.size());
 		// if there is no name, then we don't write anything else
 		if (eff.name.empty()) continue;
 
-		for (const auto& value : eff.name) outBitStream->Write<uint8_t>(value);
+		for (const auto& value : eff.name) outBitStream.Write<uint8_t>(value);
 
-		outBitStream->Write(eff.effectID);
+		outBitStream.Write(eff.effectID);
 
-		outBitStream->Write<uint8_t>(eff.type.size());
-		for (const auto& value : eff.type) outBitStream->Write<uint16_t>(value);
+		outBitStream.Write<uint8_t>(eff.type.size());
+		for (const auto& value : eff.type) outBitStream.Write<uint16_t>(value);
 
-		outBitStream->Write<float_t>(eff.priority);
-		outBitStream->Write<int64_t>(eff.secondary);
+		outBitStream.Write<float_t>(eff.priority);
+		outBitStream.Write<int64_t>(eff.secondary);
 	}
 }
 

dGame/dComponents/RenderComponent.h

@@ -65,7 +65,7 @@ public:
 
 	RenderComponent(Entity* const parentEntity, const int32_t componentId = -1);
 
-	void Serialize(RakNet::BitStream* outBitStream, bool bIsInitialUpdate) override;
+	void Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) override;
 	void Update(float deltaTime) override;
 
 	/**

dGame/dComponents/RigidbodyPhantomPhysicsComponent.cpp

@@ -11,6 +11,6 @@ RigidbodyPhantomPhysicsComponent::RigidbodyPhantomPhysicsComponent(Entity* paren
 	m_Rotation = m_Parent->GetDefaultRotation();
 }
 
-void RigidbodyPhantomPhysicsComponent::Serialize(RakNet::BitStream* outBitStream, bool bIsInitialUpdate) {
+void RigidbodyPhantomPhysicsComponent::Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) {
 	PhysicsComponent::Serialize(outBitStream, bIsInitialUpdate);
 }

dGame/dComponents/RigidbodyPhantomPhysicsComponent.h

@@ -23,7 +23,7 @@ public:
 
 	RigidbodyPhantomPhysicsComponent(Entity* parent);
 
-	void Serialize(RakNet::BitStream* outBitStream, bool bIsInitialUpdate) override;
+	void Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) override;
 };
 
 #endif // __RIGIDBODYPHANTOMPHYSICS_H__

dGame/dComponents/RocketLaunchpadControlComponent.cpp

@@ -139,7 +139,7 @@ void RocketLaunchpadControlComponent::TellMasterToPrepZone(int zoneID) {
 	CBITSTREAM;
 	BitStreamUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::PREP_ZONE);
 	bitStream.Write(zoneID);
-	Game::server->SendToMaster(&bitStream);
+	Game::server->SendToMaster(bitStream);
 }
 
 

dGame/dComponents/ScriptComponent.cpp

@@ -0,0 +1,52 @@
+/*
+ * Darkflame Universe
+ * Copyright 2018
+ */
+
+#include "Entity.h"
+#include "ScriptComponent.h"
+
+ScriptComponent::ScriptComponent(Entity* parent, std::string scriptName, bool serialized, bool client) : Component(parent) {
+	m_Serialized = serialized;
+	m_Client = client;
+
+	SetScript(scriptName);
+}
+
+ScriptComponent::~ScriptComponent() {
+
+}
+
+void ScriptComponent::Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) {
+	if (bIsInitialUpdate) {
+		const auto& networkSettings = m_Parent->GetNetworkSettings();
+		auto hasNetworkSettings = !networkSettings.empty();
+		outBitStream.Write(hasNetworkSettings);
+
+		if (hasNetworkSettings) {
+
+			// First write the most inner LDF data
+			RakNet::BitStream ldfData;
+			ldfData.Write<uint8_t>(0);
+			ldfData.Write<uint32_t>(networkSettings.size());
+
+			for (auto* networkSetting : networkSettings) {
+				networkSetting->WriteToPacket(ldfData);
+			}
+
+			// Finally write everything to the stream
+			outBitStream.Write<uint32_t>(ldfData.GetNumberOfBytesUsed());
+			outBitStream.Write(ldfData);
+		}
+	}
+}
+
+CppScripts::Script* const ScriptComponent::GetScript() {
+	return m_Script;
+}
+
+void ScriptComponent::SetScript(const std::string& scriptName) {
+	// Scripts are managed by the CppScripts class and are effecitvely singletons
+	// and they may also be used by other script components so DON'T delete them.
+	m_Script = CppScripts::GetScript(m_Parent, scriptName);
+}

dGame/dComponents/ScriptComponent.h

@@ -0,0 +1,65 @@
+/*
+ * Darkflame Universe
+ * Copyright 2018
+ */
+
+#ifndef SCRIPTCOMPONENT_H
+#define SCRIPTCOMPONENT_H
+
+#include "CppScripts.h"
+#include "Component.h"
+#include <string>
+#include "eReplicaComponentType.h"
+
+class Entity;
+
+/**
+ * Handles the loading and execution of server side scripts on entities, scripts were originally written in Lua,
+ * here they're written in C++
+ */
+class ScriptComponent final : public Component {
+public:
+	static constexpr eReplicaComponentType ComponentType = eReplicaComponentType::SCRIPT;
+
+	ScriptComponent(Entity* parent, std::string scriptName, bool serialized, bool client = false);
+	~ScriptComponent() override;
+
+	void Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) override;
+
+	/**
+	 * Returns the script that's attached to this entity
+	 * @return the script that's attached to this entity
+	 */
+	CppScripts::Script* const GetScript();
+
+	/**
+	 * Sets whether the entity should be serialized, unused
+	 * @param var whether the entity should be serialized
+	 */
+	void SetSerialized(const bool var) { m_Serialized = var; }
+
+	/**
+	 * Sets the script using a path by looking through dScripts for a script that matches
+	 * @param scriptName the name of the script to find
+	 */
+	void SetScript(const std::string& scriptName);
+
+private:
+
+	/**
+	 * The script attached to this entity
+	 */
+	CppScripts::Script* m_Script;
+
+	/**
+	 * Whether or not the comp should be serialized, unused
+	 */
+	bool m_Serialized;
+
+	/**
+	 * Whether or not this script is a client script
+	 */
+	bool m_Client;
+};
+
+#endif // SCRIPTCOMPONENT_H

dGame/dComponents/ShootingGalleryComponent.cpp

@@ -17,50 +17,50 @@ void ShootingGalleryComponent::SetDynamicParams(const DynamicShootingGalleryPara
 	Game::entityManager->SerializeEntity(m_Parent);
 }
 
-void ShootingGalleryComponent::Serialize(RakNet::BitStream* outBitStream, bool isInitialUpdate) {
+void ShootingGalleryComponent::Serialize(RakNet::BitStream& outBitStream, bool isInitialUpdate) {
 	// Start ScriptedActivityComponent
-	outBitStream->Write<bool>(true);
+	outBitStream.Write<bool>(true);
 	if (m_CurrentPlayerID == LWOOBJID_EMPTY) {
-		outBitStream->Write<uint32_t>(0);
+		outBitStream.Write<uint32_t>(0);
 	} else {
-		outBitStream->Write<uint32_t>(1);
-		outBitStream->Write<LWOOBJID>(m_CurrentPlayerID);
+		outBitStream.Write<uint32_t>(1);
+		outBitStream.Write<LWOOBJID>(m_CurrentPlayerID);
 		for (size_t i = 0; i < 10; i++) {
-			outBitStream->Write<float_t>(0.0f);
+			outBitStream.Write<float_t>(0.0f);
 		}
 
 	}
 	// End ScriptedActivityComponent
 
 	if (isInitialUpdate) {
-		outBitStream->Write<float_t>(m_StaticParams.cameraPosition.GetX());
-		outBitStream->Write<float_t>(m_StaticParams.cameraPosition.GetY());
-		outBitStream->Write<float_t>(m_StaticParams.cameraPosition.GetZ());
+		outBitStream.Write<float_t>(m_StaticParams.cameraPosition.GetX());
+		outBitStream.Write<float_t>(m_StaticParams.cameraPosition.GetY());
+		outBitStream.Write<float_t>(m_StaticParams.cameraPosition.GetZ());
 
-		outBitStream->Write<float_t>(m_StaticParams.cameraLookatPosition.GetX());
-		outBitStream->Write<float_t>(m_StaticParams.cameraLookatPosition.GetY());
-		outBitStream->Write<float_t>(m_StaticParams.cameraLookatPosition.GetZ());
+		outBitStream.Write<float_t>(m_StaticParams.cameraLookatPosition.GetX());
+		outBitStream.Write<float_t>(m_StaticParams.cameraLookatPosition.GetY());
+		outBitStream.Write<float_t>(m_StaticParams.cameraLookatPosition.GetZ());
 	}
 
-	outBitStream->Write<bool>(m_Dirty || isInitialUpdate);
+	outBitStream.Write<bool>(m_Dirty || isInitialUpdate);
 	if (m_Dirty || isInitialUpdate) {
-		outBitStream->Write<double_t>(m_DynamicParams.cannonVelocity);
-		outBitStream->Write<double_t>(m_DynamicParams.cannonRefireRate);
-		outBitStream->Write<double_t>(m_DynamicParams.cannonMinDistance);
+		outBitStream.Write<double_t>(m_DynamicParams.cannonVelocity);
+		outBitStream.Write<double_t>(m_DynamicParams.cannonRefireRate);
+		outBitStream.Write<double_t>(m_DynamicParams.cannonMinDistance);
 
-		outBitStream->Write<float_t>(m_DynamicParams.cameraBarrelOffset.GetX());
-		outBitStream->Write<float_t>(m_DynamicParams.cameraBarrelOffset.GetY());
-		outBitStream->Write<float_t>(m_DynamicParams.cameraBarrelOffset.GetZ());
+		outBitStream.Write<float_t>(m_DynamicParams.cameraBarrelOffset.GetX());
+		outBitStream.Write<float_t>(m_DynamicParams.cameraBarrelOffset.GetY());
+		outBitStream.Write<float_t>(m_DynamicParams.cameraBarrelOffset.GetZ());
 
-		outBitStream->Write<float_t>(m_DynamicParams.cannonAngle);
+		outBitStream.Write<float_t>(m_DynamicParams.cannonAngle);
 
-		outBitStream->Write<float_t>(m_DynamicParams.facing.GetX());
-		outBitStream->Write<float_t>(m_DynamicParams.facing.GetY());
-		outBitStream->Write<float_t>(m_DynamicParams.facing.GetZ());
+		outBitStream.Write<float_t>(m_DynamicParams.facing.GetX());
+		outBitStream.Write<float_t>(m_DynamicParams.facing.GetY());
+		outBitStream.Write<float_t>(m_DynamicParams.facing.GetZ());
 
-		outBitStream->Write<LWOOBJID>(m_CurrentPlayerID);
-		outBitStream->Write<float_t>(m_DynamicParams.cannonTimeout);
-		outBitStream->Write<float_t>(m_DynamicParams.cannonFOV);
+		outBitStream.Write<LWOOBJID>(m_CurrentPlayerID);
+		outBitStream.Write<float_t>(m_DynamicParams.cannonTimeout);
+		outBitStream.Write<float_t>(m_DynamicParams.cannonFOV);
 		if (!isInitialUpdate) m_Dirty = false;
 	}
 }

dGame/dComponents/ShootingGalleryComponent.h

@@ -77,7 +77,7 @@ public:
 
 	explicit ShootingGalleryComponent(Entity* parent);
 	~ShootingGalleryComponent();
-	void Serialize(RakNet::BitStream* outBitStream, bool isInitialUpdate) override;
+	void Serialize(RakNet::BitStream& outBitStream, bool isInitialUpdate) override;
 
 	/**
 	 * Returns the static params for the shooting gallery

dGame/dComponents/SimplePhysicsComponent.cpp

@@ -32,26 +32,26 @@ SimplePhysicsComponent::SimplePhysicsComponent(Entity* parent, uint32_t componen
 SimplePhysicsComponent::~SimplePhysicsComponent() {
 }
 
-void SimplePhysicsComponent::Serialize(RakNet::BitStream* outBitStream, bool bIsInitialUpdate) {
+void SimplePhysicsComponent::Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) {
 	if (bIsInitialUpdate) {
-		outBitStream->Write(m_ClimbableType != eClimbableType::CLIMBABLE_TYPE_NOT);
-		outBitStream->Write(m_ClimbableType);
+		outBitStream.Write(m_ClimbableType != eClimbableType::CLIMBABLE_TYPE_NOT);
+		outBitStream.Write(m_ClimbableType);
 	}
 
-	outBitStream->Write(m_DirtyVelocity || bIsInitialUpdate);
+	outBitStream.Write(m_DirtyVelocity || bIsInitialUpdate);
 	if (m_DirtyVelocity || bIsInitialUpdate) {
-		outBitStream->Write(m_Velocity);
-		outBitStream->Write(m_AngularVelocity);
+		outBitStream.Write(m_Velocity);
+		outBitStream.Write(m_AngularVelocity);
 
 		m_DirtyVelocity = false;
 	}
 
 	// Physics motion state
 	if (m_PhysicsMotionState != 0) {
-		outBitStream->Write1();
-		outBitStream->Write<uint32_t>(m_PhysicsMotionState);
+		outBitStream.Write1();
+		outBitStream.Write<uint32_t>(m_PhysicsMotionState);
 	} else {
-		outBitStream->Write0();
+		outBitStream.Write0();
 	}
 	PhysicsComponent::Serialize(outBitStream, bIsInitialUpdate);
 }

dGame/dComponents/SimplePhysicsComponent.h

@@ -33,7 +33,7 @@ public:
 	SimplePhysicsComponent(Entity* parent, uint32_t componentID);
 	~SimplePhysicsComponent() override;
 
-	void Serialize(RakNet::BitStream* outBitStream, bool bIsInitialUpdate) override;
+	void Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) override;
 
 	/**
 	 * Returns the velocity of this entity

dGame/dComponents/SkillComponent.cpp

@@ -31,7 +31,7 @@ ProjectileSyncEntry::ProjectileSyncEntry() {
 
 std::unordered_map<uint32_t, uint32_t> SkillComponent::m_skillBehaviorCache = {};
 
-bool SkillComponent::CastPlayerSkill(const uint32_t behaviorId, const uint32_t skillUid, RakNet::BitStream* bitStream, const LWOOBJID target, uint32_t skillID) {
+bool SkillComponent::CastPlayerSkill(const uint32_t behaviorId, const uint32_t skillUid, RakNet::BitStream& bitStream, const LWOOBJID target, uint32_t skillID) {
 	auto* context = new BehaviorContext(this->m_Parent->GetObjectID());
 
 	context->caster = m_Parent->GetObjectID();
@@ -51,7 +51,7 @@ bool SkillComponent::CastPlayerSkill(const uint32_t behaviorId, const uint32_t s
 	return !context->failed;
 }
 
-void SkillComponent::SyncPlayerSkill(const uint32_t skillUid, const uint32_t syncId, RakNet::BitStream* bitStream) {
+void SkillComponent::SyncPlayerSkill(const uint32_t skillUid, const uint32_t syncId, RakNet::BitStream& bitStream) {
 	const auto index = this->m_managedBehaviors.find(skillUid);
 
 	if (index == this->m_managedBehaviors.end()) {
@@ -66,7 +66,7 @@ void SkillComponent::SyncPlayerSkill(const uint32_t skillUid, const uint32_t syn
 }
 
 
-void SkillComponent::SyncPlayerProjectile(const LWOOBJID projectileId, RakNet::BitStream* bitStream, const LWOOBJID target) {
+void SkillComponent::SyncPlayerProjectile(const LWOOBJID projectileId, RakNet::BitStream& bitStream, const LWOOBJID target) {
 	auto index = -1;
 
 	for (auto i = 0u; i < this->m_managedProjectiles.size(); ++i) {
@@ -252,7 +252,7 @@ bool SkillComponent::CastSkill(const uint32_t skillId, LWOOBJID target, const LW
 
 
 SkillExecutionResult SkillComponent::CalculateBehavior(const uint32_t skillId, const uint32_t behaviorId, const LWOOBJID target, const bool ignoreTarget, const bool clientInitalized, const LWOOBJID originatorOverride) {
-	auto* bitStream = new RakNet::BitStream();
+	RakNet::BitStream bitStream{};
 
 	auto* behavior = Behavior::CreateBehavior(behaviorId);
 
@@ -268,12 +268,9 @@ SkillExecutionResult SkillComponent::CalculateBehavior(const uint32_t skillId, c
 
 	behavior->Calculate(context, bitStream, { target, 0 });
 
-	for (auto* script : CppScripts::GetEntityScripts(m_Parent)) {
-		script->OnSkillCast(m_Parent, skillId);
-	}
+	m_Parent->GetScript()->OnSkillCast(m_Parent, skillId);
 
 	if (!context->foundTarget) {
-		delete bitStream;
 		delete context;
 
 		// Invalid attack
@@ -299,22 +296,20 @@ SkillExecutionResult SkillComponent::CalculateBehavior(const uint32_t skillId, c
 		}
 		//start.optionalTargetID = target;
 
-		start.sBitStream.assign(reinterpret_cast<char*>(bitStream->GetData()), bitStream->GetNumberOfBytesUsed());
+		start.sBitStream.assign(reinterpret_cast<char*>(bitStream.GetData()), bitStream.GetNumberOfBytesUsed());
 
 		// Write message
 		RakNet::BitStream message;
 
 		BitStreamUtils::WriteHeader(message, eConnectionType::CLIENT, eClientMessageType::GAME_MSG);
 		message.Write(this->m_Parent->GetObjectID());
-		start.Serialize(&message);
+		start.Serialize(message);
 
-		Game::server->Send(&message, UNASSIGNED_SYSTEM_ADDRESS, true);
+		Game::server->Send(message, UNASSIGNED_SYSTEM_ADDRESS, true);
 	}
 
 	context->ExecuteUpdates();
 
-	delete bitStream;
-
 	// Valid attack
 	return { true, context->skillTime };
 }
@@ -424,13 +419,13 @@ void SkillComponent::SyncProjectileCalculation(const ProjectileSyncEntry& entry)
 
 	auto* behavior = Behavior::CreateBehavior(behaviorId);
 
-	auto* bitStream = new RakNet::BitStream();
+	RakNet::BitStream bitStream{};
 
 	behavior->Calculate(entry.context, bitStream, entry.branchContext);
 
 	DoClientProjectileImpact projectileImpact;
 
-	projectileImpact.sBitStream.assign(reinterpret_cast<char*>(bitStream->GetData()), bitStream->GetNumberOfBytesUsed());
+	projectileImpact.sBitStream.assign(reinterpret_cast<char*>(bitStream.GetData()), bitStream.GetNumberOfBytesUsed());
 	projectileImpact.i64OwnerID = this->m_Parent->GetObjectID();
 	projectileImpact.i64OrgID = entry.id;
 	projectileImpact.i64TargetID = entry.branchContext.target;
@@ -439,42 +434,34 @@ void SkillComponent::SyncProjectileCalculation(const ProjectileSyncEntry& entry)
 
 	BitStreamUtils::WriteHeader(message, eConnectionType::CLIENT, eClientMessageType::GAME_MSG);
 	message.Write(this->m_Parent->GetObjectID());
-	projectileImpact.Serialize(&message);
+	projectileImpact.Serialize(message);
 
-	Game::server->Send(&message, UNASSIGNED_SYSTEM_ADDRESS, true);
+	Game::server->Send(message, UNASSIGNED_SYSTEM_ADDRESS, true);
 
 	entry.context->ExecuteUpdates();
-
-	delete bitStream;
 }
 
 void SkillComponent::HandleUnmanaged(const uint32_t behaviorId, const LWOOBJID target, LWOOBJID source) {
-	auto* context = new BehaviorContext(source);
+	BehaviorContext context{ source };
 
-	context->unmanaged = true;
-	context->caster = target;
+	context.unmanaged = true;
+	context.caster = target;
 
 	auto* behavior = Behavior::CreateBehavior(behaviorId);
 
-	auto* bitStream = new RakNet::BitStream();
+	RakNet::BitStream bitStream{};
 
-	behavior->Handle(context, bitStream, { target });
-
-	delete bitStream;
-
-	delete context;
+	behavior->Handle(&context, bitStream, { target });
 }
 
 void SkillComponent::HandleUnCast(const uint32_t behaviorId, const LWOOBJID target) {
-	auto* context = new BehaviorContext(target);
+	BehaviorContext context{ target };
 
-	context->caster = target;
+	context.caster = target;
 
 	auto* behavior = Behavior::CreateBehavior(behaviorId);
 
-	behavior->UnCast(context, { target });
-
-	delete context;
+	behavior->UnCast(&context, { target });
 }
 
 SkillComponent::SkillComponent(Entity* parent): Component(parent) {
@@ -485,8 +472,8 @@ SkillComponent::~SkillComponent() {
 	Reset();
 }
 
-void SkillComponent::Serialize(RakNet::BitStream* outBitStream, bool bIsInitialUpdate) {
-	if (bIsInitialUpdate) outBitStream->Write0();
+void SkillComponent::Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) {
+	if (bIsInitialUpdate) outBitStream.Write0();
 }
 
 /// <summary>

dGame/dComponents/SkillComponent.h

@@ -64,7 +64,7 @@ public:
 	explicit SkillComponent(Entity* parent);
 	~SkillComponent() override;
 
-	void Serialize(RakNet::BitStream* outBitStream, bool bIsInitialUpdate) override;
+	void Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) override;
 
 	/**
 	 * Computes skill updates. Invokes CalculateUpdate.
@@ -93,7 +93,7 @@ public:
 	 * @param bitStream the bitSteam given by the client to determine the behavior path
 	 * @param target the explicit target of the skill
 	 */
-	bool CastPlayerSkill(uint32_t behaviorId, uint32_t skillUid, RakNet::BitStream* bitStream, LWOOBJID target, uint32_t skillID = 0);
+	bool CastPlayerSkill(uint32_t behaviorId, uint32_t skillUid, RakNet::BitStream& bitStream, LWOOBJID target, uint32_t skillID = 0);
 
 	/**
 	 * Continues a player skill. Should only be called when the server receives a sync message from the client.
@@ -101,7 +101,7 @@ public:
 	 * @param syncId the unique sync ID of the skill given by the client
 	 * @param bitStream the bitSteam given by the client to determine the behavior path
 	 */
-	void SyncPlayerSkill(uint32_t skillUid, uint32_t syncId, RakNet::BitStream* bitStream);
+	void SyncPlayerSkill(uint32_t skillUid, uint32_t syncId, RakNet::BitStream& bitStream);
 
 	/**
 	 * Continues a player projectile calculation. Should only be called when the server receives a projectile sync message from the client.
@@ -109,7 +109,7 @@ public:
 	 * @param bitStream the bitSteam given by the client to determine the behavior path
 	 * @param target the explicit target of the target
 	 */
-	void SyncPlayerProjectile(LWOOBJID projectileId, RakNet::BitStream* bitStream, LWOOBJID target);
+	void SyncPlayerProjectile(LWOOBJID projectileId, RakNet::BitStream& bitStream, LWOOBJID target);
 
 	/**
 	 * Registers a player projectile. Should only be called when the server is computing a player projectile.

dGame/dComponents/SoundTriggerComponent.cpp

@@ -2,28 +2,28 @@
 #include "Game.h"
 #include "Logger.h"
 
-void MusicCue::Serialize(RakNet::BitStream* outBitStream){
-	outBitStream->Write<uint8_t>(name.size());
-	outBitStream->Write(name.c_str(), name.size());
-	outBitStream->Write(result);
-	outBitStream->Write(boredomTime);
+void MusicCue::Serialize(RakNet::BitStream& outBitStream){
+	outBitStream.Write<uint8_t>(name.size());
+	outBitStream.Write(name.c_str(), name.size());
+	outBitStream.Write(result);
+	outBitStream.Write(boredomTime);
 }
 
-void MusicParameter::Serialize(RakNet::BitStream* outBitStream){
-	outBitStream->Write<uint8_t>(name.size());
-	outBitStream->Write(name.c_str(), name.size());
-	outBitStream->Write(value);
+void MusicParameter::Serialize(RakNet::BitStream& outBitStream){
+	outBitStream.Write<uint8_t>(name.size());
+	outBitStream.Write(name.c_str(), name.size());
+	outBitStream.Write(value);
 }
 
-void GUIDResults::Serialize(RakNet::BitStream* outBitStream){
+void GUIDResults::Serialize(RakNet::BitStream& outBitStream){
 	guid.Serialize(outBitStream);
-	outBitStream->Write(result);
+	outBitStream.Write(result);
 }
 
-void MixerProgram::Serialize(RakNet::BitStream* outBitStream){
-	outBitStream->Write<uint8_t>(name.size());
-	outBitStream->Write(name.c_str(), name.size());
-	outBitStream->Write(result);
+void MixerProgram::Serialize(RakNet::BitStream& outBitStream){
+	outBitStream.Write<uint8_t>(name.size());
+	outBitStream.Write(name.c_str(), name.size());
+	outBitStream.Write(result);
 }
 SoundTriggerComponent::SoundTriggerComponent(Entity* parent) : Component(parent) {
 
@@ -55,30 +55,30 @@ SoundTriggerComponent::SoundTriggerComponent(Entity* parent) : Component(parent)
 	if (!mixerName.empty()) this->m_MixerPrograms.push_back(MixerProgram(mixerName));
 }
 
-void SoundTriggerComponent::Serialize(RakNet::BitStream* outBitStream, bool bIsInitialUpdate) {
-	outBitStream->Write(this->m_Dirty || bIsInitialUpdate);
+void SoundTriggerComponent::Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) {
+	outBitStream.Write(this->m_Dirty || bIsInitialUpdate);
 	if (this->m_Dirty || bIsInitialUpdate) {
-		outBitStream->Write<uint8_t>(this->m_MusicCues.size());
+		outBitStream.Write<uint8_t>(this->m_MusicCues.size());
 		for (auto& musicCue : this->m_MusicCues) {
 			musicCue.Serialize(outBitStream);
 		}
 
-		outBitStream->Write<uint8_t>(this->m_MusicParameters.size());
+		outBitStream.Write<uint8_t>(this->m_MusicParameters.size());
 		for (auto& musicParam : this->m_MusicParameters) {
 			musicParam.Serialize(outBitStream);
 		}
 
-		outBitStream->Write<uint8_t>(this->m_2DAmbientSounds.size());
+		outBitStream.Write<uint8_t>(this->m_2DAmbientSounds.size());
 		for (auto twoDAmbientSound : this->m_2DAmbientSounds) {
 			twoDAmbientSound.Serialize(outBitStream);
 		}
 
-		outBitStream->Write<uint8_t>(this->m_3DAmbientSounds.size());
+		outBitStream.Write<uint8_t>(this->m_3DAmbientSounds.size());
 		for (auto threeDAmbientSound : this->m_3DAmbientSounds) {
 			threeDAmbientSound.Serialize(outBitStream);
 		}
 
-		outBitStream->Write<uint8_t>(this->m_MixerPrograms.size());
+		outBitStream.Write<uint8_t>(this->m_MixerPrograms.size());
 		for (auto& mixerProgram : this->m_MixerPrograms) {
 			mixerProgram.Serialize(outBitStream);
 		}

dGame/dComponents/SoundTriggerComponent.h

@@ -17,7 +17,7 @@ struct MusicCue {
 		this->boredomTime = boredomTime;
 	};
 
-	void Serialize(RakNet::BitStream* outBitStream);
+	void Serialize(RakNet::BitStream& outBitStream);
 };
 
 struct MusicParameter {
@@ -29,7 +29,7 @@ struct MusicParameter {
 		this->value = value;
 	}
 
-	void Serialize(RakNet::BitStream* outBitStream);
+	void Serialize(RakNet::BitStream& outBitStream);
 };
 
 struct GUIDResults{
@@ -41,7 +41,7 @@ struct GUIDResults{
 		this->result = result;
 	}
 
-	void Serialize(RakNet::BitStream* outBitStream);
+	void Serialize(RakNet::BitStream& outBitStream);
 };
 
 struct MixerProgram {
@@ -53,7 +53,7 @@ struct MixerProgram {
 		this->result = result;
 	}
 
-	void Serialize(RakNet::BitStream* outBitStream);
+	void Serialize(RakNet::BitStream& outBitStream);
 };
 
 
@@ -61,7 +61,7 @@ class SoundTriggerComponent : public Component {
 public:
 	static constexpr eReplicaComponentType ComponentType = eReplicaComponentType::SOUND_TRIGGER;
 	explicit SoundTriggerComponent(Entity* parent);
-	void Serialize(RakNet::BitStream* outBitStream, bool bIsInitialUpdate) override;
+	void Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) override;
 	void ActivateMusicCue(const std::string& name, float bordemTime = -1.0);
 	void DeactivateMusicCue(const std::string& name);
 

dGame/dComponents/SwitchComponent.cpp

@@ -21,8 +21,8 @@ SwitchComponent::~SwitchComponent() {
 	}
 }
 
-void SwitchComponent::Serialize(RakNet::BitStream* outBitStream, bool bIsInitialUpdate) {
-	outBitStream->Write(m_Active);
+void SwitchComponent::Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) {
+	outBitStream.Write(m_Active);
 }
 
 void SwitchComponent::SetActive(bool active) {

dGame/dComponents/SwitchComponent.h

@@ -25,7 +25,7 @@ public:
 
 	Entity* GetParentEntity() const;
 
-	void Serialize(RakNet::BitStream* outBitStream, bool bIsInitialUpdate) override;
+	void Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) override;
 
 	/**
 	 * Sets whether the switch is on or off.

dGame/dComponents/TriggerComponent.cpp

@@ -13,9 +13,11 @@
 #include "SkillComponent.h"
 #include "eEndBehavior.h"
 #include "PlayerManager.h"
+#include "Game.h"
+#include "EntityManager.h"
+#include "MovementAIComponent.h"
 
-
-TriggerComponent::TriggerComponent(Entity* parent, const std::string triggerInfo): Component(parent) {
+TriggerComponent::TriggerComponent(Entity* parent, const std::string triggerInfo) : Component(parent) {
 	m_Parent = parent;
 	m_Trigger = nullptr;
 
@@ -42,7 +44,7 @@ void TriggerComponent::TriggerEvent(eTriggerEventType event, Entity* optionalTar
 }
 
 void TriggerComponent::HandleTriggerCommand(LUTriggers::Command* command, Entity* optionalTarget) {
-	auto argArray =  GeneralUtils::SplitString(command->args, ',');
+	auto argArray = GeneralUtils::SplitString(command->args, ',');
 
 	// determine targets
 	std::vector<Entity*> targetEntities = GatherTargets(command, optionalTarget);
@@ -54,107 +56,119 @@ void TriggerComponent::HandleTriggerCommand(LUTriggers::Command* command, Entity
 		if (!targetEntity) continue;
 
 		switch (command->id) {
-			case eTriggerCommandType::ZONE_PLAYER: break;
-			case eTriggerCommandType::FIRE_EVENT:
-				HandleFireEvent(targetEntity, command->args);
-				break;
-			case eTriggerCommandType::DESTROY_OBJ:
-				HandleDestroyObject(targetEntity, command->args);
-				break;
-			case eTriggerCommandType::TOGGLE_TRIGGER:
-				HandleToggleTrigger(targetEntity, command->args);
-				break;
-			case eTriggerCommandType::RESET_REBUILD:
-				HandleResetRebuild(targetEntity, command->args);
-				break;
-			case eTriggerCommandType::SET_PATH: break;
-			case eTriggerCommandType::SET_PICK_TYPE: break;
-			case eTriggerCommandType::MOVE_OBJECT:
-				HandleMoveObject(targetEntity, argArray);
-				break;
-			case eTriggerCommandType::ROTATE_OBJECT:
-				HandleRotateObject(targetEntity, argArray);
-				break;
-			case eTriggerCommandType::PUSH_OBJECT:
-				HandlePushObject(targetEntity, argArray);
-				break;
-			case eTriggerCommandType::REPEL_OBJECT:
-				HandleRepelObject(targetEntity, command->args);
-				break;
-			case eTriggerCommandType::SET_TIMER:
-				HandleSetTimer(targetEntity, argArray);
-				break;
-			case eTriggerCommandType::CANCEL_TIMER:
-				HandleCancelTimer(targetEntity, command->args);
-				break;
-			case eTriggerCommandType::PLAY_CINEMATIC:
-				HandlePlayCinematic(targetEntity, argArray);
-				break;
-			case eTriggerCommandType::TOGGLE_BBB:
-				HandleToggleBBB(targetEntity, command->args);
-				break;
-			case eTriggerCommandType::UPDATE_MISSION:
-				HandleUpdateMission(targetEntity, argArray);
-				break;
-			case eTriggerCommandType::SET_BOUNCER_STATE: break;
-			case eTriggerCommandType::BOUNCE_ALL_ON_BOUNCER: break;
-			case eTriggerCommandType::TURN_AROUND_ON_PATH: break;
-			case eTriggerCommandType::GO_FORWARD_ON_PATH: break;
-			case eTriggerCommandType::GO_BACKWARD_ON_PATH: break;
-			case eTriggerCommandType::STOP_PATHING: break;
-			case eTriggerCommandType::START_PATHING: break;
-			case eTriggerCommandType::LOCK_OR_UNLOCK_CONTROLS: break;
-			case eTriggerCommandType::PLAY_EFFECT:
-				HandlePlayEffect(targetEntity, argArray);
-				break;
-			case eTriggerCommandType::STOP_EFFECT:
-				GameMessages::SendStopFXEffect(targetEntity, true, command->args);
-				break;
-			case eTriggerCommandType::CAST_SKILL:
-				HandleCastSkill(targetEntity, command->args);
-				break;
-			case eTriggerCommandType::DISPLAY_ZONE_SUMMARY:
-				GameMessages::SendDisplayZoneSummary(targetEntity->GetObjectID(), targetEntity->GetSystemAddress(), false, command->args == "1", m_Parent->GetObjectID());
-				break;
-			case eTriggerCommandType::SET_PHYSICS_VOLUME_EFFECT:
-				HandleSetPhysicsVolumeEffect(targetEntity, argArray);
-				break;
-			case eTriggerCommandType::SET_PHYSICS_VOLUME_STATUS:
-				HandleSetPhysicsVolumeStatus(targetEntity, command->args);
-				break;
-			case eTriggerCommandType::SET_MODEL_TO_BUILD: break;
-			case eTriggerCommandType::SPAWN_MODEL_BRICKS: break;
-			case eTriggerCommandType::ACTIVATE_SPAWNER_NETWORK:
-				HandleActivateSpawnerNetwork(command->args);
-				break;
-			case eTriggerCommandType::DEACTIVATE_SPAWNER_NETWORK:
-				HandleDeactivateSpawnerNetwork(command->args);
-				break;
-			case eTriggerCommandType::RESET_SPAWNER_NETWORK:
-				HandleResetSpawnerNetwork(command->args);
-				break;
-			case eTriggerCommandType::DESTROY_SPAWNER_NETWORK_OBJECTS:
-				HandleDestroySpawnerNetworkObjects(command->args);
-				break;
-			case eTriggerCommandType::GO_TO_WAYPOINT: break;
-			case eTriggerCommandType::ACTIVATE_PHYSICS:
-				HandleActivatePhysics(targetEntity, command->args);
-				break;
+		case eTriggerCommandType::ZONE_PLAYER: break;
+		case eTriggerCommandType::FIRE_EVENT:
+			HandleFireEvent(targetEntity, command->args);
+			break;
+		case eTriggerCommandType::DESTROY_OBJ:
+			HandleDestroyObject(targetEntity, command->args);
+			break;
+		case eTriggerCommandType::TOGGLE_TRIGGER:
+			HandleToggleTrigger(targetEntity, command->args);
+			break;
+		case eTriggerCommandType::RESET_REBUILD:
+			HandleResetRebuild(targetEntity, command->args);
+			break;
+		case eTriggerCommandType::SET_PATH:
+			HandleSetPath(targetEntity, argArray);
+			break;
+		case eTriggerCommandType::SET_PICK_TYPE: break;
+		case eTriggerCommandType::MOVE_OBJECT:
+			HandleMoveObject(targetEntity, argArray);
+			break;
+		case eTriggerCommandType::ROTATE_OBJECT:
+			HandleRotateObject(targetEntity, argArray);
+			break;
+		case eTriggerCommandType::PUSH_OBJECT:
+			HandlePushObject(targetEntity, argArray);
+			break;
+		case eTriggerCommandType::REPEL_OBJECT:
+			HandleRepelObject(targetEntity, command->args);
+			break;
+		case eTriggerCommandType::SET_TIMER:
+			HandleSetTimer(targetEntity, argArray);
+			break;
+		case eTriggerCommandType::CANCEL_TIMER:
+			HandleCancelTimer(targetEntity, command->args);
+			break;
+		case eTriggerCommandType::PLAY_CINEMATIC:
+			HandlePlayCinematic(targetEntity, argArray);
+			break;
+		case eTriggerCommandType::TOGGLE_BBB:
+			HandleToggleBBB(targetEntity, command->args);
+			break;
+		case eTriggerCommandType::UPDATE_MISSION:
+			HandleUpdateMission(targetEntity, argArray);
+			break;
+		case eTriggerCommandType::SET_BOUNCER_STATE: break;
+		case eTriggerCommandType::BOUNCE_ALL_ON_BOUNCER: break;
+		case eTriggerCommandType::TURN_AROUND_ON_PATH:
+			HandleTurnAroundOnPath(targetEntity);
+			break;
+		case eTriggerCommandType::GO_FORWARD_ON_PATH:
+			HandleGoForwardOnPath(targetEntity);
+			break;
+		case eTriggerCommandType::GO_BACKWARD_ON_PATH:
+			HandleGoBackwardOnPath(targetEntity);
+			break;
+		case eTriggerCommandType::STOP_PATHING:
+			HandleStopPathing(targetEntity);
+			break;
+		case eTriggerCommandType::START_PATHING:
+			HandleStartPathing(targetEntity);
+			break;
+		case eTriggerCommandType::LOCK_OR_UNLOCK_CONTROLS: break;
+		case eTriggerCommandType::PLAY_EFFECT:
+			HandlePlayEffect(targetEntity, argArray);
+			break;
+		case eTriggerCommandType::STOP_EFFECT:
+			GameMessages::SendStopFXEffect(targetEntity, true, command->args);
+			break;
+		case eTriggerCommandType::CAST_SKILL:
+			HandleCastSkill(targetEntity, command->args);
+			break;
+		case eTriggerCommandType::DISPLAY_ZONE_SUMMARY:
+			GameMessages::SendDisplayZoneSummary(targetEntity->GetObjectID(), targetEntity->GetSystemAddress(), false, command->args == "1", m_Parent->GetObjectID());
+			break;
+		case eTriggerCommandType::SET_PHYSICS_VOLUME_EFFECT:
+			HandleSetPhysicsVolumeEffect(targetEntity, argArray);
+			break;
+		case eTriggerCommandType::SET_PHYSICS_VOLUME_STATUS:
+			HandleSetPhysicsVolumeStatus(targetEntity, command->args);
+			break;
+		case eTriggerCommandType::SET_MODEL_TO_BUILD: break;
+		case eTriggerCommandType::SPAWN_MODEL_BRICKS: break;
+		case eTriggerCommandType::ACTIVATE_SPAWNER_NETWORK:
+			HandleActivateSpawnerNetwork(command->args);
+			break;
+		case eTriggerCommandType::DEACTIVATE_SPAWNER_NETWORK:
+			HandleDeactivateSpawnerNetwork(command->args);
+			break;
+		case eTriggerCommandType::RESET_SPAWNER_NETWORK:
+			HandleResetSpawnerNetwork(command->args);
+			break;
+		case eTriggerCommandType::DESTROY_SPAWNER_NETWORK_OBJECTS:
+			HandleDestroySpawnerNetworkObjects(command->args);
+			break;
+		case eTriggerCommandType::GO_TO_WAYPOINT: break;
+		case eTriggerCommandType::ACTIVATE_PHYSICS:
+			HandleActivatePhysics(targetEntity, command->args);
+			break;
 			// DEPRECATED BLOCK START
-			case eTriggerCommandType::ACTIVATE_MUSIC_CUE: break;
-			case eTriggerCommandType::DEACTIVATE_MUSIC_CUE: break;
-			case eTriggerCommandType::FLASH_MUSIC_CUE: break;
-			case eTriggerCommandType::SET_MUSIC_PARAMETER: break;
-			case eTriggerCommandType::PLAY_2D_AMBIENT_SOUND: break;
-			case eTriggerCommandType::STOP_2D_AMBIENT_SOUND: break;
-			case eTriggerCommandType::PLAY_3D_AMBIENT_SOUND: break;
-			case eTriggerCommandType::STOP_3D_AMBIENT_SOUND: break;
-			case eTriggerCommandType::ACTIVATE_MIXER_PROGRAM: break;
-			case eTriggerCommandType::DEACTIVATE_MIXER_PROGRAM: break;
+		case eTriggerCommandType::ACTIVATE_MUSIC_CUE: break;
+		case eTriggerCommandType::DEACTIVATE_MUSIC_CUE: break;
+		case eTriggerCommandType::FLASH_MUSIC_CUE: break;
+		case eTriggerCommandType::SET_MUSIC_PARAMETER: break;
+		case eTriggerCommandType::PLAY_2D_AMBIENT_SOUND: break;
+		case eTriggerCommandType::STOP_2D_AMBIENT_SOUND: break;
+		case eTriggerCommandType::PLAY_3D_AMBIENT_SOUND: break;
+		case eTriggerCommandType::STOP_3D_AMBIENT_SOUND: break;
+		case eTriggerCommandType::ACTIVATE_MIXER_PROGRAM: break;
+		case eTriggerCommandType::DEACTIVATE_MIXER_PROGRAM: break;
 			// DEPRECATED BLOCK END
-			default:
-				LOG_DEBUG("Event %i was not handled!", command->id);
-				break;
+		default:
+			LOG_DEBUG("Event %i was not handled!", command->id);
+			break;
 		}
 	}
 }
@@ -163,36 +177,39 @@ std::vector<Entity*> TriggerComponent::GatherTargets(LUTriggers::Command* comman
 	std::vector<Entity*> entities = {};
 
 	if (command->target == "self") entities.push_back(m_Parent);
-	else if (command->target == "zone") { /*TODO*/ }
-	else if (command->target == "target" && optionalTarget) entities.push_back(optionalTarget);
-	else if (command->target == "targetTeam" && optionalTarget) {
+	else if (command->target == "zone") {
+		/*TODO*/
+	} else if (command->target == "target" && optionalTarget) {
+		entities.push_back(optionalTarget);
+	} else if (command->target == "targetTeam" && optionalTarget) {
 		auto* team = TeamManager::Instance()->GetTeam(optionalTarget->GetObjectID());
 		for (const auto memberId : team->members) {
 			auto* member = Game::entityManager->GetEntity(memberId);
 			if (member) entities.push_back(member);
 		}
-	} else if (command->target == "objGroup") entities = Game::entityManager->GetEntitiesInGroup(command->targetName);
-	else if (command->target == "allPlayers") {
+	} else if (command->target == "objGroup") {
+		entities = Game::entityManager->GetEntitiesInGroup(command->targetName);
+	} else if (command->target == "allPlayers") {
 		for (auto* player : PlayerManager::GetAllPlayers()) {
 			entities.push_back(player);
 		}
-	} else if (command->target == "allNPCs") { /*UNUSED*/ }
+	} else if (command->target == "allNPCs") {
+		/*UNUSED*/
+	}
 
 	return entities;
 }
 
 void TriggerComponent::HandleFireEvent(Entity* targetEntity, std::string args) {
-	for (CppScripts::Script* script : CppScripts::GetEntityScripts(targetEntity)) {
-		script->OnFireEventServerSide(targetEntity, m_Parent, args, 0, 0, 0);
-	}
+	targetEntity->GetScript()->OnFireEventServerSide(targetEntity, m_Parent, args, 0, 0, 0);
 }
 
-void TriggerComponent::HandleDestroyObject(Entity* targetEntity, std::string args){
+void TriggerComponent::HandleDestroyObject(Entity* targetEntity, std::string args) {
 	const eKillType killType = GeneralUtils::TryParse<eKillType>(args).value_or(eKillType::VIOLENT);
 	targetEntity->Smash(m_Parent->GetObjectID(), killType);
 }
 
-void TriggerComponent::HandleToggleTrigger(Entity* targetEntity, std::string args){
+void TriggerComponent::HandleToggleTrigger(Entity* targetEntity, std::string args) {
 	auto* triggerComponent = targetEntity->GetComponent<TriggerComponent>();
 	if (!triggerComponent) {
 		LOG_DEBUG("Trigger component not found!");
@@ -201,7 +218,7 @@ void TriggerComponent::HandleToggleTrigger(Entity* targetEntity, std::string arg
 	triggerComponent->SetTriggerEnabled(args == "1");
 }
 
-void TriggerComponent::HandleResetRebuild(Entity* targetEntity, std::string args){
+void TriggerComponent::HandleResetRebuild(Entity* targetEntity, std::string args) {
 	auto* quickBuildComponent = targetEntity->GetComponent<QuickBuildComponent>();
 	if (!quickBuildComponent) {
 		LOG_DEBUG("Rebuild component not found!");
@@ -210,7 +227,7 @@ void TriggerComponent::HandleResetRebuild(Entity* targetEntity, std::string args
 	quickBuildComponent->ResetQuickBuild(args == "1");
 }
 
-void TriggerComponent::HandleMoveObject(Entity* targetEntity, std::vector<std::string> argArray){
+void TriggerComponent::HandleMoveObject(Entity* targetEntity, std::vector<std::string> argArray) {
 	if (argArray.size() <= 2) return;
 
 	NiPoint3 position = targetEntity->GetPosition();
@@ -220,7 +237,7 @@ void TriggerComponent::HandleMoveObject(Entity* targetEntity, std::vector<std::s
 	targetEntity->SetPosition(position);
 }
 
-void TriggerComponent::HandleRotateObject(Entity* targetEntity, std::vector<std::string> argArray){
+void TriggerComponent::HandleRotateObject(Entity* targetEntity, std::vector<std::string> argArray) {
 	if (argArray.size() <= 2) return;
 
 	const NiPoint3 vector = GeneralUtils::TryParse<NiPoint3>(argArray).value_or(NiPoint3Constant::ZERO);
@@ -229,7 +246,7 @@ void TriggerComponent::HandleRotateObject(Entity* targetEntity, std::vector<std:
 	targetEntity->SetRotation(rotation);
 }
 
-void TriggerComponent::HandlePushObject(Entity* targetEntity, std::vector<std::string> argArray){
+void TriggerComponent::HandlePushObject(Entity* targetEntity, std::vector<std::string> argArray) {
 	if (argArray.size() < 3) return;
 
 	auto* phantomPhysicsComponent = m_Parent->GetComponent<PhantomPhysicsComponent>();
@@ -247,7 +264,7 @@ void TriggerComponent::HandlePushObject(Entity* targetEntity, std::vector<std::s
 }
 
 
-void TriggerComponent::HandleRepelObject(Entity* targetEntity, std::string args){
+void TriggerComponent::HandleRepelObject(Entity* targetEntity, std::string args) {
 	auto* phantomPhysicsComponent = m_Parent->GetComponent<PhantomPhysicsComponent>();
 	if (!phantomPhysicsComponent) {
 		LOG_DEBUG("Phantom Physics component not found!");
@@ -271,7 +288,7 @@ void TriggerComponent::HandleRepelObject(Entity* targetEntity, std::string args)
 	Game::entityManager->SerializeEntity(m_Parent);
 }
 
-void TriggerComponent::HandleSetTimer(Entity* targetEntity, std::vector<std::string> argArray){
+void TriggerComponent::HandleSetTimer(Entity* targetEntity, std::vector<std::string> argArray) {
 	if (argArray.size() != 2) {
 		LOG_DEBUG("Not enough variables!");
 		return;
@@ -280,7 +297,7 @@ void TriggerComponent::HandleSetTimer(Entity* targetEntity, std::vector<std::str
 	m_Parent->AddTimer(argArray.at(0), time);
 }
 
-void TriggerComponent::HandleCancelTimer(Entity* targetEntity, std::string args){
+void TriggerComponent::HandleCancelTimer(Entity* targetEntity, std::string args) {
 	m_Parent->CancelTimer(args);
 }
 
@@ -328,7 +345,7 @@ void TriggerComponent::HandleUpdateMission(Entity* targetEntity, std::vector<std
 	// then we need a good way to convert this from a string to that enum
 	if (argArray.at(0) != "exploretask") return;
 	MissionComponent* missionComponent = targetEntity->GetComponent<MissionComponent>();
-	if (!missionComponent){
+	if (!missionComponent) {
 		LOG_DEBUG("Mission component not found!");
 		return;
 	}
@@ -340,7 +357,7 @@ void TriggerComponent::HandlePlayEffect(Entity* targetEntity, std::vector<std::s
 	const auto effectID = GeneralUtils::TryParse<int32_t>(argArray.at(1));
 	if (!effectID) return;
 	std::u16string effectType = GeneralUtils::UTF8ToUTF16(argArray.at(2));
-	
+
 	float priority = 1;
 	if (argArray.size() == 4) {
 		priority = GeneralUtils::TryParse<float>(argArray.at(3)).value_or(priority);
@@ -349,7 +366,7 @@ void TriggerComponent::HandlePlayEffect(Entity* targetEntity, std::vector<std::s
 	GameMessages::SendPlayFXEffect(targetEntity, effectID.value(), effectType, argArray.at(0), LWOOBJID_EMPTY, priority);
 }
 
-void TriggerComponent::HandleCastSkill(Entity* targetEntity, std::string args){
+void TriggerComponent::HandleCastSkill(Entity* targetEntity, std::string args) {
 	auto* skillComponent = targetEntity->GetComponent<SkillComponent>();
 	if (!skillComponent) {
 		LOG_DEBUG("Skill component not found!");
@@ -377,7 +394,7 @@ void TriggerComponent::HandleSetPhysicsVolumeEffect(Entity* targetEntity, std::v
 	phantomPhysicsComponent->SetEffectType(effectType);
 	phantomPhysicsComponent->SetDirectionalMultiplier(std::stof(argArray.at(1)));
 	if (argArray.size() > 4) {
-		const NiPoint3 direction = 
+		const NiPoint3 direction =
 			GeneralUtils::TryParse<NiPoint3>(argArray.at(2), argArray.at(3), argArray.at(4)).value_or(NiPoint3Constant::ZERO);
 
 		phantomPhysicsComponent->SetDirection(direction);
@@ -403,25 +420,25 @@ void TriggerComponent::HandleSetPhysicsVolumeStatus(Entity* targetEntity, std::s
 	Game::entityManager->SerializeEntity(targetEntity);
 }
 
-void TriggerComponent::HandleActivateSpawnerNetwork(std::string args){
+void TriggerComponent::HandleActivateSpawnerNetwork(std::string args) {
 	for (auto* spawner : Game::zoneManager->GetSpawnersByName(args)) {
 		if (spawner) spawner->Activate();
 	}
 }
 
-void TriggerComponent::HandleDeactivateSpawnerNetwork(std::string args){
+void TriggerComponent::HandleDeactivateSpawnerNetwork(std::string args) {
 	for (auto* spawner : Game::zoneManager->GetSpawnersByName(args)) {
 		if (spawner) spawner->Deactivate();
 	}
 }
 
-void TriggerComponent::HandleResetSpawnerNetwork(std::string args){
+void TriggerComponent::HandleResetSpawnerNetwork(std::string args) {
 	for (auto* spawner : Game::zoneManager->GetSpawnersByName(args)) {
 		if (spawner) spawner->Reset();
 	}
 }
 
-void TriggerComponent::HandleDestroySpawnerNetworkObjects(std::string args){
+void TriggerComponent::HandleDestroySpawnerNetworkObjects(std::string args) {
 	for (auto* spawner : Game::zoneManager->GetSpawnersByName(args)) {
 		if (spawner) spawner->DestroyAllEntities();
 	}
@@ -430,9 +447,50 @@ void TriggerComponent::HandleDestroySpawnerNetworkObjects(std::string args){
 void TriggerComponent::HandleActivatePhysics(Entity* targetEntity, std::string args) {
 	if (args == "true") {
 		// TODO add physics entity if there isn't one
-	} else if (args == "false"){
+	} else if (args == "false") {
 		// TODO remove Phsyics entity if there is one
 	} else {
 		LOG_DEBUG("Invalid argument for ActivatePhysics Trigger: %s", args.c_str());
 	}
 }
+
+void TriggerComponent::HandleSetPath(Entity* targetEntity, std::vector<std::string> argArray) {
+	auto* movementAIComponent = targetEntity->GetComponent<MovementAIComponent>();
+	if (!movementAIComponent) return;
+	// movementAIComponent->SetupPath(argArray.at(0));
+	if (argArray.size() >= 2) {
+		auto index = GeneralUtils::TryParse<int32_t>(argArray.at(1));
+		if (!index) return;
+		// movementAIComponent->SetPathStartingWaypointIndex(index.value());
+	}
+	if (argArray.size() >= 3 && argArray.at(2) == "1") {
+		// movementAIComponent->ReversePath();
+	}
+}
+
+void TriggerComponent::HandleTurnAroundOnPath(Entity* targetEntity) {
+	auto* movementAIComponent = targetEntity->GetComponent<MovementAIComponent>();
+	// if (movementAIComponent) movementAIComponent->ReversePath();
+}
+
+void TriggerComponent::HandleGoForwardOnPath(Entity* targetEntity) {
+	auto* movementAIComponent = targetEntity->GetComponent<MovementAIComponent>();
+	if (!movementAIComponent) return;
+	// if (movementAIComponent->GetIsInReverse()) movementAIComponent->ReversePath();
+}
+
+void TriggerComponent::HandleGoBackwardOnPath(Entity* targetEntity) {
+	auto* movementAIComponent = targetEntity->GetComponent<MovementAIComponent>();
+	if (!movementAIComponent) return;
+	// if (!movementAIComponent->GetIsInReverse()) movementAIComponent->ReversePath();
+}
+
+void TriggerComponent::HandleStopPathing(Entity* targetEntity) {
+	auto* movementAIComponent = targetEntity->GetComponent<MovementAIComponent>();
+	// if (movementAIComponent) movementAIComponent->Pause();
+}
+
+void TriggerComponent::HandleStartPathing(Entity* targetEntity) {
+	auto* movementAIComponent = targetEntity->GetComponent<MovementAIComponent>();
+	// if (movementAIComponent) movementAIComponent->Resume();
+}

dGame/dComponents/TriggerComponent.h

@@ -44,6 +44,12 @@ private:
 	void HandleResetSpawnerNetwork(std::string args);
 	void HandleDestroySpawnerNetworkObjects(std::string args);
 	void HandleActivatePhysics(Entity* targetEntity, std::string args);
+	void HandleTurnAroundOnPath(Entity* targetEntity);
+	void HandleGoForwardOnPath(Entity* targetEntity);
+	void HandleGoBackwardOnPath(Entity* targetEntity);
+	void HandleStopPathing(Entity* targetEntity);
+	void HandleStartPathing(Entity* targetEntity);
+	void HandleSetPath(Entity* targetEntity, std::vector<std::string> argArray);
 
 	LUTriggers::Trigger* m_Trigger;
 };

dGame/dComponents/VendorComponent.cpp

@@ -8,6 +8,11 @@
 #include "CDLootMatrixTable.h"
 #include "CDLootTableTable.h"
 #include "CDItemComponentTable.h"
+#include "InventoryComponent.h"
+#include "Character.h"
+#include "eVendorTransactionResult.h"
+#include "UserManager.h"
+#include "CheatDetection.h"
 
 VendorComponent::VendorComponent(Entity* parent) : Component(parent) {
 	m_HasStandardCostItems = false;
@@ -16,11 +21,11 @@ VendorComponent::VendorComponent(Entity* parent) : Component(parent) {
 	RefreshInventory(true);
 }
 
-void VendorComponent::Serialize(RakNet::BitStream* outBitStream, bool bIsInitialUpdate) {
-	outBitStream->Write(bIsInitialUpdate || m_DirtyVendor);
+void VendorComponent::Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) {
+	outBitStream.Write(bIsInitialUpdate || m_DirtyVendor);
 	if (bIsInitialUpdate || m_DirtyVendor) {
-		outBitStream->Write(m_HasStandardCostItems);
-		outBitStream->Write(m_HasMultiCostItems);
+		outBitStream.Write(m_HasStandardCostItems);
+		outBitStream.Write(m_HasMultiCostItems);
 		if (!bIsInitialUpdate) m_DirtyVendor = false;
 	}
 }
@@ -35,9 +40,19 @@ void VendorComponent::RefreshInventory(bool isCreation) {
 	SetHasMultiCostItems(false);
 	m_Inventory.clear();
 
-	// Custom code for Max vanity NPC and Mr.Ree cameras
-	if(isCreation && m_Parent->GetLOT() == 9749 && Game::server->GetZoneID() == 1201) {
-		SetupMaxCustomVendor();
+	// Custom code for Vanity Vendor Invetory Override
+	if(m_Parent->HasVar(u"vendorInvOverride")) {
+		std::vector<std::string> items = GeneralUtils::SplitString(m_Parent->GetVarAsString(u"vendorInvOverride"), ',');
+		uint32_t sortPriority = -1;
+		for (auto& itemString : items) {
+			itemString.erase(remove_if(itemString.begin(), itemString.end(), isspace), itemString.end());
+			auto item = GeneralUtils::TryParse<uint32_t>(itemString);
+			if (!item) continue;
+			if (SetupItem(item.value())) {
+				sortPriority++;
+				m_Inventory.push_back(SoldItem(item.value(), sortPriority));
+			}
+		}
 		return;
 	}
 
@@ -47,24 +62,12 @@ void VendorComponent::RefreshInventory(bool isCreation) {
 	if (lootMatrices.empty()) return;
 
 	auto* lootTableTable = CDClientManager::GetTable<CDLootTableTable>();
-	auto* itemComponentTable = CDClientManager::GetTable<CDItemComponentTable>();
-	auto* compRegistryTable = CDClientManager::GetTable<CDComponentsRegistryTable>();
 
 	for (const auto& lootMatrix : lootMatrices) {
 		auto vendorItems = lootTableTable->GetTable(lootMatrix.LootTableIndex);
 		if (lootMatrix.maxToDrop == 0 || lootMatrix.minToDrop == 0) {
 			for (const auto& item : vendorItems) {
-				if (!m_HasStandardCostItems || !m_HasMultiCostItems) {
-					auto itemComponentID = compRegistryTable->GetByIDAndType(item.itemid, eReplicaComponentType::ITEM, -1);
-					if (itemComponentID == -1) {
-						LOG("Attempted to add item %i with ItemComponent ID -1 to vendor %i inventory. Not adding item!", itemComponentID, m_Parent->GetLOT());
-						continue;
-					}
-					auto itemComponent = itemComponentTable->GetItemComponentByID(itemComponentID);
-					if (!m_HasStandardCostItems && itemComponent.baseValue != -1) SetHasStandardCostItems(true);
-					if (!m_HasMultiCostItems && !itemComponent.currencyCosts.empty()) SetHasMultiCostItems(true);
-				}
-				m_Inventory.push_back(SoldItem(item.itemid, item.sortPriority));
+				if (SetupItem(item.itemid)) m_Inventory.push_back(SoldItem(item.itemid, item.sortPriority));
 			}
 		} else {
 			auto randomCount = GeneralUtils::GenerateRandomNumber<int32_t>(lootMatrix.minToDrop, lootMatrix.maxToDrop);
@@ -74,17 +77,7 @@ void VendorComponent::RefreshInventory(bool isCreation) {
 				auto randomItemIndex = GeneralUtils::GenerateRandomNumber<int32_t>(0, vendorItems.size() - 1);
 				const auto& randomItem = vendorItems.at(randomItemIndex);
 				vendorItems.erase(vendorItems.begin() + randomItemIndex);
-				if (!m_HasStandardCostItems || !m_HasMultiCostItems) {
-					auto itemComponentID = compRegistryTable->GetByIDAndType(randomItem.itemid, eReplicaComponentType::ITEM, -1);
-					if (itemComponentID == -1) {
-						LOG("Attempted to add item %i with ItemComponent ID -1 to vendor %i inventory. Not adding item!", itemComponentID, m_Parent->GetLOT());
-						continue;
-					}
-					auto itemComponent = itemComponentTable->GetItemComponentByID(itemComponentID);
-					if (!m_HasStandardCostItems && itemComponent.baseValue != -1) SetHasStandardCostItems(true);
-					if (!m_HasMultiCostItems && !itemComponent.currencyCosts.empty()) SetHasMultiCostItems(true);
-				}
-				m_Inventory.push_back(SoldItem(randomItem.itemid, randomItem.sortPriority));
+				if (SetupItem(randomItem.itemid)) m_Inventory.push_back(SoldItem(randomItem.itemid, randomItem.sortPriority));
 			}
 		}
 	}
@@ -121,15 +114,6 @@ bool VendorComponent::SellsItem(const LOT item) const {
 		}) > 0;
 }
 
-
-void VendorComponent::SetupMaxCustomVendor(){
-	SetHasStandardCostItems(true);
-	m_Inventory.push_back(SoldItem(11909, 0)); // Top hat w frog
-	m_Inventory.push_back(SoldItem(7785, 0));  // Flash bulb
-	m_Inventory.push_back(SoldItem(12764, 0)); // Big fountain soda
-	m_Inventory.push_back(SoldItem(12241, 0)); // Hot cocoa (from fb)
-}
-
 void VendorComponent::HandleMrReeCameras(){
 	if (m_Parent->GetLOT() == 13569) {
 		SetHasStandardCostItems(true);
@@ -151,3 +135,80 @@ void VendorComponent::HandleMrReeCameras(){
 		m_Inventory.push_back(SoldItem(camera, 0));
 	}
 }
+
+
+void VendorComponent::Buy(Entity* buyer, LOT lot, uint32_t count) {
+
+	if (!SellsItem(lot)) {
+		auto* user = UserManager::Instance()->GetUser(buyer->GetSystemAddress());
+		CheatDetection::ReportCheat(user, buyer->GetSystemAddress(), "Attempted to buy item %i from achievement vendor %i that is not purchasable", lot, m_Parent->GetLOT());
+		GameMessages::SendVendorTransactionResult(buyer, buyer->GetSystemAddress(), eVendorTransactionResult::PURCHASE_FAIL);
+		return;
+	}
+
+	auto* inventoryComponent = buyer->GetComponent<InventoryComponent>();
+	if (!inventoryComponent) {
+		GameMessages::SendVendorTransactionResult(buyer, buyer->GetSystemAddress(), eVendorTransactionResult::PURCHASE_FAIL);
+		return;
+	}
+	CDComponentsRegistryTable* compRegistryTable = CDClientManager::GetTable<CDComponentsRegistryTable>();
+	CDItemComponentTable* itemComponentTable = CDClientManager::GetTable<CDItemComponentTable>();
+	int itemCompID = compRegistryTable->GetByIDAndType(lot, eReplicaComponentType::ITEM);
+	CDItemComponent itemComp = itemComponentTable->GetItemComponentByID(itemCompID);
+
+	// Extra currency that needs to be deducted in case of crafting
+	auto craftingCurrencies = CDItemComponentTable::ParseCraftingCurrencies(itemComp);
+	for (const auto& [crafintCurrencyLOT, crafintCurrencyCount]: craftingCurrencies) {
+		if (inventoryComponent->GetLotCount(crafintCurrencyLOT) < (crafintCurrencyCount * count)) {
+			GameMessages::SendVendorTransactionResult(buyer, buyer->GetSystemAddress(), eVendorTransactionResult::PURCHASE_FAIL);
+			return;
+		}
+	}
+	for (const auto& [crafintCurrencyLOT, crafintCurrencyCount]: craftingCurrencies) {
+		inventoryComponent->RemoveItem(crafintCurrencyLOT, crafintCurrencyCount * count);
+	}
+
+
+	float buyScalar = GetBuyScalar();
+	const auto coinCost = static_cast<uint32_t>(std::floor((itemComp.baseValue * buyScalar) * count));
+
+	Character* character = buyer->GetCharacter();
+	if (!character || character->GetCoins() < coinCost) {
+		GameMessages::SendVendorTransactionResult(buyer, buyer->GetSystemAddress(), eVendorTransactionResult::PURCHASE_FAIL);
+		return;
+	}
+
+	if (Inventory::IsValidItem(itemComp.currencyLOT)) {
+		const uint32_t altCurrencyCost = std::floor(itemComp.altCurrencyCost * buyScalar) * count;
+		if (inventoryComponent->GetLotCount(itemComp.currencyLOT) < altCurrencyCost) {
+			GameMessages::SendVendorTransactionResult(buyer, buyer->GetSystemAddress(), eVendorTransactionResult::PURCHASE_FAIL);
+			return;
+		}
+		inventoryComponent->RemoveItem(itemComp.currencyLOT, altCurrencyCost);
+	}
+
+	character->SetCoins(character->GetCoins() - (coinCost), eLootSourceType::VENDOR);
+	inventoryComponent->AddItem(lot, count, eLootSourceType::VENDOR);
+	GameMessages::SendVendorTransactionResult(buyer, buyer->GetSystemAddress(), eVendorTransactionResult::PURCHASE_SUCCESS);
+}
+
+bool VendorComponent::SetupItem(LOT item) {
+
+	auto* itemComponentTable = CDClientManager::GetTable<CDItemComponentTable>();
+	auto* compRegistryTable = CDClientManager::GetTable<CDComponentsRegistryTable>();
+
+	auto itemComponentID = compRegistryTable->GetByIDAndType(item, eReplicaComponentType::ITEM, -1);
+	if (itemComponentID == -1) {
+		LOG("Attempted to add item %i with ItemComponent ID -1 to vendor %i inventory. Not adding item!", itemComponentID, m_Parent->GetLOT());
+		return false;
+	}
+
+	if (!m_HasStandardCostItems || !m_HasMultiCostItems) {
+		auto itemComponent = itemComponentTable->GetItemComponentByID(itemComponentID);
+		if (!m_HasStandardCostItems && itemComponent.baseValue != -1) SetHasStandardCostItems(true);
+		if (!m_HasMultiCostItems && !itemComponent.currencyCosts.empty()) SetHasMultiCostItems(true);
+	}
+
+	return true;
+}
+

dGame/dComponents/VendorComponent.h

@@ -23,10 +23,10 @@ public:
 	static constexpr eReplicaComponentType ComponentType = eReplicaComponentType::VENDOR;
 	VendorComponent(Entity* parent);
 
-	void Serialize(RakNet::BitStream* outBitStream, bool bIsInitialUpdate) override;
+	void Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) override;
 
 	void OnUse(Entity* originator) override;
-	void RefreshInventory(bool isCreation = false);
+	virtual void RefreshInventory(bool isCreation = false);
 	void SetupConstants();
 	bool SellsItem(const LOT item) const;
 	float GetBuyScalar() const { return m_BuyScalar; }
@@ -47,10 +47,11 @@ public:
 		m_DirtyVendor = true;
 	}
 
+	void Buy(Entity* buyer, LOT lot, uint32_t count);
 
 private:
-	void SetupMaxCustomVendor();
 	void HandleMrReeCameras();
+	bool SetupItem(LOT item);
 	float m_BuyScalar = 0.0f;
 	float m_SellScalar = 0.0f;
 	float m_RefreshTimeSeconds = 0.0f;