fix buffer read/write

buffer.h

@@ -0,0 +1,37 @@
+#ifndef BUFFER_H
+#define BUFFER_H
+
+#include <cstring>
+#include <vector>
+
+inline void buffer_read_block(unsigned char*& p, void* dest, size_t size) {
+	std::memcpy(dest, p, size);
+	p += size;
+}
+template<typename T>
+inline T buffer_read(unsigned char*& p) {
+	T ret{};
+	buffer_read_block(p, &ret, sizeof(T));
+	return ret;
+}
+
+inline void buffer_write_block(unsigned char*& p, const void* src, size_t size) {
+	std::memcpy(p, src, size);
+	p += size;
+}
+template<typename T>
+inline void buffer_write(unsigned char*& p, T value) {
+	buffer_write_block(p, &value,sizeof(T));
+}
+
+inline void vector_write_block(std::vector<unsigned char>& buffer, const void* src, size_t size) {
+	const auto len = buffer.size();
+	buffer.resize(len + size);
+	std::memcpy(&buffer[len], src, size);
+}
+template<typename T>
+inline void vector_write(std::vector<unsigned char>& buffer, T value) {
+	vector_write_block(buffer, &value, sizeof(T));
+}
+
+#endif //BUFFER_H

card.cpp

@@ -12,6 +12,7 @@
 #include "group.h"
 #include "interpreter.h"
 #include "ocgapi.h"
+#include "buffer.h"
 #include <algorithm>
 
 const std::unordered_map<uint32, uint32> card::second_code = {
@@ -145,17 +146,16 @@ card::card(duel* pd) {
 	spsummon_code = 0;
 	current.controler = PLAYER_NONE;
 }
-inline void update_cache(uint32& tdata, uint32& cache, int32*& p, uint32& query_flag, const uint32 flag) {
+inline void update_cache(uint32& tdata, uint32& cache, byte*& p, uint32& query_flag, const uint32 flag) {
 	if (tdata != cache) {
 		cache = tdata;
-		*p = tdata;
-		++p;
+		buffer_write<uint32_t>(p, tdata);
 	}
 	else
 		query_flag &= ~flag;
 }
 int32 card::get_infos(byte* buf, uint32 query_flag, int32 use_cache) {
-	int32* p = (int32*)buf;
+	byte* p = buf;
 	std::pair<int32, int32> atk_def(-10, -10);
 	std::pair<int32, int32> base_atk_def(-10, -10);
 	if ((query_flag & QUERY_ATTACK) || (query_flag & QUERY_DEFENSE)) {
@@ -165,15 +165,13 @@ int32 card::get_infos(byte* buf, uint32 query_flag, int32 use_cache) {
 		base_atk_def = get_base_atk_def();
 	}
 	//first 8 bytes: data length, query flag
-	p += 2;
+	p += 8;
 	if (query_flag & QUERY_CODE) {
-		*p = data.code;
-		++p;
+		buffer_write<uint32_t>(p, data.code);
 	}
 	if (query_flag & QUERY_POSITION) {
 		uint32 tdata = get_info_location();
-		*p = tdata;
-		++p;
+		buffer_write<uint32_t>(p, tdata);
 		if (q_cache.info_location != tdata) {
 			q_cache.clear_cache();
 			q_cache.info_location = tdata;
@@ -182,59 +180,54 @@ int32 card::get_infos(byte* buf, uint32 query_flag, int32 use_cache) {
 	}
 	if(!use_cache) {
 		if (query_flag & QUERY_ALIAS) {
-			*p = get_code();
-			q_cache.current_code = *p;
-			++p;
+			uint32 tdata = get_code();
+			buffer_write<uint32_t>(p, tdata);
+			q_cache.current_code = tdata;
 		}
 		if (query_flag & QUERY_TYPE) {
-			*p = get_type();
-			q_cache.type = *p;
-			++p;
+			uint32 tdata = get_type();
+			buffer_write<uint32_t>(p, tdata);
+			q_cache.type = tdata;
 		}
 		if (query_flag & QUERY_LEVEL) {
-			*p = get_level();
-			q_cache.level = *p;
-			++p;
+			uint32 tdata = get_level();
+			buffer_write<uint32_t>(p, tdata);
+			q_cache.level = tdata;
 		}
 		if (query_flag & QUERY_RANK) {
-			*p = get_rank();
-			q_cache.rank = *p;
-			++p;
+			uint32 tdata = get_rank();
+			buffer_write<uint32_t>(p, tdata);
+			q_cache.rank = tdata;
 		}
 		if (query_flag & QUERY_ATTRIBUTE) {
-			*p = get_attribute();
-			q_cache.attribute = *p;
-			++p;
+			uint32 tdata = get_attribute();
+			buffer_write<uint32_t>(p, tdata);
+			q_cache.attribute = tdata;
 		}
 		if (query_flag & QUERY_RACE) {
-			*p = get_race();
-			q_cache.race = *p;
-			++p;
+			uint32 tdata = get_race();
+			buffer_write<uint32_t>(p, tdata);
+			q_cache.race = tdata;
 		}
 		if (query_flag & QUERY_ATTACK) {
-			*p = atk_def.first;
+			buffer_write<int32_t>(p, atk_def.first);
 			q_cache.attack = atk_def.first;
-			++p;
 		}
 		if (query_flag & QUERY_DEFENSE) {
-			*p = atk_def.second;
+			buffer_write<int32_t>(p, atk_def.second);
 			q_cache.defense = atk_def.second;
-			++p;
 		}
 		if (query_flag & QUERY_BASE_ATTACK) {
-			*p = base_atk_def.first;
+			buffer_write<int32_t>(p, base_atk_def.first);
 			q_cache.base_attack = base_atk_def.first;
-			++p;
 		}
 		if (query_flag & QUERY_BASE_DEFENSE) {
-			*p = base_atk_def.second;
+			buffer_write<int32_t>(p, base_atk_def.second);
 			q_cache.base_defense = base_atk_def.second;
-			++p;
 		}
 		if (query_flag & QUERY_REASON) {
-			*p = current.reason;
+			buffer_write<uint32_t>(p, current.reason);
 			q_cache.reason = current.reason;
-			++p;
 		}
 	}
 	else {
@@ -265,35 +258,31 @@ int32 card::get_infos(byte* buf, uint32 query_flag, int32 use_cache) {
 		if((query_flag & QUERY_ATTACK)) {
 			if (atk_def.first != q_cache.attack) {
 				q_cache.attack = atk_def.first;
-				*p = atk_def.first;
-				++p;
+				buffer_write<int32_t>(p, atk_def.first);
 			}
 			else
 				query_flag &= ~QUERY_ATTACK;
 		}
 		if((query_flag & QUERY_DEFENSE)) {
 			if (atk_def.second != q_cache.defense) {
 				q_cache.defense = atk_def.second;
-				*p = atk_def.second;
-				++p;
+				buffer_write<int32_t>(p, atk_def.second);
 			}
 			else
 				query_flag &= ~QUERY_DEFENSE;
 		}
 		if((query_flag & QUERY_BASE_ATTACK)) {
 			if (base_atk_def.first != q_cache.base_attack) {
 				q_cache.base_attack = base_atk_def.first;
-				*p = base_atk_def.first;
-				++p;
+				buffer_write<int32_t>(p, base_atk_def.first);
 			}
 			else
 				query_flag &= ~QUERY_BASE_ATTACK;
 		}
 		if((query_flag & QUERY_BASE_DEFENSE)) {
 			if (base_atk_def.second != q_cache.base_defense) {
 				q_cache.base_defense = base_atk_def.second;
-				*p = base_atk_def.second;
-				++p;
+				buffer_write<int32_t>(p, base_atk_def.second);
 			}
 			else
 				query_flag &= ~QUERY_BASE_DEFENSE;
@@ -304,73 +293,68 @@ int32 card::get_infos(byte* buf, uint32 query_flag, int32 use_cache) {
 		}
 	}
 	if (query_flag & QUERY_REASON_CARD) {
-		*p = current.reason_card ? current.reason_card->get_info_location() : 0;
-		++p;
+		uint32 tdata = current.reason_card ? current.reason_card->get_info_location() : 0;
+		buffer_write<uint32_t>(p, tdata);
 	}
 	if(query_flag & QUERY_EQUIP_CARD) {
 		if (equiping_target) {
-			*p = equiping_target->get_info_location();
-			++p;
+			uint32 tdata = equiping_target->get_info_location();
+			buffer_write<uint32_t>(p, tdata);
 		}
 		else
 			query_flag &= ~QUERY_EQUIP_CARD;
 	}
 	if(query_flag & QUERY_TARGET_CARD) {
-		*p = (int32)effect_target_cards.size();
-		++p;
+		buffer_write<int32_t>(p, (int32_t)effect_target_cards.size());
 		for (auto& pcard : effect_target_cards) {
-			*p = pcard->get_info_location();
-			++p;
+			uint32 tdata = pcard->get_info_location();
+			buffer_write<uint32_t>(p, tdata);
 		}
 	}
 	if(query_flag & QUERY_OVERLAY_CARD) {
-		*p = (int32)xyz_materials.size();
-		++p;
+		buffer_write<int32_t>(p, (int32_t)xyz_materials.size());
 		for (auto& xcard : xyz_materials) {
-			*p = xcard->data.code;
-			++p;
+			buffer_write<uint32_t>(p, xcard->data.code);
 		}
 	}
 	if(query_flag & QUERY_COUNTERS) {
-		*p = (int32)counters.size();
-		++p;
+		buffer_write<int32_t>(p, (int32_t)counters.size());
 		for (const auto& cmit : counters) {
-			*p = cmit.first + ((cmit.second[0] + cmit.second[1]) << 16);
-			++p;
+			int32 tdata = cmit.first + ((cmit.second[0] + cmit.second[1]) << 16);
+			buffer_write<int32_t>(p, tdata);
 		}
 	}
 	if (query_flag & QUERY_OWNER) {
-		*p = owner;
-		++p;
+		int32 tdata = owner;
+		buffer_write<int32_t>(p, tdata);
 	}
 	if(query_flag & QUERY_STATUS) {
 		uint32 tdata = status & (STATUS_DISABLED | STATUS_FORBIDDEN | STATUS_PROC_COMPLETE);
 		if(!use_cache || (tdata != q_cache.status)) {
 			q_cache.status = tdata;
-			*p = tdata;
-			++p;
+			buffer_write<uint32_t>(p, tdata);
 		}
 		else
 			query_flag &= ~QUERY_STATUS;
 	}
 	if(!use_cache) {
 		if (query_flag & QUERY_LSCALE) {
-			*p = get_lscale();
-			q_cache.lscale = *p;
-			++p;
+			uint32 tdata = get_lscale();
+			buffer_write<uint32_t>(p, tdata);
+			q_cache.lscale = tdata;
 		}
 		if (query_flag & QUERY_RSCALE) {
-			*p = get_rscale();
-			q_cache.rscale = *p;
-			++p;
+			uint32 tdata = get_rscale();
+			buffer_write<uint32_t>(p, tdata);
+			q_cache.rscale = tdata;
 		}
 		if(query_flag & QUERY_LINK) {
-			*p = get_link();
-			q_cache.link = *p;
-			++p;
-			*p = get_link_marker();
-			q_cache.link_marker = *p;
-			++p;
+			uint32 tdata = get_link();
+			buffer_write<uint32_t>(p, tdata);
+			q_cache.link = tdata;
+			tdata = get_link_marker();
+			buffer_write<uint32_t>(p, tdata);
+			q_cache.link_marker = tdata;
 		}
 	}
 	else {
@@ -387,22 +371,18 @@ int32 card::get_infos(byte* buf, uint32 query_flag, int32 use_cache) {
 			uint32 link_marker = get_link_marker();
 			if((link != q_cache.link) || (link_marker != q_cache.link_marker)) {
 				q_cache.link = link;
-				*p = (int32)link;
-				++p;
+				buffer_write<uint32_t>(p, link);
 				q_cache.link_marker = link_marker;
-				*p = (int32)link_marker;
-				++p;
+				buffer_write<uint32_t>(p, link_marker);
 			}
 			else
 				query_flag &= ~QUERY_LINK;
 		}
 	}
-	int32* finalize = (int32*)buf;
-	*finalize = (byte*)p - buf;
-	++finalize;
-	*finalize = query_flag;
-	++finalize;
-	return (byte*)p - buf;
+	byte* finalize = buf;
+	buffer_write<int32_t>(finalize, p - buf);
+	buffer_write<uint32_t>(finalize, query_flag);
+	return (int32)(p - buf);
 }
 uint32 card::get_info_location() {
 	if(overlay_target) {

duel.cpp

@@ -13,14 +13,7 @@
 #include "effect.h"
 #include "group.h"
 #include "ocgapi.h"
-
-inline void write_buffer_vector(std::vector<byte>& buffer, const void* data, int size) {
-	if (size > 0) {
-		const auto len = buffer.size();
-		buffer.resize(len + size);
-		std::memcpy(&buffer[len], data, size);
-	}
-}
+#include "buffer.h"
 
 duel::duel() {
 	lua = new interpreter(this);
@@ -122,16 +115,16 @@ void duel::restore_assumes() {
 	assumes.clear();
 }
 void duel::write_buffer(const void* data, int size) {
-	write_buffer_vector(message_buffer, data, size);
+	vector_write_block(message_buffer, data, size);
 }
 void duel::write_buffer32(uint32 value) {
-	write_buffer(&value, sizeof(value));
+	vector_write<uint32_t>(message_buffer, value);
 }
 void duel::write_buffer16(uint16 value) {
-	write_buffer(&value, sizeof(value));
+	vector_write<uint16_t>(message_buffer, value);
 }
 void duel::write_buffer8(uint8 value) {
-	write_buffer(&value, sizeof(value));
+	vector_write<unsigned char>(message_buffer, value);
 }
 void duel::clear_buffer() {
 	message_buffer.clear();