Invert frame rates (use inactive if 0 players in world, not the other way around)

.github/ISSUE_TEMPLATE/bug_report.yaml

@@ -16,10 +16,7 @@ body:
             I have validated that this issue is not a syntax error of either MySQL or SQLite.
           required: true
         - label: >
-            I have downloaded/pulled the latest version of the main branch of DarkflameServer and have confirmed that the issue exists there.
-          required: true
-        - label: >
-            I have verified that my boot.cfg is configured as per the [README](https://github.com/DarkflameUniverse/DarkflameServer?tab=readme-ov-file#allowing-a-user-to-connect-to-your-server).
+            I have pulled the latest version of the main branch of DarkflameServer and have confirmed that the issue exists there.
           required: true
   - type: input
     id: server-version

CMakeLists.txt

@@ -235,8 +235,6 @@ include_directories(
 
 	"dNet"
 
-	"dWeb"
-
 	"tests"
 	"tests/dCommonTests"
 	"tests/dGameTests"
@@ -303,7 +301,6 @@ add_subdirectory(dZoneManager)
 add_subdirectory(dNavigation)
 add_subdirectory(dPhysics)
 add_subdirectory(dServer)
-add_subdirectory(dWeb)
 
 # Create a list of common libraries shared between all binaries
 set(COMMON_LIBRARIES "dCommon" "dDatabase" "dNet" "raknet" "magic_enum")

README.md

@@ -324,15 +324,13 @@ While a character has a gmlevel of anything but `0`, some gameplay behavior will
 Some changes to the client `boot.cfg` file are needed to play on your server.
 
 ## Allowing a user to connect to your server
-**ALL OF THESE CHANGES ARE REQUIRED. PLEASE FULLY READ THIS SECTION**
-
 To connect to a server follow these steps:
 * In the client directory, locate `boot.cfg`
-* Open `boot.cfg` in a text editor and locate the line `UGCUSE3DSERVICES=7:`
+* Open it in a text editor and locate where it says `AUTHSERVERIP=0:`
+* Replace the contents after to `:` and the following `,` with what you configured as the server's public facing IP. For example `AUTHSERVERIP=0:localhost` for locally hosted servers
+* Next locate the line `UGCUSE3DSERVICES=7:`
 * Ensure the number after the 7 is a `0`
 * Alternatively, remove the line with `UGCUSE3DSERVICES` altogether
-* Next locate where it says `AUTHSERVERIP=0:`
-* Replace the contents after to `:` and the following `,` with what you configured as the server's public facing IP. For example `AUTHSERVERIP=0:localhost` for locally hosted servers
 * Launch `legouniverse.exe`, through `wine` if on a Unix-like operating system
 * Note that if you are on WSL2, you will need to configure the public IP in the server and client to be the IP of the WSL2 instance and not localhost, which can be found by running `ifconfig` in the terminal. Windows defaults to WSL1, so this will not apply to most users.
 As an example, here is what the boot.cfg is required to contain for a server with the ip 12.34.56.78

dChatFilter/dChatFilter.cpp

@@ -105,7 +105,7 @@ void dChatFilter::ExportWordlistToDCF(const std::string& filepath, bool allowLis
 	}
 }
 
-std::set<std::pair<uint8_t, uint8_t>> dChatFilter::IsSentenceOkay(const std::string& message, eGameMasterLevel gmLevel, bool allowList) {
+std::vector<std::pair<uint8_t, uint8_t>> dChatFilter::IsSentenceOkay(const std::string& message, eGameMasterLevel gmLevel, bool allowList) {
 	if (gmLevel > eGameMasterLevel::FORUM_MODERATOR) return { }; //If anything but a forum mod, return true.
 	if (message.empty()) return { };
 	if (!allowList && m_DeniedWords.empty()) return { { 0, message.length() } };
@@ -114,7 +114,7 @@ std::set<std::pair<uint8_t, uint8_t>> dChatFilter::IsSentenceOkay(const std::str
 	std::string segment;
 	std::regex reg("(!*|\\?*|\\;*|\\.*|\\,*)");
 
-	std::set<std::pair<uint8_t, uint8_t>> listOfBadSegments;
+	std::vector<std::pair<uint8_t, uint8_t>> listOfBadSegments = std::vector<std::pair<uint8_t, uint8_t>>();
 
 	uint32_t position = 0;
 
@@ -127,17 +127,17 @@ std::set<std::pair<uint8_t, uint8_t>> dChatFilter::IsSentenceOkay(const std::str
 		size_t hash = CalculateHash(segment);
 
 		if (std::find(m_UserUnapprovedWordCache.begin(), m_UserUnapprovedWordCache.end(), hash) != m_UserUnapprovedWordCache.end() && allowList) {
-			listOfBadSegments.emplace(position, originalSegment.length());
+			listOfBadSegments.emplace_back(position, originalSegment.length());
 		}
 
 		if (std::find(m_ApprovedWords.begin(), m_ApprovedWords.end(), hash) == m_ApprovedWords.end() && allowList) {
 			m_UserUnapprovedWordCache.push_back(hash);
-			listOfBadSegments.emplace(position, originalSegment.length());
+			listOfBadSegments.emplace_back(position, originalSegment.length());
 		}
 
 		if (std::find(m_DeniedWords.begin(), m_DeniedWords.end(), hash) != m_DeniedWords.end() && !allowList) {
 			m_UserUnapprovedWordCache.push_back(hash);
-			listOfBadSegments.emplace(position, originalSegment.length());
+			listOfBadSegments.emplace_back(position, originalSegment.length());
 		}
 
 		position += originalSegment.length() + 1;

dChatFilter/dChatFilter.h

@@ -24,7 +24,7 @@ public:
 	void ReadWordlistPlaintext(const std::string& filepath, bool allowList);
 	bool ReadWordlistDCF(const std::string& filepath, bool allowList);
 	void ExportWordlistToDCF(const std::string& filepath, bool allowList);
-	std::set<std::pair<uint8_t, uint8_t>> IsSentenceOkay(const std::string& message, eGameMasterLevel gmLevel, bool allowList = true);
+	std::vector<std::pair<uint8_t, uint8_t>> IsSentenceOkay(const std::string& message, eGameMasterLevel gmLevel, bool allowList = true);
 
 private:
 	bool m_DontGenerateDCF;

dChatServer/CMakeLists.txt

@@ -1,19 +1,19 @@
 set(DCHATSERVER_SOURCES
 	"ChatIgnoreList.cpp"
 	"ChatPacketHandler.cpp"
-	"ChatJSONUtils.cpp"
-	"ChatWeb.cpp"
+	"ChatWebAPI.cpp"
+	"JSONUtils.cpp"
 	"PlayerContainer.cpp"
 	"TeamContainer.cpp"
 )
 
 add_executable(ChatServer "ChatServer.cpp")
-target_include_directories(ChatServer PRIVATE "${PROJECT_SOURCE_DIR}/dChatFilter" "${PROJECT_SOURCE_DIR}/dWeb")
+target_include_directories(ChatServer PRIVATE "${PROJECT_SOURCE_DIR}/dChatFilter")
 add_compile_definitions(ChatServer PRIVATE PROJECT_VERSION="\"${PROJECT_VERSION}\"")
 
 add_library(dChatServer ${DCHATSERVER_SOURCES})
-target_include_directories(dChatServer PRIVATE "${PROJECT_SOURCE_DIR}/dServer" "${PROJECT_SOURCE_DIR}/dChatFilter")
+target_include_directories(dChatServer PRIVATE "${PROJECT_SOURCE_DIR}/dServer")
 
 target_link_libraries(dChatServer ${COMMON_LIBRARIES} dChatFilter)
-target_link_libraries(ChatServer ${COMMON_LIBRARIES} dChatFilter dChatServer dServer mongoose dWeb)
+target_link_libraries(ChatServer ${COMMON_LIBRARIES} dChatFilter dChatServer dServer mongoose)
 

dChatServer/ChatServer.cpp

@@ -29,7 +29,7 @@
 #include "RakNetDefines.h"
 #include "MessageIdentifiers.h"
 
-#include "ChatWeb.h"
+#include "ChatWebAPI.h"
 
 namespace Game {
 	Logger* logger = nullptr;
@@ -93,18 +93,17 @@ int main(int argc, char** argv) {
 		return EXIT_FAILURE;
 	}
 
-	// setup the chat api web server
-	const uint32_t web_server_port = GeneralUtils::TryParse<uint32_t>(Game::config->GetValue("web_server_port")).value_or(2005);
-	if (Game::config->GetValue("web_server_enabled") == "1" && !Game::web.Startup("localhost", web_server_port)) {
-		// if we want the web server and it fails to start, exit
+	// seyup the chat api web server
+	bool web_server_enabled = Game::config->GetValue("web_server_enabled") == "1";
+	ChatWebAPI chatwebapi;
+	if (web_server_enabled && !chatwebapi.Startup()) {
+		// if we want the web api and it fails to start, exit
 		LOG("Failed to start web server, shutting down.");
 		Database::Destroy("ChatServer");
 		delete Game::logger;
 		delete Game::config;
 		return EXIT_FAILURE;
-	}
-
-	if (Game::web.IsEnabled()) ChatWeb::RegisterRoutes();
+	};
 
 	//Find out the master's IP:
 	std::string masterIP;
@@ -168,8 +167,10 @@ int main(int argc, char** argv) {
 			packet = nullptr;
 		}
 
-		// Check and handle web requests:
-		if (Game::web.IsEnabled()) Game::web.ReceiveRequests();
+		//Check and handle web requests:
+		if (web_server_enabled) {
+			chatwebapi.ReceiveRequests();
+		}
 
 		//Push our log every 30s:
 		if (framesSinceLastFlush >= logFlushTime) {

dChatServer/ChatWeb.cpp

@@ -1,133 +0,0 @@
-#include "ChatWeb.h"
-
-#include "Logger.h"
-#include "Game.h"
-#include "json.hpp"
-#include "dCommonVars.h"
-#include "MessageType/Chat.h"
-#include "dServer.h"
-#include "dConfig.h"
-#include "PlayerContainer.h"
-#include "GeneralUtils.h"
-#include "eHTTPMethod.h"
-#include "magic_enum.hpp"
-#include "ChatPackets.h"
-#include "StringifiedEnum.h"
-#include "Database.h"
-#include "ChatJSONUtils.h"
-#include "JSONUtils.h"
-#include "eGameMasterLevel.h"
-#include "dChatFilter.h"
-#include "TeamContainer.h"
-
-using json = nlohmann::json;
-
-void HandleHTTPPlayersRequest(HTTPReply& reply, std::string body) {
-	const json data = Game::playerContainer;
-	reply.status = data.empty() ? eHTTPStatusCode::NO_CONTENT : eHTTPStatusCode::OK;
-	reply.message = data.empty() ? "{\"error\":\"No Players Online\"}" : data.dump();
-}
-
-void HandleHTTPTeamsRequest(HTTPReply& reply, std::string body) {
-	const json data = TeamContainer::GetTeamContainer();
-	reply.status = data.empty() ? eHTTPStatusCode::NO_CONTENT : eHTTPStatusCode::OK;
-	reply.message = data.empty() ? "{\"error\":\"No Teams Online\"}" : data.dump();
-}
-
-void HandleHTTPAnnounceRequest(HTTPReply& reply, std::string body) {
-	auto data = GeneralUtils::TryParse<json>(body);
-	if (!data) {
-		reply.status = eHTTPStatusCode::BAD_REQUEST;
-		reply.message = "{\"error\":\"Invalid JSON\"}";
-		return;
-	}
-
-	const auto& good_data = data.value();
-	auto check = JSONUtils::CheckRequiredData(good_data, { "title", "message" });
-	if (!check.empty()) {
-		reply.status = eHTTPStatusCode::BAD_REQUEST;
-		reply.message = check;
-	} else {
-
-		ChatPackets::Announcement announcement;
-		announcement.title = good_data["title"];
-		announcement.message = good_data["message"];
-		announcement.Broadcast();
-
-		reply.status = eHTTPStatusCode::OK;
-		reply.message = "{\"status\":\"Announcement Sent\"}";
-	}
-}
-
-void HandleWSChat(mg_connection* connection, json data) {
-	auto check = JSONUtils::CheckRequiredData(data, { "user", "message", "gmlevel", "zone" });
-	if (!check.empty()) {
-		LOG_DEBUG("Received invalid websocket message: %s", check.c_str());
-	} else {
-		const auto user = data["user"].get<std::string>();
-		const auto message = data["message"].get<std::string>();
-		const auto gmlevel = GeneralUtils::TryParse<eGameMasterLevel>(data["gmlevel"].get<std::string>()).value_or(eGameMasterLevel::CIVILIAN);
-		const auto zone = data["zone"].get<uint32_t>();
-
-		const auto filter_check = Game::chatFilter->IsSentenceOkay(message, gmlevel);
-		if (!filter_check.empty()) {
-			LOG_DEBUG("Chat message \"%s\" from %s was not allowed", message.c_str(), user.c_str());
-			data["error"] = "Chat message blocked by filter";
-			data["filtered"] = json::array();
-			for (const auto& [start, len] : filter_check) {
-				data["filtered"].push_back(message.substr(start, len));
-			}
-			mg_ws_send(connection, data.dump().c_str(), data.dump().size(), WEBSOCKET_OP_TEXT);
-			return;
-		}
-		LOG("%s: %s", user.c_str(), message.c_str());
-		
-		// TODO: Implement chat message handling from websocket message
-
-	}
-}
-
-namespace ChatWeb {
-	void RegisterRoutes() {
-		
-		// REST API v1 routes
-
-		std::string v1_route = "/api/v1/";
-		Game::web.RegisterHTTPRoute({
-			.path = v1_route + "players",
-			.method = eHTTPMethod::GET,
-			.handle = HandleHTTPPlayersRequest
-		});
-
-		Game::web.RegisterHTTPRoute({
-			.path = v1_route + "teams",
-			.method = eHTTPMethod::GET,
-			.handle = HandleHTTPTeamsRequest
-		});
-
-		Game::web.RegisterHTTPRoute({
-			.path = v1_route + "announce",
-			.method = eHTTPMethod::POST,
-			.handle = HandleHTTPAnnounceRequest
-		});
-
-		// WebSocket Events Handlers
-
-		// Game::web.RegisterWSEvent({
-		// 	.name = "chat",
-		// 	.handle = HandleWSChat
-		// });
-
-		// WebSocket subscriptions
-
-		Game::web.RegisterWSSubscription("player");
-	}
-
-	void SendWSPlayerUpdate(const PlayerData& player, eActivityType activityType) {
-		json data;
-		data["player_data"] = player;
-		data["update_type"] = magic_enum::enum_name(activityType);
-		Game::web.SendWSMessage("player", data);
-	}
-}
-

dChatServer/ChatWeb.h

@@ -1,19 +0,0 @@
-#ifndef __CHATWEB_H__
-#define __CHATWEB_H__
-
-#include <string>
-#include <functional>
-
-#include "Web.h"
-#include "PlayerContainer.h"
-#include "IActivityLog.h"
-#include "ChatPacketHandler.h"
-
-namespace ChatWeb {
-	void RegisterRoutes();
-	void SendWSPlayerUpdate(const PlayerData& player, eActivityType activityType);
-};
-
-
-#endif // __CHATWEB_H__
-

dChatServer/ChatWebAPI.cpp

@@ -0,0 +1,197 @@
+#include "ChatWebAPI.h"
+
+#include "Logger.h"
+#include "Game.h"
+#include "json.hpp"
+#include "dCommonVars.h"
+#include "MessageType/Chat.h"
+#include "dServer.h"
+#include "dConfig.h"
+#include "PlayerContainer.h"
+#include "JSONUtils.h"
+#include "GeneralUtils.h"
+#include "eHTTPMethod.h"
+#include "magic_enum.hpp"
+#include "ChatPackets.h"
+#include "StringifiedEnum.h"
+#include "Database.h"
+
+#ifdef DARKFLAME_PLATFORM_WIN32
+#pragma push_macro("DELETE")
+#undef DELETE
+#endif
+
+using json = nlohmann::json;
+
+typedef struct mg_connection mg_connection;
+typedef struct mg_http_message mg_http_message;
+
+namespace {
+	const char* json_content_type = "Content-Type: application/json\r\n";
+	std::map<std::pair<eHTTPMethod, std::string>, WebAPIHTTPRoute> Routes{};
+}
+
+bool ValidateAuthentication(const mg_http_message* http_msg) {
+	// TO DO: This is just a placeholder for now
+	// use tokens or something at a later point if we want to implement authentication
+	// bit using the listen bind address to limit external access is good enough to start with
+	return true;
+}
+
+bool ValidateJSON(std::optional<json> data, HTTPReply& reply) {
+	if (!data) {
+		reply.status = eHTTPStatusCode::BAD_REQUEST;
+		reply.message = "{\"error\":\"Invalid JSON\"}";
+		return false;
+	}
+	return true;
+}
+
+void HandlePlayersRequest(HTTPReply& reply, std::string body) {
+	const json data = Game::playerContainer;
+	reply.status = data.empty() ? eHTTPStatusCode::NO_CONTENT : eHTTPStatusCode::OK;
+	reply.message = data.empty() ? "{\"error\":\"No Players Online\"}" : data.dump();
+}
+
+void HandleTeamsRequest(HTTPReply& reply, std::string body) {
+	const json data = TeamContainer::GetTeamContainer();
+	reply.status = data.empty() ? eHTTPStatusCode::NO_CONTENT : eHTTPStatusCode::OK;
+	reply.message = data.empty() ? "{\"error\":\"No Teams Online\"}" : data.dump();
+}
+
+void HandleAnnounceRequest(HTTPReply& reply, std::string body) {
+	auto data = GeneralUtils::TryParse<json>(body);
+	if (!ValidateJSON(data, reply)) return;
+
+	const auto& good_data = data.value();
+	auto check = JSONUtils::CheckRequiredData(good_data, { "title", "message" });
+	if (!check.empty()) {
+		reply.status = eHTTPStatusCode::BAD_REQUEST;
+		reply.message = check;
+	} else {
+
+		ChatPackets::Announcement announcement;
+		announcement.title = good_data["title"];
+		announcement.message = good_data["message"];
+		announcement.Send();
+
+		reply.status = eHTTPStatusCode::OK;
+		reply.message = "{\"status\":\"Announcement Sent\"}";
+	}
+}
+
+void HandleInvalidRoute(HTTPReply& reply) {
+	reply.status = eHTTPStatusCode::NOT_FOUND;
+	reply.message = "{\"error\":\"Invalid Route\"}";
+}
+
+void HandleHTTPMessage(mg_connection* connection, const mg_http_message* http_msg) {
+	HTTPReply reply;
+
+	if (!http_msg) {
+		reply.status = eHTTPStatusCode::BAD_REQUEST;
+		reply.message = "{\"error\":\"Invalid Request\"}";
+	} else if (ValidateAuthentication(http_msg)) {
+
+		// convert method from cstring to std string
+		std::string method_string(http_msg->method.buf, http_msg->method.len);
+		// get mehtod from mg to enum
+		const eHTTPMethod method = magic_enum::enum_cast<eHTTPMethod>(method_string).value_or(eHTTPMethod::INVALID);
+
+		// convert uri from cstring to std string
+		std::string uri(http_msg->uri.buf, http_msg->uri.len);
+		std::transform(uri.begin(), uri.end(), uri.begin(), ::tolower);
+
+		// convert body from cstring to std string
+		std::string body(http_msg->body.buf, http_msg->body.len);
+
+
+		const auto routeItr = Routes.find({ method, uri });
+
+		if (routeItr != Routes.end()) {
+			const auto& [_, route] = *routeItr;
+			route.handle(reply, body);
+		} else HandleInvalidRoute(reply);
+	} else {
+		reply.status = eHTTPStatusCode::UNAUTHORIZED;
+		reply.message = "{\"error\":\"Unauthorized\"}";
+	}
+	mg_http_reply(connection, static_cast<int>(reply.status), json_content_type, reply.message.c_str());
+}
+
+
+void HandleRequests(mg_connection* connection, int request, void* request_data) {
+	switch (request) {
+	case MG_EV_HTTP_MSG:
+		HandleHTTPMessage(connection, static_cast<mg_http_message*>(request_data));
+		break;
+	default:
+		break;
+	}
+}
+
+void ChatWebAPI::RegisterHTTPRoutes(WebAPIHTTPRoute route) {
+	auto [_, success] = Routes.try_emplace({ route.method, route.path }, route);
+	if (!success) {
+		LOG_DEBUG("Failed to register route %s", route.path.c_str());
+	} else {
+		LOG_DEBUG("Registered route %s", route.path.c_str());
+	}
+}
+
+ChatWebAPI::ChatWebAPI() {
+	mg_log_set(MG_LL_NONE);
+	mg_mgr_init(&mgr);  // Initialize event manager
+}
+
+ChatWebAPI::~ChatWebAPI() {
+	mg_mgr_free(&mgr);
+}
+
+bool ChatWebAPI::Startup() {
+	// Make listen address
+	// std::string listen_ip = Game::config->GetValue("web_server_listen_ip");
+	// if (listen_ip == "localhost") listen_ip = "127.0.0.1";
+
+	const std::string& listen_port = Game::config->GetValue("web_server_listen_port");
+	// const std::string& listen_address = "http://" + listen_ip + ":" + listen_port;
+	const std::string& listen_address = "http://localhost:" + listen_port;
+	LOG("Starting web server on %s", listen_address.c_str());
+
+	// Create HTTP listener
+	if (!mg_http_listen(&mgr, listen_address.c_str(), HandleRequests, NULL)) {
+		LOG("Failed to create web server listener on %s", listen_port.c_str());
+		return false;
+	}
+
+	// Register routes
+
+	// API v1 routes
+	std::string v1_route = "/api/v1/";
+	RegisterHTTPRoutes({
+		.path = v1_route + "players",
+		.method = eHTTPMethod::GET,
+		.handle = HandlePlayersRequest
+		});
+
+	RegisterHTTPRoutes({
+		.path = v1_route + "teams",
+		.method = eHTTPMethod::GET,
+		.handle = HandleTeamsRequest
+		});
+
+	RegisterHTTPRoutes({
+		.path = v1_route + "announce",
+		.method = eHTTPMethod::POST,
+		.handle = HandleAnnounceRequest
+		});
+	return true;
+}
+
+void ChatWebAPI::ReceiveRequests() {
+	mg_mgr_poll(&mgr, 15);
+}
+
+#ifdef DARKFLAME_PLATFORM_WIN32
+#pragma pop_macro("DELETE")
+#endif

dChatServer/ChatWebAPI.h

@@ -0,0 +1,36 @@
+#ifndef __CHATWEBAPI_H__
+#define __CHATWEBAPI_H__
+#include <string>
+#include <functional>
+
+#include "mongoose.h"
+#include "eHTTPStatusCode.h"
+
+enum class eHTTPMethod;
+
+typedef struct mg_mgr mg_mgr;
+
+struct HTTPReply {
+	eHTTPStatusCode status = eHTTPStatusCode::NOT_FOUND;
+	std::string message = "{\"error\":\"Not Found\"}";
+};
+
+struct WebAPIHTTPRoute {
+	std::string path;
+	eHTTPMethod method;
+	std::function<void(HTTPReply&, const std::string&)> handle;
+};
+
+class ChatWebAPI {
+public:
+	ChatWebAPI();
+	~ChatWebAPI();
+	void ReceiveRequests();
+	void RegisterHTTPRoutes(WebAPIHTTPRoute route);
+	bool Startup();
+private:
+	mg_mgr mgr;
+
+};
+
+#endif // __CHATWEBAPI_H__

dChatServer/JSONUtils.cpp

@@ -1,4 +1,4 @@
-#include "ChatJSONUtils.h"
+#include "JSONUtils.h"
 
 #include "json.hpp"
 
@@ -47,3 +47,16 @@ void TeamContainer::to_json(json& data, const TeamContainer::Data& teamContainer
 		data.push_back(*teamData);
 	}
 }
+
+std::string JSONUtils::CheckRequiredData(const json& data, const std::vector<std::string>& requiredData) {
+	json check;
+	check["error"] = json::array();
+	for (const auto& required : requiredData) {
+		if (!data.contains(required)) {
+			check["error"].push_back("Missing Parameter: " + required);
+		} else if (data[required] == "") {
+			check["error"].push_back("Empty Parameter: " + required);
+		}
+	}
+	return check["error"].empty() ? "" : check.dump();
+}

dChatServer/JSONUtils.h

@@ -1,5 +1,5 @@
-#ifndef __CHATJSONUTILS_H__
-#define __CHATJSONUTILS_H__
+#ifndef __JSONUTILS_H__
+#define __JSONUTILS_H__
 
 #include "json_fwd.hpp"
 #include "PlayerContainer.h"
@@ -15,4 +15,9 @@ namespace TeamContainer {
 	void to_json(nlohmann::json& data, const TeamContainer::Data& teamData);
 };
 
-#endif // !__CHATJSONUTILS_H__
+namespace JSONUtils {
+	// check required data for reqeust
+	std::string CheckRequiredData(const nlohmann::json& data, const std::vector<std::string>& requiredData);
+}
+
+#endif // __JSONUTILS_H__

dChatServer/PlayerContainer.cpp

@@ -12,7 +12,6 @@
 #include "ChatPackets.h"
 #include "dConfig.h"
 #include "MessageType/Chat.h"
-#include "ChatWeb.h"
 #include "TeamContainer.h"
 
 void PlayerContainer::Initialize() {
@@ -60,9 +59,8 @@ void PlayerContainer::InsertPlayer(Packet* packet) {
 	m_PlayerCount++;
 
 	LOG("Added user: %s (%llu), zone: %i", data.playerName.c_str(), data.playerID, data.zoneID.GetMapID());
-	ChatWeb::SendWSPlayerUpdate(data, isLogin ? eActivityType::PlayerLoggedIn : eActivityType::PlayerChangedZone);
 
-	Database::Get()->UpdateActivityLog(data.playerID, isLogin ? eActivityType::PlayerLoggedIn : eActivityType::PlayerChangedZone, data.zoneID.GetMapID());
+	Database::Get()->UpdateActivityLog(data.playerID, eActivityType::PlayerLoggedIn, data.zoneID.GetMapID());
 	m_PlayersToRemove.erase(playerId);
 }
 
@@ -116,8 +114,6 @@ void PlayerContainer::RemovePlayer(const LWOOBJID playerID) {
 		}
 	}
 
-	ChatWeb::SendWSPlayerUpdate(player, eActivityType::PlayerLoggedOut);
-
 	m_PlayerCount--;
 	LOG("Removed user: %llu", playerID);
 	m_Players.erase(playerID);

dCommon/CMakeLists.txt

@@ -16,11 +16,9 @@ set(DCOMMON_SOURCES
 		"BrickByBrickFix.cpp"
 		"BinaryPathFinder.cpp"
 		"FdbToSqlite.cpp"
-		"JSONUtils.cpp"
 		"TinyXmlUtils.cpp"
 		"Sd0.cpp"
 		"Lxfml.cpp"
-		"LxfmlBugged.cpp"
 )
 
 # Workaround for compiler bug where the optimized code could result in a memcpy of 0 bytes, even though that isnt possible.

dCommon/DluAssert.h

@@ -4,7 +4,7 @@
 #include <assert.h>
 
 #ifdef _DEBUG
-#	define DluAssert(expression) do { assert(expression); } while(0)
+#	define DluAssert(expression) do { assert(expression) } while(0)
 #else
 #	define DluAssert(expression)
 #endif

dCommon/GeneralUtils.cpp

@@ -237,6 +237,57 @@ bool GeneralUtils::ReplaceInString(std::string& str, const std::string_view from
 	return true;
 }
 
+std::vector<std::wstring> GeneralUtils::SplitString(const std::wstring_view str, const wchar_t delimiter) {
+	std::vector<std::wstring> vector = std::vector<std::wstring>();
+	std::wstring current;
+
+	for (const wchar_t c : str) {
+		if (c == delimiter) {
+			vector.push_back(current);
+			current = L"";
+		} else {
+			current += c;
+		}
+	}
+
+	vector.push_back(std::move(current));
+	return vector;
+}
+
+std::vector<std::u16string> GeneralUtils::SplitString(const std::u16string_view str, const char16_t delimiter) {
+	std::vector<std::u16string> vector = std::vector<std::u16string>();
+	std::u16string current;
+
+	for (const char16_t c : str) {
+		if (c == delimiter) {
+			vector.push_back(current);
+			current = u"";
+		} else {
+			current += c;
+		}
+	}
+
+	vector.push_back(std::move(current));
+	return vector;
+}
+
+std::vector<std::string> GeneralUtils::SplitString(const std::string_view str, const char delimiter) {
+	std::vector<std::string> vector = std::vector<std::string>();
+	std::string current = "";
+
+	for (const char c : str) {
+		if (c == delimiter) {
+			vector.push_back(current);
+			current = "";
+		} else {
+			current += c;
+		}
+	}
+
+	vector.push_back(std::move(current));
+	return vector;
+}
+
 std::u16string GeneralUtils::ReadWString(RakNet::BitStream& inStream) {
 	uint32_t length;
 	inStream.Read<uint32_t>(length);

dCommon/GeneralUtils.h

@@ -3,7 +3,6 @@
 // C++
 #include <charconv>
 #include <cstdint>
-#include <cmath> 
 #include <ctime>
 #include <functional>
 #include <optional>
@@ -130,23 +129,11 @@ namespace GeneralUtils {
 
 	std::u16string ReadWString(RakNet::BitStream& inStream);
 
-	template<typename StringType, typename CharType = typename StringType::value_type>
-	std::vector<std::basic_string<CharType>> SplitString(const StringType& str, const typename StringType::value_type delimiter) {
-		std::vector<std::basic_string<CharType>> toReturn{};
+	std::vector<std::wstring> SplitString(const std::wstring_view str, const wchar_t delimiter);
 
-		toReturn.emplace_back();
-		auto itr = toReturn.rbegin();
-		for (const auto c : str) {
-			if (c == delimiter) {
-				toReturn.emplace_back();
-				itr = toReturn.rbegin();
-			} else {
-				(*itr).push_back(c);
-			}
-		}
+	std::vector<std::u16string> SplitString(const std::u16string_view str, const char16_t delimiter);
 
-		return toReturn;
-	}
+	std::vector<std::string> SplitString(const std::string_view str, const char delimiter);
 
 	std::vector<std::string> GetSqlFileNamesFromFolder(const std::string_view folder);
 
@@ -158,7 +145,7 @@ namespace GeneralUtils {
 	template <typename... Bases>
 	struct overload : Bases... {
 		using is_transparent = void;
-		using Bases::operator() ...;
+		using Bases::operator() ... ;
 	};
 
 	struct char_pointer_hash {
@@ -215,7 +202,7 @@ namespace GeneralUtils {
 	}
 
 	template<typename T>
-		requires(!Numeric<T>)
+	requires(!Numeric<T>)
 	[[nodiscard]] std::optional<T> TryParse(std::string_view str);
 
 #if !(__GNUC__ >= 11 || _MSC_VER >= 1924)
@@ -234,7 +221,7 @@ namespace GeneralUtils {
 	*/
 	template <std::floating_point T>
 	[[nodiscard]] std::optional<T> TryParse(std::string_view str) noexcept
-		try {
+	try {
 		while (!str.empty() && std::isspace(str.front())) str.remove_prefix(1);
 
 		size_t parseNum;
@@ -336,28 +323,4 @@ namespace GeneralUtils {
 
 		return GenerateRandomNumber<T>(std::numeric_limits<T>::min(), std::numeric_limits<T>::max());
 	}
-
-	// https://www.quora.com/How-do-you-round-to-specific-increments-like-0-5-in-C
-	// Rounds to the nearest floating point value specified.
-	template <typename T, std::enable_if_t<std::is_floating_point_v<T>, int> = 0>
-	T RountToNearestEven(const T value, const T modulus) {
-		const auto modulo = std::fmod(value, modulus);
-		const auto abs_modulo_2 = std::abs(modulo * 2);
-		const auto abs_modulus = std::abs(modulus);
-
-		bool round_away_from_zero = false;
-		if (abs_modulo_2 > abs_modulus) {
-			round_away_from_zero = true;
-		} else if (abs_modulo_2 == abs_modulus) {
-			const auto trunc_quot = std::floor(std::abs(value / modulus));
-			const auto odd = std::fmod(trunc_quot, T{ 2 }) != 0;
-			round_away_from_zero = odd;
-		}
-
-		if (round_away_from_zero) {
-			return value + (std::copysign(modulus, value) - modulo);
-		} else {
-			return value - modulo;
-		}
-	}
 }

dCommon/JSONUtils.cpp

@@ -1,17 +0,0 @@
-#include "JSONUtils.h"
-#include "json.hpp"
-
-using json = nlohmann::json;
-
-std::string JSONUtils::CheckRequiredData(const json& data, const std::vector<std::string>& requiredData) {
-	json check;
-	check["error"] = json::array();
-	for (const auto& required : requiredData) {
-		if (!data.contains(required)) {
-			check["error"].push_back("Missing Parameter: " + required);
-		} else if (data[required] == "") {
-			check["error"].push_back("Empty Parameter: " + required);
-		}
-	}
-	return check["error"].empty() ? "" : check.dump();
-}

dCommon/JSONUtils.h

@@ -1,11 +0,0 @@
-#ifndef _JSONUTILS_H_
-#define _JSONUTILS_H_
-
-#include "json_fwd.hpp"
-
-namespace JSONUtils {
-	// check required fields in json data
-	std::string CheckRequiredData(const nlohmann::json& data, const std::vector<std::string>& requiredData);
-}
-
-#endif // _JSONUTILS_H_

dCommon/LDFFormat.h

@@ -83,12 +83,6 @@ public:
 		this->value = value;
 	}
 
-	//! Initializer
-	LDFData(const std::string& key, const T& value) {
-		this->key = GeneralUtils::ASCIIToUTF16(key);
-		this->value = value;
-	}
-
 	//! Destructor
 	~LDFData(void) override {}
 

dCommon/Lxfml.cpp

@@ -6,7 +6,7 @@
 
 #include <ranges>
 
-Lxfml::Result Lxfml::NormalizePosition(const std::string_view data, const NiPoint3& curPosition) {
+Lxfml::Result Lxfml::NormalizePosition(const std::string_view data) {
 	Result toReturn;
 	tinyxml2::XMLDocument doc;
 	const auto err = doc.Parse(data.data());
@@ -27,7 +27,7 @@ Lxfml::Result Lxfml::NormalizePosition(const std::string_view data, const NiPoin
 	// First get all the positions of bricks
 	for (const auto& brick : lxfml["Bricks"]) {
 		const auto* part = brick.FirstChildElement("Part");
-		while (part) {
+		if (part) {
 			const auto* bone = part->FirstChildElement("Bone");
 			if (bone) {
 				auto* transformation = bone->Attribute("transformation");
@@ -36,7 +36,6 @@ Lxfml::Result Lxfml::NormalizePosition(const std::string_view data, const NiPoin
 					if (refID) transformations[refID] = transformation;
 				}
 			}
-			part = part->NextSiblingElement("Part");
 		}
 	}
 
@@ -44,42 +43,29 @@ Lxfml::Result Lxfml::NormalizePosition(const std::string_view data, const NiPoin
 	NiPoint3 lowest{ 10'000.0f, 10'000.0f, 10'000.0f };
 	NiPoint3 highest{ -10'000.0f, -10'000.0f, -10'000.0f };
 
-	NiPoint3 delta = NiPoint3Constant::ZERO;
-	if (curPosition == NiPoint3Constant::ZERO) {
-		// Calculate the lowest and highest points on the entire model
-		for (const auto& transformation : transformations | std::views::values) {
-			auto split = GeneralUtils::SplitString(transformation, ',');
-			if (split.size() < 12) {
-				LOG("Not enough in the split?");
-				continue;
-			}
-
-			auto x = GeneralUtils::TryParse<float>(split[9]).value();
-			auto y = GeneralUtils::TryParse<float>(split[10]).value();
-			auto z = GeneralUtils::TryParse<float>(split[11]).value();
-			if (x < lowest.x) lowest.x = x;
-			if (y < lowest.y) lowest.y = y;
-			if (z < lowest.z) lowest.z = z;
-
-			if (highest.x < x) highest.x = x;
-			if (highest.y < y) highest.y = y;
-			if (highest.z < z) highest.z = z;
+	// Calculate the lowest and highest points on the entire model
+	for (const auto& transformation : transformations | std::views::values) {
+		auto split = GeneralUtils::SplitString(transformation, ',');
+		if (split.size() < 12) {
+			LOG("Not enough in the split?");
+			continue;
 		}
 
-		delta = (highest - lowest) / 2.0f;
-	} else {
-		lowest = curPosition;
-		highest = curPosition;
-		delta = NiPoint3Constant::ZERO;
+		auto x = GeneralUtils::TryParse<float>(split[9]).value();
+		auto y = GeneralUtils::TryParse<float>(split[10]).value();
+		auto z = GeneralUtils::TryParse<float>(split[11]).value();
+		if (x < lowest.x) lowest.x = x;
+		if (y < lowest.y) lowest.y = y;
+		if (z < lowest.z) lowest.z = z;
+
+		if (highest.x < x) highest.x = x;
+		if (highest.y < y) highest.y = y;
+		if (highest.z < z) highest.z = z;
 	}
 
+	auto delta = (highest - lowest) / 2.0f;
 	auto newRootPos = lowest + delta;
 
-	// Need to snap this chosen position to the nearest valid spot
-	// on the LEGO grid
-	newRootPos.x = GeneralUtils::RountToNearestEven(newRootPos.x, 0.8f);
-	newRootPos.z = GeneralUtils::RountToNearestEven(newRootPos.z, 0.8f);
-
 	// Clamp the Y to the lowest point on the model 
 	newRootPos.y = lowest.y;
 
@@ -91,9 +77,9 @@ Lxfml::Result Lxfml::NormalizePosition(const std::string_view data, const NiPoin
 			continue;
 		}
 
-		auto x = GeneralUtils::TryParse<float>(split[9]).value() - newRootPos.x + curPosition.x;
-		auto y = GeneralUtils::TryParse<float>(split[10]).value() - newRootPos.y + curPosition.y;
-		auto z = GeneralUtils::TryParse<float>(split[11]).value() - newRootPos.z + curPosition.z;
+		auto x = GeneralUtils::TryParse<float>(split[9]).value() - newRootPos.x;
+		auto y = GeneralUtils::TryParse<float>(split[10]).value() - newRootPos.y;
+		auto z = GeneralUtils::TryParse<float>(split[11]).value() - newRootPos.z;
 		std::stringstream stream;
 		for (int i = 0; i < 9; i++) {
 			stream << split[i];
@@ -106,7 +92,7 @@ Lxfml::Result Lxfml::NormalizePosition(const std::string_view data, const NiPoin
 	// Finally write the new transformation back into the lxfml
 	for (auto& brick : lxfml["Bricks"]) {
 		auto* part = brick.FirstChildElement("Part");
-		while (part) {
+		if (part) {
 			auto* bone = part->FirstChildElement("Bone");
 			if (bone) {
 				auto* transformation = bone->Attribute("transformation");
@@ -117,7 +103,6 @@ Lxfml::Result Lxfml::NormalizePosition(const std::string_view data, const NiPoin
 					}
 				}
 			}
-			part = part->NextSiblingElement("Part");
 		}
 	}
 

dCommon/Lxfml.h

@@ -17,11 +17,7 @@ namespace Lxfml {
 
 	// Normalizes a LXFML model to be positioned relative to its local 0, 0, 0 rather than a game worlds 0, 0, 0.
 	// Returns a struct of its new center and the updated LXFML containing these edits.
-	[[nodiscard]] Result NormalizePosition(const std::string_view data, const NiPoint3& curPosition = NiPoint3Constant::ZERO);
-
-	// these are only for the migrations due to a bug in one of the implementations.
-	[[nodiscard]] Result NormalizePositionOnlyFirstPart(const std::string_view data);
-	[[nodiscard]] Result NormalizePositionAfterFirstPart(const std::string_view data, const NiPoint3& position);
+	[[nodiscard]] Result NormalizePosition(const std::string_view data);
 };
 
 #endif //!LXFML_H

dCommon/LxfmlBugged.cpp

@@ -1,210 +0,0 @@
-#include "Lxfml.h"
-
-#include "GeneralUtils.h"
-#include "StringifiedEnum.h"
-#include "TinyXmlUtils.h"
-
-#include <ranges>
-
-// this file should not be touched
-
-Lxfml::Result Lxfml::NormalizePositionOnlyFirstPart(const std::string_view data) {
-	Result toReturn;
-	tinyxml2::XMLDocument doc;
-	const auto err = doc.Parse(data.data());
-	if (err != tinyxml2::XML_SUCCESS) {
-		LOG("Failed to parse xml %s.", StringifiedEnum::ToString(err).data());
-		return toReturn;
-	}
-
-	TinyXmlUtils::DocumentReader reader(doc);
-	std::map<std::string/* refID */, std::string> transformations;
-
-	auto lxfml = reader["LXFML"];
-	if (!lxfml) {
-		LOG("Failed to find LXFML element.");
-		return toReturn;
-	}
-
-	// First get all the positions of bricks
-	for (const auto& brick : lxfml["Bricks"]) {
-		const auto* part = brick.FirstChildElement("Part");
-		if (part) {
-			const auto* bone = part->FirstChildElement("Bone");
-			if (bone) {
-				auto* transformation = bone->Attribute("transformation");
-				if (transformation) {
-					auto* refID = bone->Attribute("refID");
-					if (refID) transformations[refID] = transformation;
-				}
-			}
-		}
-	}
-
-	// These points are well out of bounds for an actual player
-	NiPoint3 lowest{ 10'000.0f, 10'000.0f, 10'000.0f };
-	NiPoint3 highest{ -10'000.0f, -10'000.0f, -10'000.0f };
-
-	// Calculate the lowest and highest points on the entire model
-	for (const auto& transformation : transformations | std::views::values) {
-		auto split = GeneralUtils::SplitString(transformation, ',');
-		if (split.size() < 12) {
-			LOG("Not enough in the split?");
-			continue;
-		}
-
-		auto x = GeneralUtils::TryParse<float>(split[9]).value();
-		auto y = GeneralUtils::TryParse<float>(split[10]).value();
-		auto z = GeneralUtils::TryParse<float>(split[11]).value();
-		if (x < lowest.x) lowest.x = x;
-		if (y < lowest.y) lowest.y = y;
-		if (z < lowest.z) lowest.z = z;
-
-		if (highest.x < x) highest.x = x;
-		if (highest.y < y) highest.y = y;
-		if (highest.z < z) highest.z = z;
-	}
-
-	auto delta = (highest - lowest) / 2.0f;
-	auto newRootPos = lowest + delta;
-
-	// Clamp the Y to the lowest point on the model 
-	newRootPos.y = lowest.y;
-
-	// Adjust all positions to account for the new origin
-	for (auto& transformation : transformations | std::views::values) {
-		auto split = GeneralUtils::SplitString(transformation, ',');
-		if (split.size() < 12) {
-			LOG("Not enough in the split?");
-			continue;
-		}
-
-		auto x = GeneralUtils::TryParse<float>(split[9]).value() - newRootPos.x;
-		auto y = GeneralUtils::TryParse<float>(split[10]).value() - newRootPos.y;
-		auto z = GeneralUtils::TryParse<float>(split[11]).value() - newRootPos.z;
-		std::stringstream stream;
-		for (int i = 0; i < 9; i++) {
-			stream << split[i];
-			stream << ',';
-		}
-		stream << x << ',' << y << ',' << z;
-		transformation = stream.str();
-	}
-
-	// Finally write the new transformation back into the lxfml
-	for (auto& brick : lxfml["Bricks"]) {
-		auto* part = brick.FirstChildElement("Part");
-		if (part) {
-			auto* bone = part->FirstChildElement("Bone");
-			if (bone) {
-				auto* transformation = bone->Attribute("transformation");
-				if (transformation) {
-					auto* refID = bone->Attribute("refID");
-					if (refID) {
-						bone->SetAttribute("transformation", transformations[refID].c_str());
-					}
-				}
-			}
-		}
-	}
-
-	tinyxml2::XMLPrinter printer;
-	doc.Print(&printer);
-
-	toReturn.lxfml = printer.CStr();
-	toReturn.center = newRootPos;
-	return toReturn;
-}
-
-Lxfml::Result Lxfml::NormalizePositionAfterFirstPart(const std::string_view data, const NiPoint3& position) {
-	Result toReturn;
-	tinyxml2::XMLDocument doc;
-	const auto err = doc.Parse(data.data());
-	if (err != tinyxml2::XML_SUCCESS) {
-		LOG("Failed to parse xml %s.", StringifiedEnum::ToString(err).data());
-		return toReturn;
-	}
-
-	TinyXmlUtils::DocumentReader reader(doc);
-	std::map<std::string/* refID */, std::string> transformations;
-
-	auto lxfml = reader["LXFML"];
-	if (!lxfml) {
-		LOG("Failed to find LXFML element.");
-		return toReturn;
-	}
-
-	// First get all the positions of bricks
-	for (const auto& brick : lxfml["Bricks"]) {
-		const auto* part = brick.FirstChildElement("Part");
-		bool firstPart = true;
-		while (part) {
-			if (firstPart) {
-				firstPart = false;
-			} else {
-				LOG("Found extra bricks");
-				const auto* bone = part->FirstChildElement("Bone");
-				if (bone) {
-					auto* transformation = bone->Attribute("transformation");
-					if (transformation) {
-						auto* refID = bone->Attribute("refID");
-						if (refID) transformations[refID] = transformation;
-					}
-				}
-			}
-			part = part->NextSiblingElement("Part");
-		}
-	}
-
-	auto newRootPos = position;
-
-	// Adjust all positions to account for the new origin
-	for (auto& transformation : transformations | std::views::values) {
-		auto split = GeneralUtils::SplitString(transformation, ',');
-		if (split.size() < 12) {
-			LOG("Not enough in the split?");
-			continue;
-		}
-
-		auto x = GeneralUtils::TryParse<float>(split[9]).value() - newRootPos.x;
-		auto y = GeneralUtils::TryParse<float>(split[10]).value() - newRootPos.y;
-		auto z = GeneralUtils::TryParse<float>(split[11]).value() - newRootPos.z;
-		std::stringstream stream;
-		for (int i = 0; i < 9; i++) {
-			stream << split[i];
-			stream << ',';
-		}
-		stream << x << ',' << y << ',' << z;
-		transformation = stream.str();
-	}
-
-	// Finally write the new transformation back into the lxfml
-	for (auto& brick : lxfml["Bricks"]) {
-		auto* part = brick.FirstChildElement("Part");
-		bool firstPart = true;
-		while (part) {
-			if (firstPart) {
-				firstPart = false;
-			} else {
-				auto* bone = part->FirstChildElement("Bone");
-				if (bone) {
-					auto* transformation = bone->Attribute("transformation");
-					if (transformation) {
-						auto* refID = bone->Attribute("refID");
-						if (refID) {
-							bone->SetAttribute("transformation", transformations[refID].c_str());
-						}
-					}
-				}
-			}
-			part = part->NextSiblingElement("Part");
-		}
-	}
-
-	tinyxml2::XMLPrinter printer;
-	doc.Print(&printer);
-
-	toReturn.lxfml = printer.CStr();
-	toReturn.center = newRootPos;
-	return toReturn;
-}

dCommon/dEnums/dCommonVars.h

@@ -3,14 +3,13 @@
 #ifndef __DCOMMONVARS__H__
 #define __DCOMMONVARS__H__
 
-#include <compare>
 #include <cstdint>
-#include <set>
 #include <string>
+#include <set>
 #include "BitStream.h"
-#include "BitStreamUtils.h"
-#include "MessageType/Client.h"
 #include "eConnectionType.h"
+#include "MessageType/Client.h"
+#include "BitStreamUtils.h"
 
 #pragma warning (disable:4251) //Disables SQL warnings
 
@@ -100,7 +99,6 @@ public:
 	constexpr LWOZONEID(const LWOMAPID& mapID, const LWOINSTANCEID& instanceID, const LWOCLONEID& cloneID) noexcept { m_MapID = mapID; m_InstanceID = instanceID; m_CloneID = cloneID; }
 	constexpr LWOZONEID(const LWOZONEID& replacement) noexcept { *this = replacement; }
 	constexpr bool operator==(const LWOZONEID&) const = default;
-	constexpr auto operator<=>(const LWOZONEID&) const = default;
 
 private:
 	LWOMAPID m_MapID = LWOMAPID_INVALID; //1000 for VE, 1100 for AG, etc...

dCommon/dEnums/eHTTPMethod.h

@@ -1,8 +1,6 @@
 #ifndef __EHTTPMETHODS__H__
 #define __EHTTPMETHODS__H__
 
-#include "dPlatforms.h"
-
 #ifdef DARKFLAME_PLATFORM_WIN32
 #pragma push_macro("DELETE")
 #undef DELETE

dDatabase/GameDatabase/ITables/IActivityLog.h

@@ -8,7 +8,6 @@
 enum class eActivityType : uint32_t {
 	PlayerLoggedIn,
 	PlayerLoggedOut,
-	PlayerChangedZone
 };
 
 class IActivityLog {

dDatabase/GameDatabase/ITables/IBehaviors.h

@@ -8,15 +8,15 @@
 class IBehaviors {
 public:
 	struct Info {
-		LWOOBJID behaviorId{};
+		int32_t behaviorId{};
 		uint32_t characterId{};
 		std::string behaviorInfo;
 	};
 
 	// This Add also takes care of updating if it exists.
 	virtual void AddBehavior(const Info& info) = 0;
-	virtual std::string GetBehavior(const LWOOBJID behaviorId) = 0;
-	virtual void RemoveBehavior(const LWOOBJID behaviorId) = 0;
+	virtual std::string GetBehavior(const int32_t behaviorId) = 0;
+	virtual void RemoveBehavior(const int32_t behaviorId) = 0;
 };
 
 #endif  //!IBEHAVIORS_H

dDatabase/GameDatabase/ITables/IPropertyContents.h

@@ -17,7 +17,7 @@ public:
 		LWOOBJID id{};
 		LOT lot{};
 		uint32_t ugcId{};
-		std::array<LWOOBJID, 5> behaviors{};
+		std::array<int32_t, 5> behaviors{};
 	};
 
 	// Inserts a new UGC model into the database.
@@ -34,9 +34,9 @@ public:
 	virtual void InsertNewPropertyModel(const LWOOBJID& propertyId, const IPropertyContents::Model& model, const std::string_view name) = 0;
 
 	// Update the model position and rotation for the given property id.
-	virtual void UpdateModel(const LWOOBJID& modelID, const NiPoint3& position, const NiQuaternion& rotation, const std::array<std::pair<LWOOBJID, std::string>, 5>& behaviors) = 0;
-	virtual void UpdateModel(const LWOOBJID& modelID, const NiPoint3& position, const NiQuaternion& rotation, const std::array<LWOOBJID, 5> behaviorIDs) {
-		std::array<std::pair<LWOOBJID, std::string>, 5> behaviors;
+	virtual void UpdateModel(const LWOOBJID& modelID, const NiPoint3& position, const NiQuaternion& rotation, const std::array<std::pair<int32_t, std::string>, 5>& behaviors) = 0;
+	virtual void UpdateModel(const LWOOBJID& modelID, const NiPoint3& position, const NiQuaternion& rotation, const std::array<int32_t, 5> behaviorIDs) {
+		std::array<std::pair<int32_t, std::string>, 5> behaviors;
 		for (int32_t i = 0; i < behaviors.size(); i++) behaviors[i].first = behaviorIDs[i];
 		UpdateModel(modelID, position, rotation, behaviors);
 	}

dDatabase/GameDatabase/MySQL/MySQLDatabase.h

@@ -75,7 +75,7 @@ public:
 	std::vector<IPropertyContents::Model> GetPropertyModels(const LWOOBJID& propertyId) override;
 	void RemoveUnreferencedUgcModels() override;
 	void InsertNewPropertyModel(const LWOOBJID& propertyId, const IPropertyContents::Model& model, const std::string_view name) override;
-	void UpdateModel(const LWOOBJID& modelID, const NiPoint3& position, const NiQuaternion& rotation, const std::array<std::pair<LWOOBJID, std::string>, 5>& behaviors) override;
+	void UpdateModel(const LWOOBJID& modelID, const NiPoint3& position, const NiQuaternion& rotation, const std::array<std::pair<int32_t, std::string>, 5>& behaviors) override;
 	void RemoveModel(const LWOOBJID& modelId) override;
 	void UpdatePerformanceCost(const LWOZONEID& zoneId, const float performanceCost) override;
 	void InsertNewBugReport(const IBugReports::Info& info) override;
@@ -110,8 +110,8 @@ public:
 	void InsertRewardCode(const uint32_t account_id, const uint32_t reward_code) override;
 	std::vector<uint32_t> GetRewardCodesByAccountID(const uint32_t account_id) override;
 	void AddBehavior(const IBehaviors::Info& info) override;
-	std::string GetBehavior(const LWOOBJID behaviorId) override;
-	void RemoveBehavior(const LWOOBJID characterId) override;
+	std::string GetBehavior(const int32_t behaviorId) override;
+	void RemoveBehavior(const int32_t characterId) override;
 	void UpdateAccountGmLevel(const uint32_t accountId, const eGameMasterLevel gmLevel) override;
 	std::optional<IProperty::PropertyEntranceResult> GetProperties(const IProperty::PropertyLookup& params) override;
 	std::vector<ILeaderboard::Entry> GetDescendingLeaderboard(const uint32_t activityId) override;

dDatabase/GameDatabase/MySQL/Tables/Behaviors.cpp

@@ -9,11 +9,11 @@ void MySQLDatabase::AddBehavior(const IBehaviors::Info& info) {
 	);
 }
 
-void MySQLDatabase::RemoveBehavior(const LWOOBJID behaviorId) {
+void MySQLDatabase::RemoveBehavior(const int32_t behaviorId) {
 	ExecuteDelete("DELETE FROM behaviors WHERE behavior_id = ?", behaviorId);
 }
 
-std::string MySQLDatabase::GetBehavior(const LWOOBJID behaviorId) {
+std::string MySQLDatabase::GetBehavior(const int32_t behaviorId) {
 	auto result = ExecuteSelect("SELECT behavior_info FROM behaviors WHERE behavior_id = ?", behaviorId);
 	return result->next() ? result->getString("behavior_info").c_str() : "";
 }

dDatabase/GameDatabase/MySQL/Tables/PropertyContents.cpp

@@ -20,11 +20,11 @@ std::vector<IPropertyContents::Model> MySQLDatabase::GetPropertyModels(const LWO
 		model.rotation.y = result->getFloat("ry");
 		model.rotation.z = result->getFloat("rz");
 		model.ugcId = result->getUInt64("ugc_id");
-		model.behaviors[0] = result->getUInt64("behavior_1");
-		model.behaviors[1] = result->getUInt64("behavior_2");
-		model.behaviors[2] = result->getUInt64("behavior_3");
-		model.behaviors[3] = result->getUInt64("behavior_4");
-		model.behaviors[4] = result->getUInt64("behavior_5");
+		model.behaviors[0] = result->getInt("behavior_1");
+		model.behaviors[1] = result->getInt("behavior_2");
+		model.behaviors[2] = result->getInt("behavior_3");
+		model.behaviors[3] = result->getInt("behavior_4");
+		model.behaviors[4] = result->getInt("behavior_5");
 
 		toReturn.push_back(std::move(model));
 	}
@@ -52,7 +52,7 @@ void MySQLDatabase::InsertNewPropertyModel(const LWOOBJID& propertyId, const IPr
 	}
 }
 
-void MySQLDatabase::UpdateModel(const LWOOBJID& modelID, const NiPoint3& position, const NiQuaternion& rotation, const std::array<std::pair<LWOOBJID, std::string>, 5>& behaviors) {
+void MySQLDatabase::UpdateModel(const LWOOBJID& modelID, const NiPoint3& position, const NiQuaternion& rotation, const std::array<std::pair<int32_t, std::string>, 5>& behaviors) {
 	ExecuteUpdate(
 		"UPDATE properties_contents SET x = ?, y = ?, z = ?, rx = ?, ry = ?, rz = ?, rw = ?, "
 		"behavior_1 = ?, behavior_2 = ?, behavior_3 = ?, behavior_4 = ?, behavior_5 = ? WHERE id = ?;",
@@ -79,11 +79,11 @@ IPropertyContents::Model MySQLDatabase::GetModel(const LWOOBJID modelID) {
 		model.rotation.y = result->getFloat("ry");
 		model.rotation.z = result->getFloat("rz");
 		model.ugcId = result->getUInt64("ugc_id");
-		model.behaviors[0] = result->getUInt64("behavior_1");
-		model.behaviors[1] = result->getUInt64("behavior_2");
-		model.behaviors[2] = result->getUInt64("behavior_3");
-		model.behaviors[3] = result->getUInt64("behavior_4");
-		model.behaviors[4] = result->getUInt64("behavior_5");
+		model.behaviors[0] = result->getInt("behavior_1");
+		model.behaviors[1] = result->getInt("behavior_2");
+		model.behaviors[2] = result->getInt("behavior_3");
+		model.behaviors[3] = result->getInt("behavior_4");
+		model.behaviors[4] = result->getInt("behavior_5");
 	}
 
 	return model;

dDatabase/GameDatabase/SQLite/SQLiteDatabase.h

@@ -73,7 +73,7 @@ public:
 	std::vector<IPropertyContents::Model> GetPropertyModels(const LWOOBJID& propertyId) override;
 	void RemoveUnreferencedUgcModels() override;
 	void InsertNewPropertyModel(const LWOOBJID& propertyId, const IPropertyContents::Model& model, const std::string_view name) override;
-	void UpdateModel(const LWOOBJID& modelID, const NiPoint3& position, const NiQuaternion& rotation, const std::array<std::pair<LWOOBJID, std::string>, 5>& behaviors) override;
+	void UpdateModel(const LWOOBJID& modelID, const NiPoint3& position, const NiQuaternion& rotation, const std::array<std::pair<int32_t, std::string>, 5>& behaviors) override;
 	void RemoveModel(const LWOOBJID& modelId) override;
 	void UpdatePerformanceCost(const LWOZONEID& zoneId, const float performanceCost) override;
 	void InsertNewBugReport(const IBugReports::Info& info) override;
@@ -108,8 +108,8 @@ public:
 	void InsertRewardCode(const uint32_t account_id, const uint32_t reward_code) override;
 	std::vector<uint32_t> GetRewardCodesByAccountID(const uint32_t account_id) override;
 	void AddBehavior(const IBehaviors::Info& info) override;
-	std::string GetBehavior(const LWOOBJID behaviorId) override;
-	void RemoveBehavior(const LWOOBJID characterId) override;
+	std::string GetBehavior(const int32_t behaviorId) override;
+	void RemoveBehavior(const int32_t characterId) override;
 	void UpdateAccountGmLevel(const uint32_t accountId, const eGameMasterLevel gmLevel) override;
 	std::optional<IProperty::PropertyEntranceResult> GetProperties(const IProperty::PropertyLookup& params) override;
 	std::vector<ILeaderboard::Entry> GetDescendingLeaderboard(const uint32_t activityId) override;

dDatabase/GameDatabase/SQLite/Tables/Behaviors.cpp

@@ -9,11 +9,11 @@ void SQLiteDatabase::AddBehavior(const IBehaviors::Info& info) {
 	);
 }
 
-void SQLiteDatabase::RemoveBehavior(const LWOOBJID behaviorId) {
+void SQLiteDatabase::RemoveBehavior(const int32_t behaviorId) {
 	ExecuteDelete("DELETE FROM behaviors WHERE behavior_id = ?", behaviorId);
 }
 
-std::string SQLiteDatabase::GetBehavior(const LWOOBJID behaviorId) {
+std::string SQLiteDatabase::GetBehavior(const int32_t behaviorId) {
 	auto [_, result] = ExecuteSelect("SELECT behavior_info FROM behaviors WHERE behavior_id = ?", behaviorId);
 	return !result.eof() ? result.getStringField("behavior_info") : "";
 }

dDatabase/GameDatabase/SQLite/Tables/PropertyContents.cpp

@@ -19,11 +19,11 @@ std::vector<IPropertyContents::Model> SQLiteDatabase::GetPropertyModels(const LW
 		model.rotation.y = result.getFloatField("ry");
 		model.rotation.z = result.getFloatField("rz");
 		model.ugcId = result.getInt64Field("ugc_id");
-		model.behaviors[0] = result.getInt64Field("behavior_1");
-		model.behaviors[1] = result.getInt64Field("behavior_2");
-		model.behaviors[2] = result.getInt64Field("behavior_3");
-		model.behaviors[3] = result.getInt64Field("behavior_4");
-		model.behaviors[4] = result.getInt64Field("behavior_5");
+		model.behaviors[0] = result.getIntField("behavior_1");
+		model.behaviors[1] = result.getIntField("behavior_2");
+		model.behaviors[2] = result.getIntField("behavior_3");
+		model.behaviors[3] = result.getIntField("behavior_4");
+		model.behaviors[4] = result.getIntField("behavior_5");
 
 		toReturn.push_back(std::move(model));
 		result.nextRow();
@@ -52,7 +52,7 @@ void SQLiteDatabase::InsertNewPropertyModel(const LWOOBJID& propertyId, const IP
 	}
 }
 
-void SQLiteDatabase::UpdateModel(const LWOOBJID& modelID, const NiPoint3& position, const NiQuaternion& rotation, const std::array<std::pair<LWOOBJID, std::string>, 5>& behaviors) {
+void SQLiteDatabase::UpdateModel(const LWOOBJID& modelID, const NiPoint3& position, const NiQuaternion& rotation, const std::array<std::pair<int32_t, std::string>, 5>& behaviors) {
 	ExecuteUpdate(
 		"UPDATE properties_contents SET x = ?, y = ?, z = ?, rx = ?, ry = ?, rz = ?, rw = ?, "
 		"behavior_1 = ?, behavior_2 = ?, behavior_3 = ?, behavior_4 = ?, behavior_5 = ? WHERE id = ?;",
@@ -80,11 +80,11 @@ IPropertyContents::Model SQLiteDatabase::GetModel(const LWOOBJID modelID) {
 			model.rotation.y = result.getFloatField("ry");
 			model.rotation.z = result.getFloatField("rz");
 			model.ugcId = result.getInt64Field("ugc_id");
-			model.behaviors[0] = result.getInt64Field("behavior_1");
-			model.behaviors[1] = result.getInt64Field("behavior_2");
-			model.behaviors[2] = result.getInt64Field("behavior_3");
-			model.behaviors[3] = result.getInt64Field("behavior_4");
-			model.behaviors[4] = result.getInt64Field("behavior_5");
+			model.behaviors[0] = result.getIntField("behavior_1");
+			model.behaviors[1] = result.getIntField("behavior_2");
+			model.behaviors[2] = result.getIntField("behavior_3");
+			model.behaviors[3] = result.getIntField("behavior_4");
+			model.behaviors[4] = result.getIntField("behavior_5");
 		} while (result.nextRow());
 	}
 

dDatabase/GameDatabase/TestSQL/TestSQLDatabase.cpp

@@ -168,7 +168,7 @@ void TestSQLDatabase::InsertNewPropertyModel(const LWOOBJID& propertyId, const I
 
 }
 
-void TestSQLDatabase::UpdateModel(const LWOOBJID& modelID, const NiPoint3& position, const NiQuaternion& rotation, const std::array<std::pair<LWOOBJID, std::string>, 5>& behaviors) {
+void TestSQLDatabase::UpdateModel(const LWOOBJID& modelID, const NiPoint3& position, const NiQuaternion& rotation, const std::array<std::pair<int32_t, std::string>, 5>& behaviors) {
 
 }
 
@@ -292,11 +292,11 @@ void TestSQLDatabase::AddBehavior(const IBehaviors::Info& info) {
 
 }
 
-std::string TestSQLDatabase::GetBehavior(const LWOOBJID behaviorId) {
+std::string TestSQLDatabase::GetBehavior(const int32_t behaviorId) {
 	return {};
 }
 
-void TestSQLDatabase::RemoveBehavior(const LWOOBJID behaviorId) {
+void TestSQLDatabase::RemoveBehavior(const int32_t behaviorId) {
 
 }
 

dDatabase/GameDatabase/TestSQL/TestSQLDatabase.h

@@ -52,7 +52,7 @@ class TestSQLDatabase : public GameDatabase {
 	std::vector<IPropertyContents::Model> GetPropertyModels(const LWOOBJID& propertyId) override;
 	void RemoveUnreferencedUgcModels() override;
 	void InsertNewPropertyModel(const LWOOBJID& propertyId, const IPropertyContents::Model& model, const std::string_view name) override;
-	void UpdateModel(const LWOOBJID& modelID, const NiPoint3& position, const NiQuaternion& rotation, const std::array<std::pair<LWOOBJID, std::string>, 5>& behaviors) override;
+	void UpdateModel(const LWOOBJID& modelID, const NiPoint3& position, const NiQuaternion& rotation, const std::array<std::pair<int32_t, std::string>, 5>& behaviors) override;
 	void RemoveModel(const LWOOBJID& modelId) override;
 	void UpdatePerformanceCost(const LWOZONEID& zoneId, const float performanceCost) override;
 	void InsertNewBugReport(const IBugReports::Info& info) override;
@@ -87,8 +87,8 @@ class TestSQLDatabase : public GameDatabase {
 	void InsertRewardCode(const uint32_t account_id, const uint32_t reward_code) override;
 	std::vector<uint32_t> GetRewardCodesByAccountID(const uint32_t account_id) override;
 	void AddBehavior(const IBehaviors::Info& info) override;
-	std::string GetBehavior(const LWOOBJID behaviorId) override;
-	void RemoveBehavior(const LWOOBJID behaviorId) override;
+	std::string GetBehavior(const int32_t behaviorId) override;
+	void RemoveBehavior(const int32_t behaviorId) override;
 	void UpdateAccountGmLevel(const uint32_t accountId, const eGameMasterLevel gmLevel) override;
 	std::optional<IProperty::PropertyEntranceResult> GetProperties(const IProperty::PropertyLookup& params) override { return {}; };
 	std::vector<ILeaderboard::Entry> GetDescendingLeaderboard(const uint32_t activityId) override { return {}; };

dDatabase/MigrationRunner.cpp

@@ -47,8 +47,6 @@ void MigrationRunner::RunMigrations() {
 	std::string finalSQL = "";
 	bool runSd0Migrations = false;
 	bool runNormalizeMigrations = false;
-	bool runNormalizeAfterFirstPartMigrations = false;
-	bool runBrickBuildsNotOnGrid = false;
 	for (const auto& entry : GeneralUtils::GetSqlFileNamesFromFolder((BinaryPathFinder::GetBinaryDir() / "./migrations/dlu/" / migrationFolder).string())) {
 		auto migration = LoadMigration("dlu/" + migrationFolder + "/", entry);
 
@@ -63,10 +61,6 @@ void MigrationRunner::RunMigrations() {
 			runSd0Migrations = true;
 		} else if (migration.name.ends_with("_normalize_model_positions.sql")) {
 			runNormalizeMigrations = true;
-		} else if (migration.name.ends_with("_normalize_model_positions_after_first_part.sql")) {
-			runNormalizeAfterFirstPartMigrations = true;
-		} else if (migration.name.ends_with("_brickbuilds_not_on_grid.sql")) {
-			runBrickBuildsNotOnGrid = true;
 		} else {
 			finalSQL.append(migration.data.c_str());
 		}
@@ -74,7 +68,7 @@ void MigrationRunner::RunMigrations() {
 		Database::Get()->InsertMigration(migration.name);
 	}
 
-	if (finalSQL.empty() && !runSd0Migrations && !runNormalizeMigrations && !runNormalizeAfterFirstPartMigrations && !runBrickBuildsNotOnGrid) {
+	if (finalSQL.empty() && !runSd0Migrations && !runNormalizeMigrations) {
 		LOG("Server database is up to date.");
 		return;
 	}
@@ -102,14 +96,6 @@ void MigrationRunner::RunMigrations() {
 	if (runNormalizeMigrations) {
 		ModelNormalizeMigration::Run();
 	}
-
-	if (runNormalizeAfterFirstPartMigrations) {
-		ModelNormalizeMigration::RunAfterFirstPart();
-	}
-
-	if (runBrickBuildsNotOnGrid) {
-		ModelNormalizeMigration::RunBrickBuildGrid();
-	}
 }
 
 void MigrationRunner::RunSQLiteMigrations() {

dDatabase/ModelNormalizeMigration.cpp

@@ -14,7 +14,7 @@ void ModelNormalizeMigration::Run() {
 	
 		Sd0 sd0(lxfmlData);
 		const auto asStr = sd0.GetAsStringUncompressed();
-		const auto [newLxfml, newCenter] = Lxfml::NormalizePositionOnlyFirstPart(asStr);
+		const auto [newLxfml, newCenter] = Lxfml::NormalizePosition(asStr);
 		if (newCenter == NiPoint3Constant::ZERO) {
 			LOG("Failed to update model %llu due to failure reading xml.");
 			continue;
@@ -28,44 +28,3 @@ void ModelNormalizeMigration::Run() {
 	}
 	Database::Get()->SetAutoCommit(oldCommit);
 }
-
-void ModelNormalizeMigration::RunAfterFirstPart() {
-	const auto oldCommit = Database::Get()->GetAutoCommit();
-	Database::Get()->SetAutoCommit(false);
-	for (auto& [lxfmlData, id, modelID] : Database::Get()->GetAllUgcModels()) {
-		const auto model = Database::Get()->GetModel(modelID);
-		// only BBB models (lot 14) need to have their position fixed from the above blunder
-		if (model.lot != 14) continue;
-	
-		Sd0 sd0(lxfmlData);
-		const auto asStr = sd0.GetAsStringUncompressed();
-		const auto [newLxfml, newCenter] = Lxfml::NormalizePositionAfterFirstPart(asStr, model.position);
-
-		sd0.FromData(reinterpret_cast<const uint8_t*>(newLxfml.data()), newLxfml.size());
-		auto asStream = sd0.GetAsStream();
-		Database::Get()->UpdateModel(model.id, newCenter, model.rotation, model.behaviors);
-		Database::Get()->UpdateUgcModelData(id, asStream);
-	}
-	Database::Get()->SetAutoCommit(oldCommit);
-}
-
-void ModelNormalizeMigration::RunBrickBuildGrid() {
-	const auto oldCommit = Database::Get()->GetAutoCommit();
-	Database::Get()->SetAutoCommit(false);
-	for (auto& [lxfmlData, id, modelID] : Database::Get()->GetAllUgcModels()) {
-		const auto model = Database::Get()->GetModel(modelID);
-		// only BBB models (lot 14) need to have their position fixed from the above blunder
-		if (model.lot != 14) continue;
-	
-		Sd0 sd0(lxfmlData);
-		const auto asStr = sd0.GetAsStringUncompressed();
-		const auto [newLxfml, newCenter] = Lxfml::NormalizePosition(asStr, model.position);
-
-		sd0.FromData(reinterpret_cast<const uint8_t*>(newLxfml.data()), newLxfml.size());
-		LOG("Updated model %llu to have a center of %f %f %f", modelID, newCenter.x, newCenter.y, newCenter.z);
-		auto asStream = sd0.GetAsStream();
-		Database::Get()->UpdateModel(model.id, newCenter, model.rotation, model.behaviors);
-		Database::Get()->UpdateUgcModelData(id, asStream);
-	}
-	Database::Get()->SetAutoCommit(oldCommit);
-}

dDatabase/ModelNormalizeMigration.h

@@ -6,8 +6,6 @@
 
 namespace ModelNormalizeMigration {
 	void Run();
-	void RunAfterFirstPart();
-	void RunBrickBuildGrid();
 };
 
 #endif //!MODELNORMALIZEMIGRATION_H

dGame/Entity.h

@@ -34,6 +34,7 @@ namespace tinyxml2 {
 };
 
 class Player;
+class EntityInfo;
 class User;
 class Spawner;
 class ScriptComponent;
@@ -44,7 +45,6 @@ class Item;
 class Character;
 class EntityCallbackTimer;
 class PositionUpdate;
-struct EntityInfo;
 enum class eTriggerEventType;
 enum class eGameMasterLevel : uint8_t;
 enum class eReplicaComponentType : uint32_t;
@@ -60,7 +60,7 @@ namespace CppScripts {
  */
 class Entity {
 public:
-	Entity(const LWOOBJID& objectID, const EntityInfo& info, User* parentUser = nullptr, Entity* parentEntity = nullptr);
+	explicit Entity(const LWOOBJID& objectID, EntityInfo info, User* parentUser = nullptr, Entity* parentEntity = nullptr);
 	~Entity();
 
 	void Initialize();
@@ -113,7 +113,7 @@ public:
 
 	float GetDefaultScale() const;
 
-	NiPoint3 GetPosition() const;
+	const NiPoint3& GetPosition() const;
 
 	const NiQuaternion& GetRotation() const;
 
@@ -124,8 +124,6 @@ public:
 	// then return the collision group from that.
 	int32_t GetCollisionGroup() const;
 
-	const NiPoint3& GetVelocity() const;
-
 	/**
 	 * Setters
 	 */
@@ -146,11 +144,9 @@ public:
 
 	void SetRotation(const NiQuaternion& rotation);
 
-	void SetRespawnPos(const NiPoint3& position) const;
+	void SetRespawnPos(const NiPoint3& position);
 
-	void SetRespawnRot(const NiQuaternion& rotation) const;
-
-	void SetVelocity(const NiPoint3& velocity);
+	void SetRespawnRot(const NiQuaternion& rotation);
 
 	/**
 	 * Component management
@@ -169,7 +165,7 @@ public:
 	void AddComponent(eReplicaComponentType componentId, Component* component);
 
 	// This is expceted to never return nullptr, an assert checks this.
-	CppScripts::Script* const GetScript() const;
+	CppScripts::Script* const GetScript();
 
 	void Subscribe(LWOOBJID scriptObjId, CppScripts::Script* scriptToAdd, const std::string& notificationName);
 	void Unsubscribe(LWOOBJID scriptObjId, const std::string& notificationName);
@@ -182,8 +178,8 @@ public:
 	void RemoveParent();
 
 	// Adds a timer to start next frame with the given name and time.
-	void AddTimer(const std::string& name, float time);
-	void AddCallbackTimer(float time, const std::function<void()> callback);
+	void AddTimer(std::string name, float time);
+	void AddCallbackTimer(float time, std::function<void()> callback);
 	bool HasTimer(const std::string& name);
 	void CancelCallbackTimers();
 	void CancelAllTimers();
@@ -195,7 +191,7 @@ public:
 	std::unordered_map<eReplicaComponentType, Component*>& GetComponents() { return m_Components; } // TODO: Remove
 
 	void WriteBaseReplicaData(RakNet::BitStream& outBitStream, eReplicaPacketType packetType);
-	void WriteComponents(RakNet::BitStream& outBitStream, eReplicaPacketType packetType) const;
+	void WriteComponents(RakNet::BitStream& outBitStream, eReplicaPacketType packetType);
 	void UpdateXMLDoc(tinyxml2::XMLDocument& doc);
 	void Update(float deltaTime);
 
@@ -242,21 +238,21 @@ public:
 	void AddDieCallback(const std::function<void()>& callback);
 	void Resurrect();
 
-	void AddLootItem(const Loot::Info& info) const;
-	void PickupItem(const LWOOBJID& objectID) const;
+	void AddLootItem(const Loot::Info& info);
+	void PickupItem(const LWOOBJID& objectID);
 
-	bool PickupCoins(uint64_t count) const;
-	void RegisterCoinDrop(uint64_t count) const;
+	bool CanPickupCoins(uint64_t count);
+	void RegisterCoinDrop(uint64_t count);
 
 	void ScheduleKillAfterUpdate(Entity* murderer = nullptr);
-	void TriggerEvent(eTriggerEventType event, Entity* optionalTarget = nullptr) const;
+	void TriggerEvent(eTriggerEventType event, Entity* optionalTarget = nullptr);
 	void ScheduleDestructionAfterUpdate() { m_ShouldDestroyAfterUpdate = true; }
 
 	const NiPoint3& GetRespawnPosition() const;
 	const NiQuaternion& GetRespawnRotation() const;
 
-	void Sleep() const;
-	void Wake() const;
+	void Sleep();
+	void Wake();
 	bool IsSleeping() const;
 
 	/*
@@ -266,7 +262,7 @@ public:
 	  * Retroactively corrects the model vault size due to incorrect initialization in a previous patch.
 	  *
 	  */
-	void RetroactiveVaultSize() const;
+	void RetroactiveVaultSize();
 	bool GetBoolean(const std::u16string& name) const;
 	int32_t GetI32(const std::u16string& name) const;
 	int64_t GetI64(const std::u16string& name) const;
@@ -333,9 +329,8 @@ public:
 	 * @brief The observable for player entity position updates.
 	 */
 	static Observable<Entity*, const PositionUpdate&> OnPlayerPositionUpdate;
-
-private:
-	void WriteLDFData(const std::vector<LDFBaseData*>& ldf, RakNet::BitStream& outBitStream) const;
+	
+protected:
 	LWOOBJID m_ObjectID;
 
 	LOT m_TemplateID;
@@ -358,6 +353,7 @@ private:
 	Entity* m_ParentEntity; //For spawners and the like
 	std::vector<Entity*> m_ChildEntities;
 	eGameMasterLevel m_GMLevel;
+	uint16_t m_CollectibleID;
 	std::vector<std::string> m_Groups;
 	uint16_t m_NetworkID;
 	std::vector<std::function<void()>> m_DieCallbacks;
@@ -383,8 +379,6 @@ private:
 
 	bool m_IsParentChildDirty = true;
 
-	bool m_IsSleeping = false;
-
 	/*
 	 * Collision
 	 */
@@ -393,7 +387,7 @@ private:
 	// objectID of receiver and map of notification name to script
 	std::map<LWOOBJID, std::map<std::string, CppScripts::Script*>> m_Subscriptions;
 
-	std::unordered_multimap<MessageType::Game, std::function<bool(GameMessages::GameMsg&)>> m_MsgHandlers;
+	std::multimap<MessageType::Game, std::function<bool(GameMessages::GameMsg&)>> m_MsgHandlers;
 };
 
 /**
@@ -441,7 +435,7 @@ const T& Entity::GetVar(const std::u16string& name) const {
 template<typename T>
 T Entity::GetVarAs(const std::u16string& name) const {
 	const auto data = GetVarAsString(name);
-
+	
 	return GeneralUtils::TryParse<T>(data).value_or(LDFData<T>::Default);
 }
 

dGame/EntityManager.cpp

@@ -320,7 +320,7 @@ const std::unordered_map<std::string, LWOOBJID>& EntityManager::GetSpawnPointEnt
 	return m_SpawnPoints;
 }
 
-void EntityManager::ConstructEntity(Entity* entity, const SystemAddress& sysAddr) {
+void EntityManager::ConstructEntity(Entity* entity, const SystemAddress& sysAddr, const bool skipChecks) {
 	if (!entity) {
 		LOG("Attempted to construct null entity");
 		return;
@@ -363,14 +363,16 @@ void EntityManager::ConstructEntity(Entity* entity, const SystemAddress& sysAddr
 	entity->WriteComponents(stream, eReplicaPacketType::CONSTRUCTION);
 
 	if (sysAddr == UNASSIGNED_SYSTEM_ADDRESS) {
-		for (auto* player : PlayerManager::GetAllPlayers()) {
-			// Don't need to construct the player to themselves 
-			if (entity->GetObjectID() == player->GetObjectID()) continue;
-			if (player->GetPlayerReadyForUpdates()) {
-				Game::server->Send(stream, player->GetSystemAddress(), false);
-			} else {
-				auto* ghostComponent = player->GetComponent<GhostComponent>();
-				if (ghostComponent) ghostComponent->AddLimboConstruction(entity->GetObjectID());
+		if (skipChecks) {
+			Game::server->Send(stream, UNASSIGNED_SYSTEM_ADDRESS, true);
+		} else {
+			for (auto* player : PlayerManager::GetAllPlayers()) {
+				if (player->GetPlayerReadyForUpdates()) {
+					Game::server->Send(stream, player->GetSystemAddress(), false);
+				} else {
+					auto* ghostComponent = player->GetComponent<GhostComponent>();
+					if (ghostComponent) ghostComponent->AddLimboConstruction(entity->GetObjectID());
+				}
 			}
 		}
 	} else {
@@ -394,7 +396,7 @@ void EntityManager::ConstructAllEntities(const SystemAddress& sysAddr) {
 		}
 	}
 
-	UpdateGhosting(PlayerManager::GetPlayer(sysAddr), true);
+	UpdateGhosting(PlayerManager::GetPlayer(sysAddr));
 }
 
 void EntityManager::DestructEntity(Entity* entity, const SystemAddress& sysAddr) {
@@ -417,7 +419,7 @@ void EntityManager::DestructEntity(Entity* entity, const SystemAddress& sysAddr)
 
 void EntityManager::SerializeEntity(Entity* entity) {
 	if (!entity) return;
-
+	
 	EntityManager::SerializeEntity(*entity);
 }
 
@@ -463,7 +465,7 @@ void EntityManager::UpdateGhosting() {
 	m_PlayersToUpdateGhosting.clear();
 }
 
-void EntityManager::UpdateGhosting(Entity* player, const bool constructAll) {
+void EntityManager::UpdateGhosting(Entity* player) {
 	if (!player) return;
 
 	auto* missionComponent = player->GetComponent<MissionComponent>();
@@ -511,12 +513,9 @@ void EntityManager::UpdateGhosting(Entity* player, const bool constructAll) {
 
 			ghostComponent->ObserveEntity(id);
 
-			entity->SetObservers(entity->GetObservers() + 1);
-
-			// TODO: figure out if zone control should be ghosted at all
-			if (constructAll && entity->GetObjectID() == GetZoneControlEntity()->GetObjectID()) continue;
-
 			ConstructEntity(entity, player->GetSystemAddress());
+
+			entity->SetObservers(entity->GetObservers() + 1);
 		}
 	}
 }
@@ -605,14 +604,3 @@ void EntityManager::FireEventServerSide(Entity* origin, std::string args) {
 bool EntityManager::IsExcludedFromGhosting(LOT lot) {
 	return std::find(m_GhostingExcludedLOTs.begin(), m_GhostingExcludedLOTs.end(), lot) != m_GhostingExcludedLOTs.end();
 }
-
-bool EntityManager::SendMessage(GameMessages::GameMsg& msg) const {
-	bool handled = false;
-	const auto entityItr = m_Entities.find(msg.target);
-	if (entityItr != m_Entities.end()) {
-		auto* const entity = entityItr->second;
-		if (entity) handled = entity->HandleMsg(msg);
-	}
-
-	return handled;
-}

dGame/EntityManager.h

@@ -9,15 +9,11 @@
 #include "dCommonVars.h"
 
 class Entity;
-struct EntityInfo;
+class EntityInfo;
 class Player;
 class User;
 enum class eReplicaComponentType : uint32_t;
 
-namespace GameMessages {
-	struct GameMsg;
-}
-
 struct SystemAddress;
 
 class EntityManager {
@@ -46,7 +42,7 @@ public:
 	const std::unordered_map<LWOOBJID, Entity*> GetAllEntities() const { return m_Entities; }
 #endif
 
-	void ConstructEntity(Entity* entity, const SystemAddress& sysAddr = UNASSIGNED_SYSTEM_ADDRESS);
+	void ConstructEntity(Entity* entity, const SystemAddress& sysAddr = UNASSIGNED_SYSTEM_ADDRESS, bool skipChecks = false);
 	void DestructEntity(Entity* entity, const SystemAddress& sysAddr = UNASSIGNED_SYSTEM_ADDRESS);
 	void SerializeEntity(Entity* entity);
 	void SerializeEntity(const Entity& entity);
@@ -58,7 +54,7 @@ public:
 	void SetGhostDistanceMin(float value);
 	void QueueGhostUpdate(LWOOBJID playerID);
 	void UpdateGhosting();
-	void UpdateGhosting(Entity* player, const bool constructAll = false);
+	void UpdateGhosting(Entity* player);
 	void CheckGhosting(Entity* entity);
 	Entity* GetGhostCandidate(LWOOBJID id) const;
 	bool GetGhostingEnabled() const;
@@ -76,9 +72,6 @@ public:
 	const bool GetHardcoreDropinventoryOnDeath() { return m_HardcoreDropinventoryOnDeath; };
 	const uint32_t GetHardcoreUscoreEnemiesMultiplier() { return m_HardcoreUscoreEnemiesMultiplier; };
 
-	// Messaging
-	bool SendMessage(GameMessages::GameMsg& msg) const;
-
 private:
 	void SerializeEntities();
 	void KillEntities();

dGame/LeaderboardManager.cpp

@@ -24,13 +24,12 @@ namespace LeaderboardManager {
 	std::map<GameID, Leaderboard::Type> leaderboardCache;
 }
 
-Leaderboard::Leaderboard(const GameID gameID, const Leaderboard::InfoType infoType, const bool weekly, LWOOBJID relatedPlayer, const uint32_t numResults, const Leaderboard::Type leaderboardType) {
+Leaderboard::Leaderboard(const GameID gameID, const Leaderboard::InfoType infoType, const bool weekly, LWOOBJID relatedPlayer, const Leaderboard::Type leaderboardType) {
 	this->gameID = gameID;
 	this->weekly = weekly;
 	this->infoType = infoType;
 	this->leaderboardType = leaderboardType;
 	this->relatedPlayer = relatedPlayer;
-	this->numResults = numResults;
 }
 
 Leaderboard::~Leaderboard() {
@@ -145,7 +144,7 @@ void QueryToLdf(Leaderboard& leaderboard, const std::vector<ILeaderboard::Entry>
 	}
 }
 
-std::vector<ILeaderboard::Entry> FilterToNumResults(const std::vector<ILeaderboard::Entry>& leaderboard, const uint32_t relatedPlayer, const Leaderboard::InfoType infoType, const uint32_t numResults) {
+std::vector<ILeaderboard::Entry> FilterTo10(const std::vector<ILeaderboard::Entry>& leaderboard, const uint32_t relatedPlayer, const Leaderboard::InfoType infoType) {
 	std::vector<ILeaderboard::Entry> toReturn;
 
 	int32_t index = 0;
@@ -156,19 +155,18 @@ std::vector<ILeaderboard::Entry> FilterToNumResults(const std::vector<ILeaderboa
 		}
 	}
 
-	if (leaderboard.size() < numResults) {
+	if (leaderboard.size() < 10) {
 		toReturn.assign(leaderboard.begin(), leaderboard.end());
 		index = 0;
-	} else if (index < numResults) {
-		toReturn.assign(leaderboard.begin(), leaderboard.begin() + numResults); // get the top 10 since we are in the top 10
+	} else if (index < 10) {
+		toReturn.assign(leaderboard.begin(), leaderboard.begin() + 10); // get the top 10 since we are in the top 10
 		index = 0;
-	} else if (index > leaderboard.size() - numResults) {
-		toReturn.assign(leaderboard.end() - numResults, leaderboard.end()); // get the bottom 10 since we are in the bottom 10
-		index = leaderboard.size() - numResults;
+	} else if (index > leaderboard.size() - 10) {
+		toReturn.assign(leaderboard.end() - 10, leaderboard.end()); // get the bottom 10 since we are in the bottom 10
+		index = leaderboard.size() - 10;
 	} else {
-		auto half = numResults / 2;
-		toReturn.assign(leaderboard.begin() + index - half, leaderboard.begin() + index + half); // get the 5 above and below
-		index -= half;
+		toReturn.assign(leaderboard.begin() + index - 5, leaderboard.begin() + index + 5); // get the 5 above and below
+		index -= 5;
 	}
 
 	int32_t i = index;
@@ -180,16 +178,14 @@ std::vector<ILeaderboard::Entry> FilterToNumResults(const std::vector<ILeaderboa
 }
 
 std::vector<ILeaderboard::Entry> FilterWeeklies(const std::vector<ILeaderboard::Entry>& leaderboard) {
-	using namespace std::chrono;
 	// Filter the leaderboard to only include entries from the last week
-	const auto epochTime = system_clock::now();
-	constexpr auto oneWeek = weeks(1);
+	const auto currentTime = std::chrono::system_clock::now();
+	auto epochTime = currentTime.time_since_epoch().count();
+	constexpr auto SECONDS_IN_A_WEEK = 60 * 60 * 24 * 7; // if you think im taking leap seconds into account thats cute.
 
 	std::vector<ILeaderboard::Entry> weeklyLeaderboard;
 	for (const auto& entry : leaderboard) {
-		const sys_time<seconds> asSysTime(seconds(entry.lastPlayedTimestamp));
-		const auto timeDiff = epochTime - asSysTime;
-		if (timeDiff < oneWeek) {
+		if (epochTime - entry.lastPlayedTimestamp < SECONDS_IN_A_WEEK) {
 			weeklyLeaderboard.push_back(entry);
 		}
 	}
@@ -217,15 +213,14 @@ std::vector<ILeaderboard::Entry> ProcessLeaderboard(
 	const std::vector<ILeaderboard::Entry>& leaderboard,
 	const bool weekly,
 	const Leaderboard::InfoType infoType,
-	const uint32_t relatedPlayer,
-	const uint32_t numResults) {
+	const uint32_t relatedPlayer) {
 	std::vector<ILeaderboard::Entry> toReturn;
 
 	if (infoType == Leaderboard::InfoType::Friends) {
 		const auto friendsLeaderboard = FilterFriends(leaderboard, relatedPlayer);
-		toReturn = FilterToNumResults(weekly ? FilterWeeklies(friendsLeaderboard) : friendsLeaderboard, relatedPlayer, infoType, numResults);
+		toReturn = FilterTo10(weekly ? FilterWeeklies(friendsLeaderboard) : friendsLeaderboard, relatedPlayer, infoType);
 	} else {
-		toReturn = FilterToNumResults(weekly ? FilterWeeklies(leaderboard) : leaderboard, relatedPlayer, infoType, numResults);
+		toReturn = FilterTo10(weekly ? FilterWeeklies(leaderboard) : leaderboard, relatedPlayer, infoType);
 	}
 
 	return toReturn;
@@ -260,7 +255,7 @@ void Leaderboard::SetupLeaderboard(bool weekly) {
 		break;
 	}
 
-	const auto processedLeaderboard = ProcessLeaderboard(leaderboardRes, weekly, infoType, relatedPlayer, numResults);
+	const auto processedLeaderboard = ProcessLeaderboard(leaderboardRes, weekly, infoType, relatedPlayer);
 
 	QueryToLdf(*this, processedLeaderboard);
 }
@@ -306,8 +301,8 @@ void LeaderboardManager::SaveScore(const LWOOBJID& playerID, const GameID activi
 	}
 }
 
-void LeaderboardManager::SendLeaderboard(const GameID gameID, const Leaderboard::InfoType infoType, const bool weekly, const LWOOBJID playerID, const LWOOBJID targetID, const uint32_t numResults) {
-	Leaderboard leaderboard(gameID, infoType, weekly, playerID, numResults, GetLeaderboardType(gameID));
+void LeaderboardManager::SendLeaderboard(const GameID gameID, const Leaderboard::InfoType infoType, const bool weekly, const LWOOBJID playerID, const LWOOBJID targetID) {
+	Leaderboard leaderboard(gameID, infoType, weekly, playerID, GetLeaderboardType(gameID));
 	leaderboard.SetupLeaderboard(weekly);
 	leaderboard.Send(targetID);
 }

dGame/LeaderboardManager.h

@@ -37,7 +37,7 @@ public:
 		None
 	};
 	Leaderboard() = delete;
-	Leaderboard(const GameID gameID, const Leaderboard::InfoType infoType, const bool weekly, LWOOBJID relatedPlayer, const uint32_t numResults, const Leaderboard::Type = None);
+	Leaderboard(const GameID gameID, const Leaderboard::InfoType infoType, const bool weekly, LWOOBJID relatedPlayer, const Leaderboard::Type = None);
 
 	~Leaderboard();
 
@@ -79,7 +79,6 @@ private:
 	InfoType infoType;
 	Leaderboard::Type leaderboardType;
 	bool weekly;
-	uint32_t numResults;
 public:
 	LeaderboardEntry& PushBackEntry() {
 		return entries.emplace_back();
@@ -91,7 +90,7 @@ public:
 };
 
 namespace LeaderboardManager {
-	void SendLeaderboard(const GameID gameID, const Leaderboard::InfoType infoType, const bool weekly, const LWOOBJID playerID, const LWOOBJID targetID, const uint32_t numResults);
+	void SendLeaderboard(const GameID gameID, const Leaderboard::InfoType infoType, const bool weekly, const LWOOBJID playerID, const LWOOBJID targetID);
 
 	void SaveScore(const LWOOBJID& playerID, const GameID activityId, const float primaryScore, const float secondaryScore = 0, const float tertiaryScore = 0);
 

dGame/UserManager.cpp

@@ -29,7 +29,6 @@
 #include "MessageType/Chat.h"
 #include "BitStreamUtils.h"
 #include "CheatDetection.h"
-#include "CharacterComponent.h"
 
 UserManager* UserManager::m_Address = nullptr;
 
@@ -341,10 +340,7 @@ void UserManager::CreateCharacter(const SystemAddress& sysAddr, Packet* packet)
 
 		xml << "<char acct=\"" << u->GetAccountID() << "\" cc=\"0\" gm=\"0\" ft=\"0\" llog=\"" << time(NULL) << "\" ";
 		xml << "ls=\"0\" lzx=\"-626.5847\" lzy=\"613.3515\" lzz=\"-28.6374\" lzrx=\"0.0\" lzry=\"0.7015\" lzrz=\"0.0\" lzrw=\"0.7126\" ";
-		xml << "stt=\"0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;\">";
-		xml << "<vl><l id=\"1000\" cid=\"0\"/></vl>";
-
-		xml << "</char>";
+		xml << "stt=\"0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;\"></char>";
 
 		xml << "<dest hm=\"4\" hc=\"4\" im=\"0\" ic=\"0\" am=\"0\" ac=\"0\" d=\"0\"/>";
 
@@ -526,13 +522,6 @@ void UserManager::LoginCharacter(const SystemAddress& sysAddr, uint32_t playerID
 		ZoneInstanceManager::Instance()->RequestZoneTransfer(Game::server, zoneID, character->GetZoneClone(), false, [=](bool mythranShift, uint32_t zoneID, uint32_t zoneInstance, uint32_t zoneClone, std::string serverIP, uint16_t serverPort) {
 			LOG("Transferring %s to Zone %i (Instance %i | Clone %i | Mythran Shift: %s) with IP %s and Port %i", character->GetName().c_str(), zoneID, zoneInstance, zoneClone, mythranShift == true ? "true" : "false", serverIP.c_str(), serverPort);
 			if (character) {
-				auto* entity = Game::entityManager->GetEntity(character->GetObjectID());
-				if (entity) {
-					auto* characterComponent = entity->GetComponent<CharacterComponent>();
-					if (characterComponent) {
-						characterComponent->AddVisitedLevel(LWOZONEID(zoneID, LWOINSTANCEID_INVALID, zoneClone));
-					}
-				}
 				character->SetZoneID(zoneID);
 				character->SetZoneInstance(zoneInstance);
 				character->SetZoneClone(zoneClone);

dGame/dBehaviors/PropertyTeleportBehavior.cpp

@@ -42,15 +42,10 @@ void PropertyTeleportBehavior::Handle(BehaviorContext* context, RakNet::BitStrea
 
 		LOG("Transferring %s to Zone %i (Instance %i | Clone %i | Mythran Shift: %s) with IP %s and Port %i", sysAddr.ToString(), zoneID, zoneInstance, zoneClone, mythranShift == true ? "true" : "false", serverIP.c_str(), serverPort);
 		if (entity->GetCharacter()) {
-			auto* characterComponent = entity->GetComponent<CharacterComponent>();
-			if (characterComponent) {
-				characterComponent->AddVisitedLevel(LWOZONEID(zoneID, LWOINSTANCEID_INVALID, zoneClone));
-				characterComponent->SetLastRocketConfig(u"");
-			}
-
 			entity->GetCharacter()->SetZoneID(zoneID);
 			entity->GetCharacter()->SetZoneInstance(zoneInstance);
 			entity->GetCharacter()->SetZoneClone(zoneClone);
+			entity->GetComponent<CharacterComponent>()->SetLastRocketConfig(u"");
 		}
 
 		entity->GetCharacter()->SaveXMLToDatabase();

dGame/dComponents/ActivityComponent.cpp

@@ -27,7 +27,6 @@
 #include "CDActivityRewardsTable.h"
 #include "CDActivitiesTable.h"
 #include "LeaderboardManager.h"
-#include "CharacterComponent.h"
 
 ActivityComponent::ActivityComponent(Entity* parent, int32_t activityID) : Component(parent) {
 	/*
@@ -334,7 +333,7 @@ bool ActivityComponent::IsPlayedBy(LWOOBJID playerID) const {
 	return false;
 }
 
-bool ActivityComponent::CheckCost(Entity* player) const {
+bool ActivityComponent::TakeCost(Entity* player) const {
 	if (m_ActivityInfo.optionalCostLOT <= 0 || m_ActivityInfo.optionalCostCount <= 0)
 		return true;
 
@@ -345,17 +344,9 @@ bool ActivityComponent::CheckCost(Entity* player) const {
 	if (inventoryComponent->GetLotCount(m_ActivityInfo.optionalCostLOT) < m_ActivityInfo.optionalCostCount)
 		return false;
 
-	return true;
-}
+	inventoryComponent->RemoveItem(m_ActivityInfo.optionalCostLOT, m_ActivityInfo.optionalCostCount);
 
-bool ActivityComponent::TakeCost(Entity* player) const{
-	
-	auto* inventoryComponent = player->GetComponent<InventoryComponent>();
-	if (CheckCost(player)) {
-		inventoryComponent->RemoveItem(m_ActivityInfo.optionalCostLOT, m_ActivityInfo.optionalCostCount);
-		return true;
-	}
-	else return false;
+	return true;
 }
 
 void ActivityComponent::PlayerReady(Entity* player, bool bReady) {
@@ -390,7 +381,7 @@ ActivityInstance* ActivityComponent::NewInstance() {
 void ActivityComponent::LoadPlayersIntoInstance(ActivityInstance* instance, const std::vector<LobbyPlayer*>& lobby) const {
 	for (LobbyPlayer* player : lobby) {
 		auto* entity = player->GetEntity();
-		if (entity == nullptr || !CheckCost(entity)) {
+		if (entity == nullptr || !TakeCost(entity)) {
 			continue;
 		}
 
@@ -535,11 +526,6 @@ void ActivityInstance::StartZone() {
 
 			LOG("Transferring %s to Zone %i (Instance %i | Clone %i | Mythran Shift: %s) with IP %s and Port %i", player->GetCharacter()->GetName().c_str(), zoneID, zoneInstance, zoneClone, mythranShift == true ? "true" : "false", serverIP.c_str(), serverPort);
 			if (player->GetCharacter()) {
-				auto* characterComponent = player->GetComponent<CharacterComponent>();
-				if (characterComponent) {
-					characterComponent->AddVisitedLevel(LWOZONEID(zoneID, LWOINSTANCEID_INVALID, zoneClone));
-				}
-
 				player->GetCharacter()->SetZoneID(zoneID);
 				player->GetCharacter()->SetZoneInstance(zoneInstance);
 				player->GetCharacter()->SetZoneClone(zoneClone);
@@ -575,7 +561,7 @@ void ActivityInstance::RewardParticipant(Entity* participant) {
 			maxCoins = currencyTable[0].maxvalue;
 		}
 
-		Loot::DropLoot(participant, m_Parent->GetObjectID(), activityRewards[0].LootMatrixIndex, minCoins, maxCoins);
+		Loot::DropLoot(participant, m_Parent, activityRewards[0].LootMatrixIndex, minCoins, maxCoins);
 	}
 }
 

dGame/dComponents/ActivityComponent.h

@@ -234,17 +234,10 @@ public:
 	 */
 	bool IsPlayedBy(LWOOBJID playerID) const;
 
-	/** 
-	 * Checks if the entity has enough cost to play this activity
-	 * @param player the entity to check
-	 * @return true if the entity has enough cost to play this activity, false otherwise
-	*/
-	bool CheckCost(Entity* player) const;
-
 	/**
 	 * Removes the cost of the activity (e.g. green imaginate) for the entity that plays this activity
 	 * @param player the entity to take cost for
-	 * @return true if the cost was taken, false otherwise
+	 * @return true if the cost was successfully deducted, false otherwise
 	 */
 	bool TakeCost(Entity* player) const;
 

dGame/dComponents/CharacterComponent.cpp

@@ -245,8 +245,6 @@ void CharacterComponent::LoadFromXml(const tinyxml2::XMLDocument& doc) {
 		SetReputation(0);
 	}
 
-	auto* vl = character->FirstChildElement("vl");
-	if (vl) LoadVisitedLevelsXml(*vl);
 	character->QueryUnsigned64Attribute("co", &m_ClaimCodes[0]);
 	character->QueryUnsigned64Attribute("co1", &m_ClaimCodes[1]);
 	character->QueryUnsigned64Attribute("co2", &m_ClaimCodes[2]);
@@ -376,10 +374,6 @@ void CharacterComponent::UpdateXml(tinyxml2::XMLDocument& doc) {
 		return;
 	}
 
-	auto* vl = character->FirstChildElement("vl");
-	if (!vl) vl = character->InsertNewChildElement("vl");
-	UpdateVisitedLevelsXml(*vl);
-
 	if (m_ClaimCodes[0] != 0) character->SetAttribute("co", m_ClaimCodes[0]);
 	if (m_ClaimCodes[1] != 0) character->SetAttribute("co1", m_ClaimCodes[1]);
 	if (m_ClaimCodes[2] != 0) character->SetAttribute("co2", m_ClaimCodes[2]);
@@ -861,9 +855,8 @@ void CharacterComponent::SendToZone(LWOMAPID zoneId, LWOCLONEID cloneId) const {
 			character->SetZoneID(zoneID);
 			character->SetZoneInstance(zoneInstance);
 			character->SetZoneClone(zoneClone);
-			
+
 			characterComponent->SetLastRocketConfig(u"");
-			characterComponent->AddVisitedLevel(LWOZONEID(zoneID, LWOINSTANCEID_INVALID, zoneClone));
 
 			character->SaveXMLToDatabase();
 		}
@@ -890,30 +883,3 @@ void CharacterComponent::SetRespawnPos(const NiPoint3& position) {
 void CharacterComponent::SetRespawnRot(const NiQuaternion& rotation) {
 	m_respawnRot = rotation;
 }
-
-void CharacterComponent::AddVisitedLevel(const LWOZONEID zoneID) {
-	LWOZONEID toInsert(zoneID.GetMapID(), LWOINSTANCEID_INVALID, zoneID.GetCloneID());
-	m_VisitedLevels.insert(toInsert);
-}
-
-void CharacterComponent::UpdateVisitedLevelsXml(tinyxml2::XMLElement& vl) {
-	vl.DeleteChildren();
-	// <vl>
-	for (const auto zoneID : m_VisitedLevels) {
-		// <l id=\"1100\" cid=\"0\"/>
-		auto* l = vl.InsertNewChildElement("l");
-		l->SetAttribute("id", zoneID.GetMapID());
-		l->SetAttribute("cid", zoneID.GetCloneID());
-	}
-	// </vl>
-}
-
-void CharacterComponent::LoadVisitedLevelsXml(const tinyxml2::XMLElement& vl) {
-	// <vl>
-	for (const auto* l = vl.FirstChildElement("l"); l != nullptr; l = l->NextSiblingElement("l")) {
-		// <l id=\"1100\" cid=\"0\"/>
-		LWOZONEID toInsert(l->IntAttribute("id"), LWOINSTANCEID_INVALID, l->IntAttribute("cid"));
-		m_VisitedLevels.insert(toInsert);
-	}
-	// </vl>
-}

dGame/dComponents/CharacterComponent.h

@@ -10,7 +10,6 @@
 #include "tinyxml2.h"
 #include "eReplicaComponentType.h"
 #include <array>
-#include <set>
 #include "Loot.h"
 
 enum class eGameActivity : uint32_t;
@@ -322,13 +321,6 @@ public:
 	 * Character info regarding this character, including clothing styles, etc.
 	 */
 	Character* m_Character;
-
-	/* Saves the provided zoneID as a visited level. Ignores InstanceID */
-	void AddVisitedLevel(const LWOZONEID zoneID);
-	/* Updates the VisitedLevels (vl) node of the charxml */
-	void UpdateVisitedLevelsXml(tinyxml2::XMLElement& doc);
-	/* Reads the VisitedLevels (vl) node of the charxml */
-	void LoadVisitedLevelsXml(const tinyxml2::XMLElement& doc);
 private:
 
 	bool OnRequestServerObjectInfo(GameMessages::GameMsg& msg);
@@ -627,8 +619,6 @@ private:
 	std::map<LWOOBJID, Loot::Info> m_DroppedLoot;
 
 	uint64_t m_DroppedCoins = 0;
-
-	std::set<LWOZONEID> m_VisitedLevels;
 };
 
 #endif // CHARACTERCOMPONENT_H

dGame/dComponents/DestroyableComponent.cpp

@@ -755,18 +755,18 @@ void DestroyableComponent::Smash(const LWOOBJID source, const eKillType killType
 
 					auto* member = Game::entityManager->GetEntity(specificOwner);
 
-					if (member) Loot::DropLoot(member, m_Parent->GetObjectID(), lootMatrixId, GetMinCoins(), GetMaxCoins());
+					if (member) Loot::DropLoot(member, m_Parent, lootMatrixId, GetMinCoins(), GetMaxCoins());
 				} else {
 					for (const auto memberId : team->members) { // Free for all
 						auto* member = Game::entityManager->GetEntity(memberId);
 
 						if (member == nullptr) continue;
 
-						Loot::DropLoot(member, m_Parent->GetObjectID(), lootMatrixId, GetMinCoins(), GetMaxCoins());
+						Loot::DropLoot(member, m_Parent, lootMatrixId, GetMinCoins(), GetMaxCoins());
 					}
 				}
 			} else { // drop loot for non team user
-				Loot::DropLoot(owner, m_Parent->GetObjectID(), GetLootMatrixID(), GetMinCoins(), GetMaxCoins());
+				Loot::DropLoot(owner, m_Parent, GetLootMatrixID(), GetMinCoins(), GetMaxCoins());
 			}
 		}
 	} else {
@@ -784,7 +784,7 @@ void DestroyableComponent::Smash(const LWOOBJID source, const eKillType killType
 
 				coinsTotal -= coinsToLose;
 
-				Loot::DropLoot(m_Parent, m_Parent->GetObjectID(), -1, coinsToLose, coinsToLose);
+				Loot::DropLoot(m_Parent, m_Parent, -1, coinsToLose, coinsToLose);
 				character->SetCoins(coinsTotal, eLootSourceType::PICKUP);
 			}
 		}

dGame/dComponents/InventoryComponent.cpp

@@ -1777,7 +1777,7 @@ void InventoryComponent::LoadGroupXml(const tinyxml2::XMLElement& groups) {
 			group.groupId = groupId;
 			group.groupName = groupName;
 
-			for (const auto& lotStr : GeneralUtils::SplitString(std::string_view(lots), ' ')) {
+			for (const auto& lotStr : GeneralUtils::SplitString(lots, ' ')) {
 				auto lot = GeneralUtils::TryParse<LOT>(lotStr);
 				if (lot) group.lots.insert(*lot);
 			}

dGame/dComponents/ModelComponent.cpp

@@ -7,9 +7,7 @@
 #include "BehaviorStates.h"
 #include "ControlBehaviorMsgs.h"
 #include "tinyxml2.h"
-#include "InventoryComponent.h"
 #include "SimplePhysicsComponent.h"
-#include "eObjectBits.h"
 
 #include "Database.h"
 #include "DluAssert.h"
@@ -32,17 +30,10 @@ bool ModelComponent::OnResetModelToDefaults(GameMessages::GameMsg& msg) {
 	unsmash.target = GetParent()->GetObjectID();
 	unsmash.duration = 0.0f;
 	unsmash.Send(UNASSIGNED_SYSTEM_ADDRESS);
-
-	m_Parent->SetPosition(m_OriginalPosition);
-	m_Parent->SetRotation(m_OriginalRotation);
-	m_Parent->SetVelocity(NiPoint3Constant::ZERO);
-
-	m_Speed = 3.0f;
 	m_NumListeningInteract = 0;
 	m_NumActiveUnSmash = 0;
 	m_Dirty = true;
 	Game::entityManager->SerializeEntity(GetParent());
-
 	return true;
 }
 
@@ -63,12 +54,6 @@ void ModelComponent::Update(float deltaTime) {
 	for (auto& behavior : m_Behaviors) {
 		behavior.Update(deltaTime, *this);
 	}
-
-	if (!m_RestartAtEndOfFrame) return;
-
-	GameMessages::ResetModelToDefaults reset{};
-	OnResetModelToDefaults(reset);
-	m_RestartAtEndOfFrame = false;
 }
 
 void ModelComponent::LoadBehaviors() {
@@ -76,30 +61,25 @@ void ModelComponent::LoadBehaviors() {
 	for (const auto& behavior : behaviors) {
 		if (behavior.empty()) continue;
 
-		const auto behaviorId = GeneralUtils::TryParse<LWOOBJID>(behavior);
+		const auto behaviorId = GeneralUtils::TryParse<int32_t>(behavior);
 		if (!behaviorId.has_value() || behaviorId.value() == 0) continue;
 
-		// add behavior at the back
-		LoadBehavior(behaviorId.value(), m_Behaviors.size(), false);
-	}
-}
+		LOG_DEBUG("Loading behavior %d", behaviorId.value());
+		auto& inserted = m_Behaviors.emplace_back();
+		inserted.SetBehaviorId(*behaviorId);
 
-void ModelComponent::LoadBehavior(const LWOOBJID behaviorID, const size_t index, const bool isIndexed) {
-	LOG_DEBUG("Loading behavior %d", behaviorID);
-	auto& inserted = *m_Behaviors.emplace(m_Behaviors.begin() + index, PropertyBehavior(isIndexed));
-	inserted.SetBehaviorId(behaviorID);
+		const auto behaviorStr = Database::Get()->GetBehavior(behaviorId.value());
 
-	const auto behaviorStr = Database::Get()->GetBehavior(behaviorID);
+		tinyxml2::XMLDocument behaviorXml;
+		auto res = behaviorXml.Parse(behaviorStr.c_str(), behaviorStr.size());
+		LOG_DEBUG("Behavior %i %d: %s", res, behaviorId.value(), behaviorStr.c_str());
 
-	tinyxml2::XMLDocument behaviorXml;
-	auto res = behaviorXml.Parse(behaviorStr.c_str(), behaviorStr.size());
-	LOG_DEBUG("Behavior %i %llu: %s", res, behaviorID, behaviorStr.c_str());
-
-	const auto* const behaviorRoot = behaviorXml.FirstChildElement("Behavior");
-	if (behaviorRoot) {
+		const auto* const behaviorRoot = behaviorXml.FirstChildElement("Behavior");
+		if (!behaviorRoot) {
+			LOG("Failed to load behavior %d due to missing behavior root", behaviorId.value());
+			continue;
+		}
 		inserted.Deserialize(*behaviorRoot);
-	} else {
-		LOG("Failed to load behavior %d due to missing behavior root", behaviorID);
 	}
 }
 
@@ -130,12 +110,8 @@ void ModelComponent::Serialize(RakNet::BitStream& outBitStream, bool bIsInitialU
 	if (bIsInitialUpdate) outBitStream.Write0(); // We are not writing model editing info
 }
 
-void ModelComponent::UpdatePendingBehaviorId(const LWOOBJID newId, const LWOOBJID oldId) {
-	for (auto& behavior : m_Behaviors) {
-		if (behavior.GetBehaviorId() != oldId) continue;
-		behavior.SetBehaviorId(newId);
-		behavior.SetIsLoot(false);
-	}
+void ModelComponent::UpdatePendingBehaviorId(const int32_t newId) {
+	for (auto& behavior : m_Behaviors) if (behavior.GetBehaviorId() == -1) behavior.SetBehaviorId(newId);
 }
 
 void ModelComponent::SendBehaviorListToClient(AMFArrayValue& args) const {
@@ -152,7 +128,7 @@ void ModelComponent::VerifyBehaviors() {
 	for (auto& behavior : m_Behaviors) behavior.VerifyLastEditedState();
 }
 
-void ModelComponent::SendBehaviorBlocksToClient(const LWOOBJID behaviorToSend, AMFArrayValue& args) const {
+void ModelComponent::SendBehaviorBlocksToClient(int32_t behaviorToSend, AMFArrayValue& args) const {
 	args.Insert("BehaviorID", std::to_string(behaviorToSend));
 	args.Insert("objectID", std::to_string(m_Parent->GetObjectID()));
 	for (auto& behavior : m_Behaviors) if (behavior.GetBehaviorId() == behaviorToSend) behavior.SendBehaviorBlocksToClient(args);
@@ -161,21 +137,8 @@ void ModelComponent::SendBehaviorBlocksToClient(const LWOOBJID behaviorToSend, A
 void ModelComponent::AddBehavior(AddMessage& msg) {
 	// Can only have 1 of the loot behaviors
 	for (auto& behavior : m_Behaviors) if (behavior.GetBehaviorId() == msg.GetBehaviorId()) return;
-
-	// If we're loading a behavior from an ADD, it is from the database.
-	// Mark it as not modified by default to prevent wasting persistentIDs.
-	LoadBehavior(msg.GetBehaviorId(), msg.GetBehaviorIndex(), true);
-	auto& insertedBehavior = m_Behaviors[msg.GetBehaviorIndex()];
-
-	auto* const playerEntity = Game::entityManager->GetEntity(msg.GetOwningPlayerID());
-	if (playerEntity) {
-		auto* inventoryComponent = playerEntity->GetComponent<InventoryComponent>();
-		if (inventoryComponent) {
-			// Check if this behavior is able to be found via lot (if so, its a loot behavior).
-			insertedBehavior.SetIsLoot(inventoryComponent->FindItemByLot(msg.GetBehaviorId(), eInventoryType::BEHAVIORS));
-		}
-	}
-
+	m_Behaviors.insert(m_Behaviors.begin() + msg.GetBehaviorIndex(), PropertyBehavior());
+	m_Behaviors.at(msg.GetBehaviorIndex()).HandleMsg(msg);
 	auto* const simplePhysComponent = m_Parent->GetComponent<SimplePhysicsComponent>();
 	if (simplePhysComponent) {
 		simplePhysComponent->SetPhysicsMotionState(1);
@@ -183,41 +146,8 @@ void ModelComponent::AddBehavior(AddMessage& msg) {
 	}
 }
 
-std::string ModelComponent::SaveBehavior(const PropertyBehavior& behavior) const {
-	tinyxml2::XMLDocument doc;
-	auto* root = doc.NewElement("Behavior");
-	behavior.Serialize(*root);
-	doc.InsertFirstChild(root);
-
-	tinyxml2::XMLPrinter printer(0, true, 0);
-	doc.Print(&printer);
-	return printer.CStr();
-}
-
-void ModelComponent::RemoveBehavior(MoveToInventoryMessage& msg, const bool keepItem) {
+void ModelComponent::MoveToInventory(MoveToInventoryMessage& msg) {
 	if (msg.GetBehaviorIndex() >= m_Behaviors.size() || m_Behaviors.at(msg.GetBehaviorIndex()).GetBehaviorId() != msg.GetBehaviorId()) return;
-	const auto behavior = m_Behaviors[msg.GetBehaviorIndex()];
-	if (keepItem) {
-		auto* const playerEntity = Game::entityManager->GetEntity(msg.GetOwningPlayerID());
-		if (playerEntity) {
-			auto* const inventoryComponent = playerEntity->GetComponent<InventoryComponent>();
-			if (inventoryComponent && !behavior.GetIsLoot()) {
-				// config is owned by the item
-				std::vector<LDFBaseData*> config;
-				config.push_back(new LDFData<std::string>(u"userModelName", behavior.GetName()));
-				inventoryComponent->AddItem(7965, 1, eLootSourceType::PROPERTY, eInventoryType::BEHAVIORS, config, LWOOBJID_EMPTY, true, false, msg.GetBehaviorId());
-			}
-		}
-	}
-
-	// save the behavior before deleting it so players can re-add them
-	IBehaviors::Info info{};
-	info.behaviorId = msg.GetBehaviorId();
-	info.behaviorInfo = SaveBehavior(behavior);
-	info.characterId = msg.GetOwningPlayerID();
-
-	Database::Get()->AddBehavior(info);
-
 	m_Behaviors.erase(m_Behaviors.begin() + msg.GetBehaviorIndex());
 	// TODO move to the inventory
 	if (m_Behaviors.empty()) {
@@ -229,14 +159,22 @@ void ModelComponent::RemoveBehavior(MoveToInventoryMessage& msg, const bool keep
 	}
 }
 
-std::array<std::pair<LWOOBJID, std::string>, 5> ModelComponent::GetBehaviorsForSave() const {
-	std::array<std::pair<LWOOBJID, std::string>, 5> toReturn{};
+std::array<std::pair<int32_t, std::string>, 5> ModelComponent::GetBehaviorsForSave() const {
+	std::array<std::pair<int32_t, std::string>, 5> toReturn{};
 	for (auto i = 0; i < m_Behaviors.size(); i++) {
 		const auto& behavior = m_Behaviors.at(i);
 		if (behavior.GetBehaviorId() == -1) continue;
 		auto& [id, behaviorData] = toReturn[i];
 		id = behavior.GetBehaviorId();
-		behaviorData = SaveBehavior(behavior);
+
+		tinyxml2::XMLDocument doc;
+		auto* root = doc.NewElement("Behavior");
+		behavior.Serialize(*root);
+		doc.InsertFirstChild(root);
+
+		tinyxml2::XMLPrinter printer(0, true, 0);
+		doc.Print(&printer);
+		behaviorData = printer.CStr();
 	}
 	return toReturn;
 }
@@ -265,35 +203,3 @@ void ModelComponent::RemoveUnSmash() {
 	LOG_DEBUG("Removing UnSmash %i", m_NumActiveUnSmash);
 	m_NumActiveUnSmash--;
 }
-
-bool ModelComponent::TrySetVelocity(const NiPoint3& velocity) const {
-	auto currentVelocity = m_Parent->GetVelocity();
-
-	// If we're currently moving on an axis, prevent the move so only 1 behavior can have control over an axis
-	if (velocity != NiPoint3Constant::ZERO) {
-		const auto [x, y, z] = velocity * m_Speed;
-		if (x != 0.0f) {
-			if (currentVelocity.x != 0.0f) return false;
-			currentVelocity.x = x;
-		} else if (y != 0.0f) {
-			if (currentVelocity.y != 0.0f) return false;
-			currentVelocity.y = y;
-		} else if (z != 0.0f) {
-			if (currentVelocity.z != 0.0f) return false;
-			currentVelocity.z = z;
-		}
-	} else {
-		currentVelocity = velocity;
-	}
-
-	m_Parent->SetVelocity(currentVelocity);
-	return true;
-}
-
-void ModelComponent::SetVelocity(const NiPoint3& velocity) const {
-	m_Parent->SetVelocity(velocity);
-}
-
-void ModelComponent::OnChatMessageReceived(const std::string& sMessage) {
-	for (auto& behavior : m_Behaviors) behavior.OnChatMessageReceived(sMessage);
-}

dGame/dComponents/ModelComponent.h

@@ -41,7 +41,7 @@ public:
 	 * Returns the original position of the model
 	 * @return the original position of the model
 	 */
-	const NiPoint3& GetOriginalPosition() { return m_OriginalPosition; }
+	const NiPoint3& GetPosition() { return m_OriginalPosition; }
 
 	/**
 	 * Sets the original position of the model
@@ -53,7 +53,7 @@ public:
 	 * Returns the original rotation of the model
 	 * @return the original rotation of the model
 	 */
-	const NiQuaternion& GetOriginalRotation() { return m_OriginalRotation; }
+	const NiQuaternion& GetRotation() { return m_OriginalRotation; }
 
 	/**
 	 * Sets the original rotation of the model
@@ -66,18 +66,15 @@ public:
 	 *
 	 * @tparam Msg The message type to pass
 	 * @param args the arguments of the message to be deserialized
-	 *
-	 * @return returns true if a new behaviorID is needed.
 	 */
 	template<typename Msg>
-	bool HandleControlBehaviorsMsg(const 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) {
 			if (behavior.GetBehaviorId() == msg.GetBehaviorId()) {
-				behavior.CheckModifyState(msg);
 				behavior.HandleMsg(msg);
-				return msg.GetNeedsNewBehaviorID();
+				return;
 			}
 		}
 
@@ -85,24 +82,22 @@ public:
 		if (m_Behaviors.size() > 5) m_Behaviors.resize(5);
 
 		// Do not allow more than 5 to be added. The client UI will break if you do!
-		if (m_Behaviors.size() == 5) return false;
+		if (m_Behaviors.size() == 5) return;
 
 		auto newBehavior = m_Behaviors.insert(m_Behaviors.begin(), PropertyBehavior());
 		// Generally if we are inserting a new behavior, it is because the client is creating a new behavior.
 		// However if we are testing behaviors the behavior will not exist on the initial pass, so we set the ID here to that of the msg.
 		// This will either set the ID to -1 (no change in the current default) or set the ID to the ID of the behavior we are testing.
 		newBehavior->SetBehaviorId(msg.GetBehaviorId());
-		newBehavior->CheckModifyState(msg);
 		newBehavior->HandleMsg(msg);
-		return msg.GetNeedsNewBehaviorID();
 	};
 
 	void AddBehavior(AddMessage& msg);
 
-	void RemoveBehavior(MoveToInventoryMessage& msg, const bool keepItem);
+	void MoveToInventory(MoveToInventoryMessage& msg);
 
 	// Updates the pending behavior ID to the new ID.
-	void UpdatePendingBehaviorId(const LWOOBJID newId, const LWOOBJID oldId);
+	void UpdatePendingBehaviorId(const int32_t newId);
 
 	// Sends the behavior list to the client.
 
@@ -117,11 +112,11 @@ public:
 	 */
 	void SendBehaviorListToClient(AMFArrayValue& args) const;
 
-	void SendBehaviorBlocksToClient(const LWOOBJID behaviorToSend, AMFArrayValue& args) const;
+	void SendBehaviorBlocksToClient(int32_t behaviorToSend, AMFArrayValue& args) const;
 
 	void VerifyBehaviors();
 
-	std::array<std::pair<LWOOBJID, std::string>, 5> GetBehaviorsForSave() const;
+	std::array<std::pair<int32_t, std::string>, 5> GetBehaviorsForSave() const;
 
 	const std::vector<PropertyBehavior>& GetBehaviors() const { return m_Behaviors; };
 
@@ -135,30 +130,7 @@ public:
 	bool IsUnSmashing() const { return m_NumActiveUnSmash != 0; }
 
 	void Resume();
-
-	// Attempts to set the velocity of an axis for movement.
-	// If the axis currently has a velocity of zero, returns true.
-	// If the axis is currently controlled by a behavior, returns false.
-	bool TrySetVelocity(const NiPoint3& velocity) const;
-
-	// Force sets the velocity to a value.
-	void SetVelocity(const NiPoint3& velocity) const;
-
-	void OnChatMessageReceived(const std::string& sMessage);
-
-	// Sets the speed of the model
-	void SetSpeed(const float newSpeed) { m_Speed = newSpeed; }
-
-	// Whether or not to restart at the end of the frame
-	void RestartAtEndOfFrame() { m_RestartAtEndOfFrame = true; }
 private:
-
-	// Loads a behavior from the database.
-	void LoadBehavior(const LWOOBJID behaviorID, const size_t index, const bool isIndexed);
-
-	// Writes a behavior to a string so it can be saved.
-	std::string SaveBehavior(const PropertyBehavior& behavior) const;
-
 	// Number of Actions that are awaiting an UnSmash to finish.
 	uint32_t m_NumActiveUnSmash{};
 
@@ -191,10 +163,4 @@ private:
 	 * The ID of the user that made the model
 	 */
 	LWOOBJID m_userModelID;
-
-	// The speed at which this model moves
-	float m_Speed{ 3.0f };
-
-	// Whether or not to restart at the end of the frame.
-	bool m_RestartAtEndOfFrame{ false };
 };

dGame/dComponents/MovementAIComponent.cpp

@@ -54,7 +54,6 @@ MovementAIComponent::MovementAIComponent(Entity* parent, MovementAIInfo info) :
 	m_SourcePosition = m_Parent->GetPosition();
 	m_Paused = false;
 	m_SavedVelocity = NiPoint3Constant::ZERO;
-	m_IsBounced = false;
 
 	if (!m_Parent->GetComponent<BaseCombatAIComponent>()) SetPath(m_Parent->GetVarAsString(u"attached_path"));
 }
@@ -159,9 +158,8 @@ void MovementAIComponent::Update(const float deltaTime) {
 				if (m_Path->pathBehavior == PathBehavior::Loop) {
 					SetPath(m_Path->pathWaypoints);
 				} else if (m_Path->pathBehavior == PathBehavior::Bounce) {
-					m_IsBounced = !m_IsBounced;
 					std::vector<PathWaypoint> waypoints = m_Path->pathWaypoints;
-					if (m_IsBounced) std::reverse(waypoints.begin(), waypoints.end());
+					std::reverse(waypoints.begin(), waypoints.end());
 					SetPath(waypoints);
 				} else if (m_Path->pathBehavior == PathBehavior::Once) {
 					Stop();

dGame/dComponents/MovementAIComponent.h

@@ -321,8 +321,6 @@ private:
 	bool m_Paused;
 
 	NiPoint3 m_SavedVelocity;
-
-	bool m_IsBounced{};
 };
 
 #endif // MOVEMENTAICOMPONENT_H

dGame/dComponents/PetComponent.cpp

@@ -42,6 +42,35 @@ std::unordered_map<LWOOBJID, LWOOBJID> PetComponent::activePets{};
  * Maps all the pet lots to a flag indicating that the player has caught it. All basic pets have been guessed by ObjID
  * while the faction ones could be checked using their respective missions.
  */
+const std::map<LOT, int32_t> PetComponent::petFlags{
+		{ 3050, 801 },  // Elephant
+		{ 3054, 803 },  // Cat
+		{ 3195, 806 },  // Triceratops
+		{ 3254, 807 },  // Terrier
+		{ 3261, 811 },  // Skunk
+		{ 3672, 813 },  // Bunny
+		{ 3994, 814 },  // Crocodile
+		{ 5635, 815 },  // Doberman
+		{ 5636, 816 },  // Buffalo
+		{ 5637, 818 },  // Robot Dog
+		{ 5639, 819 },  // Red Dragon
+		{ 5640, 820 },  // Tortoise
+		{ 5641, 821 },  // Green Dragon
+		{ 5643, 822 },  // Panda, see mission 786
+		{ 5642, 823 },  // Mantis
+		{ 6720, 824 },  // Warthog
+		{ 3520, 825 },  // Lion, see mission 1318
+		{ 7638, 826 },  // Goat
+		{ 7694, 827 },  // Crab
+		{ 12294, 829 }, // Reindeer
+		{ 12431, 830 }, // Stegosaurus, see mission 1386
+		{ 12432, 831 }, // Saber cat, see mission 1389
+		{ 12433, 832 }, // Gryphon, see mission 1392
+		{ 12434, 833 }, // Alien, see mission 1188
+		// 834: unknown?, see mission 506, 688
+		{ 16210, 836 },  // Ninjago Earth Dragon, see mission 1836
+		{ 13067, 838 }, // Skeleton dragon
+};
 
 PetComponent::PetComponent(Entity* parentEntity, uint32_t componentId) : Component{ parentEntity } {
 	m_PetInfo = CDClientManager::GetTable<CDPetComponentTable>()->GetByID(componentId); // TODO: Make reference when safe
@@ -527,8 +556,9 @@ void PetComponent::NotifyTamingBuildSuccess(NiPoint3 position) {
 	);
 
 	// Triggers the catch a pet missions
-	constexpr auto PET_FLAG_BASE = 800;
-	tamer->GetCharacter()->SetPlayerFlag(PET_FLAG_BASE + m_ComponentId, true);
+	if (petFlags.find(m_Parent->GetLOT()) != petFlags.end()) {
+		tamer->GetCharacter()->SetPlayerFlag(petFlags.at(m_Parent->GetLOT()), true);
+	}
 
 	auto* missionComponent = tamer->GetComponent<MissionComponent>();
 
@@ -912,11 +942,6 @@ void PetComponent::Command(const NiPoint3& position, const LWOOBJID source, cons
 	if (commandType == 1) {
 		// Emotes
 		GameMessages::SendPlayEmote(m_Parent->GetObjectID(), typeId, owner->GetObjectID(), UNASSIGNED_SYSTEM_ADDRESS);
-		GameMessages::EmotePlayed msg;
-		msg.target = owner->GetObjectID();
-		msg.emoteID = typeId;
-		msg.targetID = 0; // Or set to the intended target entity's ID, or 0 if no target
-		msg.Send(UNASSIGNED_SYSTEM_ADDRESS);
 	} else if (commandType == 3) {
 		// Follow me, ???
 	} else if (commandType == 6) {

dGame/dComponents/PetComponent.h

@@ -250,6 +250,11 @@ private:
 	 */
 	static std::unordered_map<LWOOBJID, LWOOBJID> currentActivities;
 
+	/**
+	 * Flags that indicate that a player has tamed a pet, indexed by the LOT of the pet
+	 */
+	static const std::map<LOT, int32_t> petFlags;
+
 	/**
 	 * The ID of the component in the pet component table
 	 */

dGame/dComponents/PhysicsComponent.cpp

@@ -29,13 +29,6 @@ PhysicsComponent::PhysicsComponent(Entity* parent, int32_t componentId) : Compon
 	}
 
 	if (m_Parent->HasVar(u"CollisionGroupID")) m_CollisionGroup = m_Parent->GetVar<int32_t>(u"CollisionGroupID");
-
-	RegisterMsg(MessageType::Game::GET_POSITION, this, &PhysicsComponent::OnGetPosition);
-}
-
-bool PhysicsComponent::OnGetPosition(GameMessages::GameMsg& msg) {
-	static_cast<GameMessages::GetPosition&>(msg).pos = GetPosition();
-	return true;
 }
 
 void PhysicsComponent::Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) {

dGame/dComponents/PhysicsComponent.h

@@ -20,7 +20,7 @@ public:
 
 	void Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) override;
 
-	const NiPoint3& GetPosition() const noexcept { return m_Position; }
+	const NiPoint3& GetPosition() const { return m_Position; }
 	virtual void SetPosition(const NiPoint3& pos) { if (m_Position == pos) return; m_Position = pos; m_DirtyPosition = true; }
 
 	const NiQuaternion& GetRotation() const { return m_Rotation; }
@@ -35,8 +35,6 @@ protected:
 
 	void SpawnVertices(dpEntity* entity) const;
 
-	bool OnGetPosition(GameMessages::GameMsg& msg);
-
 	NiPoint3 m_Position;
 
 	NiQuaternion m_Rotation;

dGame/dComponents/PropertyManagementComponent.cpp

@@ -272,10 +272,6 @@ void PropertyManagementComponent::OnStartBuilding() {
 			model->HandleMsg(reset);
 		}
 	}
-
-	for (auto* const entity : Game::entityManager->GetEntitiesInGroup("SpawnedPropertyEnemies")) {
-		if (entity) entity->Smash();
-	}
 }
 
 void PropertyManagementComponent::OnFinishBuilding() {
@@ -300,10 +296,6 @@ void PropertyManagementComponent::OnFinishBuilding() {
 			model->HandleMsg(reset);
 		}
 	}
-
-	for (auto* const entity : Game::entityManager->GetEntitiesInGroup("SpawnedPropertyEnemies")) {
-		if (entity) entity->Smash();
-	}
 }
 
 void PropertyManagementComponent::UpdateModelPosition(const LWOOBJID id, const NiPoint3 position, NiQuaternion rotation) {
@@ -704,9 +696,8 @@ void PropertyManagementComponent::Save() {
 			Database::Get()->AddBehavior(info);
 		}
 
-		// Always save the original position so we can move the model freely
-		const auto& position = modelComponent->GetOriginalPosition();
-		const auto& rotation = modelComponent->GetOriginalRotation();
+		const auto position = entity->GetPosition();
+		const auto rotation = entity->GetRotation();
 
 		if (std::find(present.begin(), present.end(), id) == present.end()) {
 			IPropertyContents::Model model;
@@ -817,14 +808,3 @@ void PropertyManagementComponent::SetOwnerId(const LWOOBJID value) {
 const std::map<LWOOBJID, LWOOBJID>& PropertyManagementComponent::GetModels() const {
 	return models;
 }
-
-void PropertyManagementComponent::OnChatMessageReceived(const std::string& sMessage) const {
-	for (const auto& modelID : models | std::views::keys) {
-		auto* const model = Game::entityManager->GetEntity(modelID);
-		if (!model) continue;
-		auto* const modelComponent = model->GetComponent<ModelComponent>();
-		if (!modelComponent) continue;
-		
-		modelComponent->OnChatMessageReceived(sMessage);
-	}
-}

dGame/dComponents/PropertyManagementComponent.h

@@ -164,8 +164,6 @@ public:
 
 	LWOOBJID GetId() const noexcept { return propertyId; }
 
-
-	void OnChatMessageReceived(const std::string& sMessage) const;
 private:
 	/**
 	 * This
@@ -195,7 +193,7 @@ private:
 	/**
 	 * The models that are placed on this property
 	 */
-	std::map<LWOOBJID /* ObjectID */, LWOOBJID /* SpawnerID */> models = {};
+	std::map<LWOOBJID, LWOOBJID> models = {};
 
 	/**
 	 * The name of this property

dGame/dComponents/QuickBuildComponent.cpp

@@ -459,7 +459,7 @@ void QuickBuildComponent::CompleteQuickBuild(Entity* const user) {
 			auto* missionComponent = builder->GetComponent<MissionComponent>();
 			if (missionComponent) missionComponent->Progress(eMissionTaskType::ACTIVITY, m_ActivityId);
 		}
-		Loot::DropActivityLoot(builder, m_Parent->GetObjectID(), m_ActivityId, 1);
+		Loot::DropActivityLoot(builder, m_Parent, m_ActivityId, 1);
 	}
 
 	// Notify scripts

dGame/dComponents/RacingControlComponent.cpp

@@ -393,7 +393,7 @@ void RacingControlComponent::HandleMessageBoxResponse(Entity* player, int32_t bu
 		}
 
 		const auto score = playersRating * 10 + data->finished;
-		Loot::GiveActivityLoot(player, m_Parent->GetObjectID(), m_ActivityID, score);
+		Loot::GiveActivityLoot(player, m_Parent, m_ActivityID, score);
 
 		// Giving rewards
 		GameMessages::SendNotifyRacingClient(

dGame/dComponents/ShootingGalleryComponent.cpp

@@ -2,9 +2,11 @@
 #include "EntityManager.h"
 #include "ScriptedActivityComponent.h"
 
-ShootingGalleryComponent::ShootingGalleryComponent(Entity* parent, int32_t activityID) : ActivityComponent(parent, activityID) {
+ShootingGalleryComponent::ShootingGalleryComponent(Entity* parent) : Component(parent) {
 }
 
+ShootingGalleryComponent::~ShootingGalleryComponent() = default;
+
 void ShootingGalleryComponent::SetStaticParams(const StaticShootingGalleryParams& params) {
 	m_StaticParams = params;
 }

dGame/dComponents/ShootingGalleryComponent.h

@@ -4,7 +4,6 @@
 #include "Entity.h"
 #include "Component.h"
 #include "eReplicaComponentType.h"
-#include "ActivityComponent.h"
 
 /**
  * Parameters for the shooting gallery that change during playtime
@@ -72,11 +71,12 @@ struct StaticShootingGalleryParams {
  * A very ancient component that was used to guide shooting galleries, it's still kind of used but a lot of logic is
  * also in the related scripts.
  */
-class ShootingGalleryComponent final : public ActivityComponent {
+class ShootingGalleryComponent final : public Component {
 public:
 	static constexpr eReplicaComponentType ComponentType = eReplicaComponentType::SHOOTING_GALLERY;
 
-	explicit ShootingGalleryComponent(Entity* parent, int32_t activityID);
+	explicit ShootingGalleryComponent(Entity* parent);
+	~ShootingGalleryComponent();
 	void Serialize(RakNet::BitStream& outBitStream, bool isInitialUpdate) override;
 
 	/**

dGame/dComponents/SimplePhysicsComponent.cpp

@@ -33,13 +33,6 @@ SimplePhysicsComponent::SimplePhysicsComponent(Entity* parent, int32_t component
 SimplePhysicsComponent::~SimplePhysicsComponent() {
 }
 
-void SimplePhysicsComponent::Update(const float deltaTime) {
-	if (m_Velocity == NiPoint3Constant::ZERO) return;
-	m_Position += m_Velocity * deltaTime;
-	m_DirtyPosition = true;
-	Game::entityManager->SerializeEntity(m_Parent);
-}
-
 void SimplePhysicsComponent::Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) {
 	if (bIsInitialUpdate) {
 		outBitStream.Write(m_ClimbableType != eClimbableType::CLIMBABLE_TYPE_NOT);

dGame/dComponents/SimplePhysicsComponent.h

@@ -33,8 +33,6 @@ public:
 	SimplePhysicsComponent(Entity* parent, int32_t componentID);
 	~SimplePhysicsComponent() override;
 
-	void Update(const float deltaTime) override;
-
 	void Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) override;
 
 	/**

dGame/dGameMessages/GameMessageHandler.cpp

@@ -158,10 +158,6 @@ void GameMessageHandler::HandleMessage(RakNet::BitStream& inStream, const System
 
 				inv->AddItemSkills(item.lot);
 			}
-
-			// Fixes a bug where testmapping too fast causes large item inventories to become invisible.
-			// Only affects item inventory
-			GameMessages::SendSetInventorySize(entity, eInventoryType::ITEMS, inv->GetInventory(eInventoryType::ITEMS)->GetSize());
 		}
 
 		GameMessages::SendRestoreToPostLoadStats(entity, sysAddr);

dGame/dGameMessages/GameMessages.cpp

@@ -1698,8 +1698,7 @@ void GameMessages::HandleRequestActivitySummaryLeaderboardData(RakNet::BitStream
 
 	bool weekly = inStream.ReadBit();
 
-	// The client won't accept more than 10 results even if we wanted it to
-	LeaderboardManager::SendLeaderboard(gameID, queryType, weekly, entity->GetObjectID(), entity->GetObjectID(), 10);
+	LeaderboardManager::SendLeaderboard(gameID, queryType, weekly, entity->GetObjectID(), entity->GetObjectID());
 }
 
 void GameMessages::HandleActivityStateChangeRequest(RakNet::BitStream& inStream, Entity* entity) {
@@ -4926,11 +4925,6 @@ void GameMessages::HandleFireEventServerSide(RakNet::BitStream& inStream, Entity
 			LOG("Transferring %s to Zone %i (Instance %i | Clone %i | Mythran Shift: %s) with IP %s and Port %i", character->GetName().c_str(), zoneID, zoneInstance, zoneClone, mythranShift == true ? "true" : "false", serverIP.c_str(), serverPort);
 
 			if (character) {
-				auto* characterComponent = player->GetComponent<CharacterComponent>();
-				if (characterComponent) {
-					characterComponent->AddVisitedLevel(LWOZONEID(zoneID, LWOINSTANCEID_INVALID, zoneClone));
-				}
-
 				character->SetZoneID(zoneID);
 				character->SetZoneInstance(zoneInstance);
 				character->SetZoneClone(zoneClone);
@@ -4963,7 +4957,7 @@ void GameMessages::HandleQuickBuildCancel(RakNet::BitStream& inStream, Entity* e
 }
 
 void GameMessages::HandlePlayEmote(RakNet::BitStream& inStream, Entity* entity) {
-	int32_t emoteID;
+	int emoteID;
 	LWOOBJID targetID;
 
 	inStream.Read(emoteID);
@@ -4982,11 +4976,7 @@ void GameMessages::HandlePlayEmote(RakNet::BitStream& inStream, Entity* entity)
 		if (emote) sAnimationName = emote->animationName;
 	}
 
-	GameMessages::EmotePlayed msg;
-	msg.target = entity->GetObjectID();
-	msg.emoteID = emoteID;
-	msg.targetID = targetID;      // The emote’s target entity or 0 if none
-	msg.Send(UNASSIGNED_SYSTEM_ADDRESS);  // Broadcast to all clients
+	RenderComponent::PlayAnimation(entity, sAnimationName);
 
 	MissionComponent* missionComponent = entity->GetComponent<MissionComponent>();
 	if (!missionComponent) return;
@@ -5207,7 +5197,7 @@ void GameMessages::HandlePickupCurrency(RakNet::BitStream& inStream, Entity* ent
 	if (currency == 0) return;
 
 	auto* ch = entity->GetCharacter();
-	if (ch && entity->PickupCoins(currency)) {
+	if (entity->CanPickupCoins(currency)) {
 		ch->SetCoins(ch->GetCoins() + currency, eLootSourceType::PICKUP);
 	}
 }
@@ -6312,10 +6302,6 @@ void GameMessages::SendUpdateInventoryUi(LWOOBJID objectId, const SystemAddress&
 }
 
 namespace GameMessages {
-	bool GameMsg::Send() {
-		return Game::entityManager->SendMessage(*this);
-	}
-
 	void GameMsg::Send(const SystemAddress& sysAddr) const {
 		CBITSTREAM;
 		CMSGHEADER;
@@ -6477,9 +6463,4 @@ namespace GameMessages {
 		stream.Write(soundID != -1);
 		if (soundID != -1) stream.Write(soundID);
 	}
-
-	void EmotePlayed::Serialize(RakNet::BitStream& stream) const {
-		stream.Write(emoteID);
-		stream.Write(targetID);
-	}
 }

dGame/dGameMessages/GameMessages.h

@@ -54,12 +54,6 @@ namespace GameMessages {
 		GameMsg(MessageType::Game gmId, eGameMasterLevel lvl) : msgId{ gmId }, requiredGmLevel{ lvl } {}
 		GameMsg(MessageType::Game gmId) : GameMsg(gmId, eGameMasterLevel::CIVILIAN) {}
 		virtual ~GameMsg() = default;
-
-		// Sends a message to the entity manager to route to the target
-		bool Send();
-
-		// Sends the message to the specified client or
-		// all clients if UNASSIGNED_SYSTEM_ADDRESS is specified
 		void Send(const SystemAddress& sysAddr) const;
 		virtual void Serialize(RakNet::BitStream& bitStream) const {}
 		virtual bool Deserialize(RakNet::BitStream& bitStream) { return true; }
@@ -839,20 +833,6 @@ namespace GameMessages {
 	struct ResetModelToDefaults : public GameMsg {
 		ResetModelToDefaults() : GameMsg(MessageType::Game::RESET_MODEL_TO_DEFAULTS) {}
 	};
-
-	struct EmotePlayed : public GameMsg {
-		EmotePlayed() : GameMsg(MessageType::Game::EMOTE_PLAYED), emoteID(0), targetID(0) {}
-	
-		void Serialize(RakNet::BitStream& stream) const override;
-	
-		int32_t emoteID;
-		LWOOBJID targetID;
-	};
-
-	struct GetPosition : public GameMsg {
-		GetPosition() : GameMsg(MessageType::Game::GET_POSITION) {}
-
-		NiPoint3 pos{};
-	};
 };
+
 #endif // GAMEMESSAGES_H

dGame/dInventory/Item.cpp

@@ -21,8 +21,6 @@
 #include "eUseItemResponse.h"
 #include "dZoneManager.h"
 #include "ChatPackets.h"
-#include "MissionComponent.h"
-#include "eMissionTaskType.h"
 
 #include "CDBrickIDTableTable.h"
 #include "CDObjectSkillsTable.h"
@@ -270,9 +268,9 @@ bool Item::IsEquipped() const {
 }
 
 bool Item::Consume() {
-	auto* const skillsTable = CDClientManager::GetTable<CDObjectSkillsTable>();
+	auto* skillsTable = CDClientManager::GetTable<CDObjectSkillsTable>();
 
-	const auto skills = skillsTable->Query([this](const CDObjectSkills& entry) {
+	auto skills = skillsTable->Query([this](const CDObjectSkills entry) {
 		return entry.objectTemplate == static_cast<uint32_t>(lot);
 		});
 
@@ -290,12 +288,7 @@ bool Item::Consume() {
 	GameMessages::SendUseItemResult(inventory->GetComponent()->GetParent(), lot, success);
 
 	if (success) {
-		// Save this because if this is the last item in the inventory
-		// we may delete ourself (lol)
-		const auto myLot = this->lot;
 		inventory->GetComponent()->RemoveItem(lot, 1);
-		auto* missionComponent = inventory->GetComponent()->GetParent()->GetComponent<MissionComponent>();
-		if (missionComponent) missionComponent->Progress(eMissionTaskType::GATHER, myLot, LWOOBJID_EMPTY, "", -1);
 	}
 
 	return success;

dGame/dPropertyBehaviors/CMakeLists.txt

@@ -20,7 +20,6 @@ target_include_directories(dPropertyBehaviors PUBLIC "." "ControlBehaviorMessage
 	"${PROJECT_SOURCE_DIR}/dGame/dUtilities" # ObjectIdManager.h
 	"${PROJECT_SOURCE_DIR}/dGame/dGameMessages" # GameMessages.h
 	"${PROJECT_SOURCE_DIR}/dGame/dComponents" # ModelComponent.h
-	"${PROJECT_SOURCE_DIR}/dChatFilter" # dChatFilter.h
 )
 target_precompile_headers(dPropertyBehaviors REUSE_FROM dGameBase)
 

dGame/dPropertyBehaviors/ControlBehaviorMessages/AddActionMessage.cpp

@@ -10,5 +10,5 @@ AddActionMessage::AddActionMessage(const AMFArrayValue& arguments)
 
 	m_Action = Action{ *actionValue };
 
-	LOG_DEBUG("actionIndex %i stripId %i stateId %i type %s valueParameterName %s valueParameterString %s valueParameterDouble %f m_BehaviorId %llu", m_ActionIndex, m_ActionContext.GetStripId(), m_ActionContext.GetStateId(), m_Action.GetType().data(), m_Action.GetValueParameterName().data(), m_Action.GetValueParameterString().data(), m_Action.GetValueParameterDouble(), m_BehaviorId);
+	LOG_DEBUG("actionIndex %i stripId %i stateId %i type %s valueParameterName %s valueParameterString %s valueParameterDouble %f m_BehaviorId %i", m_ActionIndex, m_ActionContext.GetStripId(), m_ActionContext.GetStateId(), m_Action.GetType().data(), m_Action.GetValueParameterName().data(), m_Action.GetValueParameterString().data(), m_Action.GetValueParameterDouble(), m_BehaviorId);
 }

dGame/dPropertyBehaviors/ControlBehaviorMessages/AddMessage.cpp

@@ -1,9 +1,9 @@
 #include "AddMessage.h"
 
-AddMessage::AddMessage(const AMFArrayValue& arguments, const LWOOBJID _owningPlayerID) : m_OwningPlayerID{ _owningPlayerID }, BehaviorMessageBase { arguments } {
+AddMessage::AddMessage(const AMFArrayValue& arguments) : BehaviorMessageBase{ arguments } {
 	const auto* const behaviorIndexValue = arguments.Get<double>("BehaviorIndex");
 	if (!behaviorIndexValue) return;
 
 	m_BehaviorIndex = static_cast<uint32_t>(behaviorIndexValue->GetValue());
-	LOG_DEBUG("behaviorId %llu index %i", m_BehaviorId, m_BehaviorIndex);
+	LOG_DEBUG("behaviorId %i index %i", m_BehaviorId, m_BehaviorIndex);
 }

dGame/dPropertyBehaviors/ControlBehaviorMessages/AddMessage.h

@@ -9,13 +9,11 @@
  */
 class AddMessage : public BehaviorMessageBase {
 public:
-	AddMessage(const AMFArrayValue& arguments, const LWOOBJID _owningPlayerID);
+	AddMessage(const AMFArrayValue& arguments);
 	[[nodiscard]] uint32_t GetBehaviorIndex() const noexcept { return m_BehaviorIndex; };
-	[[nodiscard]] LWOOBJID GetOwningPlayerID() const noexcept { return m_OwningPlayerID; };
 
 private:
 	uint32_t m_BehaviorIndex{ 0 };
-	LWOOBJID m_OwningPlayerID{};
 };
 
 #endif  //!__ADDMESSAGE__H__

dGame/dPropertyBehaviors/ControlBehaviorMessages/AddStripMessage.cpp

@@ -19,7 +19,7 @@ AddStripMessage::AddStripMessage(const AMFArrayValue& arguments)
 
 		m_ActionsToAdd.emplace_back(*actionValue);
 
-		LOG_DEBUG("xPosition %f yPosition %f stripId %i stateId %i behaviorId %llu t %s valueParameterName %s valueParameterString %s valueParameterDouble %f", m_Position.GetX(), m_Position.GetY(), m_ActionContext.GetStripId(), m_ActionContext.GetStateId(), m_BehaviorId, m_ActionsToAdd.back().GetType().data(), m_ActionsToAdd.back().GetValueParameterName().data(), m_ActionsToAdd.back().GetValueParameterString().data(), m_ActionsToAdd.back().GetValueParameterDouble());
+		LOG_DEBUG("xPosition %f yPosition %f stripId %i stateId %i behaviorId %i t %s valueParameterName %s valueParameterString %s valueParameterDouble %f", m_Position.GetX(), m_Position.GetY(), m_ActionContext.GetStripId(), m_ActionContext.GetStateId(), m_BehaviorId, m_ActionsToAdd.back().GetType().data(), m_ActionsToAdd.back().GetValueParameterName().data(), m_ActionsToAdd.back().GetValueParameterString().data(), m_ActionsToAdd.back().GetValueParameterDouble());
 	}
 	LOG_DEBUG("number of actions %i", m_ActionsToAdd.size());
 }

dGame/dPropertyBehaviors/ControlBehaviorMessages/BehaviorMessageBase.cpp

@@ -4,14 +4,14 @@
 #include "BehaviorStates.h"
 #include "dCommonVars.h"
 
-LWOOBJID BehaviorMessageBase::GetBehaviorIdFromArgument(const AMFArrayValue& arguments) {
+int32_t BehaviorMessageBase::GetBehaviorIdFromArgument(const AMFArrayValue& arguments) {
 	static constexpr std::string_view key = "BehaviorID";
 	const auto* const behaviorIDValue = arguments.Get<std::string>(key);
-	LWOOBJID behaviorId = DefaultBehaviorId;
+	int32_t behaviorId = DefaultBehaviorId;
 
 	if (behaviorIDValue && behaviorIDValue->GetValueType() == eAmf::String) {
 		behaviorId =
-			GeneralUtils::TryParse<LWOOBJID>(behaviorIDValue->GetValue()).value_or(behaviorId);
+			GeneralUtils::TryParse<int32_t>(behaviorIDValue->GetValue()).value_or(behaviorId);
 	} else if (arguments.Get(key) && arguments.Get(key)->GetValueType() != eAmf::Undefined) {
 		throw std::invalid_argument("Unable to find behavior ID");
 	}

dGame/dPropertyBehaviors/ControlBehaviorMessages/BehaviorMessageBase.h

@@ -11,22 +11,19 @@ enum class BehaviorState : uint32_t;
 
 /**
  * @brief The behaviorID target of this ControlBehaviors message
- *
+ * 
  */
 class BehaviorMessageBase {
 public:
-	static constexpr LWOOBJID DefaultBehaviorId{ -1 };
+	static constexpr int32_t DefaultBehaviorId{ -1 };
 	BehaviorMessageBase(const AMFArrayValue& arguments) : m_BehaviorId{ GetBehaviorIdFromArgument(arguments) } {}
-	[[nodiscard]] LWOOBJID GetBehaviorId() const noexcept { return m_BehaviorId; }
+	[[nodiscard]] int32_t GetBehaviorId() const noexcept { return m_BehaviorId; }
 	[[nodiscard]] bool IsDefaultBehaviorId() const noexcept { return m_BehaviorId == DefaultBehaviorId; }
-	[[nodiscard]] bool GetNeedsNewBehaviorID() const noexcept { return m_NeedsNewBehaviorID; }
-	void SetNeedsNewBehaviorID(const bool val) noexcept { m_NeedsNewBehaviorID = val; }
 
 protected:
-	[[nodiscard]] LWOOBJID GetBehaviorIdFromArgument(const AMFArrayValue& arguments);
+	[[nodiscard]] int32_t GetBehaviorIdFromArgument(const AMFArrayValue& arguments);
 	[[nodiscard]] int32_t GetActionIndexFromArgument(const AMFArrayValue& arguments, const std::string_view keyName = "actionIndex") const;
-	LWOOBJID m_BehaviorId{ DefaultBehaviorId };
-	bool m_NeedsNewBehaviorID{ false };
+	int32_t m_BehaviorId{ DefaultBehaviorId };
 };
 
 #endif  //!__BEHAVIORMESSAGEBASE__H__

dGame/dPropertyBehaviors/ControlBehaviorMessages/MergeStripsMessage.cpp

@@ -6,6 +6,6 @@ MergeStripsMessage::MergeStripsMessage(const AMFArrayValue& arguments)
 	, m_SourceActionContext{ arguments, "srcStateID", "srcStripID" }
 	, m_DestinationActionContext{ arguments, "dstStateID", "dstStripID" } {
 
-	LOG_DEBUG("srcstripId %i dststripId %i srcstateId %i dststateId %i dstactionIndex %i behaviorId %llu", m_SourceActionContext.GetStripId(), m_DestinationActionContext.GetStripId(), m_SourceActionContext.GetStateId(), m_DestinationActionContext.GetStateId(), m_DstActionIndex, m_BehaviorId);
+	LOG_DEBUG("srcstripId %i dststripId %i srcstateId %i dststateId %i dstactionIndex %i behaviorId %i", m_SourceActionContext.GetStripId(), m_DestinationActionContext.GetStripId(), m_SourceActionContext.GetStateId(), m_DestinationActionContext.GetStateId(), m_DstActionIndex, m_BehaviorId);
 }
 

dGame/dPropertyBehaviors/ControlBehaviorMessages/MigrateActionsMessage.cpp

@@ -7,5 +7,5 @@ MigrateActionsMessage::MigrateActionsMessage(const AMFArrayValue& arguments)
 	, m_SourceActionContext{ arguments, "srcStateID", "srcStripID" }
 	, m_DestinationActionContext{ arguments, "dstStateID", "dstStripID" } {
 
-	LOG_DEBUG("srcactionIndex %i dstactionIndex %i srcstripId %i dststripId %i srcstateId %i dststateId %i behaviorId %llu", m_SrcActionIndex, m_DstActionIndex, m_SourceActionContext.GetStripId(), m_DestinationActionContext.GetStripId(), m_SourceActionContext.GetStateId(), m_DestinationActionContext.GetStateId(), m_BehaviorId);
+	LOG_DEBUG("srcactionIndex %i dstactionIndex %i srcstripId %i dststripId %i srcstateId %i dststateId %i behaviorId %i", m_SrcActionIndex, m_DstActionIndex, m_SourceActionContext.GetStripId(), m_DestinationActionContext.GetStripId(), m_SourceActionContext.GetStateId(), m_DestinationActionContext.GetStateId(), m_BehaviorId);
 }

dGame/dPropertyBehaviors/ControlBehaviorMessages/MoveToInventoryMessage.cpp

@@ -1,9 +1,9 @@
 #include "MoveToInventoryMessage.h"
 
-MoveToInventoryMessage::MoveToInventoryMessage(const AMFArrayValue& arguments, const LWOOBJID _owningPlayerID) : m_OwningPlayerID{ _owningPlayerID }, BehaviorMessageBase{ arguments } {
+MoveToInventoryMessage::MoveToInventoryMessage(const AMFArrayValue& arguments) : BehaviorMessageBase{ arguments } {
 	const auto* const behaviorIndexValue = arguments.Get<double>("BehaviorIndex");
 	if (!behaviorIndexValue) return;
 
 	m_BehaviorIndex = static_cast<uint32_t>(behaviorIndexValue->GetValue());
-	LOG_DEBUG("behaviorId %llu behaviorIndex %i", m_BehaviorId, m_BehaviorIndex);
+	LOG_DEBUG("behaviorId %i behaviorIndex %i", m_BehaviorId, m_BehaviorIndex);
 }

dGame/dPropertyBehaviors/ControlBehaviorMessages/MoveToInventoryMessage.h

@@ -10,13 +10,11 @@ class AMFArrayValue;
  */
 class MoveToInventoryMessage : public BehaviorMessageBase {
 public:
-	MoveToInventoryMessage(const AMFArrayValue& arguments, const LWOOBJID owningPlayerID);
+	MoveToInventoryMessage(const AMFArrayValue& arguments);
 	[[nodiscard]] uint32_t GetBehaviorIndex() const noexcept { return m_BehaviorIndex; };
-	[[nodiscard]] LWOOBJID GetOwningPlayerID() const noexcept { return m_OwningPlayerID; };
 
 private:
 	uint32_t m_BehaviorIndex;
-	LWOOBJID m_OwningPlayerID{};
 };
 
 #endif  //!__MOVETOINVENTORYMESSAGE__H__

dGame/dPropertyBehaviors/ControlBehaviorMessages/RearrangeStripMessage.cpp

@@ -6,5 +6,5 @@ RearrangeStripMessage::RearrangeStripMessage(const AMFArrayValue& arguments)
 	, m_DstActionIndex{ GetActionIndexFromArgument(arguments, "dstActionIndex") }
 	, m_ActionContext{ arguments } {
 
-	LOG_DEBUG("srcactionIndex %i dstactionIndex %i stripId %i behaviorId %llu stateId %i", m_SrcActionIndex, m_DstActionIndex, m_ActionContext.GetStripId(), m_BehaviorId, m_ActionContext.GetStateId());
+	LOG_DEBUG("srcactionIndex %i dstactionIndex %i stripId %i behaviorId %i stateId %i", m_SrcActionIndex, m_DstActionIndex, m_ActionContext.GetStripId(), m_BehaviorId, m_ActionContext.GetStateId());
 }

dGame/dPropertyBehaviors/ControlBehaviorMessages/RemoveActionsMessage.cpp

@@ -5,5 +5,5 @@ RemoveActionsMessage::RemoveActionsMessage(const AMFArrayValue& arguments)
 	, m_ActionIndex{ GetActionIndexFromArgument(arguments) }
 	, m_ActionContext{ arguments } {
 
-	LOG_DEBUG("behaviorId %llu actionIndex %i stripId %i stateId %i", m_BehaviorId, m_ActionIndex, m_ActionContext.GetStripId(), m_ActionContext.GetStateId());
+	LOG_DEBUG("behaviorId %i actionIndex %i stripId %i stateId %i", m_BehaviorId, m_ActionIndex, m_ActionContext.GetStripId(), m_ActionContext.GetStateId());
 }

dGame/dPropertyBehaviors/ControlBehaviorMessages/RemoveStripMessage.cpp

@@ -4,5 +4,5 @@ RemoveStripMessage::RemoveStripMessage(const AMFArrayValue& arguments)
 	: BehaviorMessageBase{ arguments }
 	, m_ActionContext{ arguments } {
 
-	LOG_DEBUG("stripId %i stateId %i behaviorId %llu", m_ActionContext.GetStripId(), m_ActionContext.GetStateId(), m_BehaviorId);
+	LOG_DEBUG("stripId %i stateId %i behaviorId %i", m_ActionContext.GetStripId(), m_ActionContext.GetStateId(), m_BehaviorId);
 }

dGame/dPropertyBehaviors/ControlBehaviorMessages/RenameMessage.cpp

@@ -5,5 +5,5 @@ RenameMessage::RenameMessage(const AMFArrayValue& arguments) : BehaviorMessageBa
 	if (!nameAmf) return;
 
 	m_Name = nameAmf->GetValue();
-	LOG_DEBUG("behaviorId %llu n %s", m_BehaviorId, m_Name.c_str());
+	LOG_DEBUG("behaviorId %i n %s", m_BehaviorId, m_Name.c_str());
 }

dGame/dPropertyBehaviors/ControlBehaviorMessages/SplitStripMessage.cpp

@@ -7,5 +7,5 @@ SplitStripMessage::SplitStripMessage(const AMFArrayValue& arguments)
 	, m_DestinationActionContext{ arguments, "dstStateID", "dstStripID" }
 	, m_DestinationPosition{ arguments, "dstStripUI" } {
 
-	LOG_DEBUG("behaviorId %llu xPosition %f yPosition %f sourceStrip %i destinationStrip %i sourceState %i destinationState %i srcActindex %i", m_BehaviorId, m_DestinationPosition.GetX(), m_DestinationPosition.GetY(), m_SourceActionContext.GetStripId(), m_DestinationActionContext.GetStripId(), m_SourceActionContext.GetStateId(), m_DestinationActionContext.GetStateId(), m_SrcActionIndex);
+	LOG_DEBUG("behaviorId %i xPosition %f yPosition %f sourceStrip %i destinationStrip %i sourceState %i destinationState %i srcActindex %i", m_BehaviorId, m_DestinationPosition.GetX(), m_DestinationPosition.GetY(), m_SourceActionContext.GetStripId(), m_DestinationActionContext.GetStripId(), m_SourceActionContext.GetStateId(), m_DestinationActionContext.GetStateId(), m_SrcActionIndex);
 }

dGame/dPropertyBehaviors/ControlBehaviorMessages/UpdateActionMessage.cpp

@@ -12,5 +12,5 @@ UpdateActionMessage::UpdateActionMessage(const AMFArrayValue& arguments)
 	
 	m_Action = Action{ *actionValue };
 
-	LOG_DEBUG("type %s valueParameterName %s valueParameterString %s valueParameterDouble %f behaviorId %llu actionIndex %i stripId %i stateId %i", m_Action.GetType().data(), m_Action.GetValueParameterName().data(), m_Action.GetValueParameterString().data(), m_Action.GetValueParameterDouble(), m_BehaviorId, m_ActionIndex, m_ActionContext.GetStripId(), m_ActionContext.GetStateId());
+	LOG_DEBUG("type %s valueParameterName %s valueParameterString %s valueParameterDouble %f behaviorId %i actionIndex %i stripId %i stateId %i", m_Action.GetType().data(), m_Action.GetValueParameterName().data(), m_Action.GetValueParameterString().data(), m_Action.GetValueParameterDouble(), m_BehaviorId, m_ActionIndex, m_ActionContext.GetStripId(), m_ActionContext.GetStateId());
 }

dGame/dPropertyBehaviors/ControlBehaviorMessages/UpdateStripUiMessage.cpp

@@ -5,5 +5,5 @@ UpdateStripUiMessage::UpdateStripUiMessage(const AMFArrayValue& arguments)
 	, m_Position{ arguments }
 	, m_ActionContext{ arguments } {
 
-	LOG_DEBUG("xPosition %f yPosition %f stripId %i stateId %i behaviorId %llu", m_Position.GetX(), m_Position.GetY(), m_ActionContext.GetStripId(), m_ActionContext.GetStateId(), m_BehaviorId);
+	LOG_DEBUG("xPosition %f yPosition %f stripId %i stateId %i behaviorId %i", m_Position.GetX(), m_Position.GetY(), m_ActionContext.GetStripId(), m_ActionContext.GetStateId(), m_BehaviorId);
 }

dGame/dPropertyBehaviors/ControlBehaviors.cpp

@@ -30,27 +30,22 @@
 #include "SplitStripMessage.h"
 #include "UpdateActionMessage.h"
 #include "UpdateStripUiMessage.h"
-#include "eObjectBits.h"
 
 void ControlBehaviors::RequestUpdatedID(ControlBehaviorContext& context) {
-	BehaviorMessageBase msgBase{ context.arguments };
-	const auto oldBehaviorID = msgBase.GetBehaviorId();
 	ObjectIDManager::RequestPersistentID(
-		[context, oldBehaviorID](uint32_t persistentId) {
+		[context](uint32_t persistentId) {
 			if (!context) {
 				LOG("Model to update behavior ID for is null. Cannot update ID.");
 				return;
 			}
-			LWOOBJID persistentIdBig = persistentId;
-			GeneralUtils::SetBit(persistentIdBig, eObjectBits::CHARACTER);
 			// This updates the behavior ID of the behavior should this be a new behavior
 			AMFArrayValue args;
 
-			args.Insert("behaviorID", std::to_string(persistentIdBig));
+			args.Insert("behaviorID", std::to_string(persistentId));
 			args.Insert("objectID", std::to_string(context.modelComponent->GetParent()->GetObjectID()));
 
 			GameMessages::SendUIMessageServerToSingleClient(context.modelOwner, context.modelOwner->GetSystemAddress(), "UpdateBehaviorID", args);
-			context.modelComponent->UpdatePendingBehaviorId(persistentIdBig, oldBehaviorID);
+			context.modelComponent->UpdatePendingBehaviorId(persistentId);
 
 			ControlBehaviors::Instance().SendBehaviorListToClient(context);
 		});
@@ -107,12 +102,9 @@ void ControlBehaviors::ProcessCommand(Entity* const modelEntity, const AMFArrayV
 	if (!modelComponent) return;
 
 	ControlBehaviorContext context{ arguments, modelComponent, modelOwner };
-	bool needsNewBehaviorID = false;
 
 	if (command == "sendBehaviorListToClient") {
 		SendBehaviorListToClient(context);
-	} else if (command == "sendBehaviorBlocksToClient") {
-		SendBehaviorBlocksToClient(context);
 	} else if (command == "modelTypeChanged") {
 		const auto* const modelType = arguments.Get<double>("ModelType");
 		if (!modelType) return;
@@ -121,54 +113,52 @@ void ControlBehaviors::ProcessCommand(Entity* const modelEntity, const AMFArrayV
 	} else if (command == "toggleExecutionUpdates") {
 		// TODO
 	} else if (command == "addStrip") {
-		needsNewBehaviorID = context.modelComponent->HandleControlBehaviorsMsg<AddStripMessage>(context.arguments);
+		if (BehaviorMessageBase(context.arguments).IsDefaultBehaviorId()) RequestUpdatedID(context);
+
+		context.modelComponent->HandleControlBehaviorsMsg<AddStripMessage>(context.arguments);
 	} else if (command == "removeStrip") {
-		needsNewBehaviorID = context.modelComponent->HandleControlBehaviorsMsg<RemoveStripMessage>(arguments);
+		context.modelComponent->HandleControlBehaviorsMsg<RemoveStripMessage>(arguments);
 	} else if (command == "mergeStrips") {
-		needsNewBehaviorID = context.modelComponent->HandleControlBehaviorsMsg<MergeStripsMessage>(arguments);
+		context.modelComponent->HandleControlBehaviorsMsg<MergeStripsMessage>(arguments);
 	} else if (command == "splitStrip") {
-		needsNewBehaviorID = context.modelComponent->HandleControlBehaviorsMsg<SplitStripMessage>(arguments);
+		context.modelComponent->HandleControlBehaviorsMsg<SplitStripMessage>(arguments);
 	} else if (command == "updateStripUI") {
-		needsNewBehaviorID = context.modelComponent->HandleControlBehaviorsMsg<UpdateStripUiMessage>(arguments);
+		context.modelComponent->HandleControlBehaviorsMsg<UpdateStripUiMessage>(arguments);
 	} else if (command == "addAction") {
-		needsNewBehaviorID = context.modelComponent->HandleControlBehaviorsMsg<AddActionMessage>(arguments);
+		context.modelComponent->HandleControlBehaviorsMsg<AddActionMessage>(arguments);
 	} else if (command == "migrateActions") {
-		needsNewBehaviorID = context.modelComponent->HandleControlBehaviorsMsg<MigrateActionsMessage>(arguments);
+		context.modelComponent->HandleControlBehaviorsMsg<MigrateActionsMessage>(arguments);
 	} else if (command == "rearrangeStrip") {
-		needsNewBehaviorID = context.modelComponent->HandleControlBehaviorsMsg<RearrangeStripMessage>(arguments);
+		context.modelComponent->HandleControlBehaviorsMsg<RearrangeStripMessage>(arguments);
+	} else if (command == "add") {
+		AddMessage msg{ context.arguments };
+		context.modelComponent->AddBehavior(msg);
+		SendBehaviorListToClient(context);
 	} else if (command == "removeActions") {
-		needsNewBehaviorID = context.modelComponent->HandleControlBehaviorsMsg<RemoveActionsMessage>(arguments);
-	} else if (command == "updateAction") {
-		needsNewBehaviorID = context.modelComponent->HandleControlBehaviorsMsg<UpdateActionMessage>(arguments);
+		context.modelComponent->HandleControlBehaviorsMsg<RemoveActionsMessage>(arguments);
 	} else if (command == "rename") {
-		needsNewBehaviorID = context.modelComponent->HandleControlBehaviorsMsg<RenameMessage>(arguments);
+		context.modelComponent->HandleControlBehaviorsMsg<RenameMessage>(arguments);
 
 		// Send the list back to the client so the name is updated.
 		SendBehaviorListToClient(context);
-	} else if (command == "add") {
-		AddMessage msg{ context.arguments, context.modelOwner->GetObjectID() };
-		context.modelComponent->AddBehavior(msg);
-		SendBehaviorListToClient(context);
-	} else if (command == "moveToInventory" || command == "remove") {
-		// both moveToInventory and remove use the same args
-		const bool isRemove = command != "remove";
-		MoveToInventoryMessage msg{ arguments, modelOwner->GetObjectID() };
-		context.modelComponent->RemoveBehavior(msg, isRemove);
+	} else if (command == "sendBehaviorBlocksToClient") {
+		SendBehaviorBlocksToClient(context);
+	} else if (command == "moveToInventory") {
+		MoveToInventoryMessage msg{ arguments };
+		context.modelComponent->MoveToInventory(msg);
 		auto* characterComponent = modelOwner->GetComponent<CharacterComponent>();
 		if (!characterComponent) return;
 
-		if (!isRemove) {
-			AMFArrayValue args;
-			args.Insert("BehaviorID", std::to_string(msg.GetBehaviorId()));
-			GameMessages::SendUIMessageServerToSingleClient(modelOwner, characterComponent->GetSystemAddress(), "BehaviorRemoved", args);
-		}
+		AMFArrayValue args;
+		args.Insert("BehaviorID", std::to_string(msg.GetBehaviorId()));
+		GameMessages::SendUIMessageServerToSingleClient(modelOwner, characterComponent->GetSystemAddress(), "BehaviorRemoved", args);
 
 		SendBehaviorListToClient(context);
+	} else if (command == "updateAction") {
+		context.modelComponent->HandleControlBehaviorsMsg<UpdateActionMessage>(arguments);
 	} else {
 		LOG("Unknown behavior command (%s)", command.data());
 	}
-
-	if (needsNewBehaviorID) RequestUpdatedID(context);
 }
 
 ControlBehaviors::ControlBehaviors() {

dGame/dPropertyBehaviors/PropertyBehavior.cpp

@@ -8,12 +8,9 @@
 
 #include <ranges>
 
-PropertyBehavior::PropertyBehavior(bool _isTemplated) {
+PropertyBehavior::PropertyBehavior() {
 	m_LastEditedState = BehaviorState::HOME_STATE;
 	m_ActiveState = BehaviorState::HOME_STATE;
-
-	// Starts off as true so that only specific ways of adding behaviors allow a new id to be requested.
-	isTemplated = _isTemplated;
 }
 
 template<>
@@ -84,6 +81,13 @@ void PropertyBehavior::HandleMsg(RenameMessage& msg) {
 	m_Name = msg.GetName();
 };
 
+template<>
+void PropertyBehavior::HandleMsg(AddMessage& msg) {
+	// TODO Parse the corresponding behavior xml file.
+	m_BehaviorId = msg.GetBehaviorId();
+	isLoot = m_BehaviorId != 7965;
+};
+
 template<>
 void PropertyBehavior::HandleMsg(GameMessages::RequestUse& msg) {
 	m_States[m_ActiveState].HandleMsg(msg);
@@ -95,12 +99,6 @@ void PropertyBehavior::HandleMsg(GameMessages::ResetModelToDefaults& msg) {
 	for (auto& state : m_States | std::views::values) state.HandleMsg(msg);
 }
 
-void PropertyBehavior::CheckModifyState(BehaviorMessageBase& msg) {
-	if (!isTemplated && m_BehaviorId != BehaviorMessageBase::DefaultBehaviorId) return;
-	isTemplated = false;
-	msg.SetNeedsNewBehaviorID(true);
-}
-
 void PropertyBehavior::SendBehaviorListToClient(AMFArrayValue& args) const {
 	args.Insert("id", std::to_string(m_BehaviorId));
 	args.Insert("name", m_Name);
@@ -149,9 +147,6 @@ void PropertyBehavior::Serialize(tinyxml2::XMLElement& behavior) const {
 	behavior.SetAttribute("isLocked", isLocked);
 	behavior.SetAttribute("isLoot", isLoot);
 
-	// CUSTOM XML ATTRIBUTE
-	behavior.SetAttribute("isTemplated", isTemplated);
-
 	for (const auto& [stateId, state] : m_States) {
 		if (state.IsEmpty()) continue;
 		auto* const stateElement = behavior.InsertNewChildElement("State");
@@ -166,9 +161,6 @@ void PropertyBehavior::Deserialize(const tinyxml2::XMLElement& behavior) {
 	behavior.QueryBoolAttribute("isLocked", &isLocked);
 	behavior.QueryBoolAttribute("isLoot", &isLoot);
 
-	// CUSTOM XML ATTRIBUTE
-	if (!isTemplated) behavior.QueryBoolAttribute("isTemplated", &isTemplated);
-
 	for (const auto* stateElement = behavior.FirstChildElement("State"); stateElement; stateElement = stateElement->NextSiblingElement("State")) {
 		int32_t stateId = -1;
 		stateElement->QueryIntAttribute("id", &stateId);
@@ -180,7 +172,3 @@ void PropertyBehavior::Deserialize(const tinyxml2::XMLElement& behavior) {
 void PropertyBehavior::Update(float deltaTime, ModelComponent& modelComponent) {
 	for (auto& state : m_States | std::views::values) state.Update(deltaTime, modelComponent);
 }
-
-void PropertyBehavior::OnChatMessageReceived(const std::string& sMessage) {
-	for (auto& state : m_States | std::views::values) state.OnChatMessageReceived(sMessage);
-}

dGame/dPropertyBehaviors/PropertyBehavior.h

@@ -10,7 +10,6 @@ namespace tinyxml2 {
 enum class BehaviorState : uint32_t;
 
 class AMFArrayValue;
-class BehaviorMessageBase;
 class ModelComponent;
 
 /**
@@ -18,7 +17,7 @@ class ModelComponent;
  */
 class PropertyBehavior {
 public:
-	PropertyBehavior(bool _isTemplated = false);
+	PropertyBehavior();
 
 	template <typename Msg>
 	void HandleMsg(Msg& msg);
@@ -27,21 +26,14 @@ public:
 	void VerifyLastEditedState();
 	void SendBehaviorListToClient(AMFArrayValue& args) const;
 	void SendBehaviorBlocksToClient(AMFArrayValue& args) const;
-	void CheckModifyState(BehaviorMessageBase& msg);
 
-	[[nodiscard]] LWOOBJID GetBehaviorId() const noexcept { return m_BehaviorId; }
-	void SetBehaviorId(LWOOBJID id) noexcept { m_BehaviorId = id; }
-
-	bool GetIsLoot() const noexcept { return isLoot; }
-	void SetIsLoot(const bool val) noexcept { isLoot = val; }
-
-	const std::string& GetName() const noexcept { return m_Name; }
+	[[nodiscard]] int32_t GetBehaviorId() const noexcept { return m_BehaviorId; }
+	void SetBehaviorId(int32_t id) noexcept { m_BehaviorId = id; }
 
 	void Serialize(tinyxml2::XMLElement& behavior) const;
 	void Deserialize(const tinyxml2::XMLElement& behavior);
 
 	void Update(float deltaTime, ModelComponent& modelComponent);
-	void OnChatMessageReceived(const std::string& sMessage);
 
 private:
 	// The current active behavior state. Behaviors can only be in ONE state at a time.
@@ -59,16 +51,13 @@ private:
 	// Whether this behavior is custom or pre-fab.
 	bool isLoot = false;
 
-	// Whether or not the behavior has been modified from its original state.
-	bool isTemplated;
-
 	// The last state that was edited. This is used so when the client re-opens the behavior editor, it will open to the last edited state.
 	// If the last edited state has no strips, it will open to the first state that has strips.
 	BehaviorState m_LastEditedState;
 
 	// The behavior id for this behavior. This is expected to be fully unique, however an id of -1 means this behavior was just created
 	// and needs to be assigned an id.
-	LWOOBJID m_BehaviorId = -1;
+	int32_t m_BehaviorId = -1;
 };
 
 #endif  //!__PROPERTYBEHAVIOR__H__

dGame/dPropertyBehaviors/State.cpp

@@ -166,7 +166,3 @@ void State::Deserialize(const tinyxml2::XMLElement& state) {
 void State::Update(float deltaTime, ModelComponent& modelComponent) {
 	for (auto& strip : m_Strips) strip.Update(deltaTime, modelComponent);
 }
-
-void State::OnChatMessageReceived(const std::string& sMessage) {
-	for (auto& strip : m_Strips) strip.OnChatMessageReceived(sMessage);
-}

dGame/dPropertyBehaviors/State.h

@@ -22,8 +22,6 @@ public:
 	void Deserialize(const tinyxml2::XMLElement& state);
 
 	void Update(float deltaTime, ModelComponent& modelComponent);
-
-	void OnChatMessageReceived(const std::string& sMessage);
 private:
 
 	// The strips contained within this state.

dGame/dPropertyBehaviors/Strip.cpp

@@ -5,12 +5,7 @@
 #include "tinyxml2.h"
 #include "dEntity/EntityInfo.h"
 #include "ModelComponent.h"
-#include "ChatPackets.h"
-#include "PropertyManagementComponent.h"
 #include "PlayerManager.h"
-#include "SimplePhysicsComponent.h"
-
-#include "dChatFilter.h"
 
 #include "DluAssert.h"
 
@@ -89,11 +84,9 @@ void Strip::HandleMsg(MigrateActionsMessage& msg) {
 
 template<>
 void Strip::HandleMsg(GameMessages::RequestUse& msg) {
-	if (m_PausedTime > 0.0f || !HasMinimumActions()) return;
+	if (m_PausedTime > 0.0f) return;
 
-	auto& nextAction = GetNextAction();
-
-	if (nextAction.GetType() == "OnInteract") {
+	if (m_Actions[m_NextActionIndex].GetType() == "OnInteract") {
 		IncrementAction();
 		m_WaitingForAction = false;
 	}
@@ -104,18 +97,6 @@ void Strip::HandleMsg(GameMessages::ResetModelToDefaults& msg) {
 	m_WaitingForAction = false;
 	m_PausedTime = 0.0f;
 	m_NextActionIndex = 0;
-	m_InActionMove = NiPoint3Constant::ZERO;
-	m_PreviousFramePosition = NiPoint3Constant::ZERO;
-}
-
-void Strip::OnChatMessageReceived(const std::string& sMessage) {
-	if (m_PausedTime > 0.0f || !HasMinimumActions()) return;
-
-	const auto& nextAction = GetNextAction();
-	if (nextAction.GetType() == "OnChat" && nextAction.GetValueParameterString() == sMessage) {
-		IncrementAction();
-		m_WaitingForAction = false;
-	}
 }
 
 void Strip::IncrementAction() {
@@ -130,9 +111,7 @@ void Strip::Spawn(LOT lot, Entity& entity) {
 	info.pos = entity.GetPosition();
 	info.rot = NiQuaternionConstant::IDENTITY;
 	info.spawnerID = entity.GetObjectID();
-	auto* const spawnedEntity = Game::entityManager->CreateEntity(info, nullptr, &entity);
-	spawnedEntity->AddToGroup("SpawnedPropertyEnemies");
-	Game::entityManager->ConstructEntity(spawnedEntity);
+	Game::entityManager->ConstructEntity(Game::entityManager->CreateEntity(info, nullptr, &entity));
 }
 
 // Spawns a specific drop for all
@@ -146,51 +125,21 @@ void Strip::ProcNormalAction(float deltaTime, ModelComponent& modelComponent) {
 	auto& entity = *modelComponent.GetParent();
 	auto& nextAction = GetNextAction();
 	auto number = nextAction.GetValueParameterDouble();
-	auto valueStr = nextAction.GetValueParameterString();
 	auto numberAsInt = static_cast<int32_t>(number);
 	auto nextActionType = GetNextAction().GetType();
-
-	// TODO replace with switch case and nextActionType with enum
-	/* BEGIN Move */
-	if (nextActionType == "MoveRight" || nextActionType == "MoveLeft") {
-		// X axis
-		bool isMoveLeft = nextActionType == "MoveLeft";
-		int negative = isMoveLeft ? -1 : 1;
-		// Default velocity is 3 units per second.
-		if (modelComponent.TrySetVelocity(NiPoint3Constant::UNIT_X * negative)) {
-			m_PreviousFramePosition = entity.GetPosition();
-			m_InActionMove.x = isMoveLeft ? -number : number;
-		}
-	} else if (nextActionType == "FlyUp" || nextActionType == "FlyDown") {
-		// Y axis
-		bool isFlyDown = nextActionType == "FlyDown";
-		int negative = isFlyDown ? -1 : 1;
-		// Default velocity is 3 units per second.
-		if (modelComponent.TrySetVelocity(NiPoint3Constant::UNIT_Y * negative)) {
-			m_PreviousFramePosition = entity.GetPosition();
-			m_InActionMove.y = isFlyDown ? -number : number;
-		}
-
-	} else if (nextActionType == "MoveForward" || nextActionType == "MoveBackward") {
-		// Z axis
-		bool isMoveBackward = nextActionType == "MoveBackward";
-		int negative = isMoveBackward ? -1 : 1;
-		// Default velocity is 3 units per second.
-		if (modelComponent.TrySetVelocity(NiPoint3Constant::UNIT_Z * negative)) {
-			m_PreviousFramePosition = entity.GetPosition();
-			m_InActionMove.z = isMoveBackward ? -number : number;
-		}
-	}
-	/* END Move */
-
-	/* BEGIN Navigation */
-	else if (nextActionType == "SetSpeed") {
-		modelComponent.SetSpeed(number);
-	}
-	/* END Navigation */
-
-	/* BEGIN Action */
-	else if (nextActionType == "Smash") {
+	if (nextActionType == "SpawnStromling") {
+		Spawn(10495, entity); // Stromling property
+	} else if (nextActionType == "SpawnPirate") {
+		Spawn(10497, entity); // Maelstrom Pirate property
+	} else if (nextActionType == "SpawnRonin") {
+		Spawn(10498, entity); // Dark Ronin property
+	} else if (nextActionType == "DropImagination") {
+		for (; numberAsInt > 0; numberAsInt--) SpawnDrop(935, entity); // 1 Imagination powerup
+	} else if (nextActionType == "DropHealth") {
+		for (; numberAsInt > 0; numberAsInt--) SpawnDrop(177, entity); // 1 Life powerup
+	} else if (nextActionType == "DropArmor") {
+		for (; numberAsInt > 0; numberAsInt--) SpawnDrop(6431, entity); // 1 Armor powerup
+	} else if (nextActionType == "Smash") {
 		if (!modelComponent.IsUnSmashing()) {
 			GameMessages::Smash smash{};
 			smash.target = entity.GetObjectID();
@@ -208,44 +157,18 @@ void Strip::ProcNormalAction(float deltaTime, ModelComponent& modelComponent) {
 		m_PausedTime = number;
 	} else if (nextActionType == "Wait") {
 		m_PausedTime = number;
-	} else if (nextActionType == "Chat") {
-		bool isOk = Game::chatFilter->IsSentenceOkay(valueStr.data(), eGameMasterLevel::CIVILIAN).empty();
-		// In case a word is removed from the whitelist after it was approved
-		const auto modelName = "%[Objects_" + std::to_string(entity.GetLOT()) + "_name]";
-		if (isOk) ChatPackets::SendChatMessage(UNASSIGNED_SYSTEM_ADDRESS, 12, modelName, entity.GetObjectID(), false, GeneralUtils::ASCIIToUTF16(valueStr));
-		PropertyManagementComponent::Instance()->OnChatMessageReceived(valueStr.data());
-	} else if (nextActionType == "PrivateMessage") {
-		PropertyManagementComponent::Instance()->OnChatMessageReceived(valueStr.data());
 	} else if (nextActionType == "PlaySound") {
 		GameMessages::PlayBehaviorSound sound;
 		sound.target = modelComponent.GetParent()->GetObjectID();
 		sound.soundID = numberAsInt;
 		sound.Send(UNASSIGNED_SYSTEM_ADDRESS);
-	} else if (nextActionType == "Restart") {
-		modelComponent.RestartAtEndOfFrame();
-	}
-	/* END Action */
-	/* BEGIN Gameplay */
-	else if (nextActionType == "SpawnStromling") {
-		Spawn(10495, entity); // Stromling property
-	} else if (nextActionType == "SpawnPirate") {
-		Spawn(10497, entity); // Maelstrom Pirate property
-	} else if (nextActionType == "SpawnRonin") {
-		Spawn(10498, entity); // Dark Ronin property
-	} else if (nextActionType == "DropImagination") {
-		for (; numberAsInt > 0; numberAsInt--) SpawnDrop(935, entity); // 1 Imagination powerup
-	} else if (nextActionType == "DropHealth") {
-		for (; numberAsInt > 0; numberAsInt--) SpawnDrop(177, entity); // 1 Life powerup
-	} else if (nextActionType == "DropArmor") {
-		for (; numberAsInt > 0; numberAsInt--) SpawnDrop(6431, entity); // 1 Armor powerup
-	}
-	/* END Gameplay */
-	else {
+	} else {
 		static std::set<std::string> g_WarnedActions;
 		if (!g_WarnedActions.contains(nextActionType.data())) {
 			LOG("Tried to play action (%s) which is not supported.", nextActionType.data());
 			g_WarnedActions.insert(nextActionType.data());
 		}
+		return;
 	}
 
 	IncrementAction();
@@ -264,67 +187,12 @@ void Strip::RemoveStates(ModelComponent& modelComponent) const {
 	}
 }
 
-bool Strip::CheckMovement(float deltaTime, ModelComponent& modelComponent) {
-	auto& entity = *modelComponent.GetParent();
-	const auto& currentPos = entity.GetPosition();
-	const auto diff = currentPos - m_PreviousFramePosition;
-	const auto [moveX, moveY, moveZ] = m_InActionMove;
-	m_PreviousFramePosition = currentPos;
-
-	// Only want to subtract from the move if one is being performed.
-	// Starts at true because we may not be doing a move at all.
-	// If one is being done, then one of the move_ variables will be non-zero
-	bool moveFinished = true;
-	NiPoint3 finalPositionAdjustment = NiPoint3Constant::ZERO;
-	if (moveX != 0.0f) {
-		m_InActionMove.x -= diff.x;
-		// If the sign bit is different between the two numbers, then we have finished our move.
-		moveFinished = std::signbit(m_InActionMove.x) != std::signbit(moveX);
-		finalPositionAdjustment.x = m_InActionMove.x;
-	} else if (moveY != 0.0f) {
-		m_InActionMove.y -= diff.y;
-		// If the sign bit is different between the two numbers, then we have finished our move.
-		moveFinished = std::signbit(m_InActionMove.y) != std::signbit(moveY);
-		finalPositionAdjustment.y = m_InActionMove.y;
-	} else if (moveZ != 0.0f) {
-		m_InActionMove.z -= diff.z;
-		// If the sign bit is different between the two numbers, then we have finished our move.
-		moveFinished = std::signbit(m_InActionMove.z) != std::signbit(moveZ);
-		finalPositionAdjustment.z = m_InActionMove.z;
-	}
-
-	// Once done, set the in action move & velocity to zero
-	if (moveFinished && m_InActionMove != NiPoint3Constant::ZERO) {
-		auto entityVelocity = entity.GetVelocity();
-		// Zero out only the velocity that was acted on
-		if (moveX != 0.0f) entityVelocity.x = 0.0f;
-		else if (moveY != 0.0f) entityVelocity.y = 0.0f;
-		else if (moveZ != 0.0f) entityVelocity.z = 0.0f;
-		modelComponent.SetVelocity(entityVelocity);
-
-		// Do the final adjustment so we will have moved exactly the requested units
-		entity.SetPosition(entity.GetPosition() + finalPositionAdjustment);
-		m_InActionMove = NiPoint3Constant::ZERO;
-	}
-
-	return moveFinished;
-}
-
 void Strip::Update(float deltaTime, ModelComponent& modelComponent) {
-	// No point in running a strip with only one action.
-	// Strips are also designed to have 2 actions or more to run.
-	if (!HasMinimumActions()) return;
-
-	// Return if this strip has an active movement action
-	if (!CheckMovement(deltaTime, modelComponent)) return;
-
-	// Don't run this strip if we're paused.
 	m_PausedTime -= deltaTime;
 	if (m_PausedTime > 0.0f) return;
 
 	m_PausedTime = 0.0f;
 
-	// Return here if we're waiting for external interactions to continue.
 	if (m_WaitingForAction) return;
 
 	auto& entity = *modelComponent.GetParent();
@@ -332,16 +200,13 @@ void Strip::Update(float deltaTime, ModelComponent& modelComponent) {
 
 	RemoveStates(modelComponent);
 
-	// Check for trigger blocks and if not a trigger block proc this blocks action
+	// Check for starting blocks and if not a starting block proc this blocks action
 	if (m_NextActionIndex == 0) {
 		if (nextAction.GetType() == "OnInteract") {
 			modelComponent.AddInteract();
 			Game::entityManager->SerializeEntity(entity);
 			m_WaitingForAction = true;
 
-		} else if (nextAction.GetType() == "OnChat") {
-			Game::entityManager->SerializeEntity(entity);
-			m_WaitingForAction = true;
 		}
 	} else { // should be a normal block
 		ProcNormalAction(deltaTime, modelComponent);

dGame/dPropertyBehaviors/Strip.h

@@ -29,25 +29,15 @@ public:
 
 	void IncrementAction();
 	void Spawn(LOT object, Entity& entity);
-
-	// Checks the movement logic for whether or not to proceed
-	// Returns true if the movement can continue, false if it needs to wait more.
-	bool CheckMovement(float deltaTime, ModelComponent& modelComponent);
 	void Update(float deltaTime, ModelComponent& modelComponent);
 	void SpawnDrop(LOT dropLOT, Entity& entity);
 	void ProcNormalAction(float deltaTime, ModelComponent& modelComponent);
 	void RemoveStates(ModelComponent& modelComponent) const;
-
-	// 2 actions are required for strips to work
-	bool HasMinimumActions() const { return m_Actions.size() >= 2; }
-	
-	void OnChatMessageReceived(const std::string& sMessage);
 private:
 	// Indicates this Strip is waiting for an action to be taken upon it to progress to its actions
 	bool m_WaitingForAction{ false };
 
-	// The amount of time this strip is paused for. Any interactions with this strip should be bounced if this is greater than 0.
-	// Actions that do not use time do not use this (ex. positions).
+	// The amount of time this strip is paused for.  Any interactions with this strip should be bounced if this is greater than 0.
 	float m_PausedTime{ 0.0f };
 
 	// The index of the next action to be played. This should always be within range of [0, m_Actions.size()).
@@ -58,15 +48,6 @@ private:
 
 	// The location of this strip on the UGBehaviorEditor UI
 	StripUiPosition m_Position;
-
-	// The current actions remaining distance to the target
-	// Only 1 of these vertexs' will be active at once for any given strip.
-	NiPoint3 m_InActionMove{};
-
-	// The position of the parent model on the previous frame
-	NiPoint3 m_PreviousFramePosition{};
-
-	NiPoint3 m_SavedVelocity{};
 };
 
 #endif  //!__STRIP__H__

dGame/dUtilities/Loot.cpp

@@ -24,8 +24,9 @@ namespace {
 }
 
 void Loot::CacheMatrix(uint32_t matrixIndex) {
-	if (CachedMatrices.contains(matrixIndex)) return;
-
+	if (CachedMatrices.find(matrixIndex) != CachedMatrices.end()) {
+		return;
+	}
 	CachedMatrices.insert(matrixIndex);
 	CDComponentsRegistryTable* componentsRegistryTable = CDClientManager::GetTable<CDComponentsRegistryTable>();
 	CDItemComponentTable* itemComponentTable = CDClientManager::GetTable<CDItemComponentTable>();
@@ -214,7 +215,7 @@ void Loot::GiveLoot(Entity* player, std::unordered_map<LOT, int32_t>& result, eL
 	}
 }
 
-void Loot::GiveActivityLoot(Entity* player, const LWOOBJID source, uint32_t activityID, int32_t rating) {
+void Loot::GiveActivityLoot(Entity* player, Entity* source, uint32_t activityID, int32_t rating) {
 	CDActivityRewardsTable* activityRewardsTable = CDClientManager::GetTable<CDActivityRewardsTable>();
 	std::vector<CDActivityRewards> activityRewards = activityRewardsTable->Query([activityID](CDActivityRewards entry) { return (entry.objectTemplate == activityID); });
 
@@ -248,7 +249,7 @@ void Loot::GiveActivityLoot(Entity* player, const LWOOBJID source, uint32_t acti
 	character->SetCoins(character->GetCoins() + coins, eLootSourceType::ACTIVITY);
 }
 
-void Loot::DropLoot(Entity* player, const LWOOBJID source, uint32_t matrixIndex, uint32_t minCoins, uint32_t maxCoins) {
+void Loot::DropLoot(Entity* player, Entity* killedObject, uint32_t matrixIndex, uint32_t minCoins, uint32_t maxCoins) {
 	player = player->GetOwner(); // if the owner is overwritten, we collect that here
 
 	auto* inventoryComponent = player->GetComponent<InventoryComponent>();
@@ -258,10 +259,10 @@ void Loot::DropLoot(Entity* player, const LWOOBJID source, uint32_t matrixIndex,
 
 	std::unordered_map<LOT, int32_t> result = RollLootMatrix(player, matrixIndex);
 
-	DropLoot(player, source, result, minCoins, maxCoins);
+	DropLoot(player, killedObject, result, minCoins, maxCoins);
 }
 
-void Loot::DropLoot(Entity* player, const LWOOBJID source, std::unordered_map<LOT, int32_t>& result, uint32_t minCoins, uint32_t maxCoins) {
+void Loot::DropLoot(Entity* player, Entity* killedObject, std::unordered_map<LOT, int32_t>& result, uint32_t minCoins, uint32_t maxCoins) {
 	player = player->GetOwner(); // if the owner is overwritten, we collect that here
 
 	auto* inventoryComponent = player->GetComponent<InventoryComponent>();
@@ -269,11 +270,9 @@ void Loot::DropLoot(Entity* player, const LWOOBJID source, std::unordered_map<LO
 	if (!inventoryComponent)
 		return;
 
-	GameMessages::GetPosition posMsg;
-	posMsg.target = source;
-	posMsg.Send();
+	const auto spawnPosition = killedObject->GetPosition();
 
-	const auto spawnPosition = posMsg.pos;
+	const auto source = killedObject->GetObjectID();
 
 	for (const auto& pair : result) {
 		for (int i = 0; i < pair.second; ++i) {
@@ -286,7 +285,7 @@ void Loot::DropLoot(Entity* player, const LWOOBJID source, std::unordered_map<LO
 	GameMessages::SendDropClientLoot(player, source, LOT_NULL, coins, spawnPosition);
 }
 
-void Loot::DropActivityLoot(Entity* player, const LWOOBJID source, uint32_t activityID, int32_t rating) {
+void Loot::DropActivityLoot(Entity* player, Entity* source, uint32_t activityID, int32_t rating) {
 	CDActivityRewardsTable* activityRewardsTable = CDClientManager::GetTable<CDActivityRewardsTable>();
 	std::vector<CDActivityRewards> activityRewards = activityRewardsTable->Query([activityID](CDActivityRewards entry) { return (entry.objectTemplate == activityID); });