update gframe

Classes/gframe/client_card.cpp

@@ -5,50 +5,27 @@
 
 namespace ygo {
 
-ClientCard::ClientCard() {
-	curAlpha = 255;
-	dAlpha = 0;
-	aniFrame = 0;
-	is_moving = false;
-	is_fading = false;
-	is_hovered = false;
-	is_selectable = false;
-	is_selected = false;
-	is_showequip = false;
-	is_showtarget = false;
-	is_showchaintarget = false;
-	is_highlighting = false;
-	status = 0;
-	is_reversed = false;
-	cmdFlag = 0;
-	code = 0;
-	chain_code = 0;
-	location = 0;
-	type = 0;
-	alias = 0;
-	level = 0;
-	rank = 0;
-	link = 0;
-	race = 0;
-	attribute = 0;
-	attack = 0;
-	defense = 0;
-	base_attack = 0;
-	base_defense = 0;
-	lscale = 0;
-	rscale = 0;
-	link_marker = 0;
-	position = 0;
-	cHint = 0;
-	chValue = 0;
-	atkstring[0] = 0;
-	defstring[0] = 0;
-	lvstring[0] = 0;
-	linkstring[0] = 0;
-	rscstring[0] = 0;
-	lscstring[0] = 0;
-	overlayTarget = 0;
-	equipTarget = 0;
+ClientCard::~ClientCard() {
+	ClearTarget();
+	if (equipTarget)
+		equipTarget->equipped.erase(this);
+	for (auto card : equipped) {
+		card->equipTarget = nullptr;
+	}
+	equipped.clear();
+	if (overlayTarget) {
+		for (auto it = overlayTarget->overlayed.begin(); it != overlayTarget->overlayed.end(); ) {
+			if (*it == this) {
+				it = overlayTarget->overlayed.erase(it);
+			}
+			else
+				++it;
+		}
+	}
+	for (auto card : overlayed) {
+		card->overlayTarget = nullptr;
+	}
+	overlayed.clear();
 }
 void ClientCard::SetCode(int code) {
 	if((location == LOCATION_HAND) && (this->code != (unsigned int)code)) {
@@ -59,8 +36,10 @@ void ClientCard::SetCode(int code) {
 }
 void ClientCard::UpdateInfo(unsigned char* buf) {
 	int flag = BufferIO::ReadInt32(buf);
-	if(flag == 0)
+	if (flag == 0) {
+		ClearData();
 		return;
+	}
 	int pdata;
 	if(flag & QUERY_CODE) {
 		pdata = BufferIO::ReadInt32(buf);
@@ -133,8 +112,10 @@ void ClientCard::UpdateInfo(unsigned char* buf) {
 		int s = BufferIO::ReadInt8(buf);
 		BufferIO::ReadInt8(buf);
 		ClientCard* ecard = mainGame->dField.GetCard(mainGame->LocalPlayer(c), l, s);
-		equipTarget = ecard;
-		ecard->equipped.insert(this);
+		if (ecard) {
+			equipTarget = ecard;
+			ecard->equipped.insert(this);
+		}
 	}
 	if(flag & QUERY_TARGET_CARD) {
 		int count = BufferIO::ReadInt32(buf);
@@ -144,8 +125,10 @@ void ClientCard::UpdateInfo(unsigned char* buf) {
 			int s = BufferIO::ReadInt8(buf);
 			BufferIO::ReadInt8(buf);
 			ClientCard* tcard = mainGame->dField.GetCard(mainGame->LocalPlayer(c), l, s);
-			cardTarget.insert(tcard);
-			tcard->ownerTarget.insert(this);
+			if (tcard) {
+				cardTarget.insert(tcard);
+				tcard->ownerTarget.insert(this);
+			}
 		}
 	}
 	if(flag & QUERY_OVERLAY_CARD) {
@@ -198,6 +181,35 @@ void ClientCard::ClearTarget() {
 	cardTarget.clear();
 	ownerTarget.clear();
 }
+void ClientCard::ClearData() {
+	alias = 0;
+	type = 0;
+	level = 0;
+	rank = 0;
+	race = 0;
+	attribute = 0;
+	attack = 0;
+	defense = 0;
+	base_attack = 0;
+	base_defense = 0;
+	lscale = 0;
+	rscale = 0;
+	link = 0;
+	link_marker = 0;
+	status = 0;
+	
+	atkstring[0] = 0;
+	defstring[0] = 0;
+	lvstring[0] = 0;
+	linkstring[0] = 0;
+	rscstring[0] = 0;
+	lscstring[0] = 0;
+	counters.clear();
+	for (auto card : equipped) {
+		card->equipTarget = nullptr;
+	}
+	equipped.clear();
+}
 bool ClientCard::client_card_sort(ClientCard* c1, ClientCard* c2) {
 	if(c1->is_selected != c2->is_selected)
 		return c1->is_selected < c2->is_selected;

Classes/gframe/client_card.h

@@ -53,67 +53,70 @@ public:
 	irr::core::vector3df curRot;
 	irr::core::vector3df dPos;
 	irr::core::vector3df dRot;
-	u32 curAlpha;
-	u32 dAlpha;
-	u32 aniFrame;
-	bool is_moving;
-	bool is_fading;
-	bool is_hovered;
-	bool is_selectable;
-	bool is_selected;
-	bool is_showequip;
-	bool is_showtarget;
-	bool is_showchaintarget;
-	bool is_highlighting;
-	bool is_reversed;
-	u32 code;
-	u32 chain_code;
-	u32 alias;
-	u32 type;
-	u32 level;
-	u32 rank;
-	u32 link;
-	u32 attribute;
-	u32 race;
-	s32 attack;
-	s32 defense;
-	s32 base_attack;
-	s32 base_defense;
-	u32 lscale;
-	u32 rscale;
-	u32 link_marker;
-	u32 reason;
-	u32 select_seq;
-	u8 owner;
-	u8 controler;
-	u8 location;
-	u8 sequence;
-	u8 position;
-	u32 status;
-	u8 cHint;
-	u32 chValue;
-	u32 opParam;
-	u32 symbol;
-	u32 cmdFlag;
-	ClientCard* overlayTarget;
+	u32 curAlpha{ 255 };
+	u32 dAlpha{ 0 };
+	u32 aniFrame{ 0 };
+	bool is_moving{ false };
+	bool is_fading{ false };
+	bool is_hovered{ false };
+	bool is_selectable{ false };
+	bool is_selected{ false };
+	bool is_showequip{ false };
+	bool is_showtarget{ false };
+	bool is_showchaintarget{ false };
+	bool is_highlighting{ false };
+	bool is_reversed{ false };
+
+	unsigned int code{ 0 };
+	unsigned int chain_code{ 0 };
+	unsigned int alias{ 0 };
+	unsigned int type{ 0 };
+	unsigned int level{ 0 };
+	unsigned int rank{ 0 };
+	unsigned int link{ 0 };
+	unsigned int attribute{ 0 };
+	unsigned int race{ 0 };
+	int attack{ 0 };
+	int defense{ 0 };
+	int base_attack{ 0 };
+	int base_defense{ 0 };
+	unsigned int lscale{ 0 };
+	unsigned int rscale{ 0 };
+	unsigned int link_marker{ 0 };
+	unsigned int reason{ 0 };
+	unsigned int select_seq{ 0 };
+	unsigned char owner{ PLAYER_NONE };
+	unsigned char controler{ PLAYER_NONE };
+	unsigned char location{ 0 };
+	unsigned char sequence{ 0 };
+	unsigned char position{ 0 };
+	unsigned int status{ 0 };
+	unsigned char cHint{ 0 };
+	unsigned int chValue{ 0 };
+	unsigned int opParam{ 0 };
+	unsigned int symbol{ 0 };
+	unsigned int cmdFlag{ 0 };
+	ClientCard* overlayTarget{ nullptr };
 	std::vector<ClientCard*> overlayed;
-	ClientCard* equipTarget;
+	ClientCard* equipTarget{ nullptr };
 	std::set<ClientCard*> equipped;
 	std::set<ClientCard*> cardTarget;
 	std::set<ClientCard*> ownerTarget;
 	std::map<int, int> counters;
 	std::map<int, int> desc_hints;
-	wchar_t atkstring[16];
-	wchar_t defstring[16];
-	wchar_t lvstring[16];
-	wchar_t linkstring[16];
-	wchar_t lscstring[16];
-	wchar_t rscstring[16];
+	wchar_t atkstring[16]{ 0 };
+	wchar_t defstring[16]{ 0 };
+	wchar_t lvstring[16]{ 0 };
+	wchar_t linkstring[16]{ 0 };
+	wchar_t lscstring[16]{ 0 };
+	wchar_t rscstring[16]{ 0 };
 
-	ClientCard();
+	ClientCard() = default;
+	~ClientCard();
 	void SetCode(int code);
 	void UpdateInfo(unsigned char* buf);
 	void ClearTarget();
+	void ClearData();
 	static bool client_card_sort(ClientCard* c1, ClientCard* c2);
 	static bool deck_sort_lv(code_pointer l1, code_pointer l2);
 	static bool deck_sort_atk(code_pointer l1, code_pointer l2);

Classes/gframe/client_field.cpp

@@ -11,7 +11,6 @@
 namespace ygo {
 
 ClientField::ClientField() {
-	panel = 0;
 	//drag cardtext and lists
 	is_dragging_cardtext = false;
 	is_dragging_lstLog = false;
@@ -24,25 +23,6 @@ ClientField::ClientField() {
 	dragging_tab_start_pos = 0;
 	dragging_tab_start_y = 0;
 
-	hovered_card = 0;
-	clicked_card = 0;
-	highlighting_card = 0;
-	menu_card = 0;
-	hovered_controler = 0;
-	hovered_location = 0;
-	hovered_sequence = 0;
-	selectable_field = 0;
-	selected_field = 0;
-	deck_act = false;
-	grave_act = false;
-	remove_act = false;
-	extra_act = false;
-	pzone_act[0] = false;
-	pzone_act[1] = false;
-	conti_act = false;
-	deck_reversed = false;
-	conti_selecting = false;
-	cant_check_grave = false;
 	for(int p = 0; p < 2; ++p) {
 		mzone[p].resize(7, 0);
 		szone[p].resize(8, 0);
@@ -320,8 +300,9 @@ ClientCard* ClientField::RemoveCard(int controler, int location, int sequence) {
 }
 void ClientField::UpdateCard(int controler, int location, int sequence, unsigned char* data) {
 	ClientCard* pcard = GetCard(controler, location, sequence);
-	if(pcard)
-		pcard->UpdateInfo(data + 4);
+	int len = BufferIO::ReadInt32(data);
+	if (pcard && len > LEN_HEADER)
+		pcard->UpdateInfo(data);
 	RefreshCardCountDisplay();
 }
 void ClientField::UpdateFieldCard(int controler, int location, unsigned char* data) {
@@ -354,7 +335,7 @@ void ClientField::UpdateFieldCard(int controler, int location, unsigned char* da
 	int len;
 	for(auto cit = lst->begin(); cit != lst->end(); ++cit) {
 		len = BufferIO::ReadInt32(data);
-		if(len > 8)
+		if(len > LEN_HEADER)
 			(*cit)->UpdateInfo(data);
 		data += len - 4;
 	}
@@ -447,7 +428,7 @@ void ClientField::ShowSelectCard(bool buttonok, bool chain) {
 		else if(conti_selecting)
 			mainGame->imageLoading.insert(std::make_pair(mainGame->btnCardSelect[i], selectable_cards[i]->chain_code));
 		else
-			mainGame->btnCardSelect[i]->setImage(imageManager.tCover[selectable_cards[i]->controler]);
+			mainGame->btnCardSelect[i]->setImage(imageManager.tCover[selectable_cards[i]->controler + 2]);
 		mainGame->btnCardSelect[i]->setRelativePosition(rect<s32>((startpos + i * 125) * mainGame->xScale, 65 * mainGame->yScale, (startpos + 120 + i * 125) * mainGame->xScale, 235 * mainGame->yScale));
 		mainGame->btnCardSelect[i]->setPressed(false);
 		mainGame->btnCardSelect[i]->setVisible(true);

Classes/gframe/client_field.h

@@ -37,6 +37,7 @@ public:
 	std::vector<ClientCard*> remove[2];
 	std::vector<ClientCard*> extra[2];
 	std::set<ClientCard*> overlay_cards;
+
 	std::vector<ClientCard*> summonable_cards;
 	std::vector<ClientCard*> spsummonable_cards;
 	std::vector<ClientCard*> msetable_cards;
@@ -49,25 +50,25 @@ public:
 	std::vector<int> select_options;
 	std::vector<int> select_options_index;
 	std::vector<ChainInfo> chains;
-	int extra_p_count[2];
+	int extra_p_count[2]{ 0 };
 
-	size_t selected_option;
-	ClientCard* attacker;
-	ClientCard* attack_target;
-	unsigned int disabled_field;
-	unsigned int selectable_field;
-	unsigned int selected_field;
-	int select_min;
-	int select_max;
-	int must_select_count;
-	int select_sumval;
-	int select_mode;
-	bool select_cancelable;
-	bool select_panalmode;
-	bool select_ready;
-	int announce_count;
-	int select_counter_count;
-	int select_counter_type;
+	size_t selected_option{ 0 };
+	ClientCard* attacker{ nullptr };
+	ClientCard* attack_target{ nullptr };
+	unsigned int disabled_field{ 0 };
+	unsigned int selectable_field{ 0 };
+	unsigned int selected_field{ 0 };
+	int select_min{ 0 };
+	int select_max{ 0 };
+	int must_select_count{ 0 };
+	int select_sumval{ 0 };
+	int select_mode{ 0 };
+	bool select_cancelable{ false };
+	bool select_panalmode{ false };
+	bool select_ready{ false };
+	int announce_count{ 0 };
+	int select_counter_count{ 0 };
+	int select_counter_type{ 0 };
 	std::vector<ClientCard*> selectable_cards;
 	std::vector<ClientCard*> selected_cards;
 	std::set<ClientCard*> selectsum_cards;
@@ -76,18 +77,18 @@ public:
 	std::vector<ClientCard*> display_cards;
 	std::vector<int> sort_list;
 	std::map<int, int> player_desc_hints[2];
-	bool grave_act;
-	bool remove_act;
-	bool deck_act;
-	bool extra_act;
-	bool pzone_act[2];
-	bool conti_act;
-	bool chain_forced;
+	bool grave_act{ false };
+	bool remove_act{ false };
+	bool deck_act{ false };
+	bool extra_act{ false };
+	bool pzone_act[2]{ false };
+	bool conti_act{ false };
+	bool chain_forced{ false };
 	ChainInfo current_chain;
-	bool last_chain;
-	bool deck_reversed;
-	bool conti_selecting;
-	bool cant_check_grave;
+	bool last_chain{ false };
+	bool deck_reversed{ false };
+	bool conti_selecting{ false };
+	bool cant_check_grave{ false };
 	mt19937 rnd;
 
 	ClientField();
@@ -126,7 +127,7 @@ public:
 	void UpdateDeclarableList();
 	void RefreshCardCountDisplay();
 
-	irr::gui::IGUIElement* panel;
+	irr::gui::IGUIElement* panel{ nullptr };
 	bool is_dragging_cardtext;
 	bool is_dragging_lstLog;
 	bool is_dragging_lstReplayList;
@@ -137,20 +138,20 @@ public:
     bool is_selectable;
     int dragging_tab_start_pos;
 	int dragging_tab_start_y;
-    std::vector<int> ancard;
-	int hovered_controler;
-	int hovered_location;
-	size_t hovered_sequence;
-	int command_controler;
-	int command_location;
-	size_t command_sequence;
-	ClientCard* hovered_card;
-	int hovered_player;
-	ClientCard* clicked_card;
-	ClientCard* command_card;
-	ClientCard* highlighting_card;
-	ClientCard* menu_card;
-	int list_command;
+	std::vector<int> ancard;
+	int hovered_controler{ 0 };
+	int hovered_location{ 0 };
+	size_t hovered_sequence{ 0 };
+	int command_controler{ 0 };
+	int command_location{ 0 };
+	size_t command_sequence{ 0 };
+	ClientCard* hovered_card{ nullptr };
+	int hovered_player{ 0 };
+	ClientCard* clicked_card{ nullptr };
+	ClientCard* command_card{ nullptr };
+	ClientCard* highlighting_card{ nullptr };
+	ClientCard* menu_card{ nullptr };
+	int list_command{ 0 };
 
 	virtual bool OnEvent(const irr::SEvent& event);
 	virtual bool OnCommonEvent(const irr::SEvent& event);

Classes/gframe/deck_con.cpp

@@ -120,7 +120,7 @@ void DeckBuilder::Terminate() {
 	mainGame->ClearTextures();
 	mainGame->scrFilter->setVisible(false);
 	mainGame->scrPackCards->setVisible(false);
-    mainGame->scrPackCards->setPos(0);
+	mainGame->scrPackCards->setPos(0);
 	int catesel = mainGame->cbDBCategory->getSelected();
 	char linebuf[256];
 	if(catesel >= 0)

Classes/gframe/duelclient.cpp

@@ -2543,7 +2543,7 @@ int DuelClient::ClientAnalyze(char * msg, unsigned int len) {
 		}
 		int appear = mainGame->gameConf.quick_animation ? 12 : 20;
 		if (pl == 0) {
-			ClientCard* pcard = new ClientCard();
+			ClientCard* pcard = new ClientCard;
 			pcard->position = cp;
 			pcard->SetCode(code);
 			if(!mainGame->dInfo.isReplay || !mainGame->dInfo.isReplaySkiping) {
@@ -3836,7 +3836,7 @@ int DuelClient::ClientAnalyze(char * msg, unsigned int len) {
 			}
 		} else {
 			while(mainGame->dField.deck[player].size() < mcount) {
-				ClientCard* ccard = new ClientCard();
+				ClientCard* ccard = new ClientCard;
 				ccard->controler = player;
 				ccard->location = LOCATION_DECK;
 				ccard->sequence = mainGame->dField.deck[player].size();
@@ -3851,7 +3851,7 @@ int DuelClient::ClientAnalyze(char * msg, unsigned int len) {
 			}
 		} else {
 			while(mainGame->dField.hand[player].size() < hcount) {
-				ClientCard* ccard = new ClientCard();
+				ClientCard* ccard = new ClientCard;
 				ccard->controler = player;
 				ccard->location = LOCATION_HAND;
 				ccard->sequence = mainGame->dField.hand[player].size();
@@ -3866,7 +3866,7 @@ int DuelClient::ClientAnalyze(char * msg, unsigned int len) {
 			}
 		} else {
 			while(mainGame->dField.extra[player].size() < ecount) {
-				ClientCard* ccard = new ClientCard();
+				ClientCard* ccard = new ClientCard;
 				ccard->controler = player;
 				ccard->location = LOCATION_EXTRA;
 				ccard->sequence = mainGame->dField.extra[player].size();

Classes/gframe/replay.h

@@ -53,7 +53,7 @@ public:
 	static bool RenameReplay(const wchar_t* oldname, const wchar_t* newname);
 	bool ReadNextResponse(unsigned char resp[64]);
 	void ReadName(wchar_t* data);
-	void ReadHeader(ReplayHeader& header);
+	//void ReadHeader(ReplayHeader& header);
 	void ReadData(void* data, int length);
 	int ReadInt32();
 	short ReadInt16();

Classes/gframe/replay_mode.cpp

@@ -873,15 +873,10 @@ bool ReplayMode::ReplayAnalyze(unsigned char* msg, unsigned int len) {
 	}
 	return true;
 }
-void ReplayMode::ReloadLocation(int player, int location, int flag, std::vector<unsigned char>& queryBuffer) {
+inline 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) {
 	std::vector<byte> queryBuffer;
 	queryBuffer.resize(SIZE_QUERY_BUFFER);
@@ -892,17 +887,22 @@ void ReplayMode::ReplayRefresh(int flag) {
 	ReloadLocation(0, LOCATION_HAND, flag, queryBuffer);
 	ReloadLocation(1, LOCATION_HAND, flag, queryBuffer);
 }
-void ReplayMode::ReplayRefreshHand(int player, int flag) {
-	RefreshLocation(player, LOCATION_HAND, flag);
+void ReplayMode::ReplayRefreshLocation(int player, int location, int flag) {
+	std::vector<unsigned char> queryBuffer;
+	queryBuffer.resize(SIZE_QUERY_BUFFER);
+	ReloadLocation(player, location, flag, queryBuffer);
+}
+inline void ReplayMode::ReplayRefreshHand(int player, int flag) {
+	ReplayRefreshLocation(player, LOCATION_HAND, flag);
 }
-void ReplayMode::ReplayRefreshGrave(int player, int flag) {
-	RefreshLocation(player, LOCATION_GRAVE, flag);
+inline void ReplayMode::ReplayRefreshGrave(int player, int flag) {
+	ReplayRefreshLocation(player, LOCATION_GRAVE, flag);
 }
-void ReplayMode::ReplayRefreshDeck(int player, int flag) {
-	RefreshLocation(player, LOCATION_DECK, flag);
+inline void ReplayMode::ReplayRefreshDeck(int player, int flag) {
+	ReplayRefreshLocation(player, LOCATION_DECK, flag);
 }
-void ReplayMode::ReplayRefreshExtra(int player, int flag) {
-	RefreshLocation(player, LOCATION_EXTRA, flag);
+inline void ReplayMode::ReplayRefreshExtra(int player, int flag) {
+	ReplayRefreshLocation(player, LOCATION_EXTRA, flag);
 }
 void ReplayMode::ReplayRefreshSingle(int player, int location, int sequence, int flag) {
 	unsigned char queryBuffer[0x1000];

Classes/gframe/replay_mode.h

 #ifndef REPLAY_MODE_H
 #define REPLAY_MODE_H
 
+#include <stdint.h>
+#include <vector>
 #include "config.h"
 #include "data_manager.h"
 #include "deck_manager.h"
@@ -22,6 +24,7 @@ private:
 	static int skip_turn;
 	static int current_step;
 	static int skip_step;
+	static void ReloadLocation(int player, int location, int flag, std::vector<unsigned char>& queryBuffer);
 
 public:
 	static Replay cur_replay;
@@ -39,9 +42,8 @@ public:
 	static void Undo();
 	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 ReplayRefreshLocation(int player, int location, int flag);
 	static void ReplayRefreshHand(int player, int flag = 0x781fff);
 	static void ReplayRefreshGrave(int player, int flag = 0x181fff);
 	static void ReplayRefreshDeck(int player, int flag = 0x181fff);

Classes/gframe/single_duel.cpp

@@ -579,6 +579,7 @@ void SingleDuel::Surrender(DuelPlayer* dp) {
 	DuelEndProc();
 	event_del(etimer);
 }
+// Analyze ocgcore message
 int SingleDuel::Analyze(unsigned char* msgbuffer, unsigned int len) {
 	unsigned char* offset, *pbufw, *pbuf = msgbuffer;
 	int player, count, type;
@@ -1463,108 +1464,114 @@ void SingleDuel::TimeConfirm(DuelPlayer* dp) {
 	if(time_elapsed < 10)
 		time_elapsed = 0;
 }
-void SingleDuel::RefreshMzone(int player, int flag, int use_cache) {
-	unsigned char query_buffer[0x2000];
-	auto qbuf = query_buffer;
+inline int SingleDuel::WriteUpdateData(int& player, int location, int& flag, unsigned char*& qbuf, int& use_cache) {
+	flag |= (QUERY_CODE | QUERY_POSITION);
 	BufferIO::WriteInt8(qbuf, MSG_UPDATE_DATA);
 	BufferIO::WriteInt8(qbuf, player);
-	BufferIO::WriteInt8(qbuf, LOCATION_MZONE);
-	int len = query_field_card(pduel, player, LOCATION_MZONE, flag, (unsigned char*)qbuf, use_cache);
-	NetServer::SendBufferToPlayer(players[player], STOC_GAME_MSG, query_buffer, len + 3);
+	BufferIO::WriteInt8(qbuf, location);
+	int len = query_field_card(pduel, player, location, flag, qbuf, use_cache);
+	return len;
+}
+inline unsigned int GetPosition(unsigned char*& qbuf, int offset) {
+	unsigned int info = *(unsigned int*)(qbuf + offset);
+	return info >> 24;
+}
+void SingleDuel::RefreshMzone(int player, int flag, int use_cache) {
+	std::vector<unsigned char> query_buffer;
+	query_buffer.resize(SIZE_QUERY_BUFFER);
+	auto qbuf = query_buffer.data();
+	auto len = WriteUpdateData(player, LOCATION_MZONE, flag, qbuf, use_cache);
+	NetServer::SendBufferToPlayer(players[player], STOC_GAME_MSG, query_buffer.data(), len + 3);
 	int qlen = 0;
 	while(qlen < len) {
-		int clen = BufferIO::ReadInt32(qbuf);
+		const int clen = BufferIO::ReadInt32(qbuf);
 		qlen += clen;
-		if (clen == 4)
+		if (clen <= LEN_HEADER)
 			continue;
-		if (qbuf[11] & POS_FACEDOWN)
+		auto position = GetPosition(qbuf, 8);
+		if (position & POS_FACEDOWN)
 			memset(qbuf, 0, clen - 4);
 		qbuf += clen - 4;
 	}
-	NetServer::SendBufferToPlayer(players[1 - player], STOC_GAME_MSG, query_buffer, len + 3);
+	NetServer::SendBufferToPlayer(players[1 - player], STOC_GAME_MSG, query_buffer.data(), len + 3);
 	for(auto pit = observers.begin(); pit != observers.end(); ++pit)
 		NetServer::ReSendToPlayer(*pit);
 }
 void SingleDuel::RefreshSzone(int player, int flag, int use_cache) {
-	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, qbuf, use_cache);
-	NetServer::SendBufferToPlayer(players[player], STOC_GAME_MSG, query_buffer, len + 3);
+	std::vector<unsigned char> query_buffer;
+	query_buffer.resize(SIZE_QUERY_BUFFER);
+	auto qbuf = query_buffer.data();
+	auto len = WriteUpdateData(player, LOCATION_SZONE, flag, qbuf, use_cache);
+	NetServer::SendBufferToPlayer(players[player], STOC_GAME_MSG, query_buffer.data(), len + 3);
 	int qlen = 0;
 	while(qlen < len) {
-		int clen = BufferIO::ReadInt32(qbuf);
+		const int clen = BufferIO::ReadInt32(qbuf);
 		qlen += clen;
-		if (clen == 4)
+		if (clen <= LEN_HEADER)
 			continue;
-		if (qbuf[11] & POS_FACEDOWN)
+		auto position = GetPosition(qbuf, 8);
+		if (position & POS_FACEDOWN)
 			memset(qbuf, 0, clen - 4);
 		qbuf += clen - 4;
 	}
-	NetServer::SendBufferToPlayer(players[1 - player], STOC_GAME_MSG, query_buffer, len + 3);
+	NetServer::SendBufferToPlayer(players[1 - player], STOC_GAME_MSG, query_buffer.data(), len + 3);
 	for(auto pit = observers.begin(); pit != observers.end(); ++pit)
 		NetServer::ReSendToPlayer(*pit);
 }
 void SingleDuel::RefreshHand(int player, int flag, int use_cache) {
-	unsigned char query_buffer[0x2000];
-	auto qbuf = query_buffer;
-	BufferIO::WriteInt8(qbuf, MSG_UPDATE_DATA);
-	BufferIO::WriteInt8(qbuf, player);
-	BufferIO::WriteInt8(qbuf, LOCATION_HAND);
-	int len = query_field_card(pduel, player, LOCATION_HAND, flag | QUERY_POSITION, (unsigned char*)qbuf, use_cache);
-	NetServer::SendBufferToPlayer(players[player], STOC_GAME_MSG, query_buffer, len + 3);
+	std::vector<unsigned char> query_buffer;
+	query_buffer.resize(SIZE_QUERY_BUFFER);
+	auto qbuf = query_buffer.data();
+	auto len = WriteUpdateData(player, LOCATION_HAND, flag, qbuf, use_cache);
+	NetServer::SendBufferToPlayer(players[player], STOC_GAME_MSG, query_buffer.data(), len + 3);
 	int qlen = 0;
 	while(qlen < len) {
-		int slen = BufferIO::ReadInt32(qbuf);
-		int qflag = *(int*)qbuf;
-		int offset = 8;
-		if(!(qflag & QUERY_CODE))
-			offset -= 4;
-		unsigned position = ((*(int*)(qbuf + offset)) >> 24) & 0xff;
+		const int slen = BufferIO::ReadInt32(qbuf);
+		qlen += slen;
+		if (slen <= LEN_HEADER)
+			continue;
+		auto position = GetPosition(qbuf, 8);
 		if(!(position & POS_FACEUP))
 			memset(qbuf, 0, slen - 4);
 		qbuf += slen - 4;
-		qlen += slen;
 	}
-	NetServer::SendBufferToPlayer(players[1 - player], STOC_GAME_MSG, query_buffer, len + 3);
+	NetServer::SendBufferToPlayer(players[1 - player], STOC_GAME_MSG, query_buffer.data(), len + 3);
 	for(auto pit = observers.begin(); pit != observers.end(); ++pit)
 		NetServer::ReSendToPlayer(*pit);
 }
 void SingleDuel::RefreshGrave(int player, int flag, int use_cache) {
-	unsigned char query_buffer[0x2000];
-	auto qbuf = query_buffer;
-	BufferIO::WriteInt8(qbuf, MSG_UPDATE_DATA);
-	BufferIO::WriteInt8(qbuf, player);
-	BufferIO::WriteInt8(qbuf, LOCATION_GRAVE);
-	int len = query_field_card(pduel, player, LOCATION_GRAVE, flag, (unsigned char*)qbuf, use_cache);
-	NetServer::SendBufferToPlayer(players[0], STOC_GAME_MSG, query_buffer, len + 3);
+	std::vector<unsigned char> query_buffer;
+	query_buffer.resize(SIZE_QUERY_BUFFER);
+	auto qbuf = query_buffer.data();
+	auto len = WriteUpdateData(player, LOCATION_GRAVE, flag, qbuf, use_cache);
+	NetServer::SendBufferToPlayer(players[0], STOC_GAME_MSG, query_buffer.data(), len + 3);
 	NetServer::ReSendToPlayer(players[1]);
 	for(auto pit = observers.begin(); pit != observers.end(); ++pit)
 		NetServer::ReSendToPlayer(*pit);
 }
 void SingleDuel::RefreshExtra(int player, int flag, int use_cache) {
-	unsigned char query_buffer[0x2000];
-	auto qbuf = query_buffer;
-	BufferIO::WriteInt8(qbuf, MSG_UPDATE_DATA);
-	BufferIO::WriteInt8(qbuf, player);
-	BufferIO::WriteInt8(qbuf, LOCATION_EXTRA);
-	int len = query_field_card(pduel, player, LOCATION_EXTRA, flag, (unsigned char*)qbuf, use_cache);
-	NetServer::SendBufferToPlayer(players[player], STOC_GAME_MSG, query_buffer, len + 3);
+	std::vector<unsigned char> query_buffer;
+	query_buffer.resize(SIZE_QUERY_BUFFER);
+	auto qbuf = query_buffer.data();
+	auto len = WriteUpdateData(player, LOCATION_EXTRA, flag, qbuf, use_cache);
+	NetServer::SendBufferToPlayer(players[player], STOC_GAME_MSG, query_buffer.data(), len + 3);
 }
 void SingleDuel::RefreshSingle(int player, int location, int sequence, int flag) {
-	unsigned char query_buffer[0x2000];
+	flag |= (QUERY_CODE | QUERY_POSITION);
+	unsigned char query_buffer[0x1000];
 	auto qbuf = query_buffer;
 	BufferIO::WriteInt8(qbuf, MSG_UPDATE_CARD);
 	BufferIO::WriteInt8(qbuf, player);
 	BufferIO::WriteInt8(qbuf, location);
 	BufferIO::WriteInt8(qbuf, sequence);
-	int len = query_card(pduel, player, location, sequence, flag, (unsigned char*)qbuf, 0);
+	int len = query_card(pduel, player, location, sequence, flag, qbuf, 0);
 	NetServer::SendBufferToPlayer(players[player], STOC_GAME_MSG, query_buffer, len + 4);
-	if(location == LOCATION_REMOVED && (qbuf[15] & POS_FACEDOWN))
+	if (len <= LEN_HEADER)
+		return;
+	auto position = GetPosition(qbuf, 12);
+	if(location == LOCATION_REMOVED && (position & POS_FACEDOWN))
 		return;
-	if ((location & 0x90) || ((location & 0x2c) && (qbuf[15] & POS_FACEUP))) {
+	if ((location & 0x90) || ((location & 0x2c) && (position & POS_FACEUP))) {
 		NetServer::ReSendToPlayer(players[1 - player]);
 		for(auto pit = observers.begin(); pit != observers.end(); ++pit)
 			NetServer::ReSendToPlayer(*pit);

Classes/gframe/single_duel.h

@@ -40,6 +40,9 @@ public:
 
 	static int MessageHandler(intptr_t fduel, int type);
 	static void SingleTimer(evutil_socket_t fd, short events, void* arg);
+
+private:
+	int WriteUpdateData(int& player, int location, int& flag, unsigned char*& qbuf, int& use_cache);
 	
 protected:
 	DuelPlayer* players[2];

Classes/gframe/single_mode.cpp

@@ -764,15 +764,10 @@ bool SingleMode::SinglePlayAnalyze(unsigned char* msg, unsigned int len) {
 	}
 	return is_continuing;
 }
-void SingleMode::ReloadLocation(int player, int location, int flag, std::vector<unsigned char>& queryBuffer) {
+inline 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) {
 	std::vector<unsigned char> queryBuffer;
 	queryBuffer.resize(SIZE_QUERY_BUFFER);
@@ -783,17 +778,22 @@ void SingleMode::SinglePlayRefresh(int flag) {
 	ReloadLocation(0, LOCATION_HAND, flag, queryBuffer);
 	ReloadLocation(1, LOCATION_HAND, flag, queryBuffer);
 }
-void SingleMode::SinglePlayRefreshHand(int player, int flag) {
-	RefreshLocation(player, LOCATION_HAND, flag);
+void SingleMode::SingleRefreshLocation(int player, int location, int flag) {
+	std::vector<unsigned char> queryBuffer;
+	queryBuffer.resize(SIZE_QUERY_BUFFER);
+	ReloadLocation(player, location, flag, queryBuffer);
+}
+inline void SingleMode::SinglePlayRefreshHand(int player, int flag) {
+	SingleRefreshLocation(player, LOCATION_HAND, flag);
 }
-void SingleMode::SinglePlayRefreshGrave(int player, int flag) {
-	RefreshLocation(player, LOCATION_GRAVE, flag);
+inline void SingleMode::SinglePlayRefreshGrave(int player, int flag) {
+	SingleRefreshLocation(player, LOCATION_GRAVE, flag);
 }
-void SingleMode::SinglePlayRefreshDeck(int player, int flag) {
-	RefreshLocation(player, LOCATION_DECK, flag);
+inline void SingleMode::SinglePlayRefreshDeck(int player, int flag) {
+	SingleRefreshLocation(player, LOCATION_DECK, flag);
 }
-void SingleMode::SinglePlayRefreshExtra(int player, int flag) {
-	RefreshLocation(player, LOCATION_EXTRA, flag);
+inline void SingleMode::SinglePlayRefreshExtra(int player, int flag) {
+	SingleRefreshLocation(player, LOCATION_EXTRA, flag);
 }
 void SingleMode::SinglePlayRefreshSingle(int player, int location, int sequence, int flag) {
 	unsigned char queryBuffer[0x1000];

Classes/gframe/single_mode.h

 #ifndef SINGLE_MODE_H
 #define SINGLE_MODE_H
 
+#include <stdint.h>
+#include <vector>
 #include "replay.h"
 
 namespace ygo {
@@ -10,6 +12,7 @@ private:
 	static intptr_t pduel;
 	static bool is_closing;
 	static bool is_continuing;
+	static void ReloadLocation(int player, int location, int flag, std::vector<unsigned char>& queryBuffer);
 
 public:
 	static bool StartPlay();
@@ -18,9 +21,8 @@ public:
 	static int SinglePlayThread();
 	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 SingleRefreshLocation(int player, int location, int flag);
 	static void SinglePlayRefreshHand(int player, int flag = 0x781fff);
 	static void SinglePlayRefreshGrave(int player, int flag = 0x181fff);
 	static void SinglePlayRefreshDeck(int player, int flag = 0x181fff);

Classes/gframe/tag_duel.cpp

@@ -1550,93 +1550,97 @@ void TagDuel::TimeConfirm(DuelPlayer* dp) {
 	if(time_elapsed < 10)
 		time_elapsed = 0;
 }
-void TagDuel::RefreshMzone(int player, int flag, int use_cache) {
-	unsigned char query_buffer[0x4000];
-	auto qbuf = query_buffer;
+inline int TagDuel::WriteUpdateData(int& player, int location, int& flag, unsigned char*& qbuf, int& use_cache) {
+	flag |= (QUERY_CODE | QUERY_POSITION);
 	BufferIO::WriteInt8(qbuf, MSG_UPDATE_DATA);
 	BufferIO::WriteInt8(qbuf, player);
-	BufferIO::WriteInt8(qbuf, LOCATION_MZONE);
-	int len = query_field_card(pduel, player, LOCATION_MZONE, flag, (unsigned char*)qbuf, use_cache);
+	BufferIO::WriteInt8(qbuf, location);
+	int len = query_field_card(pduel, player, location, flag, qbuf, use_cache);
+	return len;
+}
+inline unsigned int GetPosition(unsigned char*& qbuf, int offset) {
+	unsigned int info = *(unsigned int*)(qbuf + offset);
+	return info >> 24;
+}
+void TagDuel::RefreshMzone(int player, int flag, int use_cache) {
+	std::vector<unsigned char> query_buffer;
+	query_buffer.resize(SIZE_QUERY_BUFFER);
+	auto qbuf = query_buffer.data();
+	auto len = WriteUpdateData(player, LOCATION_MZONE, flag, qbuf, use_cache);
 	int pid = (player == 0) ? 0 : 2;
-	NetServer::SendBufferToPlayer(players[pid], STOC_GAME_MSG, query_buffer, len + 3);
+	NetServer::SendBufferToPlayer(players[pid], STOC_GAME_MSG, query_buffer.data(), len + 3);
 	NetServer::ReSendToPlayer(players[pid + 1]);
 	int qlen = 0;
 	while(qlen < len) {
 		int clen = BufferIO::ReadInt32(qbuf);
 		qlen += clen;
-		if (clen == 4)
+		if (clen <= LEN_HEADER)
 			continue;
-		if (qbuf[11] & POS_FACEDOWN)
+		auto position = GetPosition(qbuf, 8);
+		if (position & POS_FACEDOWN)
 			memset(qbuf, 0, clen - 4);
 		qbuf += clen - 4;
 	}
 	pid = 2 - pid;
-	NetServer::SendBufferToPlayer(players[pid], STOC_GAME_MSG, query_buffer, len + 3);
+	NetServer::SendBufferToPlayer(players[pid], STOC_GAME_MSG, query_buffer.data(), len + 3);
 	NetServer::ReSendToPlayer(players[pid + 1]);
 	for(auto pit = observers.begin(); pit != observers.end(); ++pit)
 		NetServer::ReSendToPlayer(*pit);
 }
 void TagDuel::RefreshSzone(int player, int flag, int use_cache) {
-	unsigned char query_buffer[0x4000];
-	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);
+	std::vector<unsigned char> query_buffer;
+	query_buffer.resize(SIZE_QUERY_BUFFER);
+	auto qbuf = query_buffer.data();
+	auto len = WriteUpdateData(player, LOCATION_SZONE, flag, qbuf, use_cache);
 	int pid = (player == 0) ? 0 : 2;
-	NetServer::SendBufferToPlayer(players[pid], STOC_GAME_MSG, query_buffer, len + 3);
+	NetServer::SendBufferToPlayer(players[pid], STOC_GAME_MSG, query_buffer.data(), len + 3);
 	NetServer::ReSendToPlayer(players[pid + 1]);
 	int qlen = 0;
 	while(qlen < len) {
 		int clen = BufferIO::ReadInt32(qbuf);
 		qlen += clen;
-		if (clen == 4)
+		if (clen <= LEN_HEADER)
 			continue;
-		if (qbuf[11] & POS_FACEDOWN)
+		auto position = GetPosition(qbuf, 8);
+		if (position & POS_FACEDOWN)
 			memset(qbuf, 0, clen - 4);
 		qbuf += clen - 4;
 	}
 	pid = 2 - pid;
-	NetServer::SendBufferToPlayer(players[pid], STOC_GAME_MSG, query_buffer, len + 3);
+	NetServer::SendBufferToPlayer(players[pid], STOC_GAME_MSG, query_buffer.data(), len + 3);
 	NetServer::ReSendToPlayer(players[pid + 1]);
 	for(auto pit = observers.begin(); pit != observers.end(); ++pit)
 		NetServer::ReSendToPlayer(*pit);
 }
 void TagDuel::RefreshHand(int player, int flag, int use_cache) {
-	unsigned char query_buffer[0x4000];
-	auto qbuf = query_buffer;
-	BufferIO::WriteInt8(qbuf, MSG_UPDATE_DATA);
-	BufferIO::WriteInt8(qbuf, player);
-	BufferIO::WriteInt8(qbuf, LOCATION_HAND);
-	int len = query_field_card(pduel, player, LOCATION_HAND, flag | QUERY_POSITION, (unsigned char*)qbuf, use_cache);
-	NetServer::SendBufferToPlayer(cur_player[player], STOC_GAME_MSG, query_buffer, len + 3);
+	std::vector<unsigned char> query_buffer;
+	query_buffer.resize(SIZE_QUERY_BUFFER);
+	auto qbuf = query_buffer.data();
+	auto len = WriteUpdateData(player, LOCATION_HAND, flag, qbuf, use_cache);
+	NetServer::SendBufferToPlayer(cur_player[player], STOC_GAME_MSG, query_buffer.data(), len + 3);
 	int qlen = 0;
 	while(qlen < len) {
 		int slen = BufferIO::ReadInt32(qbuf);
-		int qflag = *(int*)qbuf;
-		int offset = 8;
-		if(!(qflag & QUERY_CODE))
-			offset -= 4;
-		unsigned position = ((*(int*)(qbuf + offset)) >> 24) & 0xff;
+		qlen += slen;
+		if (slen <= LEN_HEADER)
+			continue;
+		auto position = GetPosition(qbuf, 8);
 		if(!(position & POS_FACEUP))
 			memset(qbuf, 0, slen - 4);
 		qbuf += slen - 4;
-		qlen += slen;
 	}
 	for(int i = 0; i < 4; ++i)
 		if(players[i] != cur_player[player])
-			NetServer::SendBufferToPlayer(players[i], STOC_GAME_MSG, query_buffer, len + 3);
+			NetServer::SendBufferToPlayer(players[i], STOC_GAME_MSG, query_buffer.data(), len + 3);
 	for(auto pit = observers.begin(); pit != observers.end(); ++pit)
 		NetServer::ReSendToPlayer(*pit);
 }
 void TagDuel::RefreshGrave(int player, int flag, int use_cache) {
-	unsigned char query_buffer[0x4000];
-	auto qbuf = query_buffer;
-	BufferIO::WriteInt8(qbuf, MSG_UPDATE_DATA);
-	BufferIO::WriteInt8(qbuf, player);
-	BufferIO::WriteInt8(qbuf, LOCATION_GRAVE);
-	int len = query_field_card(pduel, player, LOCATION_GRAVE, flag, (unsigned char*)qbuf, use_cache);
-	NetServer::SendBufferToPlayer(players[0], STOC_GAME_MSG, query_buffer, len + 3);
+	std::vector<unsigned char> query_buffer;
+	query_buffer.resize(SIZE_QUERY_BUFFER);
+	auto qbuf = query_buffer.data();
+	auto len = WriteUpdateData(player, LOCATION_GRAVE, flag, qbuf, use_cache);
+	NetServer::SendBufferToPlayer(players[0], STOC_GAME_MSG, query_buffer.data(), len + 3);
 	NetServer::ReSendToPlayer(players[1]);
 	NetServer::ReSendToPlayer(players[2]);
 	NetServer::ReSendToPlayer(players[3]);
@@ -1644,27 +1648,27 @@ void TagDuel::RefreshGrave(int player, int flag, int use_cache) {
 		NetServer::ReSendToPlayer(*pit);
 }
 void TagDuel::RefreshExtra(int player, int flag, int use_cache) {
-	unsigned char query_buffer[0x4000];
-	auto qbuf = query_buffer;
-	BufferIO::WriteInt8(qbuf, MSG_UPDATE_DATA);
-	BufferIO::WriteInt8(qbuf, player);
-	BufferIO::WriteInt8(qbuf, LOCATION_EXTRA);
-	int len = query_field_card(pduel, player, LOCATION_EXTRA, flag, (unsigned char*)qbuf, use_cache);
-	NetServer::SendBufferToPlayer(cur_player[player], STOC_GAME_MSG, query_buffer, len + 3);
+	std::vector<unsigned char> query_buffer;
+	query_buffer.resize(SIZE_QUERY_BUFFER);
+	auto qbuf = query_buffer.data();
+	auto len = WriteUpdateData(player, LOCATION_EXTRA, flag, qbuf, use_cache);
+	NetServer::SendBufferToPlayer(cur_player[player], STOC_GAME_MSG, query_buffer.data(), len + 3);
 }
 void TagDuel::RefreshSingle(int player, int location, int sequence, int flag) {
-	unsigned char query_buffer[0x4000];
+	flag |= (QUERY_CODE | QUERY_POSITION);
+	unsigned char query_buffer[0x1000];
 	auto qbuf = query_buffer;
 	BufferIO::WriteInt8(qbuf, MSG_UPDATE_CARD);
 	BufferIO::WriteInt8(qbuf, player);
 	BufferIO::WriteInt8(qbuf, location);
 	BufferIO::WriteInt8(qbuf, sequence);
-	int len = query_card(pduel, player, location, sequence, flag, (unsigned char*)qbuf, 0);
+	int len = query_card(pduel, player, location, sequence, flag, qbuf, 0);
+	auto position = GetPosition(qbuf, 12);
 	if(location & LOCATION_ONFIELD) {
 		int pid = (player == 0) ? 0 : 2;
 		NetServer::SendBufferToPlayer(players[pid], STOC_GAME_MSG, query_buffer, len + 4);
 		NetServer::ReSendToPlayer(players[pid + 1]);
-		if(qbuf[15] & POS_FACEUP) {
+		if(position & POS_FACEUP) {
 			pid = 2 - pid;
 			NetServer::SendBufferToPlayer(players[pid], STOC_GAME_MSG, query_buffer, len + 4);
 			NetServer::ReSendToPlayer(players[pid + 1]);
@@ -1675,7 +1679,7 @@ void TagDuel::RefreshSingle(int player, int location, int sequence, int flag) {
 		int pid = (player == 0) ? 0 : 2;
 		NetServer::SendBufferToPlayer(players[pid], STOC_GAME_MSG, query_buffer, len + 4);
 		NetServer::ReSendToPlayer(players[pid + 1]);
-		if(location == LOCATION_REMOVED && (qbuf[15] & POS_FACEDOWN))
+		if(location == LOCATION_REMOVED && (position & POS_FACEDOWN))
 			return;
 		if (location & 0x90) {
 			for(int i = 0; i < 4; ++i)

Classes/gframe/tag_duel.h

@@ -40,6 +40,9 @@ public:
 
 	static int MessageHandler(intptr_t fduel, int type);
 	static void TagTimer(evutil_socket_t fd, short events, void* arg);
+
+private:
+	int WriteUpdateData(int& player, int location, int& flag, unsigned char*& qbuf, int& use_cache);
 	
 protected:
 	DuelPlayer* players[4];