Const qualify type on write

Author: Chaosvex

schemas/world/types.json

@@ -124,7 +124,7 @@
 		"ChatType": {
 			"kind": "enum_class",
 			"underlying": "uint8",
-			"cpp_namespace": "ember::protocol::server",
+			"cpp_namespace": "ember::protocol",
 			"values": {
 				"say":                 0,
 				"party":               1,
@@ -166,7 +166,7 @@
 		"PlayerChatTag": {
 			"kind": "enum_class",
 			"underlying": "uint8",
-			"cpp_namespace": "ember::protocol::server",
+			"cpp_namespace": "ember::protocol",
 			"values": {
 				"tag_none": 0,
 				"tag_afk":  1,
@@ -177,7 +177,7 @@
 		"StatusID": {
 			"kind": "enum_class",
 			"underlying": "uint8",
-			"cpp_namespace": "ember::protocol::server",
+			"cpp_namespace": "ember::protocol",
 			"values": {
 				"none":        0,
 				"wait_queue":  1,
@@ -2363,18 +2363,6 @@
 				"sixty":    5
 			}
 		},
-		"StatusId": {
-			"kind": "enum_class",
-			"underlying": "uint8",
-			"cpp_namespace": "ember::protocol",
-			"values": {
-				"none":        0,
-				"wait_queue":  1,
-				"wait_join":   2,
-				"in_progress": 3,
-				"wait_leave":  4
-			}
-		},
 		"Emote": {
 			"kind": "external",
 			"include": "dbcs/MemoryDefs.h",

src/libs/protocol/include/protocol/Packets.h

@@ -35,7 +35,6 @@
 #include <protocol/server/Weather.h>
 #include <protocol/server/AccountDataTimes.h>
 #include <protocol/server/GenericMove.h>
-#include <protocol/server/MessageChat.h>
 #include <protocol/server/TriggerCinematic.h>
 #include <protocol/server/StandStateUpdate.h>
 #include <protocol/server/Notification.h>
@@ -86,7 +85,6 @@ using smsg_weather                    = ServerPacket<ServerOpcode::smsg_weather,
 using smsg_account_data_times         = ServerPacket<ServerOpcode::smsg_account_data_times,         server::AccountDataTimes>;
 using smsg_channel_notify             = ServerPacket<ServerOpcode::smsg_channel_notify,             server::ChannelNotify>;
 using msg_move_set_facing_s           = ServerPacket<ServerOpcode::msg_move_set_facing,             server::GenericMove>;
-using smsg_messagechat                = ServerPacket<ServerOpcode::smsg_messagechat,                server::MessageChat>;
 using smsg_trigger_cinematic          = ServerPacket<ServerOpcode::smsg_trigger_cinematic,          server::TriggerCinematic>;
 using smsg_standstate_update          = ServerPacket<ServerOpcode::smsg_standstate_update,          server::StandStateUpdate>;
 using smsg_notification               = ServerPacket<ServerOpcode::smsg_notification,               server::Notification>;

src/libs/protocol/include/protocol/server/MessageChat.h

@@ -1,76 +1 @@
-/*
- * Copyright (c) 2026 Ember
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/.
- */
-
-#pragma once
-
-#include <protocol/Concepts.h>
-#include <protocol/StreamResult.h>
-#include <protocol/ResultCodes.h>
-#include <protocol/server/ChatTypes.h>
-#include <stdexcept>
-#include <cstdint>
-
-namespace ember::protocol::server {
-
-struct MessageChat final {
-	ChatType type;
-	std::uint32_t language;
-	std::string message;
-	std::uint64_t speech_bubble_attr;
-	std::uint64_t chat_name_attr;
-	std::string channel_name;
-	std::uint32_t player_rank;
-	std::uint64_t player_guid;
-	std::string monster_name;
-	PlayerChatTag player_tag;
-
-	StreamResult read_from_stream(le_stream auto& stream) {
-		stream >> type;
-		stream >> language;
-
-		if(type == SAY || type == YELL || type == PARTY) {
-			stream >> speech_bubble_attr;
-			stream >> chat_name_attr;
-		} else if(type == CHANNEL) {
-			stream >> spark::io::prefixed_null_terminated<std::string, std::uint32_t>(channel_name);
-			stream >> player_rank;
-			stream >> player_guid;
-		}
-
-		stream >> spark::io::prefixed_null_terminated<std::string, std::uint32_t>(message);
-		stream >> player_tag;
-		return stream? StreamResult::success : StreamResult::failed;
-	}
-
-	StreamResult write_to_stream(le_stream auto& stream) const {
-		stream << type;
-		stream << language;
-
-		if(type == MONSTER_WHISPER) {
-			stream << monster_name;
-			stream << std::uint64_t(0);
-		} else if(type == SAY || type == YELL || type == PARTY) {
-			stream << speech_bubble_attr;
-			stream << chat_name_attr;
-		} else if(type == WHISPER) {
-			//stream << destination;
-		} else if(type == CHANNEL) {
-			stream << spark::io::null_terminated(channel_name);
-			stream << player_rank;
-			stream << player_guid;
-		} else {
-			stream << player_guid;
-		}
-
-		stream << spark::io::prefixed_null_terminated<const std::string>(message);
-		stream << player_tag;
-		return stream? StreamResult::success : StreamResult::failed;
-	}
-};
-
-} // server, protocol, ember
+#include <generated/server/MessageChat.h>

src/realm/states/WorldEnter.cpp

@@ -22,6 +22,7 @@
 #include <protocol/client/ZoneUpdate.h>
 #include <protocol/client/ItemQuerySingle.h>
 #include <protocol/server/BattlefieldStatus.h>
+#include <protocol/server/MessageChat.h>
 #include <chrono>
 #include <format>
 #include <span>
@@ -59,7 +60,7 @@ void initiate_player_login(ClientContext& ctx, const PlayerLogin& event) {
     state_ctx.character_id = event.character_id_;
 
 	protocol::smsg_trigger_cinematic cinematic;
-	cinematic->sequence_id = protocol::CinematicSequence::human;
+	cinematic->sequence_id = 84; // temp
 	ctx.send(cinematic);
 
 	protocol::smsg_login_verify_world verify_world;
@@ -93,10 +94,10 @@ void initiate_player_login(ClientContext& ctx, const PlayerLogin& event) {
 
 	protocol::smsg_messagechat motd;
 	motd->language = 0;
-	motd->type = protocol::server::SYSTEM;
+	motd->type = protocol::ChatType::system;
 	motd->message = "Welcome to a hacked together Ember test.";
 	motd->player_guid = 0;
-	motd->player_tag = protocol::server::TAG_NONE;
+	motd->player_tag = protocol::PlayerChatTag::tag_none;
 	ctx.send(motd);
 }
 
@@ -407,7 +408,7 @@ void handle_messagechat(ClientContext& ctx) {
 	response->message = packet->message;
 	response->language = 0; // universal, we don't have any learned skills in this test
 	response->player_guid = packed_guid;
-	response->player_tag = protocol::server::TAG_GM;
+	response->player_tag = protocol::PlayerChatTag::tag_gm;
 
 	if(packet->type == protocol::client::CHANNEL) {
 		response->channel_name = packet->destination;
@@ -561,10 +562,10 @@ void log_msg(ClientContext& ctx, const LogRedirect& event) {
 
 	protocol::smsg_messagechat msg;
 	msg->language = 0;
-	msg->type = protocol::server::SYSTEM;
+	msg->type = protocol::ChatType::system;
 	msg->message = event.message;
 	msg->player_guid = 0;
-	msg->player_tag = protocol::server::TAG_NONE;
+	msg->player_tag = protocol::PlayerChatTag::tag_none;
 	ctx.send(msg);
 }
 
@@ -578,16 +579,16 @@ void system_msg(ClientContext& ctx, const SystemMessage& event) {
 	msg->language = 0;
 
 	if(event.type == SystemMessage::Type::whisper) {
-		msg->type = protocol::server::MONSTER_WHISPER;
-		msg->monster_name = "System";
+		msg->type = protocol::ChatType::monster_whisper;
+		msg->channel_name = "System";
 		msg->message = event.message;
 	} else {
-		msg->type = protocol::server::SYSTEM;
+		msg->type = protocol::ChatType::system;
 		msg->message = std::format("[SERVER] {}", event.message);
 	}
 
 	msg->player_guid = 0;
-	msg->player_tag = protocol::server::TAG_NONE;
+	msg->player_tag = protocol::PlayerChatTag::tag_none;
 	ctx.send(msg);
 }
 

src/tools/protogen/Generator.cpp

@@ -23,6 +23,12 @@
 
 namespace ember::protogen {
 
+enum class Dir {
+	Read,
+	Write,
+	Both
+};
+
 struct WalkState {
 	std::vector<std::string> members;
 	std::set<std::string> includes;
@@ -141,7 +147,7 @@ std::string cpp_type_name(const std::string& type, const TypeRegistry& reg) {
 	return leaf;
 }
 
-std::string string_adaptor_expr(const jsoncons::json& type_def, std::string_view expr) {
+std::string string_adaptor_expr(const jsoncons::json& type_def, std::string_view expr, Dir dir) {
 	const auto encoding = type_def["encoding"].as<std::string>();
 
 	if(encoding == "null_terminated") {
@@ -150,13 +156,14 @@ std::string string_adaptor_expr(const jsoncons::json& type_def, std::string_view
 
 	const auto length_type = type_def["length_type"].as<std::string>();
 	const auto length_cpp = cpp_type_for_primitive(length_type);
+	std::string_view qualifier = (dir == Dir::Write)? "const " : "";
 
 	if(encoding == "prefixed") {
-		return std::format("spark::io::prefixed<std::string, {}>({})", length_cpp, expr);
+		return std::format("spark::io::prefixed<{}std::string, {}>({})", qualifier, length_cpp, expr);
 	}
 
 	if(encoding == "prefixed_null_terminated") {
-		return std::format("spark::io::prefixed_null_terminated<std::string, {}>({})", length_cpp, expr);
+		return std::format("spark::io::prefixed_null_terminated<{}std::string, {}>({})", qualifier, length_cpp, expr);
 	}
 
 	throw std::runtime_error(
@@ -262,8 +269,6 @@ std::string cpp_element_type(const std::string& type, const TypeRegistry& reg) {
 	return cpp_type_name(type, reg);
 }
 
-enum class Dir { Read, Write, Both };
-
 // Emits stream ops for a single scalar value. `dir` controls which of
 // `read_ops` / `write_ops` are appended to — helpers that build their own
 // loops (e.g. until_end, which has asymmetric read vs write) use Read /
@@ -370,13 +375,16 @@ void emit_scalar_stream_op(const std::string& name, const std::string& type,
 	}
 
 	if(kind == "string") {
-		const auto adaptor = string_adaptor_expr(*def, qualified);
 		if(do_read) {
+			const auto adaptor = string_adaptor_expr(*def, qualified, Dir::Read);
 			state.read_ops.emplace_back(std::format("{}stream >> {};", indent(state.read_tab), adaptor));
 		}
+
 		if(do_write) {
+			const auto adaptor = string_adaptor_expr(*def, qualified, Dir::Write);
 			state.write_ops.emplace_back(std::format("{}stream << {};", indent(state.write_tab), adaptor));
 		}
+
 		state.includes.insert("spark/buffers/StringAdaptors.h");
 		return;
 	}