update gframe

Classes/gframe/bufferio.h

@@ -7,35 +7,35 @@
 
 class BufferIO {
 public:
-	inline static int ReadInt32(char*& p) {
+	inline static int ReadInt32(unsigned char*& p) {
 		int ret = *(int*)p;
 		p += 4;
 		return ret;
 	}
-	inline static short ReadInt16(char*& p) {
+	inline static short ReadInt16(unsigned char*& p) {
 		short ret = *(short*)p;
 		p += 2;
 		return ret;
 	}
-	inline static char ReadInt8(char*& p) {
+	inline static char ReadInt8(unsigned char*& p) {
 		char ret = *(char*)p;
 		p++;
 		return ret;
 	}
-	inline static unsigned char ReadUInt8(char*& p) {
+	inline static unsigned char ReadUInt8(unsigned char*& p) {
 		unsigned char ret = *(unsigned char*)p;
 		p++;
 		return ret;
 	}
-	inline static void WriteInt32(char*& p, int val) {
+	inline static void WriteInt32(unsigned char*& p, int val) {
 		(*(int*)p) = val;
 		p += 4;
 	}
-	inline static void WriteInt16(char*& p, short val) {
+	inline static void WriteInt16(unsigned char*& p, short val) {
 		(*(short*)p) = val;
 		p += 2;
 	}
-	inline static void WriteInt8(char*& p, char val) {
+	inline static void WriteInt8(unsigned char*& p, char val) {
 		*p = val;
 		p++;
 	}

Classes/gframe/client_card.cpp

@@ -57,7 +57,7 @@ void ClientCard::SetCode(int code) {
 	} else
 		this->code = code;
 }
-void ClientCard::UpdateInfo(char* buf) {
+void ClientCard::UpdateInfo(unsigned char* buf) {
 	int flag = BufferIO::ReadInt32(buf);
 	if(flag == 0)
 		return;
@@ -213,10 +213,10 @@ bool ClientCard::client_card_sort(ClientCard* c1, ClientCard* c2) {
 		else return c1->sequence < c2->sequence;
 	else {
 		if(c1->location & (LOCATION_DECK | LOCATION_GRAVE | LOCATION_REMOVED | LOCATION_EXTRA)) {
-			auto it1 = std::find_if(mainGame->dField.chains.rbegin(), mainGame->dField.chains.rend(), [c1](const ChainInfo& ch) {
+			auto it1 = std::find_if(mainGame->dField.chains.rbegin(), mainGame->dField.chains.rend(), [c1](const auto& ch) {
 				return c1 == ch.chain_card || ch.target.find(c1) != ch.target.end();
 				});
-			auto it2 = std::find_if(mainGame->dField.chains.rbegin(), mainGame->dField.chains.rend(), [c2](const ChainInfo& ch) {
+			auto it2 = std::find_if(mainGame->dField.chains.rbegin(), mainGame->dField.chains.rend(), [c2](const auto& ch) {
 				return c2 == ch.chain_card || ch.target.find(c2) != ch.target.end();
 				});
 			if(it1 != mainGame->dField.chains.rend() || it2 != mainGame->dField.chains.rend()) {

Classes/gframe/client_card.h

@@ -112,7 +112,7 @@ public:
 
 	ClientCard();
 	void SetCode(int code);
-	void UpdateInfo(char* buf);
+	void UpdateInfo(unsigned char* buf);
 	void ClearTarget();
 	static bool client_card_sort(ClientCard* c1, ClientCard* c2);
 	static bool deck_sort_lv(code_pointer l1, code_pointer l2);

Classes/gframe/client_field.cpp

@@ -47,7 +47,7 @@ ClientField::ClientField() {
 		mzone[p].resize(7, 0);
 		szone[p].resize(8, 0);
 	}
-	rnd.reset(std::random_device()());
+	rnd.reset((uint_fast32_t)std::random_device()());
 }
 void ClientField::Clear() {
 	for(int i = 0; i < 2; ++i) {
@@ -318,13 +318,13 @@ ClientCard* ClientField::RemoveCard(int controler, int location, int sequence) {
 	RefreshCardCountDisplay();
 	return pcard;
 }
-void ClientField::UpdateCard(int controler, int location, int sequence, char* data) {
+void ClientField::UpdateCard(int controler, int location, int sequence, unsigned char* data) {
 	ClientCard* pcard = GetCard(controler, location, sequence);
 	if(pcard)
 		pcard->UpdateInfo(data + 4);
 	RefreshCardCountDisplay();
 }
-void ClientField::UpdateFieldCard(int controler, int location, char* data) {
+void ClientField::UpdateFieldCard(int controler, int location, unsigned char* data) {
 	std::vector<ClientCard*>* lst = 0;
 	switch(location) {
 	case LOCATION_DECK:
@@ -1068,18 +1068,18 @@ void ClientField::GetCardLocation(ClientCard* pcard, irr::core::vector3df* t, ir
 			return;
 		}
 		int oseq = pcard->overlayTarget->sequence;
-        int mseq = (sequence < MAX_LAYER_COUNT) ? sequence : (MAX_LAYER_COUNT - 1);
-        if (pcard->overlayTarget->controler == 0) {
+		int mseq = (sequence < MAX_LAYER_COUNT) ? sequence : (MAX_LAYER_COUNT - 1);
+		if (pcard->overlayTarget->controler == 0) {
 			t->X = (matManager.vFieldMzone[0][oseq][0].Pos.X + matManager.vFieldMzone[0][oseq][1].Pos.X) / 2 - 0.12f + 0.06f * mseq;
 			t->Y = (matManager.vFieldMzone[0][oseq][0].Pos.Y + matManager.vFieldMzone[0][oseq][2].Pos.Y) / 2 + 0.05f;
-            t->Z = overlay_buttom + mseq * material_height;
-            r->X = 0.0f;
+			t->Z = overlay_buttom + mseq * material_height;
+			r->X = 0.0f;
 			r->Y = 0.0f;
 			r->Z = 0.0f;
 		} else {
 			t->X = (matManager.vFieldMzone[1][oseq][0].Pos.X + matManager.vFieldMzone[1][oseq][1].Pos.X) / 2 + 0.12f - 0.06f * mseq;
 			t->Y = (matManager.vFieldMzone[1][oseq][0].Pos.Y + matManager.vFieldMzone[1][oseq][2].Pos.Y) / 2 - 0.05f;
-            t->Z = overlay_buttom + mseq * material_height;
+			t->Z = overlay_buttom + mseq * material_height;
 			r->X = 0.0f;
 			r->Y = 0.0f;
 			r->Z = 3.1415926f;

Classes/gframe/client_field.h

@@ -96,8 +96,8 @@ public:
 	ClientCard* GetCard(int controler, int location, int sequence, int sub_seq = 0);
 	void AddCard(ClientCard* pcard, int controler, int location, int sequence);
 	ClientCard* RemoveCard(int controler, int location, int sequence);
-	void UpdateCard(int controler, int location, int sequence, char* data);
-	void UpdateFieldCard(int controler, int location, char* data);
+	void UpdateCard(int controler, int location, int sequence, unsigned char* data);
+	void UpdateFieldCard(int controler, int location, unsigned char* data);
 	void ClearCommandFlag();
 	void ClearSelect();
 	void ClearChainSelect();

Classes/gframe/config.h

@@ -14,8 +14,8 @@
 #endif
 #ifdef _WIN32
 
-#include <WinSock2.h>
 #define NOMINMAX
+#include <WinSock2.h>
 #include <windows.h>
 #include <ws2tcpip.h>
 
@@ -90,7 +90,6 @@ inline int _wtoi(const wchar_t * s) {
 #include <iostream>
 #include <stdio.h>
 #include <stdlib.h>
-#include <memory.h>
 #include <time.h>
 #include <thread>
 #include <mutex>
@@ -120,6 +119,7 @@ using namespace video;
 using namespace io;
 using namespace gui;
 using namespace os;
+typedef int BOOL;
 
 extern const unsigned short PRO_VERSION;
 extern int enable_log;

Classes/gframe/deck_con.cpp

@@ -82,7 +82,7 @@ void DeckBuilder::Initialize() {
 	mainGame->btnSideReload->setVisible(false);
 	filterList = &deckManager._lfList[mainGame->gameConf.use_lflist ? mainGame->gameConf.default_lflist : deckManager._lfList.size() - 1].content;
 	ClearSearch();
-	rnd.reset((unsigned int)time(nullptr));
+	rnd.reset((uint_fast32_t)time(nullptr));
 	mouse_pos.set(0, 0);
 	hovered_code = 0;
 	hovered_pos = 0;
@@ -720,8 +720,8 @@ bool DeckBuilder::OnEvent(const irr::SEvent& event) {
 				}
 				mainGame->ClearCardInfo();
                 mainGame->imgChat->setVisible(true);
-				char deckbuf[1024];
-				char* pdeck = deckbuf;
+				unsigned char deckbuf[1024];
+				auto pdeck = deckbuf;
 				BufferIO::WriteInt32(pdeck, deckManager.current_deck.main.size() + deckManager.current_deck.extra.size());
 				BufferIO::WriteInt32(pdeck, deckManager.current_deck.side.size());
 				for(size_t i = 0; i < deckManager.current_deck.main.size(); ++i)

Classes/gframe/duelclient.cpp

@@ -21,14 +21,14 @@ unsigned char DuelClient::selftype = 0;
 bool DuelClient::is_host = false;
 event_base* DuelClient::client_base = 0;
 bufferevent* DuelClient::client_bev = 0;
-char DuelClient::duel_client_read[0x2000];
-char DuelClient::duel_client_write[0x2000];
+unsigned char DuelClient::duel_client_read[0x2000];
+unsigned char DuelClient::duel_client_write[0x2000];
 bool DuelClient::is_closing = false;
 bool DuelClient::is_swapping = false;
 int DuelClient::select_hint = 0;
 int DuelClient::select_unselect_hint = 0;
 int DuelClient::last_select_hint = 0;
-char DuelClient::last_successful_msg[0x2000];
+unsigned char DuelClient::last_successful_msg[0x2000];
 unsigned int DuelClient::last_successful_msg_length = 0;
 wchar_t DuelClient::event_string[256];
 mt19937 DuelClient::rnd;
@@ -60,7 +60,7 @@ bool DuelClient::StartClient(unsigned int ip, unsigned short port, bool create_g
 		return false;
 	}
 	connect_state = 0x1;
-	rnd.reset((unsigned int)time(nullptr));
+	rnd.reset((uint_fast32_t)std::random_device()());
 	if(!create_game) {
 		timeval timeout = {5, 0};
 		event* resp_event = event_new(client_base, 0, EV_TIMEOUT, ConnectTimeout, 0);

Classes/gframe/duelclient.h

@@ -27,14 +27,14 @@ private:
 	static bool is_host;
 	static event_base* client_base;
 	static bufferevent* client_bev;
-	static char duel_client_read[0x2000];
-	static char duel_client_write[0x2000];
+	static unsigned char duel_client_read[0x2000];
+	static unsigned char duel_client_write[0x2000];
 	static bool is_closing;
 	static bool is_swapping;
 	static int select_hint;
 	static int select_unselect_hint;
 	static int last_select_hint;
-	static char last_successful_msg[0x2000];
+	static unsigned char last_successful_msg[0x2000];
 	static unsigned int last_successful_msg_length;
 	static wchar_t event_string[256];
 	static mt19937 rnd;
@@ -45,28 +45,28 @@ public:
 	static void ClientRead(bufferevent* bev, void* ctx);
 	static void ClientEvent(bufferevent *bev, short events, void *ctx);
 	static int ClientThread();
-	static void HandleSTOCPacketLan(char* data, unsigned int len);
-	static int ClientAnalyze(char* msg, unsigned int len);
+	static void HandleSTOCPacketLan(unsigned char* data, unsigned int len);
+	static int ClientAnalyze(unsigned char* msg, unsigned int len);
 	static void SwapField();
 	static void SetResponseI(int respI);
 	static void SetResponseB(void* respB, unsigned char len);
 	static void SendResponse();
 	static void SendPacketToServer(unsigned char proto) {
-		char* p = duel_client_write;
+		auto p = duel_client_write;
 		BufferIO::WriteInt16(p, 1);
 		BufferIO::WriteInt8(p, proto);
 		bufferevent_write(client_bev, duel_client_write, 3);
 	}
 	template<typename ST>
 	static void SendPacketToServer(unsigned char proto, ST& st) {
-		char* p = duel_client_write;
+		auto p = duel_client_write;
 		BufferIO::WriteInt16(p, 1 + sizeof(ST));
 		BufferIO::WriteInt8(p, proto);
 		memcpy(p, &st, sizeof(ST));
 		bufferevent_write(client_bev, duel_client_write, sizeof(ST) + 3);
 	}
 	static void SendBufferToServer(unsigned char proto, void* buffer, size_t len) {
-		char* p = duel_client_write;
+		auto p = duel_client_write;
 		BufferIO::WriteInt16(p, 1 + len);
 		BufferIO::WriteInt8(p, proto);
 		memcpy(p, buffer, len);

Classes/gframe/game.h

@@ -918,6 +918,19 @@ extern Game* mainGame;
 #define BUTTON_BIG_CARD_ZOOM_OUT	382
 #define BUTTON_BIG_CARD_ORIG_SIZE	383
 
+//gframe messages
+#define MSG_WAITING				3
+#define MSG_START				4
+#define MSG_UPDATE_DATA			6
+#define MSG_UPDATE_CARD			7
+#define MSG_REQUEST_DECK		8
+#define MSG_REFRESH_DECK		34
+#define MSG_CARD_SELECTED		80
+#define MSG_UNEQUIP				95
+#define MSG_BE_CHAIN_TARGET		121
+#define MSG_CREATE_RELATION		122
+#define MSG_RELEASE_RELATION	123
+
 #define AVAIL_OCG					0x1
 #define AVAIL_TCG					0x2
 #define AVAIL_CUSTOM				0x4

Classes/gframe/menu_handler.cpp

@@ -21,8 +21,8 @@ void UpdateDeck() {
 	BufferIO::EncodeUTF8(mainGame->gameConf.lastdeck, linebuf);
 	android::setLastDeck(mainGame->appMain, linebuf);
 		
-	char deckbuf[1024];
-	char* pdeck = deckbuf;
+	unsigned char deckbuf[1024];
+	auto pdeck = deckbuf;
 	BufferIO::WriteInt32(pdeck, deckManager.current_deck.main.size() + deckManager.current_deck.extra.size());
 	BufferIO::WriteInt32(pdeck, deckManager.current_deck.side.size());
 	for(size_t i = 0; i < deckManager.current_deck.main.size(); ++i)

Classes/gframe/netserver.cpp

@@ -9,8 +9,8 @@ event_base* NetServer::net_evbase = 0;
 event* NetServer::broadcast_ev = 0;
 evconnlistener* NetServer::listener = 0;
 DuelMode* NetServer::duel_mode = 0;
-char NetServer::net_server_read[0x2000];
-char NetServer::net_server_write[0x2000];
+unsigned char NetServer::net_server_read[0x2000];
+unsigned char NetServer::net_server_write[0x2000];
 unsigned short NetServer::last_sent = 0;
 
 bool NetServer::StartServer(unsigned short port) {
@@ -171,8 +171,8 @@ void NetServer::DisconnectPlayer(DuelPlayer* dp) {
 		users.erase(bit);
 	}
 }
-void NetServer::HandleCTOSPacket(DuelPlayer* dp, char* data, unsigned int len) {
-	char* pdata = data;
+void NetServer::HandleCTOSPacket(DuelPlayer* dp, unsigned char* data, unsigned int len) {
+	auto pdata = data;
 	unsigned char pktType = BufferIO::ReadUInt8(pdata);
 	if((pktType != CTOS_SURRENDER) && (pktType != CTOS_CHAT) && (dp->state == 0xff || (dp->state && dp->state != pktType)))
 		return;

Classes/gframe/netserver.h

@@ -18,8 +18,8 @@ private:
 	static event* broadcast_ev;
 	static evconnlistener* listener;
 	static DuelMode* duel_mode;
-	static char net_server_read[0x2000];
-	static char net_server_write[0x2000];
+	static unsigned char net_server_read[0x2000];
+	static unsigned char net_server_write[0x2000];
 	static unsigned short last_sent;
 
 public:
@@ -35,9 +35,9 @@ public:
 	static void ServerEchoEvent(bufferevent* bev, short events, void* ctx);
 	static int ServerThread();
 	static void DisconnectPlayer(DuelPlayer* dp);
-	static void HandleCTOSPacket(DuelPlayer* dp, char* data, unsigned int len);
+	static void HandleCTOSPacket(DuelPlayer* dp, unsigned char* data, unsigned int len);
 	static void SendPacketToPlayer(DuelPlayer* dp, unsigned char proto) {
-		char* p = net_server_write;
+		auto p = net_server_write;
 		BufferIO::WriteInt16(p, 1);
 		BufferIO::WriteInt8(p, proto);
 		last_sent = 3;
@@ -47,7 +47,7 @@ public:
 	}
 	template<typename ST>
 	static void SendPacketToPlayer(DuelPlayer* dp, unsigned char proto, ST& st) {
-		char* p = net_server_write;
+		auto p = net_server_write;
 		BufferIO::WriteInt16(p, 1 + sizeof(ST));
 		BufferIO::WriteInt8(p, proto);
 		memcpy(p, &st, sizeof(ST));
@@ -56,7 +56,7 @@ public:
 			bufferevent_write(dp->bev, net_server_write, last_sent);
 	}
 	static void SendBufferToPlayer(DuelPlayer* dp, unsigned char proto, void* buffer, size_t len) {
-		char* p = net_server_write;
+		auto p = net_server_write;
 		BufferIO::WriteInt16(p, 1 + len);
 		BufferIO::WriteInt8(p, proto);
 		memcpy(p, buffer, len);

Classes/gframe/replay_mode.cpp

 #include "replay_mode.h"
 #include "duelclient.h"
 #include "game.h"
-#include "single_mode.h"
 #include "../ocgcore/common.h"
 #include "../ocgcore/mtrandom.h"
 
@@ -74,13 +73,14 @@ int ReplayMode::ReplayThread() {
 	mainGame->dInfo.isFinished = false;
 	mainGame->dInfo.isReplay = true;
 	mainGame->dInfo.isReplaySkiping = (skip_turn > 0);
-	char engineBuffer[0x1000];
+	std::vector<unsigned char> engineBuffer;
+	engineBuffer.resize(SIZE_MESSAGE_BUFFER);
 	is_continuing = true;
 	skip_step = 0;
 	if(mainGame->dInfo.isSingleMode) {
-		int len = get_message(pduel, (byte*)engineBuffer);
+		int len = get_message(pduel, engineBuffer.data());
 		if (len > 0)
-			is_continuing = ReplayAnalyze(engineBuffer, len);
+			is_continuing = ReplayAnalyze(engineBuffer.data(), len);
 	} else {
 		ReplayRefreshDeck(0);
 		ReplayRefreshDeck(1);
@@ -92,12 +92,13 @@ int ReplayMode::ReplayThread() {
 	if(mainGame->dInfo.isReplaySkiping)
 		mainGame->gMutex.lock();
 	while (is_continuing && !exit_pending) {
-		int result = process(pduel);
-		int len = result & 0xffff;
-		/*int flag = result >> 16;*/
+		unsigned int result = process(pduel);
+		int len = result & PROCESSOR_BUFFER_LEN;
 		if (len > 0) {
-			get_message(pduel, (byte*)engineBuffer);
-			is_continuing = ReplayAnalyze(engineBuffer, len);
+			if (len > (int)engineBuffer.size())
+				engineBuffer.resize(len);
+			get_message(pduel, engineBuffer.data());
+			is_continuing = ReplayAnalyze(engineBuffer.data(), len);
 			if(is_restarting) {
 				mainGame->gMutex.lock();
 				is_restarting = false;
@@ -109,9 +110,9 @@ int ReplayMode::ReplayThread() {
 				if(mainGame->dInfo.isSingleMode) {
 					is_continuing = true;
 					skip_step = 0;
-					int len = get_message(pduel, (byte*)engineBuffer);
+					int len = get_message(pduel, engineBuffer.data());
 					if (len > 0) {
-						is_continuing = ReplayAnalyze(engineBuffer, len);
+						is_continuing = ReplayAnalyze(engineBuffer.data(), len);
 					}
 				} else {
 					ReplayRefreshDeck(0);
@@ -295,8 +296,8 @@ void ReplayMode::Undo() {
 	is_restarting = true;
 	Pause(false, false);
 }
-bool ReplayMode::ReplayAnalyze(char* msg, unsigned int len) {
-	char* pbuf = msg;
+bool ReplayMode::ReplayAnalyze(unsigned char* msg, unsigned int len) {
+	unsigned char* pbuf = msg;
 	int player, count;
 	is_restarting = false;
 	while (pbuf - msg < (int)len) {
@@ -312,7 +313,7 @@ bool ReplayMode::ReplayAnalyze(char* msg, unsigned int len) {
 			mainGame->gMutex.unlock();
 			is_swaping = false;
 		}
-		char* offset = pbuf;
+		auto offset = pbuf;
 		bool pauseable = true;
 		mainGame->dInfo.curMsg = BufferIO::ReadUInt8(pbuf);
 		switch (mainGame->dInfo.curMsg) {
@@ -872,77 +873,61 @@ bool ReplayMode::ReplayAnalyze(char* msg, unsigned int len) {
 	}
 	return true;
 }
+void ReplayMode::ReloadLocation(int player, int location, int flag, std::vector<unsigned char>& queryBuffer) {
+	query_field_card(pduel, player, location, flag, queryBuffer.data(), 0);
+	mainGame->dField.UpdateFieldCard(mainGame->LocalPlayer(player), location, queryBuffer.data());
+}
+void ReplayMode::RefreshLocation(int player, int location, int flag) {
+	std::vector<unsigned char> queryBuffer;
+	queryBuffer.resize(SIZE_QUERY_BUFFER);
+	ReloadLocation(player, location, flag, queryBuffer);
+}
 void ReplayMode::ReplayRefresh(int flag) {
-	unsigned char queryBuffer[0x4000];
-	/*int len = */query_field_card(pduel, 0, LOCATION_MZONE, flag, queryBuffer, 0);
-	mainGame->dField.UpdateFieldCard(mainGame->LocalPlayer(0), LOCATION_MZONE, (char*)queryBuffer);
-	/*len = */query_field_card(pduel, 1, LOCATION_MZONE, flag, queryBuffer, 0);
-	mainGame->dField.UpdateFieldCard(mainGame->LocalPlayer(1), LOCATION_MZONE, (char*)queryBuffer);
-	/*len = */query_field_card(pduel, 0, LOCATION_SZONE, flag, queryBuffer, 0);
-	mainGame->dField.UpdateFieldCard(mainGame->LocalPlayer(0), LOCATION_SZONE, (char*)queryBuffer);
-	/*len = */query_field_card(pduel, 1, LOCATION_SZONE, flag, queryBuffer, 0);
-	mainGame->dField.UpdateFieldCard(mainGame->LocalPlayer(1), LOCATION_SZONE, (char*)queryBuffer);
-	/*len = */query_field_card(pduel, 0, LOCATION_HAND, flag, queryBuffer, 0);
-	mainGame->dField.UpdateFieldCard(mainGame->LocalPlayer(0), LOCATION_HAND, (char*)queryBuffer);
-	/*len = */query_field_card(pduel, 1, LOCATION_HAND, flag, queryBuffer, 0);
-	mainGame->dField.UpdateFieldCard(mainGame->LocalPlayer(1), LOCATION_HAND, (char*)queryBuffer);
+	std::vector<byte> queryBuffer;
+	queryBuffer.resize(SIZE_QUERY_BUFFER);
+	ReloadLocation(0, LOCATION_MZONE, flag, queryBuffer);
+	ReloadLocation(1, LOCATION_MZONE, flag, queryBuffer);
+	ReloadLocation(0, LOCATION_SZONE, flag, queryBuffer);
+	ReloadLocation(1, LOCATION_SZONE, flag, queryBuffer);
+	ReloadLocation(0, LOCATION_HAND, flag, queryBuffer);
+	ReloadLocation(1, LOCATION_HAND, flag, queryBuffer);
 }
 void ReplayMode::ReplayRefreshHand(int player, int flag) {
-	unsigned char queryBuffer[0x2000];
-	/*int len = */query_field_card(pduel, player, LOCATION_HAND, flag, queryBuffer, 0);
-	mainGame->dField.UpdateFieldCard(mainGame->LocalPlayer(player), LOCATION_HAND, (char*)queryBuffer);
+	RefreshLocation(player, LOCATION_HAND, flag);
 }
 void ReplayMode::ReplayRefreshGrave(int player, int flag) {
-	unsigned char queryBuffer[0x2000];
-	/*int len = */query_field_card(pduel, player, LOCATION_GRAVE, flag, queryBuffer, 0);
-	mainGame->dField.UpdateFieldCard(mainGame->LocalPlayer(player), LOCATION_GRAVE, (char*)queryBuffer);
+	RefreshLocation(player, LOCATION_GRAVE, flag);
 }
 void ReplayMode::ReplayRefreshDeck(int player, int flag) {
-	unsigned char queryBuffer[0x2000];
-	/*int len = */query_field_card(pduel, player, LOCATION_DECK, flag, queryBuffer, 0);
-	mainGame->dField.UpdateFieldCard(mainGame->LocalPlayer(player), LOCATION_DECK, (char*)queryBuffer);
+	RefreshLocation(player, LOCATION_DECK, flag);
 }
 void ReplayMode::ReplayRefreshExtra(int player, int flag) {
-	unsigned char queryBuffer[0x2000];
-	/*int len = */query_field_card(pduel, player, LOCATION_EXTRA, flag, queryBuffer, 0);
-	mainGame->dField.UpdateFieldCard(mainGame->LocalPlayer(player), LOCATION_EXTRA, (char*)queryBuffer);
+	RefreshLocation(player, LOCATION_EXTRA, flag);
 }
 void ReplayMode::ReplayRefreshSingle(int player, int location, int sequence, int flag) {
-	unsigned char queryBuffer[0x4000];
+	unsigned char queryBuffer[0x1000];
 	/*int len = */query_card(pduel, player, location, sequence, flag, queryBuffer, 0);
-	mainGame->dField.UpdateCard(mainGame->LocalPlayer(player), location, sequence, (char*)queryBuffer);
+	mainGame->dField.UpdateCard(mainGame->LocalPlayer(player), location, sequence, queryBuffer);
 }
 void ReplayMode::ReplayReload() {
-	unsigned char queryBuffer[0x4000];
+	std::vector<unsigned char> queryBuffer;
+	queryBuffer.resize(SIZE_QUERY_BUFFER);
 	unsigned int flag = 0xffdfff;
-	/*int len = */query_field_card(pduel, 0, LOCATION_MZONE, flag, queryBuffer, 0);
-	mainGame->dField.UpdateFieldCard(mainGame->LocalPlayer(0), LOCATION_MZONE, (char*)queryBuffer);
-	/*len = */query_field_card(pduel, 1, LOCATION_MZONE, flag, queryBuffer, 0);
-	mainGame->dField.UpdateFieldCard(mainGame->LocalPlayer(1), LOCATION_MZONE, (char*)queryBuffer);
-	/*len = */query_field_card(pduel, 0, LOCATION_SZONE, flag, queryBuffer, 0);
-	mainGame->dField.UpdateFieldCard(mainGame->LocalPlayer(0), LOCATION_SZONE, (char*)queryBuffer);
-	/*len = */query_field_card(pduel, 1, LOCATION_SZONE, flag, queryBuffer, 0);
-	mainGame->dField.UpdateFieldCard(mainGame->LocalPlayer(1), LOCATION_SZONE, (char*)queryBuffer);
-	/*len = */query_field_card(pduel, 0, LOCATION_HAND, flag, queryBuffer, 0);
-	mainGame->dField.UpdateFieldCard(mainGame->LocalPlayer(0), LOCATION_HAND, (char*)queryBuffer);
-	/*len = */query_field_card(pduel, 1, LOCATION_HAND, flag, queryBuffer, 0);
-	mainGame->dField.UpdateFieldCard(mainGame->LocalPlayer(1), LOCATION_HAND, (char*)queryBuffer);
-	/*len = */query_field_card(pduel, 0, LOCATION_DECK, flag, queryBuffer, 0);
-	mainGame->dField.UpdateFieldCard(mainGame->LocalPlayer(0), LOCATION_DECK, (char*)queryBuffer);
-	/*len = */query_field_card(pduel, 1, LOCATION_DECK, flag, queryBuffer, 0);
-	mainGame->dField.UpdateFieldCard(mainGame->LocalPlayer(1), LOCATION_DECK, (char*)queryBuffer);
-	/*len = */query_field_card(pduel, 0, LOCATION_EXTRA, flag, queryBuffer, 0);
-	mainGame->dField.UpdateFieldCard(mainGame->LocalPlayer(0), LOCATION_EXTRA, (char*)queryBuffer);
-	/*len = */query_field_card(pduel, 1, LOCATION_EXTRA, flag, queryBuffer, 0);
-	mainGame->dField.UpdateFieldCard(mainGame->LocalPlayer(1), LOCATION_EXTRA, (char*)queryBuffer);
-	/*len = */query_field_card(pduel, 0, LOCATION_GRAVE, flag, queryBuffer, 0);
-	mainGame->dField.UpdateFieldCard(mainGame->LocalPlayer(0), LOCATION_GRAVE, (char*)queryBuffer);
-	/*len = */query_field_card(pduel, 1, LOCATION_GRAVE, flag, queryBuffer, 0);
-	mainGame->dField.UpdateFieldCard(mainGame->LocalPlayer(1), LOCATION_GRAVE, (char*)queryBuffer);
-	/*len = */query_field_card(pduel, 0, LOCATION_REMOVED, flag, queryBuffer, 0);
-	mainGame->dField.UpdateFieldCard(mainGame->LocalPlayer(0), LOCATION_REMOVED, (char*)queryBuffer);
-	/*len = */query_field_card(pduel, 1, LOCATION_REMOVED, flag, queryBuffer, 0);
-	mainGame->dField.UpdateFieldCard(mainGame->LocalPlayer(1), LOCATION_REMOVED, (char*)queryBuffer);
+	ReloadLocation(0, LOCATION_MZONE, flag, queryBuffer);
+	ReloadLocation(1, LOCATION_MZONE, flag, queryBuffer);
+	ReloadLocation(0, LOCATION_SZONE, flag, queryBuffer);
+	ReloadLocation(1, LOCATION_SZONE, flag, queryBuffer);
+	ReloadLocation(0, LOCATION_HAND, flag, queryBuffer);
+	ReloadLocation(1, LOCATION_HAND, flag, queryBuffer);
+
+	ReloadLocation(0, LOCATION_DECK, flag, queryBuffer);
+	ReloadLocation(1, LOCATION_DECK, flag, queryBuffer);
+	ReloadLocation(0, LOCATION_EXTRA, flag, queryBuffer);
+	ReloadLocation(1, LOCATION_EXTRA, flag, queryBuffer);
+	ReloadLocation(0, LOCATION_GRAVE, flag, queryBuffer);
+	ReloadLocation(1, LOCATION_GRAVE, flag, queryBuffer);
+	ReloadLocation(0, LOCATION_REMOVED, flag, queryBuffer);
+	ReloadLocation(1, LOCATION_REMOVED, flag, queryBuffer);
 }
 int ReplayMode::MessageHandler(intptr_t fduel, int type) {
 	if(!enable_log)

Classes/gframe/replay_mode.h

@@ -37,8 +37,10 @@ public:
 	static void EndDuel();
 	static void Restart(bool refresh);
 	static void Undo();
-	static bool ReplayAnalyze(char* msg, unsigned int len);
+	static bool ReplayAnalyze(unsigned char* msg, unsigned int len);
 	
+	inline static void ReloadLocation(int player, int location, int flag, std::vector<unsigned char>& queryBuffer);
+	inline static void RefreshLocation(int player, int location, int flag);
 	static void ReplayRefresh(int flag = 0xf81fff);
 	static void ReplayRefreshHand(int player, int flag = 0x781fff);
 	static void ReplayRefreshGrave(int player, int flag = 0x181fff);

Classes/gframe/single_duel.cpp

@@ -282,7 +282,7 @@ void SingleDuel::PlayerKick(DuelPlayer* dp, unsigned char pos) {
 void SingleDuel::UpdateDeck(DuelPlayer* dp, void* pdata, unsigned int len) {
 	if(dp->type > 1 || ready[dp->type])
 		return;
-	char* deckbuf = (char*)pdata;
+	unsigned char* deckbuf = (unsigned char*)pdata;
 	int mainc = BufferIO::ReadInt32(deckbuf);
 	int sidec = BufferIO::ReadInt32(deckbuf);
 	// verify data
@@ -327,8 +327,8 @@ void SingleDuel::StartDuel(DuelPlayer* dp) {
 		(*oit)->state = CTOS_LEAVE_GAME;
 		NetServer::ReSendToPlayer(*oit);
 	}
-	char deckbuff[12];
-	char* pbuf = deckbuff;
+	unsigned char deckbuff[12];
+	auto pbuf = deckbuff;
 	BufferIO::WriteInt16(pbuf, pdeck[0].main.size());
 	BufferIO::WriteInt16(pbuf, pdeck[0].extra.size());
 	BufferIO::WriteInt16(pbuf, pdeck[0].side.size());
@@ -410,8 +410,8 @@ void SingleDuel::TPResult(DuelPlayer* dp, unsigned char tp) {
 	dp->state = CTOS_RESPONSE;
 	std::random_device rd;
 	unsigned int seed = rd();
-	mt19937 rnd(seed);
-	unsigned int duel_seed = rnd.rand();
+	mt19937 rnd((uint_fast32_t)seed);
+	auto duel_seed = rnd.rand();
 	ReplayHeader rh;
 	rh.id = 0x31707279;
 	rh.version = PRO_VERSION;
@@ -463,7 +463,8 @@ void SingleDuel::TPResult(DuelPlayer* dp, unsigned char tp) {
 		last_replay.WriteInt32(pdeck[1].extra[i]->first, false);
 	}
 	last_replay.Flush();
-	char startbuf[32], *pbuf = startbuf;
+	unsigned char startbuf[32];
+	auto pbuf = startbuf;
 	BufferIO::WriteInt8(pbuf, MSG_START);
 	BufferIO::WriteInt8(pbuf, 0);
 	BufferIO::WriteInt8(pbuf, host_info.duel_rule);
@@ -492,18 +493,22 @@ void SingleDuel::TPResult(DuelPlayer* dp, unsigned char tp) {
 	Process();
 }
 void SingleDuel::Process() {
-	char engineBuffer[0x1000];
-	unsigned int engFlag = 0, engLen = 0;
+	std::vector<unsigned char> engineBuffer;
+	engineBuffer.reserve(SIZE_MESSAGE_BUFFER);
+	unsigned int engFlag = 0;
+	int engLen = 0;
 	int stop = 0;
 	while (!stop) {
-		if (engFlag == 2)
+		if (engFlag == PROCESSOR_END)
 			break;
-		int result = process(pduel);
-		engLen = result & 0xffff;
-		engFlag = result >> 16;
+		unsigned int result = process(pduel);
+		engLen = result & PROCESSOR_BUFFER_LEN;
+		engFlag = result & PROCESSOR_FLAG;
 		if (engLen > 0) {
-			get_message(pduel, (byte*)&engineBuffer);
-			stop = Analyze(engineBuffer, engLen);
+			if (engLen > (int)engineBuffer.size())
+				engineBuffer.resize(engLen);
+			get_message(pduel, engineBuffer.data());
+			stop = Analyze(engineBuffer.data(), engLen);
 		}
 	}
 	if(stop == 2)
@@ -574,8 +579,8 @@ void SingleDuel::Surrender(DuelPlayer* dp) {
 	DuelEndProc();
 	event_del(etimer);
 }
-int SingleDuel::Analyze(char* msgbuffer, unsigned int len) {
-	char* offset, *pbufw, *pbuf = msgbuffer;
+int SingleDuel::Analyze(unsigned char* msgbuffer, unsigned int len) {
+	unsigned char* offset, *pbufw, *pbuf = msgbuffer;
 	int player, count, type;
 	while (pbuf - msgbuffer < (int)len) {
 		offset = pbuf;
@@ -1459,8 +1464,8 @@ void SingleDuel::TimeConfirm(DuelPlayer* dp) {
 		time_elapsed = 0;
 }
 void SingleDuel::RefreshMzone(int player, int flag, int use_cache) {
-	char query_buffer[0x2000];
-	char* qbuf = query_buffer;
+	unsigned char query_buffer[0x2000];
+	auto qbuf = query_buffer;
 	BufferIO::WriteInt8(qbuf, MSG_UPDATE_DATA);
 	BufferIO::WriteInt8(qbuf, player);
 	BufferIO::WriteInt8(qbuf, LOCATION_MZONE);
@@ -1481,12 +1486,12 @@ void SingleDuel::RefreshMzone(int player, int flag, int use_cache) {
 		NetServer::ReSendToPlayer(*pit);
 }
 void SingleDuel::RefreshSzone(int player, int flag, int use_cache) {
-	char query_buffer[0x2000];
-	char* qbuf = query_buffer;
+	unsigned char query_buffer[0x2000];
+	auto qbuf = query_buffer;
 	BufferIO::WriteInt8(qbuf, MSG_UPDATE_DATA);
 	BufferIO::WriteInt8(qbuf, player);
 	BufferIO::WriteInt8(qbuf, LOCATION_SZONE);
-	int len = query_field_card(pduel, player, LOCATION_SZONE, flag, (unsigned char*)qbuf, use_cache);
+	int len = query_field_card(pduel, player, LOCATION_SZONE, flag, qbuf, use_cache);
 	NetServer::SendBufferToPlayer(players[player], STOC_GAME_MSG, query_buffer, len + 3);
 	int qlen = 0;
 	while(qlen < len) {
@@ -1503,8 +1508,8 @@ void SingleDuel::RefreshSzone(int player, int flag, int use_cache) {
 		NetServer::ReSendToPlayer(*pit);
 }
 void SingleDuel::RefreshHand(int player, int flag, int use_cache) {
-	char query_buffer[0x2000];
-	char* qbuf = query_buffer;
+	unsigned char query_buffer[0x2000];
+	auto qbuf = query_buffer;
 	BufferIO::WriteInt8(qbuf, MSG_UPDATE_DATA);
 	BufferIO::WriteInt8(qbuf, player);
 	BufferIO::WriteInt8(qbuf, LOCATION_HAND);
@@ -1528,8 +1533,8 @@ void SingleDuel::RefreshHand(int player, int flag, int use_cache) {
 		NetServer::ReSendToPlayer(*pit);
 }
 void SingleDuel::RefreshGrave(int player, int flag, int use_cache) {
-	char query_buffer[0x2000];
-	char* qbuf = query_buffer;
+	unsigned char query_buffer[0x2000];
+	auto qbuf = query_buffer;
 	BufferIO::WriteInt8(qbuf, MSG_UPDATE_DATA);
 	BufferIO::WriteInt8(qbuf, player);
 	BufferIO::WriteInt8(qbuf, LOCATION_GRAVE);
@@ -1540,8 +1545,8 @@ void SingleDuel::RefreshGrave(int player, int flag, int use_cache) {
 		NetServer::ReSendToPlayer(*pit);
 }
 void SingleDuel::RefreshExtra(int player, int flag, int use_cache) {
-	char query_buffer[0x2000];
-	char* qbuf = query_buffer;
+	unsigned char query_buffer[0x2000];
+	auto qbuf = query_buffer;
 	BufferIO::WriteInt8(qbuf, MSG_UPDATE_DATA);
 	BufferIO::WriteInt8(qbuf, player);
 	BufferIO::WriteInt8(qbuf, LOCATION_EXTRA);
@@ -1549,8 +1554,8 @@ void SingleDuel::RefreshExtra(int player, int flag, int use_cache) {
 	NetServer::SendBufferToPlayer(players[player], STOC_GAME_MSG, query_buffer, len + 3);
 }
 void SingleDuel::RefreshSingle(int player, int location, int sequence, int flag) {
-	char query_buffer[0x2000];
-	char* qbuf = query_buffer;
+	unsigned char query_buffer[0x2000];
+	auto qbuf = query_buffer;
 	BufferIO::WriteInt8(qbuf, MSG_UPDATE_CARD);
 	BufferIO::WriteInt8(qbuf, player);
 	BufferIO::WriteInt8(qbuf, location);

Classes/gframe/single_duel.h

@@ -24,7 +24,7 @@ public:
 	virtual void TPResult(DuelPlayer* dp, unsigned char tp);
 	virtual void Process();
 	virtual void Surrender(DuelPlayer* dp);
-	virtual int Analyze(char* msgbuffer, unsigned int len);
+	virtual int Analyze(unsigned char* msgbuffer, unsigned int len);
 	virtual void GetResponse(DuelPlayer* dp, void* pdata, unsigned int len);
 	virtual void TimeConfirm(DuelPlayer* dp);
 	virtual void EndDuel();

Classes/gframe/single_mode.cpp

@@ -35,7 +35,7 @@ int SingleMode::SinglePlayThread() {
 	int opt = 0;
 	std::random_device rd;
 	unsigned int seed = rd();
-	mt19937 rnd(seed);
+	mt19937 rnd((uint_fast32_t)seed);
 	set_script_reader((script_reader)DataManager::ScriptReaderEx);
 	set_card_reader((card_reader)DataManager::CardReader);
 	set_message_handler((message_handler)MessageHandler);
@@ -87,12 +87,13 @@ int SingleMode::SinglePlayThread() {
 	mainGame->dInfo.isSingleMode = true;
 	mainGame->device->setEventReceiver(&mainGame->dField);
 	mainGame->gMutex.unlock();
-	char engineBuffer[0x1000];
+	std::vector<unsigned char> engineBuffer;
+	engineBuffer.resize(SIZE_MESSAGE_BUFFER);
 	is_closing = false;
 	is_continuing = true;
-	int len = get_message(pduel, (byte*)engineBuffer);
+	int len = get_message(pduel, engineBuffer.data());
 	if (len > 0)
-		is_continuing = SinglePlayAnalyze(engineBuffer, len);
+		is_continuing = SinglePlayAnalyze(engineBuffer.data(), len);
 	last_replay.BeginRecord();
 	last_replay.WriteHeader(rh);
 	unsigned short buffer[20];
@@ -109,12 +110,13 @@ int SingleMode::SinglePlayThread() {
 	last_replay.Flush();
 	start_duel(pduel, opt);
 	while (is_continuing) {
-		int result = process(pduel);
-		len = result & 0xffff;
-		/* int flag = result >> 16; */
+		unsigned int result = process(pduel);
+		len = result & PROCESSOR_BUFFER_LEN;
 		if (len > 0) {
-			get_message(pduel, (byte*)engineBuffer);
-			is_continuing = SinglePlayAnalyze(engineBuffer, len);
+			if (len > (int)engineBuffer.size())
+				engineBuffer.resize(len);
+			get_message(pduel, engineBuffer.data());
+			is_continuing = SinglePlayAnalyze(engineBuffer.data(), len);
 		}
 	}
 	last_replay.EndRecord();
@@ -162,8 +164,8 @@ int SingleMode::SinglePlayThread() {
 	}
 	return 0;
 }
-bool SingleMode::SinglePlayAnalyze(char* msg, unsigned int len) {
-	char* offset, *pbuf = msg;
+bool SingleMode::SinglePlayAnalyze(unsigned char* msg, unsigned int len) {
+	unsigned char* offset, * pbuf = msg;
 	int player, count;
 	while (pbuf - msg < (int)len) {
 		if(is_closing || !is_continuing)
@@ -735,7 +737,7 @@ bool SingleMode::SinglePlayAnalyze(char* msg, unsigned int len) {
 			char namebuf[128];
 			wchar_t wname[128];
 			int len = BufferIO::ReadInt16(pbuf);
-			char* begin = pbuf;
+			auto begin = pbuf;
 			pbuf += len + 1;
 			memcpy(namebuf, begin, len + 1);
 			BufferIO::DecodeUTF8(namebuf, wname);
@@ -746,7 +748,7 @@ bool SingleMode::SinglePlayAnalyze(char* msg, unsigned int len) {
 			char msgbuf[1024];
 			wchar_t msg[1024];
 			int len = BufferIO::ReadInt16(pbuf);
-			char* begin = pbuf;
+			auto begin = pbuf;
 			pbuf += len + 1;
 			memcpy(msgbuf, begin, len + 1);
 			BufferIO::DecodeUTF8(msgbuf, msg);
@@ -762,77 +764,61 @@ bool SingleMode::SinglePlayAnalyze(char* msg, unsigned int len) {
 	}
 	return is_continuing;
 }
+void SingleMode::ReloadLocation(int player, int location, int flag, std::vector<unsigned char>& queryBuffer) {
+	query_field_card(pduel, player, location, flag, queryBuffer.data(), 0);
+	mainGame->dField.UpdateFieldCard(mainGame->LocalPlayer(player), location, queryBuffer.data());
+}
+void SingleMode::RefreshLocation(int player, int location, int flag) {
+	std::vector<unsigned char> queryBuffer;
+	queryBuffer.resize(SIZE_QUERY_BUFFER);
+	ReloadLocation(player, location, flag, queryBuffer);
+}
 void SingleMode::SinglePlayRefresh(int flag) {
-	unsigned char queryBuffer[0x2000];
-	/*int len = */query_field_card(pduel, 0, LOCATION_MZONE, flag, queryBuffer, 0);
-	mainGame->dField.UpdateFieldCard(mainGame->LocalPlayer(0), LOCATION_MZONE, (char*)queryBuffer);
-	/*len = */query_field_card(pduel, 1, LOCATION_MZONE, flag, queryBuffer, 0);
-	mainGame->dField.UpdateFieldCard(mainGame->LocalPlayer(1), LOCATION_MZONE, (char*)queryBuffer);
-	/*len = */query_field_card(pduel, 0, LOCATION_SZONE, flag, queryBuffer, 0);
-	mainGame->dField.UpdateFieldCard(mainGame->LocalPlayer(0), LOCATION_SZONE, (char*)queryBuffer);
-	/*len = */query_field_card(pduel, 1, LOCATION_SZONE, flag, queryBuffer, 0);
-	mainGame->dField.UpdateFieldCard(mainGame->LocalPlayer(1), LOCATION_SZONE, (char*)queryBuffer);
-	/*len = */query_field_card(pduel, 0, LOCATION_HAND, flag, queryBuffer, 0);
-	mainGame->dField.UpdateFieldCard(mainGame->LocalPlayer(0), LOCATION_HAND, (char*)queryBuffer);
-	/*len = */query_field_card(pduel, 1, LOCATION_HAND, flag, queryBuffer, 0);
-	mainGame->dField.UpdateFieldCard(mainGame->LocalPlayer(1), LOCATION_HAND, (char*)queryBuffer);
+	std::vector<unsigned char> queryBuffer;
+	queryBuffer.resize(SIZE_QUERY_BUFFER);
+	ReloadLocation(0, LOCATION_MZONE, flag, queryBuffer);
+	ReloadLocation(1, LOCATION_MZONE, flag, queryBuffer);
+	ReloadLocation(0, LOCATION_SZONE, flag, queryBuffer);
+	ReloadLocation(1, LOCATION_SZONE, flag, queryBuffer);
+	ReloadLocation(0, LOCATION_HAND, flag, queryBuffer);
+	ReloadLocation(1, LOCATION_HAND, flag, queryBuffer);
 }
 void SingleMode::SinglePlayRefreshHand(int player, int flag) {
-	unsigned char queryBuffer[0x2000];
-	/*int len = */query_field_card(pduel, player, LOCATION_HAND, flag, queryBuffer, 0);
-	mainGame->dField.UpdateFieldCard(mainGame->LocalPlayer(player), LOCATION_HAND, (char*)queryBuffer);
+	RefreshLocation(player, LOCATION_HAND, flag);
 }
 void SingleMode::SinglePlayRefreshGrave(int player, int flag) {
-	unsigned char queryBuffer[0x2000];
-	/*int len = */query_field_card(pduel, player, LOCATION_GRAVE, flag, queryBuffer, 0);
-	mainGame->dField.UpdateFieldCard(mainGame->LocalPlayer(player), LOCATION_GRAVE, (char*)queryBuffer);
+	RefreshLocation(player, LOCATION_GRAVE, flag);
 }
 void SingleMode::SinglePlayRefreshDeck(int player, int flag) {
-	unsigned char queryBuffer[0x2000];
-	/*int len = */query_field_card(pduel, player, LOCATION_DECK, flag, queryBuffer, 0);
-	mainGame->dField.UpdateFieldCard(mainGame->LocalPlayer(player), LOCATION_DECK, (char*)queryBuffer);
+	RefreshLocation(player, LOCATION_DECK, flag);
 }
 void SingleMode::SinglePlayRefreshExtra(int player, int flag) {
-	unsigned char queryBuffer[0x2000];
-	/*int len = */query_field_card(pduel, player, LOCATION_EXTRA, flag, queryBuffer, 0);
-	mainGame->dField.UpdateFieldCard(mainGame->LocalPlayer(player), LOCATION_EXTRA, (char*)queryBuffer);
+	RefreshLocation(player, LOCATION_EXTRA, flag);
 }
 void SingleMode::SinglePlayRefreshSingle(int player, int location, int sequence, int flag) {
-	unsigned char queryBuffer[0x2000];
+	unsigned char queryBuffer[0x1000];
 	/*int len = */query_card(pduel, player, location, sequence, flag, queryBuffer, 0);
-	mainGame->dField.UpdateCard(mainGame->LocalPlayer(player), location, sequence, (char*)queryBuffer);
+	mainGame->dField.UpdateCard(mainGame->LocalPlayer(player), location, sequence, queryBuffer);
 }
 void SingleMode::SinglePlayReload() {
-	unsigned char queryBuffer[0x2000];
+	std::vector<byte> queryBuffer;
+	queryBuffer.resize(SIZE_QUERY_BUFFER);
 	unsigned int flag = 0xffdfff;
-	/*int len = */query_field_card(pduel, 0, LOCATION_MZONE, flag, queryBuffer, 0);
-	mainGame->dField.UpdateFieldCard(mainGame->LocalPlayer(0), LOCATION_MZONE, (char*)queryBuffer);
-	/*len = */query_field_card(pduel, 1, LOCATION_MZONE, flag, queryBuffer, 0);
-	mainGame->dField.UpdateFieldCard(mainGame->LocalPlayer(1), LOCATION_MZONE, (char*)queryBuffer);
-	/*len = */query_field_card(pduel, 0, LOCATION_SZONE, flag, queryBuffer, 0);
-	mainGame->dField.UpdateFieldCard(mainGame->LocalPlayer(0), LOCATION_SZONE, (char*)queryBuffer);
-	/*len = */query_field_card(pduel, 1, LOCATION_SZONE, flag, queryBuffer, 0);
-	mainGame->dField.UpdateFieldCard(mainGame->LocalPlayer(1), LOCATION_SZONE, (char*)queryBuffer);
-	/*len = */query_field_card(pduel, 0, LOCATION_HAND, flag, queryBuffer, 0);
-	mainGame->dField.UpdateFieldCard(mainGame->LocalPlayer(0), LOCATION_HAND, (char*)queryBuffer);
-	/*len = */query_field_card(pduel, 1, LOCATION_HAND, flag, queryBuffer, 0);
-	mainGame->dField.UpdateFieldCard(mainGame->LocalPlayer(1), LOCATION_HAND, (char*)queryBuffer);
-	/*len = */query_field_card(pduel, 0, LOCATION_DECK, flag, queryBuffer, 0);
-	mainGame->dField.UpdateFieldCard(mainGame->LocalPlayer(0), LOCATION_DECK, (char*)queryBuffer);
-	/*len = */query_field_card(pduel, 1, LOCATION_DECK, flag, queryBuffer, 0);
-	mainGame->dField.UpdateFieldCard(mainGame->LocalPlayer(1), LOCATION_DECK, (char*)queryBuffer);
-	/*len = */query_field_card(pduel, 0, LOCATION_EXTRA, flag, queryBuffer, 0);
-	mainGame->dField.UpdateFieldCard(mainGame->LocalPlayer(0), LOCATION_EXTRA, (char*)queryBuffer);
-	/*len = */query_field_card(pduel, 1, LOCATION_EXTRA, flag, queryBuffer, 0);
-	mainGame->dField.UpdateFieldCard(mainGame->LocalPlayer(1), LOCATION_EXTRA, (char*)queryBuffer);
-	/*len = */query_field_card(pduel, 0, LOCATION_GRAVE, flag, queryBuffer, 0);
-	mainGame->dField.UpdateFieldCard(mainGame->LocalPlayer(0), LOCATION_GRAVE, (char*)queryBuffer);
-	/*len = */query_field_card(pduel, 1, LOCATION_GRAVE, flag, queryBuffer, 0);
-	mainGame->dField.UpdateFieldCard(mainGame->LocalPlayer(1), LOCATION_GRAVE, (char*)queryBuffer);
-	/*len = */query_field_card(pduel, 0, LOCATION_REMOVED, flag, queryBuffer, 0);
-	mainGame->dField.UpdateFieldCard(mainGame->LocalPlayer(0), LOCATION_REMOVED, (char*)queryBuffer);
-	/*len = */query_field_card(pduel, 1, LOCATION_REMOVED, flag, queryBuffer, 0);
-	mainGame->dField.UpdateFieldCard(mainGame->LocalPlayer(1), LOCATION_REMOVED, (char*)queryBuffer);
+	ReloadLocation(0, LOCATION_MZONE, flag, queryBuffer);
+	ReloadLocation(1, LOCATION_MZONE, flag, queryBuffer);
+	ReloadLocation(0, LOCATION_SZONE, flag, queryBuffer);
+	ReloadLocation(1, LOCATION_SZONE, flag, queryBuffer);
+	ReloadLocation(0, LOCATION_HAND, flag, queryBuffer);
+	ReloadLocation(1, LOCATION_HAND, flag, queryBuffer);
+
+	ReloadLocation(0, LOCATION_DECK, flag, queryBuffer);
+	ReloadLocation(1, LOCATION_DECK, flag, queryBuffer);
+	ReloadLocation(0, LOCATION_EXTRA, flag, queryBuffer);
+	ReloadLocation(1, LOCATION_EXTRA, flag, queryBuffer);
+	ReloadLocation(0, LOCATION_GRAVE, flag, queryBuffer);
+	ReloadLocation(1, LOCATION_GRAVE, flag, queryBuffer);
+	ReloadLocation(0, LOCATION_REMOVED, flag, queryBuffer);
+	ReloadLocation(1, LOCATION_REMOVED, flag, queryBuffer);
 }
 int SingleMode::MessageHandler(intptr_t fduel, int type) {
 	if(!enable_log)

Classes/gframe/single_mode.h

@@ -16,8 +16,10 @@ public:
 	static void StopPlay(bool is_exiting = false);
 	static void SetResponse(unsigned char* resp, unsigned int len);
 	static int SinglePlayThread();
-	static bool SinglePlayAnalyze(char* msg, unsigned int len);
+	static bool SinglePlayAnalyze(unsigned char* msg, unsigned int len);
 	
+	inline static void ReloadLocation(int player, int location, int flag, std::vector<unsigned char>& queryBuffer);
+	inline static void RefreshLocation(int player, int location, int flag);
 	static void SinglePlayRefresh(int flag = 0xf81fff);
 	static void SinglePlayRefreshHand(int player, int flag = 0x781fff);
 	static void SinglePlayRefreshGrave(int player, int flag = 0x181fff);

Classes/gframe/tag_duel.cpp

@@ -257,7 +257,7 @@ void TagDuel::PlayerKick(DuelPlayer* dp, unsigned char pos) {
 void TagDuel::UpdateDeck(DuelPlayer* dp, void* pdata, unsigned int len) {
 	if(dp->type > 3 || ready[dp->type])
 		return;
-	char* deckbuf = (char*)pdata;
+	unsigned char* deckbuf = (unsigned char*)pdata;
 	int mainc = BufferIO::ReadInt32(deckbuf);
 	int sidec = BufferIO::ReadInt32(deckbuf);
 	// verify data
@@ -284,8 +284,8 @@ void TagDuel::StartDuel(DuelPlayer* dp) {
 		(*oit)->state = CTOS_LEAVE_GAME;
 		NetServer::ReSendToPlayer(*oit);
 	}
-	char deckbuff[12];
-	char* pbuf = deckbuff;
+	unsigned char deckbuff[12];
+	auto pbuf = deckbuff;
 	BufferIO::WriteInt16(pbuf, pdeck[0].main.size());
 	BufferIO::WriteInt16(pbuf, pdeck[0].extra.size());
 	BufferIO::WriteInt16(pbuf, pdeck[0].side.size());
@@ -375,8 +375,8 @@ void TagDuel::TPResult(DuelPlayer* dp, unsigned char tp) {
 	dp->state = CTOS_RESPONSE;
 	std::random_device rd;
 	unsigned int seed = rd();
-	mt19937 rnd(seed);
-	unsigned int duel_seed = rnd.rand();
+	mt19937 rnd((uint_fast32_t)seed);
+	auto duel_seed = rnd.rand();
 	ReplayHeader rh;
 	rh.id = 0x31707279;
 	rh.version = PRO_VERSION;
@@ -457,7 +457,8 @@ void TagDuel::TPResult(DuelPlayer* dp, unsigned char tp) {
 		last_replay.WriteInt32(pdeck[2].extra[i]->first, false);
 	}
 	last_replay.Flush();
-	char startbuf[32], *pbuf = startbuf;
+	unsigned char startbuf[32];
+	auto pbuf = startbuf;
 	BufferIO::WriteInt8(pbuf, MSG_START);
 	BufferIO::WriteInt8(pbuf, 0);
 	BufferIO::WriteInt8(pbuf, host_info.duel_rule);
@@ -488,18 +489,22 @@ void TagDuel::TPResult(DuelPlayer* dp, unsigned char tp) {
 	Process();
 }
 void TagDuel::Process() {
-	char engineBuffer[0x1000];
-	unsigned int engFlag = 0, engLen = 0;
+	std::vector<unsigned char> engineBuffer;
+	engineBuffer.reserve(SIZE_MESSAGE_BUFFER);
+	unsigned int engFlag = 0;
+	int engLen = 0;
 	int stop = 0;
 	while (!stop) {
-		if (engFlag == 2)
+		if (engFlag == PROCESSOR_END)
 			break;
-		int result = process(pduel);
-		engLen = result & 0xffff;
-		engFlag = result >> 16;
+		unsigned int result = process(pduel);
+		engLen = result & PROCESSOR_BUFFER_LEN;
+		engFlag = result & PROCESSOR_FLAG;
 		if (engLen > 0) {
-			get_message(pduel, (byte*)&engineBuffer);
-			stop = Analyze(engineBuffer, engLen);
+			if (engLen > (int)engineBuffer.size())
+				engineBuffer.resize(engLen);
+			get_message(pduel, engineBuffer.data());
+			stop = Analyze(engineBuffer.data(), engLen);
 		}
 	}
 	if(stop == 2)
@@ -517,8 +522,8 @@ void TagDuel::DuelEndProc() {
 void TagDuel::Surrender(DuelPlayer* dp) {
 	return;
 }
-int TagDuel::Analyze(char* msgbuffer, unsigned int len) {
-	char* offset, *pbufw, *pbuf = msgbuffer;
+int TagDuel::Analyze(unsigned char* msgbuffer, unsigned int len) {
+	unsigned char* offset, *pbufw, *pbuf = msgbuffer;
 	int player, count, type;
 	while (pbuf - msgbuffer < (int)len) {
 		offset = pbuf;
@@ -1546,8 +1551,8 @@ void TagDuel::TimeConfirm(DuelPlayer* dp) {
 		time_elapsed = 0;
 }
 void TagDuel::RefreshMzone(int player, int flag, int use_cache) {
-	char query_buffer[0x4000];
-	char* qbuf = query_buffer;
+	unsigned char query_buffer[0x4000];
+	auto qbuf = query_buffer;
 	BufferIO::WriteInt8(qbuf, MSG_UPDATE_DATA);
 	BufferIO::WriteInt8(qbuf, player);
 	BufferIO::WriteInt8(qbuf, LOCATION_MZONE);
@@ -1572,8 +1577,8 @@ void TagDuel::RefreshMzone(int player, int flag, int use_cache) {
 		NetServer::ReSendToPlayer(*pit);
 }
 void TagDuel::RefreshSzone(int player, int flag, int use_cache) {
-	char query_buffer[0x4000];
-	char* qbuf = query_buffer;
+	unsigned char query_buffer[0x4000];
+	auto qbuf = query_buffer;
 	BufferIO::WriteInt8(qbuf, MSG_UPDATE_DATA);
 	BufferIO::WriteInt8(qbuf, player);
 	BufferIO::WriteInt8(qbuf, LOCATION_SZONE);
@@ -1598,8 +1603,8 @@ void TagDuel::RefreshSzone(int player, int flag, int use_cache) {
 		NetServer::ReSendToPlayer(*pit);
 }
 void TagDuel::RefreshHand(int player, int flag, int use_cache) {
-	char query_buffer[0x4000];
-	char* qbuf = query_buffer;
+	unsigned char query_buffer[0x4000];
+	auto qbuf = query_buffer;
 	BufferIO::WriteInt8(qbuf, MSG_UPDATE_DATA);
 	BufferIO::WriteInt8(qbuf, player);
 	BufferIO::WriteInt8(qbuf, LOCATION_HAND);
@@ -1625,8 +1630,8 @@ void TagDuel::RefreshHand(int player, int flag, int use_cache) {
 		NetServer::ReSendToPlayer(*pit);
 }
 void TagDuel::RefreshGrave(int player, int flag, int use_cache) {
-	char query_buffer[0x4000];
-	char* qbuf = query_buffer;
+	unsigned char query_buffer[0x4000];
+	auto qbuf = query_buffer;
 	BufferIO::WriteInt8(qbuf, MSG_UPDATE_DATA);
 	BufferIO::WriteInt8(qbuf, player);
 	BufferIO::WriteInt8(qbuf, LOCATION_GRAVE);
@@ -1639,8 +1644,8 @@ void TagDuel::RefreshGrave(int player, int flag, int use_cache) {
 		NetServer::ReSendToPlayer(*pit);
 }
 void TagDuel::RefreshExtra(int player, int flag, int use_cache) {
-	char query_buffer[0x4000];
-	char* qbuf = query_buffer;
+	unsigned char query_buffer[0x4000];
+	auto qbuf = query_buffer;
 	BufferIO::WriteInt8(qbuf, MSG_UPDATE_DATA);
 	BufferIO::WriteInt8(qbuf, player);
 	BufferIO::WriteInt8(qbuf, LOCATION_EXTRA);
@@ -1648,8 +1653,8 @@ void TagDuel::RefreshExtra(int player, int flag, int use_cache) {
 	NetServer::SendBufferToPlayer(cur_player[player], STOC_GAME_MSG, query_buffer, len + 3);
 }
 void TagDuel::RefreshSingle(int player, int location, int sequence, int flag) {
-	char query_buffer[0x4000];
-	char* qbuf = query_buffer;
+	unsigned char query_buffer[0x4000];
+	auto qbuf = query_buffer;
 	BufferIO::WriteInt8(qbuf, MSG_UPDATE_CARD);
 	BufferIO::WriteInt8(qbuf, player);
 	BufferIO::WriteInt8(qbuf, location);

Classes/gframe/tag_duel.h

@@ -24,7 +24,7 @@ public:
 	virtual void TPResult(DuelPlayer* dp, unsigned char tp);
 	virtual void Process();
 	virtual void Surrender(DuelPlayer* dp);
-	virtual int Analyze(char* msgbuffer, unsigned int len);
+	virtual int Analyze(unsigned char* msgbuffer, unsigned int len);
 	virtual void GetResponse(DuelPlayer* dp, void* pdata, unsigned int len);
 	virtual void TimeConfirm(DuelPlayer* dp);
 	virtual void EndDuel();