recon

gframe/client_card.cpp

@@ -16,6 +16,7 @@ ClientCard::ClientCard() {
 	is_showtarget = false;
 	is_highlighting = false;
 	is_disabled = false;
+	is_confirming = false;
 	cmdFlag = 0;
 	code = 0;
 	type = 0;

gframe/client_card.h

@@ -58,6 +58,7 @@ public:
 	bool is_showequip;
 	bool is_showtarget;
 	bool is_highlighting;
+	bool is_confirming;
 	u32 code;
 	u32 alias;
 	u32 type;

gframe/client_field.cpp

@@ -595,9 +595,15 @@ void ClientField::GetCardLocation(ClientCard* pcard, irr::core::vector3df* t, ir
 				t->Y = 4.0f;
 				t->Z = 0.5f + 0.001f * sequence;
 			}
-			r->X = -0.661f;
-			r->Y = 0.0f;
-			r->Z = 0.0f;
+			if(!pcard->is_confirming && !pcard->code) {
+				r->X = -0.661f;
+				r->Y = 0.0f;
+				r->Z = 0.0f;
+			} else {
+				r->X = -0.661f;
+				r->Y = 0;
+				r->Z = 0;
+			}
 		} else {
 			if (count <= 6)
 				t->X = 6.25f - (5.5f - 0.8f * count) / 2 - sequence * 0.8f;

gframe/duelclient.cpp

@@ -242,13 +242,25 @@ void DuelClient::HandleSTOCPacketLan(char* data, unsigned int len) {
 		}
 		break;
 	}
-	case STOC_GAME_START: {
+	case STOC_DUEL_START: {
 		mainGame->gMutex.Lock();
 		mainGame->dField.Clear();
 		mainGame->dInfo.isStarted = true;
+		mainGame->wCardImg->setVisible(true);
+		mainGame->wInfos->setVisible(true);
 		mainGame->gMutex.Unlock();
 		break;
 	}
+	case STOC_DUEL_END: {
+
+		break;
+	}
+	case STOC_REPLAY: {
+		mainGame->localAction.Reset();
+		mainGame->ShowElement(mainGame->wReplaySave);
+		mainGame->localAction.Wait();
+		break;
+	}
 	case STOC_HS_PLAYER_ENTER: {
 		STOC_HS_PlayerEnter* pkt = (STOC_HS_PlayerEnter*)pdata;
 		if(pkt->pos > 1)

gframe/game.cpp

@@ -204,6 +204,16 @@ bool Game::Initialize() {
 	chkAutoChain = env->addCheckBox(false, rect<s32>(20, 80, 280, 105), tabSystem, -1, dataManager.GetSysString(1276));
 	chkAutoChain->setChecked(true);
 	chkWaitChain = env->addCheckBox(false, rect<s32>(20, 110, 280, 135), tabSystem, -1, dataManager.GetSysString(1277));
+	//
+	wHand = env->addWindow(rect<s32>(500, 450, 825, 605), false, L"");
+	wHand->getCloseButton()->setVisible(false);
+	wHand->setDraggable(false);
+	wHand->setDrawTitlebar(false);
+	wHand->setVisible(false);
+	for(int i = 0; i < 3; ++i) {
+		btnHand[i] = env->addButton(rect<s32>(10 + 105 * i, 10, 105 + 105 * i, 144), wHand, BUTTON_HAND1 + i, L"");
+		btnHand[i]->setImage(imageManager.tHand[i]);
+	}
 	//message (310)
 	wMessage = env->addWindow(rect<s32>(490, 200, 840, 340), false, dataManager.GetSysString(1216));
 	wMessage->getCloseButton()->setVisible(false);

gframe/game.h

@@ -218,6 +218,9 @@ public:
 	//replay
 	irr::gui::IGUIListBox* lstReplayList;
 	irr::gui::IGUIButton* btnLoadReplay;
+	//hand
+	irr::gui::IGUIWindow* wHand;
+	irr::gui::IGUIButton* btnHand[3];
 	//message
 	irr::gui::IGUIWindow* wMessage;
 	irr::gui::IGUIStaticText* stMessage;
@@ -362,6 +365,9 @@ extern Game* mainGame;
 #define BUTTON_MSG_OK				200
 #define BUTTON_YES					201
 #define BUTTON_NO					202
+#define BUTTON_HAND1				205
+#define BUTTON_HAND2				206
+#define BUTTON_HAND3				207
 #define BUTTON_POS_AU				210
 #define BUTTON_POS_AD				211
 #define BUTTON_POS_DU				212

gframe/image_manager.cpp

@@ -17,6 +17,9 @@ bool ImageManager::Initial() {
 	tEquip = driver->getTexture("textures/equip.png");
 	tTarget = driver->getTexture("textures/target.png");
 	tLim = driver->getTexture("textures/lim.png");
+	tHand[0] = driver->getTexture("textures/f1.jpg");
+	tHand[1] = driver->getTexture("textures/f2.jpg");
+	tHand[2] = driver->getTexture("textures/f3.jpg");
 	tBackGround = driver->getTexture("textures/bg.jpg");
 	return true;
 }

gframe/image_manager.h

@@ -32,6 +32,7 @@ public:
 	irr::video::ITexture* tEquip;
 	irr::video::ITexture* tTarget;
 	irr::video::ITexture* tLim;
+	irr::video::ITexture* tHand[3];
 	irr::video::ITexture* tBackGround;
 };
 

gframe/netserver.cpp

@@ -108,14 +108,29 @@ void NetServer::HandleCTOSPacket(DuelPlayer* dp, char* data, unsigned int len) {
 	if(dp->state == 0xff || (dp->state && dp->state != pktType))
 		return;
 	switch(pktType) {
-	case CTOS_RESPONSE:
+	case CTOS_RESPONSE: {
 		break;
+	}
 	case CTOS_UPDATE_DECK: {
 		if(!dp->game || !duel_mode)
 			return;
 		duel_mode->UpdateDeck(dp, pdata);
 		break;
 	}
+	case CTOS_HAND_RESULT: {
+		if(!dp->game)
+			return;
+		CTOS_HandResult* pkt = (CTOS_HandResult*)pdata;
+		dp->game->HandResult(dp, pkt->res);
+		break;
+	}
+	case CTOS_TP_RESULT: {
+		if(!dp->game)
+			return;
+		CTOS_TPResult* pkt = (CTOS_TPResult*)pdata;
+		dp->game->TPResult(dp, pkt->res);
+		break;
+	}
 	case CTOS_PLAYER_INFO: {
 		CTOS_PlayerInfo* pkt = (CTOS_PlayerInfo*)pdata;
 		BufferIO::CopyWStr(pkt->name, dp->name, 20);

gframe/network.h

@@ -32,6 +32,12 @@ struct HostPacket {
 struct HostRequest {
 	unsigned short identifier;
 };
+struct CTOS_HandResult {
+	unsigned char res;
+};
+struct CTOS_TPResult {
+	unsigned char res;
+};
 struct CTOS_PlayerInfo {
 	unsigned short name[20];
 };
@@ -51,6 +57,10 @@ struct STOC_ErrorMsg {
 	unsigned char msg;
 	unsigned int code;
 };
+struct STOC_HandResult {
+	unsigned char res1;
+	unsigned char res2;
+};
 struct STOC_CreateGame {
 	unsigned int gameid;
 };
@@ -93,31 +103,23 @@ struct DuelPlayer {
 
 class DuelMode {
 public:
-	DuelMode() {
-		for(int i = 0; i < 6; ++i) {
-			players[i] = 0;
-			ready[i] = false;
-		}
-		host_player = 0;
-		pduel = 0;
-	}
+	DuelMode(): host_player(0), pduel(0) {}
 	virtual ~DuelMode() {}
-	virtual void JoinGame(DuelPlayer* dp, void* pdata, bool is_creater) = 0;
-	virtual void LeaveGame(DuelPlayer* dp) = 0;
-	virtual void ToDuelist(DuelPlayer* dp) = 0;
-	virtual void ToObserver(DuelPlayer* dp) = 0;
-	virtual void PlayerReady(DuelPlayer* dp, bool is_ready) = 0;
-	virtual void PlayerKick(DuelPlayer* dp, unsigned char pos) = 0;
-	virtual void UpdateDeck(DuelPlayer* dp, void* pdata) = 0;
-	virtual void StartDuel(DuelPlayer* dp) = 0;
-	virtual void Process() = 0;
-	virtual void EndDuel() = 0;
-	
+	virtual void JoinGame(DuelPlayer* dp, void* pdata, bool is_creater) {};
+	virtual void LeaveGame(DuelPlayer* dp) {};
+	virtual void ToDuelist(DuelPlayer* dp) {};
+	virtual void ToObserver(DuelPlayer* dp) {};
+	virtual void PlayerReady(DuelPlayer* dp, bool is_ready) {};
+	virtual void PlayerKick(DuelPlayer* dp, unsigned char pos) {};
+	virtual void UpdateDeck(DuelPlayer* dp, void* pdata) {};
+	virtual void StartDuel(DuelPlayer* dp) {};
+	virtual void HandResult(DuelPlayer* dp, unsigned char res) {};
+	virtual void TPResult(DuelPlayer* dp, unsigned char tp) {};
+	virtual void Process() {};
+	virtual int Analyze(char* msgbuffer, unsigned int len) {};
+	virtual void EndDuel() {};
+
 public:
-	DuelPlayer* players[6];
-	bool ready[6];
-	Deck pdeck[6];
-	std::set<DuelPlayer*> observers;
 	DuelPlayer* host_player;
 	HostInfo host_info;
 	unsigned long pduel;
@@ -140,6 +142,8 @@ public:
 
 #define CTOS_RESPONSE		0x1
 #define CTOS_UPDATE_DECK	0x2
+#define CTOS_HAND_RESULT	0x3
+#define CTOS_TP_RESULT		0x4
 #define CTOS_PLAYER_INFO	0x10
 #define CTOS_CREATE_GAME	0x11
 #define CTOS_JOIN_GAME		0x12
@@ -153,11 +157,17 @@ public:
 
 #define STOC_GAME_MSG		0x1
 #define STOC_ERROR_MSG		0x2
+#define STOC_SELECT_HAND	0x3
+#define STOC_SELECT_TP		0x4
+#define STOC_HAND_RESULT	0x5
+#define STOC_TP_RESULT		0x6
 #define STOC_CREATE_GAME	0x11
 #define STOC_JOIN_GAME		0x12
 #define STOC_TYPE_CHANGE	0x13
 #define STOC_LEAVE_GAME		0x14
-#define STOC_GAME_START		0x15
+#define STOC_DUEL_START		0x15
+#define STOC_DUEL_END		0x16
+#define STOC_REPLAY			0x17
 #define STOC_HS_PLAYER_ENTER	0x20
 #define STOC_HS_PLAYER_CHANGE	0x21
 #define STOC_HS_WATCH_CHANGE	0x22

gframe/single_duel.cpp

@@ -7,6 +7,14 @@
 
 namespace ygo {
 
+SingleDuel::SingleDuel() {
+	for(int i = 0; i < 2; ++i) {
+		players[i] = 0;
+		ready[i] = false;
+	}
+}
+SingleDuel::~SingleDuel() {
+}
 void SingleDuel::JoinGame(DuelPlayer* dp, void* pdata, bool is_creater) {
 	if(!is_creater) {
 		if(dp->game && dp->type != 0xff) {
@@ -224,10 +232,864 @@ void SingleDuel::StartDuel(DuelPlayer* dp) {
 	if(!ready[0] || !ready[1])
 		return;
 	NetServer::StopListen();
+	NetServer::SendPacketToPlayer(players[0], STOC_DUEL_START);
+	NetServer::ReSendToPlayer(players[1]);
+	for(auto oit = observers.begin(); oit != observers.end(); ++oit) {
+		(*oit)->state = CTOS_LEAVE_GAME;
+		NetServer::ReSendToPlayer(*oit);
+	}
+	NetServer::SendPacketToPlayer(players[0], STOC_SELECT_HAND);
+	NetServer::ReSendToPlayer(players[1]);
+	hand_result[0] = 0;
+	hand_result[1] = 0;
+	players[0]->state = CTOS_HAND_RESULT;
+	players[1]->state = CTOS_HAND_RESULT;
+}
+void SingleDuel::HandResult(DuelPlayer* dp, unsigned char res) {
+	if(res > 3)
+		return;
+	if(dp->state != CTOS_HAND_RESULT)
+		return;
+	hand_result[dp->type] = res;
+	if(hand_result[0] && hand_result[1]) {
+		STOC_HandResult schr;
+		schr.res1 = hand_result[0];
+		schr.res1 = hand_result[1];
+		NetServer::SendPacketToPlayer(players[0], STOC_HAND_RESULT, schr);
+		schr.res1 = hand_result[1];
+		schr.res1 = hand_result[0];
+		NetServer::SendPacketToPlayer(players[1], STOC_HAND_RESULT, schr);
+		if(hand_result[0] == hand_result[1]) {
+			NetServer::SendPacketToPlayer(players[0], STOC_SELECT_HAND);
+			NetServer::ReSendToPlayer(players[1]);
+			hand_result[0] = 0;
+			hand_result[1] = 0;
+			players[0]->state = CTOS_HAND_RESULT;
+			players[1]->state = CTOS_HAND_RESULT;
+		} else if((hand_result[0] == 1 && hand_result[1] == 2)
+		          || (hand_result[0] == 2 && hand_result[1] == 3)
+		          || (hand_result[0] == 3 && hand_result[1] == 1)) {
+			NetServer::SendPacketToPlayer(players[1], CTOS_TP_RESULT);
+			players[0]->state = 0xff;
+			players[1]->state = CTOS_TP_RESULT;
+		} else {
+			NetServer::SendPacketToPlayer(players[0], CTOS_TP_RESULT);
+			players[1]->state = 0xff;
+			players[0]->state = CTOS_TP_RESULT;
+		}
+	}
+}
+void SingleDuel::TPResult(DuelPlayer* dp, unsigned char tp) {
+	if(dp->state != CTOS_TP_RESULT)
+		return;
+	if((tp && dp->type == 1) || (!tp && dp->type == 0)) {
+		DuelPlayer* p = players[0];
+		players[0] = players[1];
+		players[1] = p;
+		players[0]->type = 0;
+		players[1]->type = 1;
+		Deck d = pdeck[0];
+		pdeck[0] = pdeck[1];
+		pdeck[1] = d;
+	}
+	dp->state = CTOS_RESPONSE;
+	ReplayHeader rh;
+	rh.id = 0x31707279;
+	rh.version = PRO_VERSION;
+	time_t seed = time(0);
+	rh.seed = seed;
+	last_replay.BeginRecord();
+	last_replay.WriteHeader(rh);
+	rnd.reset(seed);
+	last_replay.WriteData(players[0], 40, false);
+	last_replay.WriteData(players[1], 40, false);
+	for(int i = 0; i < pdeck[0].main.size(); ++i) {
+		int swap = rnd.real() * pdeck[0].main.size();
+		auto tmp = pdeck[0].main[i];
+		pdeck[0].main[i] = pdeck[0].main[swap];
+		pdeck[0].main[swap] = tmp;
+	}
+	for(int i = 0; i < pdeck[1].main.size(); ++i) {
+		int swap = rnd.real() * pdeck[1].main.size();
+		auto tmp = pdeck[1].main[i];
+		pdeck[1].main[i] = pdeck[1].main[swap];
+		pdeck[1].main[swap] = tmp;
+	}
+	set_card_reader((card_reader)DataManager::CardReader);
+	set_message_handler((message_handler)SingleDuel::MessageHandler);
+	rnd.reset(seed);
+	pduel = create_duel(rnd.rand());
+	set_player_info(pduel, 0, host_info.start_lp, host_info.start_hand, host_info.draw_count);
+	set_player_info(pduel, 1, host_info.start_lp, host_info.start_hand, host_info.draw_count);
+	int opt = 0;
+	last_replay.WriteInt32(host_info.start_lp, false);
+	last_replay.WriteInt32(host_info.start_hand, false);
+	last_replay.WriteInt32(host_info.draw_count, false);
+	last_replay.WriteInt32(opt, false);
+	last_replay.Flush();
+	last_replay.WriteInt32(pdeck[0].main.size(), false);
+	for(int i = pdeck[0].main.size() - 1; i >= 0; --i) {
+		new_card(pduel, pdeck[0].main[i]->first, 0, 0, LOCATION_DECK, 0, 0);
+		last_replay.WriteInt32(pdeck[0].main[i]->first, false);
+	}
+	last_replay.WriteInt32(pdeck[0].extra.size(), false);
+	for(int i = pdeck[0].extra.size() - 1; i >= 0; --i) {
+		new_card(pduel, pdeck[0].extra[i]->first, 0, 0, LOCATION_EXTRA, 0, 0);
+		last_replay.WriteInt32(pdeck[0].extra[i]->first, false);
+	}
+	last_replay.WriteInt32(pdeck[1].main.size(), false);
+	for(int i = pdeck[1].main.size() - 1; i >= 0; --i) {
+		new_card(pduel, pdeck[1].main[i]->first, 1, 1, LOCATION_DECK, 0, 0);
+		last_replay.WriteInt32(pdeck[1].main[i]->first, false);
+	}
+	last_replay.WriteInt32(pdeck[1].extra.size(), false);
+	for(int i = pdeck[1].extra.size() - 1; i >= 0; --i) {
+		new_card(pduel, pdeck[1].extra[i]->first, 1, 1, LOCATION_EXTRA, 0, 0);
+		last_replay.WriteInt32(pdeck[1].extra[i]->first, false);
+	}
+	last_replay.Flush();
+	char startbuf[32], *pbuf = startbuf;
+	BufferIO::WriteInt8(pbuf, MSG_START);
+	BufferIO::WriteInt8(pbuf, 0);
+	BufferIO::WriteInt32(pbuf, host_info.start_lp);
+	BufferIO::WriteInt32(pbuf, host_info.start_lp);
+	BufferIO::WriteInt16(pbuf, query_field_count(pduel, 0, 0x1));
+	BufferIO::WriteInt16(pbuf, query_field_count(pduel, 0, 0x40));
+	BufferIO::WriteInt16(pbuf, query_field_count(pduel, 1, 0x1));
+	BufferIO::WriteInt16(pbuf, query_field_count(pduel, 1, 0x40));
+	NetServer::SendBufferToPlayer(players[0], STOC_GAME_MSG, startbuf, 18);
+	for(auto oit = observers.begin(); oit != observers.end(); ++oit)
+		NetServer::ReSendToPlayer(*oit);
+	startbuf[1] = 1;
+	NetServer::SendBufferToPlayer(players[1], STOC_GAME_MSG, startbuf, 18);
+	RefreshExtra(0);
+	RefreshExtra(1);
+	start_duel(pduel, opt);
 }
 void SingleDuel::Process() {
+	char engineBuffer[0x1000];
+	unsigned int engFlag = 0, engLen = 0;
+	int stop = 0;
+	while (!stop) {
+		if (engFlag == 2)
+			break;
+		int result = process(pduel);
+		engLen = result & 0xffff;
+		engFlag = result >> 16;
+		if (engLen > 0) {
+			get_message(pduel, (byte*)&engineBuffer);
+			stop = Analyze(engineBuffer, engLen);
+		}
+	}
+	if(stop == 2) {
+		EndDuel();
+		NetServer::StopServer();
+	}
+}
+int SingleDuel::Analyze(char* msgbuffer, unsigned int len) {
+	char* offset, *pbufw, *pbuf = msgbuffer;
+	int player, count, type;
+	while (pbuf - msgbuffer < len) {
+		offset = pbuf;
+		unsigned char engType = BufferIO::ReadUInt8(pbuf);
+		switch (engType) {
+		case MSG_RETRY: {
+			NetServer::SendBufferToPlayer(players[last_response], STOC_GAME_MSG, offset, pbuf - offset);
+			WaitforResponse(last_response);
+			return 1;
+		}
+		case MSG_HINT: {
+			type = BufferIO::ReadInt8(pbuf);
+			player = BufferIO::ReadInt8(pbuf);
+			BufferIO::ReadInt32(pbuf);
+			switch (type) {
+			case 1:
+			case 2:
+			case 3:
+			case 5: {
+				NetServer::SendBufferToPlayer(players[player], STOC_GAME_MSG, offset, pbuf - offset);
+				break;
+			}
+			case 4:
+			case 6:
+			case 7:
+			case 8:
+			case 9: {
+				NetServer::SendBufferToPlayer(players[1 - player], STOC_GAME_MSG, offset, pbuf - offset);
+				for(auto oit = observers.begin(); oit != observers.end(); ++oit)
+					NetServer::ReSendToPlayer(*oit);
+				break;
+			}
+			}
+			break;
+		}
+		case MSG_WIN: {
+			player = BufferIO::ReadInt8(pbuf);
+			type = BufferIO::ReadInt8(pbuf);
+			NetServer::SendBufferToPlayer(players[0], STOC_GAME_MSG, offset, pbuf - offset);
+			NetServer::SendBufferToPlayer(players[1], STOC_GAME_MSG, offset, pbuf - offset);
+			last_replay.EndRecord();
+			char replaybuf[0x2000], *pbuf = replaybuf;
+			memcpy(pbuf, &last_replay.pheader, sizeof(ReplayHeader));
+			pbuf += sizeof(ReplayHeader);
+			memcpy(pbuf, last_replay.comp_data, last_replay.comp_size);
+			NetServer::SendBufferToPlayer(players[0], STOC_REPLAY, replaybuf, sizeof(ReplayHeader) + last_replay.comp_size);
+			NetServer::ReSendToPlayer(players[1]);
+			for(auto oit = observers.begin(); oit != observers.end(); ++oit)
+				NetServer::ReSendToPlayer(*oit);
+			NetServer::SendPacketToPlayer(players[0], STOC_DUEL_END);
+			NetServer::ReSendToPlayer(players[1]);
+			for(auto oit = observers.begin(); oit != observers.end(); ++oit)
+				NetServer::ReSendToPlayer(*oit);
+			return 2;
+		}
+		case MSG_SELECT_BATTLECMD: {
+			player = BufferIO::ReadInt8(pbuf);
+			count = BufferIO::ReadInt8(pbuf);
+			pbuf += count * 11;
+			count = BufferIO::ReadInt8(pbuf);
+			pbuf += count * 8 + 2;
+			RefreshMzone(0);
+			RefreshMzone(1);
+			RefreshSzone(0);
+			RefreshSzone(1);
+			RefreshHand(0);
+			RefreshHand(1);
+			NetServer::SendBufferToPlayer(players[player], STOC_GAME_MSG, offset, pbuf - offset);
+			WaitforResponse(player);
+			return 1;
+		}
+		case MSG_SELECT_IDLECMD: {
+			player = BufferIO::ReadInt8(pbuf);
+			count = BufferIO::ReadInt8(pbuf);
+			pbuf += count * 7;
+			count = BufferIO::ReadInt8(pbuf);
+			pbuf += count * 7;
+			count = BufferIO::ReadInt8(pbuf);
+			pbuf += count * 7;
+			count = BufferIO::ReadInt8(pbuf);
+			pbuf += count * 7;
+			count = BufferIO::ReadInt8(pbuf);
+			pbuf += count * 7;
+			count = BufferIO::ReadInt8(pbuf);
+			pbuf += count * 11 + 2;
+			RefreshMzone(0);
+			RefreshMzone(1);
+			RefreshSzone(0);
+			RefreshSzone(1);
+			RefreshHand(0);
+			RefreshHand(1);
+			NetServer::SendBufferToPlayer(players[player], STOC_GAME_MSG, offset, pbuf - offset);
+			WaitforResponse(player);
+			return 1;
+		}
+		case MSG_SELECT_EFFECTYN: {
+			player = BufferIO::ReadInt8(pbuf);
+			pbuf += 8;
+			NetServer::SendBufferToPlayer(players[player], STOC_GAME_MSG, offset, pbuf - offset);
+			WaitforResponse(player);
+			return 1;
+		}
+		case MSG_SELECT_YESNO: {
+			player = BufferIO::ReadInt8(pbuf);
+			pbuf += 4;
+			NetServer::SendBufferToPlayer(players[player], STOC_GAME_MSG, offset, pbuf - offset);
+			WaitforResponse(player);
+			return 1;
+		}
+		case MSG_SELECT_OPTION: {
+			player = BufferIO::ReadInt8(pbuf);
+			count = BufferIO::ReadInt8(pbuf);
+			pbuf += count * 4;
+			NetServer::SendBufferToPlayer(players[player], STOC_GAME_MSG, offset, pbuf - offset);
+			WaitforResponse(player);
+			return 1;
+		}
+		case MSG_SELECT_CARD:
+		case MSG_SELECT_TRIBUTE: {
+			player = BufferIO::ReadInt8(pbuf);
+			pbuf += 3;
+			count = BufferIO::ReadInt8(pbuf);
+			int c, l, s, ss, code;
+			for (int i = 0; i < count; ++i) {
+				pbufw = pbuf;
+				code = BufferIO::ReadInt32(pbuf);
+				c = BufferIO::ReadInt8(pbuf);
+				l = BufferIO::ReadInt8(pbuf);
+				s = BufferIO::ReadInt8(pbuf);
+				ss = BufferIO::ReadInt8(pbuf);
+				if (c != player) BufferIO::WriteInt32(pbufw, 0);
+			}
+			NetServer::SendBufferToPlayer(players[player], STOC_GAME_MSG, offset, pbuf - offset);
+			WaitforResponse(player);
+			return 1;
+		}
+		case MSG_SELECT_CHAIN: {
+			player = BufferIO::ReadInt8(pbuf);
+			count = BufferIO::ReadInt8(pbuf);
+			pbuf += 9 + count * 11;
+			NetServer::SendBufferToPlayer(players[player], STOC_GAME_MSG, offset, pbuf - offset);
+			WaitforResponse(player);
+			return 1;
+		}
+		case MSG_SELECT_PLACE:
+		case MSG_SELECT_DISFIELD: {
+			player = BufferIO::ReadInt8(pbuf);
+			pbuf += 5;
+			NetServer::SendBufferToPlayer(players[player], STOC_GAME_MSG, offset, pbuf - offset);
+			WaitforResponse(player);
+			return 1;
+		}
+		case MSG_SELECT_POSITION: {
+			player = BufferIO::ReadInt8(pbuf);
+			pbuf += 5;
+			NetServer::SendBufferToPlayer(players[player], STOC_GAME_MSG, offset, pbuf - offset);
+			WaitforResponse(player);
+			return 1;
+		}
+		case MSG_SELECT_COUNTER: {
+			player = BufferIO::ReadInt8(pbuf);
+			pbuf += 3;
+			count = BufferIO::ReadInt8(pbuf);
+			pbuf += count * 8;
+			NetServer::SendBufferToPlayer(players[player], STOC_GAME_MSG, offset, pbuf - offset);
+			WaitforResponse(player);
+			return 1;
+		}
+		case MSG_SELECT_SUM: {
+			pbuf++;
+			player = BufferIO::ReadInt8(pbuf);
+			pbuf += 5;
+			count = BufferIO::ReadInt8(pbuf);
+			pbuf += count * 11;
+			NetServer::SendBufferToPlayer(players[player], STOC_GAME_MSG, offset, pbuf - offset);
+			WaitforResponse(player);
+			return 1;
+		}
+		case MSG_SORT_CARD:
+		case MSG_SORT_CHAIN: {
+			player = BufferIO::ReadInt8(pbuf);
+			count = BufferIO::ReadInt8(pbuf);
+			pbuf += count * 7;
+			NetServer::SendBufferToPlayer(players[player], STOC_GAME_MSG, offset, pbuf - offset);
+			WaitforResponse(player);
+			return 1;
+		}
+		case MSG_CONFIRM_DECKTOP: {
+			player = BufferIO::ReadInt8(pbuf);
+			count = BufferIO::ReadInt8(pbuf);
+			pbuf += count * 7;
+			NetServer::SendBufferToPlayer(players[0], STOC_GAME_MSG, offset, pbuf - offset);
+			NetServer::ReSendToPlayer(players[1]);
+			for(auto oit = observers.begin(); oit != observers.end(); ++oit)
+				NetServer::ReSendToPlayer(*oit);
+			break;
+		}
+		case MSG_CONFIRM_CARDS: {
+			player = BufferIO::ReadInt8(pbuf);
+			count = BufferIO::ReadInt8(pbuf);
+			pbuf += count * 7;
+			NetServer::SendBufferToPlayer(players[player], STOC_GAME_MSG, offset, pbuf - offset);
+			break;
+		}
+		case MSG_SHUFFLE_DECK: {
+			pbuf++;
+			NetServer::SendBufferToPlayer(players[0], STOC_GAME_MSG, offset, pbuf - offset);
+			NetServer::ReSendToPlayer(players[1]);
+			for(auto oit = observers.begin(); oit != observers.end(); ++oit)
+				NetServer::ReSendToPlayer(*oit);
+			break;
+		}
+		case MSG_SHUFFLE_HAND: {
+			player = BufferIO::ReadInt8(pbuf);
+			NetServer::SendBufferToPlayer(players[0], STOC_GAME_MSG, offset, pbuf - offset);
+			NetServer::ReSendToPlayer(players[1]);
+			for(auto oit = observers.begin(); oit != observers.end(); ++oit)
+				NetServer::ReSendToPlayer(*oit);
+			RefreshHand(player, 0x181fff, 0);
+			break;
+		}
+		case MSG_REFRESH_DECK: {
+			pbuf++;
+			NetServer::SendBufferToPlayer(players[0], STOC_GAME_MSG, offset, pbuf - offset);
+			NetServer::ReSendToPlayer(players[1]);
+			for(auto oit = observers.begin(); oit != observers.end(); ++oit)
+				NetServer::ReSendToPlayer(*oit);
+			break;
+		}
+		case MSG_SWAP_GRAVE_DECK: {
+			player = BufferIO::ReadInt8(pbuf);
+			NetServer::SendBufferToPlayer(players[0], STOC_GAME_MSG, offset, pbuf - offset);
+			NetServer::ReSendToPlayer(players[1]);
+			for(auto oit = observers.begin(); oit != observers.end(); ++oit)
+				NetServer::ReSendToPlayer(*oit);
+			RefreshGrave(player);
+			break;
+		}
+		case MSG_SHUFFLE_SET_CARD: {
+			count = BufferIO::ReadInt8(pbuf);
+			pbuf += count * 8;
+			NetServer::SendBufferToPlayer(players[0], STOC_GAME_MSG, offset, pbuf - offset);
+			NetServer::ReSendToPlayer(players[1]);
+			for(auto oit = observers.begin(); oit != observers.end(); ++oit)
+				NetServer::ReSendToPlayer(*oit);
+			RefreshMzone(0, 0x181fff, 0);
+			RefreshMzone(1, 0x181fff, 0);
+			break;
+		}
+		case MSG_NEW_TURN: {
+			RefreshMzone(0);
+			RefreshMzone(1);
+			RefreshSzone(0);
+			RefreshSzone(1);
+			pbuf++;
+			NetServer::SendBufferToPlayer(players[0], STOC_GAME_MSG, offset, pbuf - offset);
+			NetServer::ReSendToPlayer(players[1]);
+			for(auto oit = observers.begin(); oit != observers.end(); ++oit)
+				NetServer::ReSendToPlayer(*oit);
+			break;
+		}
+		case MSG_NEW_PHASE: {
+			pbuf++;
+			NetServer::SendBufferToPlayer(players[0], STOC_GAME_MSG, offset, pbuf - offset);
+			NetServer::ReSendToPlayer(players[1]);
+			for(auto oit = observers.begin(); oit != observers.end(); ++oit)
+				NetServer::ReSendToPlayer(*oit);
+			RefreshMzone(0);
+			RefreshMzone(1);
+			RefreshSzone(0);
+			RefreshSzone(1);
+			break;
+		}
+		case MSG_MOVE: {
+			pbufw = pbuf;
+			int pc = pbuf[4];
+			int pl = pbuf[5];
+			int ps = pbuf[6];
+			int pp = pbuf[7];
+			int cc = pbuf[8];
+			int cl = pbuf[9];
+			int cs = pbuf[10];
+			int cp = pbuf[11];
+			pbuf += 16;
+			if(cl == LOCATION_REMOVED && (cp & POS_FACEDOWN)) {
+				BufferIO::WriteInt32(pbufw, 0);
+				NetServer::SendBufferToPlayer(players[cc], STOC_GAME_MSG, offset, pbuf - offset);
+				NetServer::ReSendToPlayer(players[1 - cc]);
+				for(auto oit = observers.begin(); oit != observers.end(); ++oit)
+					NetServer::ReSendToPlayer(*oit);
+			} else {
+				NetServer::SendBufferToPlayer(players[cc], STOC_GAME_MSG, offset, pbuf - offset);
+				if (!(cl & 0xb0) && !((cl & 0xc) && (cp & POS_FACEUP)))
+					BufferIO::WriteInt32(pbufw, 0);
+				NetServer::SendBufferToPlayer(players[1 - cc], STOC_GAME_MSG, offset, pbuf - offset);
+				for(auto oit = observers.begin(); oit != observers.end(); ++oit)
+					NetServer::ReSendToPlayer(*oit);
+			}
+			if (cl != 0 && (cl & 0x80) == 0 && (cl != pl || pc != cc))
+				RefreshSingle(cc, cl, cs);
+			break;
+		}
+		case MSG_POS_CHANGE: {
+			int cc = pbuf[4];
+			int cl = pbuf[5];
+			int cs = pbuf[6];
+			int pp = pbuf[7];
+			int cp = pbuf[8];
+			pbuf += 9;
+			NetServer::SendBufferToPlayer(players[0], STOC_GAME_MSG, offset, pbuf - offset);
+			NetServer::SendBufferToPlayer(players[1], STOC_GAME_MSG, offset, pbuf - offset);
+			if((pp & POS_FACEDOWN) && (cp & POS_FACEUP))
+				RefreshSingle(cc, cl, cs);
+			break;
+		}
+		case MSG_SET: {
+			BufferIO::WriteInt32(pbuf, 0);
+			pbuf += 4;
+			NetServer::SendBufferToPlayer(players[0], STOC_GAME_MSG, offset, pbuf - offset);
+			NetServer::ReSendToPlayer(players[1]);
+			for(auto oit = observers.begin(); oit != observers.end(); ++oit)
+				NetServer::ReSendToPlayer(*oit);
+			break;
+		}
+		case MSG_SWAP: {
+			pbuf += 16;
+			NetServer::SendBufferToPlayer(players[0], STOC_GAME_MSG, offset, pbuf - offset);
+			NetServer::ReSendToPlayer(players[1]);
+			for(auto oit = observers.begin(); oit != observers.end(); ++oit)
+				NetServer::ReSendToPlayer(*oit);
+			break;
+		}
+		case MSG_FIELD_DISABLED: {
+			pbuf += 4;
+			NetServer::SendBufferToPlayer(players[0], STOC_GAME_MSG, offset, pbuf - offset);
+			NetServer::ReSendToPlayer(players[1]);
+			for(auto oit = observers.begin(); oit != observers.end(); ++oit)
+				NetServer::ReSendToPlayer(*oit);
+			break;
+		}
+		case MSG_SUMMONING: {
+			pbuf += 8;
+			NetServer::SendBufferToPlayer(players[0], STOC_GAME_MSG, offset, pbuf - offset);
+			NetServer::ReSendToPlayer(players[1]);
+			for(auto oit = observers.begin(); oit != observers.end(); ++oit)
+				NetServer::ReSendToPlayer(*oit);
+			break;
+		}
+		case MSG_SUMMONED: {
+			NetServer::SendBufferToPlayer(players[0], STOC_GAME_MSG, offset, pbuf - offset);
+			NetServer::ReSendToPlayer(players[1]);
+			for(auto oit = observers.begin(); oit != observers.end(); ++oit)
+				NetServer::ReSendToPlayer(*oit);
+			RefreshMzone(0);
+			RefreshMzone(1);
+			RefreshSzone(0);
+			RefreshSzone(1);
+			break;
+		}
+		case MSG_SPSUMMONING: {
+			pbuf += 8;
+			NetServer::SendBufferToPlayer(players[0], STOC_GAME_MSG, offset, pbuf - offset);
+			NetServer::ReSendToPlayer(players[1]);
+			for(auto oit = observers.begin(); oit != observers.end(); ++oit)
+				NetServer::ReSendToPlayer(*oit);
+			break;
+		}
+		case MSG_SPSUMMONED: {
+			NetServer::SendBufferToPlayer(players[0], STOC_GAME_MSG, offset, pbuf - offset);
+			NetServer::ReSendToPlayer(players[1]);
+			for(auto oit = observers.begin(); oit != observers.end(); ++oit)
+				NetServer::ReSendToPlayer(*oit);
+			RefreshMzone(0);
+			RefreshMzone(1);
+			RefreshSzone(0);
+			RefreshSzone(1);
+			break;
+		}
+		case MSG_FLIPSUMMONING: {
+			RefreshSingle(pbuf[4], pbuf[5], pbuf[6]);
+			pbuf += 8;
+			NetServer::SendBufferToPlayer(players[0], STOC_GAME_MSG, offset, pbuf - offset);
+			NetServer::ReSendToPlayer(players[1]);
+			for(auto oit = observers.begin(); oit != observers.end(); ++oit)
+				NetServer::ReSendToPlayer(*oit);
+			break;
+		}
+		case MSG_FLIPSUMMONED: {
+			NetServer::SendBufferToPlayer(players[0], STOC_GAME_MSG, offset, pbuf - offset);
+			NetServer::ReSendToPlayer(players[1]);
+			for(auto oit = observers.begin(); oit != observers.end(); ++oit)
+				NetServer::ReSendToPlayer(*oit);
+			RefreshMzone(0);
+			RefreshMzone(1);
+			RefreshSzone(0);
+			RefreshSzone(1);
+			break;
+		}
+		case MSG_CHAINING: {
+			pbuf += 16;
+			NetServer::SendBufferToPlayer(players[0], STOC_GAME_MSG, offset, pbuf - offset);
+			NetServer::ReSendToPlayer(players[1]);
+			for(auto oit = observers.begin(); oit != observers.end(); ++oit)
+				NetServer::ReSendToPlayer(*oit);
+			break;
+		}
+		case MSG_CHAINED: {
+			pbuf++;
+			NetServer::SendBufferToPlayer(players[0], STOC_GAME_MSG, offset, pbuf - offset);
+			NetServer::ReSendToPlayer(players[1]);
+			for(auto oit = observers.begin(); oit != observers.end(); ++oit)
+				NetServer::ReSendToPlayer(*oit);
+			RefreshMzone(0);
+			RefreshMzone(1);
+			RefreshSzone(0);
+			RefreshSzone(1);
+			break;
+		}
+		case MSG_CHAIN_SOLVING: {
+			pbuf++;
+			NetServer::SendBufferToPlayer(players[0], STOC_GAME_MSG, offset, pbuf - offset);
+			NetServer::ReSendToPlayer(players[1]);
+			for(auto oit = observers.begin(); oit != observers.end(); ++oit)
+				NetServer::ReSendToPlayer(*oit);
+			break;
+		}
+		case MSG_CHAIN_SOLVED: {
+			pbuf++;
+			NetServer::SendBufferToPlayer(players[0], STOC_GAME_MSG, offset, pbuf - offset);
+			NetServer::ReSendToPlayer(players[1]);
+			for(auto oit = observers.begin(); oit != observers.end(); ++oit)
+				NetServer::ReSendToPlayer(*oit);
+			RefreshMzone(0);
+			RefreshMzone(1);
+			RefreshSzone(0);
+			RefreshSzone(1);
+			break;
+		}
+		case MSG_CHAIN_END: {
+			NetServer::SendBufferToPlayer(players[0], STOC_GAME_MSG, offset, pbuf - offset);
+			NetServer::ReSendToPlayer(players[1]);
+			for(auto oit = observers.begin(); oit != observers.end(); ++oit)
+				NetServer::ReSendToPlayer(*oit);
+			RefreshMzone(0);
+			RefreshMzone(1);
+			RefreshSzone(0);
+			RefreshSzone(1);
+			break;
+		}
+		case MSG_CHAIN_INACTIVATED: {
+			pbuf++;
+			NetServer::SendBufferToPlayer(players[0], STOC_GAME_MSG, offset, pbuf - offset);
+			NetServer::ReSendToPlayer(players[1]);
+			for(auto oit = observers.begin(); oit != observers.end(); ++oit)
+				NetServer::ReSendToPlayer(*oit);
+			RefreshMzone(0);
+			RefreshMzone(1);
+			RefreshSzone(0);
+			RefreshSzone(1);
+			break;
+		}
+		case MSG_CHAIN_DISABLED: {
+			pbuf++;
+			NetServer::SendBufferToPlayer(players[0], STOC_GAME_MSG, offset, pbuf - offset);
+			NetServer::ReSendToPlayer(players[1]);
+			for(auto oit = observers.begin(); oit != observers.end(); ++oit)
+				NetServer::ReSendToPlayer(*oit);
+			break;
+		}
+		case MSG_CARD_SELECTED: {
+			player = BufferIO::ReadInt8(pbuf);
+			count = BufferIO::ReadInt8(pbuf);
+			pbuf += count * 4;
+			break;
+		}
+		case MSG_RANDOM_SELECTED: {
+			player = BufferIO::ReadInt8(pbuf);
+			count = BufferIO::ReadInt8(pbuf);
+			pbuf += count * 4;
+			NetServer::SendBufferToPlayer(players[player], STOC_GAME_MSG, offset, pbuf - offset);
+			NetServer::ReSendToPlayer(players[1]);
+			for(auto oit = observers.begin(); oit != observers.end(); ++oit)
+				NetServer::ReSendToPlayer(*oit);
+			break;
+		}
+		case MSG_BECOME_TARGET: {
+			count = BufferIO::ReadInt8(pbuf);
+			pbuf += count * 4;
+			NetServer::SendBufferToPlayer(players[0], STOC_GAME_MSG, offset, pbuf - offset);
+			NetServer::ReSendToPlayer(players[1]);
+			for(auto oit = observers.begin(); oit != observers.end(); ++oit)
+				NetServer::ReSendToPlayer(*oit);
+			break;
+		}
+		case MSG_DRAW: {
+			player = BufferIO::ReadInt8(pbuf);
+			count = BufferIO::ReadInt8(pbuf);
+			pbufw = pbuf;
+			pbuf += count * 4;
+			NetServer::SendBufferToPlayer(players[player], STOC_GAME_MSG, offset, pbuf - offset);
+			for (int i = 0; i < count; ++i)
+				BufferIO::WriteInt32(pbufw, 0);
+			NetServer::SendBufferToPlayer(players[1 - player], STOC_GAME_MSG, offset, pbuf - offset);
+			for(auto oit = observers.begin(); oit != observers.end(); ++oit)
+				NetServer::ReSendToPlayer(*oit);
+			break;
+		}
+		case MSG_DAMAGE: {
+			pbuf += 5;
+			NetServer::SendBufferToPlayer(players[0], STOC_GAME_MSG, offset, pbuf - offset);
+			NetServer::ReSendToPlayer(players[1]);
+			for(auto oit = observers.begin(); oit != observers.end(); ++oit)
+				NetServer::ReSendToPlayer(*oit);
+			break;
+		}
+		case MSG_RECOVER: {
+			pbuf += 5;
+			NetServer::SendBufferToPlayer(players[0], STOC_GAME_MSG, offset, pbuf - offset);
+			NetServer::ReSendToPlayer(players[1]);
+			for(auto oit = observers.begin(); oit != observers.end(); ++oit)
+				NetServer::ReSendToPlayer(*oit);
+			break;
+		}
+		case MSG_EQUIP: {
+			pbuf += 8;
+			NetServer::SendBufferToPlayer(players[0], STOC_GAME_MSG, offset, pbuf - offset);
+			NetServer::ReSendToPlayer(players[1]);
+			for(auto oit = observers.begin(); oit != observers.end(); ++oit)
+				NetServer::ReSendToPlayer(*oit);
+			break;
+		}
+		case MSG_LPUPDATE: {
+			pbuf += 5;
+			NetServer::SendBufferToPlayer(players[0], STOC_GAME_MSG, offset, pbuf - offset);
+			NetServer::ReSendToPlayer(players[1]);
+			for(auto oit = observers.begin(); oit != observers.end(); ++oit)
+				NetServer::ReSendToPlayer(*oit);
+			break;
+		}
+		case MSG_UNEQUIP: {
+			pbuf += 4;
+			NetServer::SendBufferToPlayer(players[0], STOC_GAME_MSG, offset, pbuf - offset);
+			NetServer::ReSendToPlayer(players[1]);
+			for(auto oit = observers.begin(); oit != observers.end(); ++oit)
+				NetServer::ReSendToPlayer(*oit);
+			break;
+		}
+		case MSG_CARD_TARGET: {
+			pbuf += 8;
+			NetServer::SendBufferToPlayer(players[0], STOC_GAME_MSG, offset, pbuf - offset);
+			NetServer::ReSendToPlayer(players[1]);
+			for(auto oit = observers.begin(); oit != observers.end(); ++oit)
+				NetServer::ReSendToPlayer(*oit);
+			break;
+		}
+		case MSG_CANCEL_TARGET: {
+			pbuf += 8;
+			NetServer::SendBufferToPlayer(players[0], STOC_GAME_MSG, offset, pbuf - offset);
+			NetServer::ReSendToPlayer(players[1]);
+			for(auto oit = observers.begin(); oit != observers.end(); ++oit)
+				NetServer::ReSendToPlayer(*oit);
+			break;
+		}
+		case MSG_PAY_LPCOST: {
+			pbuf += 5;
+			NetServer::SendBufferToPlayer(players[0], STOC_GAME_MSG, offset, pbuf - offset);
+			NetServer::ReSendToPlayer(players[1]);
+			for(auto oit = observers.begin(); oit != observers.end(); ++oit)
+				NetServer::ReSendToPlayer(*oit);
+			break;
+		}
+		case MSG_ADD_COUNTER: {
+			pbuf += 6;
+			NetServer::SendBufferToPlayer(players[0], STOC_GAME_MSG, offset, pbuf - offset);
+			NetServer::ReSendToPlayer(players[1]);
+			for(auto oit = observers.begin(); oit != observers.end(); ++oit)
+				NetServer::ReSendToPlayer(*oit);
+			break;
+		}
+		case MSG_REMOVE_COUNTER: {
+			pbuf += 6;
+			NetServer::SendBufferToPlayer(players[0], STOC_GAME_MSG, offset, pbuf - offset);
+			NetServer::ReSendToPlayer(players[1]);
+			for(auto oit = observers.begin(); oit != observers.end(); ++oit)
+				NetServer::ReSendToPlayer(*oit);
+			break;
+		}
+		case MSG_ATTACK: {
+			pbuf += 8;
+			NetServer::SendBufferToPlayer(players[0], STOC_GAME_MSG, offset, pbuf - offset);
+			NetServer::ReSendToPlayer(players[1]);
+			for(auto oit = observers.begin(); oit != observers.end(); ++oit)
+				NetServer::ReSendToPlayer(*oit);
+			break;
+		}
+		case MSG_BATTLE: {
+			pbuf += 18;
+			NetServer::SendBufferToPlayer(players[0], STOC_GAME_MSG, offset, pbuf - offset);
+			NetServer::ReSendToPlayer(players[1]);
+			for(auto oit = observers.begin(); oit != observers.end(); ++oit)
+				NetServer::ReSendToPlayer(*oit);
+			break;
+		}
+		case MSG_ATTACK_DISABLED: {
+			NetServer::SendBufferToPlayer(players[0], STOC_GAME_MSG, offset, pbuf - offset);
+			NetServer::ReSendToPlayer(players[1]);
+			for(auto oit = observers.begin(); oit != observers.end(); ++oit)
+				NetServer::ReSendToPlayer(*oit);
+			break;
+		}
+		case MSG_DAMAGE_STEP_START: {
+			NetServer::SendBufferToPlayer(players[0], STOC_GAME_MSG, offset, pbuf - offset);
+			NetServer::ReSendToPlayer(players[1]);
+			for(auto oit = observers.begin(); oit != observers.end(); ++oit)
+				NetServer::ReSendToPlayer(*oit);
+			RefreshMzone(0);
+			RefreshMzone(1);
+			break;
+		}
+		case MSG_DAMAGE_STEP_END: {
+			NetServer::SendBufferToPlayer(players[0], STOC_GAME_MSG, offset, pbuf - offset);
+			NetServer::ReSendToPlayer(players[1]);
+			for(auto oit = observers.begin(); oit != observers.end(); ++oit)
+				NetServer::ReSendToPlayer(*oit);
+			RefreshMzone(0);
+			RefreshMzone(1);
+			break;
+		}
+		case MSG_MISSED_EFFECT: {
+			player = pbuf[0];
+			pbuf += 8;
+			NetServer::SendBufferToPlayer(players[player], STOC_GAME_MSG, offset, pbuf - offset);
+			break;
+		}
+		case MSG_TOSS_COIN: {
+			player = BufferIO::ReadInt8(pbuf);
+			count = BufferIO::ReadInt8(pbuf);
+			pbuf += count;
+			NetServer::SendBufferToPlayer(players[0], STOC_GAME_MSG, offset, pbuf - offset);
+			NetServer::ReSendToPlayer(players[1]);
+			for(auto oit = observers.begin(); oit != observers.end(); ++oit)
+				NetServer::ReSendToPlayer(*oit);
+			break;
+		}
+		case MSG_TOSS_DICE: {
+			player = BufferIO::ReadInt8(pbuf);
+			count = BufferIO::ReadInt8(pbuf);
+			pbuf += count;
+			NetServer::SendBufferToPlayer(players[0], STOC_GAME_MSG, offset, pbuf - offset);
+			NetServer::ReSendToPlayer(players[1]);
+			for(auto oit = observers.begin(); oit != observers.end(); ++oit)
+				NetServer::ReSendToPlayer(*oit);
+			break;
+		}
+		case MSG_ANNOUNCE_RACE: {
+			player = BufferIO::ReadInt8(pbuf);
+			pbuf += 5;
+			NetServer::SendBufferToPlayer(players[player], STOC_GAME_MSG, offset, pbuf - offset);
+			WaitforResponse(player);
+			return 1;
+		}
+		case MSG_ANNOUNCE_ATTRIB: {
+			player = BufferIO::ReadInt8(pbuf);
+			pbuf += 5;
+			NetServer::SendBufferToPlayer(players[player], STOC_GAME_MSG, offset, pbuf - offset);
+			WaitforResponse(player);
+			return 1;
+		}
+		case MSG_ANNOUNCE_CARD: {
+			player = BufferIO::ReadInt8(pbuf);
+			NetServer::SendBufferToPlayer(players[player], STOC_GAME_MSG, offset, pbuf - offset);
+			WaitforResponse(player);
+			return 1;
+		}
+		case MSG_ANNOUNCE_NUMBER: {
+			player = BufferIO::ReadInt8(pbuf);
+			count = BufferIO::ReadInt8(pbuf);
+			pbuf += 4 * count;
+			NetServer::SendBufferToPlayer(players[player], STOC_GAME_MSG, offset, pbuf - offset);
+			WaitforResponse(player);
+			return 1;
+		}
+		case MSG_COUNT_TURN: {
+			pbuf += 6;
+			NetServer::SendBufferToPlayer(players[0], STOC_GAME_MSG, offset, pbuf - offset);
+			NetServer::ReSendToPlayer(players[1]);
+			for(auto oit = observers.begin(); oit != observers.end(); ++oit)
+				NetServer::ReSendToPlayer(*oit);
+			break;
+		}
+		}
+	}
+	return 0;
 }
 void SingleDuel::EndDuel() {
+	if(pduel)
+		end_duel(pduel);
+	pduel = 0;
+}
+void SingleDuel::WaitforResponse(int playerid) {
+	last_response = playerid;
+	players[playerid]->state = CTOS_RESPONSE;
 }
 void SingleDuel::RefreshMzone(int player, int flag, int use_cache) {
 	char query_buffer[0x1000];
@@ -236,7 +1098,7 @@ void SingleDuel::RefreshMzone(int player, int flag, int use_cache) {
 	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_mapping[player]], STOC_GAME_MSG, query_buffer, len + 3);
+	NetServer::SendBufferToPlayer(players[player], STOC_GAME_MSG, query_buffer, len + 3);
 	for (int i = 0; i < 5; ++i) {
 		int clen = BufferIO::ReadInt32(qbuf);
 		if (clen == 4)
@@ -245,7 +1107,7 @@ void SingleDuel::RefreshMzone(int player, int flag, int use_cache) {
 			memset(qbuf, 0, clen - 4);
 		qbuf += clen - 4;
 	}
-	NetServer::SendBufferToPlayer(players[player_mapping[1 - player]], STOC_GAME_MSG, query_buffer, len + 3);
+	NetServer::SendBufferToPlayer(players[1 - player], STOC_GAME_MSG, query_buffer, len + 3);
 	for(auto pit = observers.begin(); pit != observers.end(); ++pit)
 		NetServer::ReSendToPlayer(*pit);
 }
@@ -256,7 +1118,7 @@ void SingleDuel::RefreshSzone(int player, int flag, int use_cache) {
 	BufferIO::WriteInt8(qbuf, player);
 	BufferIO::WriteInt8(qbuf, LOCATION_SZONE);
 	int len = query_field_card(pduel, player, LOCATION_SZONE, flag, (unsigned char*)qbuf, use_cache);
-	NetServer::SendBufferToPlayer(players[player_mapping[player]], STOC_GAME_MSG, query_buffer, len + 3);
+	NetServer::SendBufferToPlayer(players[player], STOC_GAME_MSG, query_buffer, len + 3);
 	for (int i = 0; i < 6; ++i) {
 		int clen = BufferIO::ReadInt32(qbuf);
 		if (clen == 4)
@@ -265,7 +1127,7 @@ void SingleDuel::RefreshSzone(int player, int flag, int use_cache) {
 			memset(qbuf, 0, clen - 4);
 		qbuf += clen - 4;
 	}
-	NetServer::SendBufferToPlayer(players[player_mapping[1 - player]], STOC_GAME_MSG, query_buffer, len + 3);
+	NetServer::SendBufferToPlayer(players[1 - player], STOC_GAME_MSG, query_buffer, len + 3);
 	for(auto pit = observers.begin(); pit != observers.end(); ++pit)
 		NetServer::ReSendToPlayer(*pit);
 }
@@ -276,7 +1138,7 @@ void SingleDuel::RefreshHand(int player, int flag, int use_cache) {
 	BufferIO::WriteInt8(qbuf, player);
 	BufferIO::WriteInt8(qbuf, LOCATION_HAND);
 	int len = query_field_card(pduel, player, LOCATION_HAND, flag, (unsigned char*)qbuf, use_cache);
-	NetServer::SendBufferToPlayer(players[player_mapping[player]], STOC_GAME_MSG, query_buffer, len + 3);
+	NetServer::SendBufferToPlayer(players[player], STOC_GAME_MSG, query_buffer, len + 3);
 }
 void SingleDuel::RefreshGrave(int player, int flag, int use_cache) {
 	char query_buffer[0x1000];
@@ -297,7 +1159,7 @@ void SingleDuel::RefreshExtra(int player, int flag, int use_cache) {
 	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_mapping[player]], STOC_GAME_MSG, query_buffer, len + 3);
+	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[0x1000];
@@ -309,9 +1171,9 @@ void SingleDuel::RefreshSingle(int player, int location, int sequence, int flag)
 	int len = query_card(pduel, player, location, sequence, flag, (unsigned char*)qbuf, 0);
 	if(location == LOCATION_REMOVED && (qbuf[15] & POS_FACEDOWN))
 		return;
-	NetServer::SendBufferToPlayer(players[player_mapping[player]], STOC_GAME_MSG, query_buffer, len + 4);
+	NetServer::SendBufferToPlayer(players[player], STOC_GAME_MSG, query_buffer, len + 4);
 	if ((location & 0x90) || ((location & 0x2c) && (qbuf[15] & POS_FACEUP))) {
-		NetServer::ReSendToPlayer(players[player_mapping[1 - player]]);
+		NetServer::ReSendToPlayer(players[1 - player]);
 		for(auto pit = observers.begin(); pit != observers.end(); ++pit)
 			NetServer::ReSendToPlayer(*pit);
 	}

gframe/single_duel.h

@@ -3,11 +3,15 @@
 
 #include "config.h"
 #include "network.h"
+#include "Replay.h"
+#include "../ocgcore/mtrandom.h"
 
 namespace ygo {
 
 class SingleDuel: public DuelMode {
 public:
+	SingleDuel();
+	virtual ~SingleDuel();
 	virtual void JoinGame(DuelPlayer* dp, void* pdata, bool is_creater);
 	virtual void LeaveGame(DuelPlayer* dp);
 	virtual void ToDuelist(DuelPlayer* dp);
@@ -16,9 +20,13 @@ public:
 	virtual void PlayerKick(DuelPlayer* dp, unsigned char pos);
 	virtual void UpdateDeck(DuelPlayer* dp, void* pdata);
 	virtual void StartDuel(DuelPlayer* dp);
+	virtual void HandResult(DuelPlayer* dp, unsigned char res);
+	virtual void TPResult(DuelPlayer* dp, unsigned char tp);
 	virtual void Process();
+	virtual int Analyze(char* msgbuffer, unsigned int len);
 	virtual void EndDuel();
 	
+	void WaitforResponse(int playerid);
 	void RefreshMzone(int player, int flag = 0x181fff, int use_cache = 1);
 	void RefreshSzone(int player, int flag = 0x181fff, int use_cache = 1);
 	void RefreshHand(int player, int flag = 0x181fff, int use_cache = 1);
@@ -27,8 +35,16 @@ public:
 	void RefreshSingle(int player, int location, int sequence, int flag = 0x181fff);
 	
 	static int MessageHandler(long fduel, int type);
+	
 protected:
-	unsigned char player_mapping[2];
+	DuelPlayer* players[2];
+	bool ready[2];
+	Deck pdeck[2];
+	unsigned char hand_result[2];
+	unsigned char last_response;
+	std::set<DuelPlayer*> observers;
+	Replay last_replay;
+	mtrandom rnd;
 };
 
 }

ocgcore/interpreter.cpp

@@ -442,7 +442,7 @@ static const struct luaL_Reg duellib[] = {
 	{ NULL, NULL }
 };
 
-interpreter::interpreter(duel* pd) {
+interpreter::interpreter(duel* pd): coroutines(256) {
 	lua_state = luaL_newstate();
 	current_state = lua_state;
 	pduel = pd;

ocgcore/interpreter.h

@@ -20,7 +20,7 @@ extern "C" {
 #endif
 }
 #include "common.h"
-#include <map>
+#include <unordered_map>
 #include <list>
 
 class card;
@@ -30,7 +30,7 @@ class duel;
 
 class interpreter {
 public:
-	typedef std::map<int32, lua_State*> coroutine_map;
+	typedef std::unordered_map<int32, lua_State*> coroutine_map;
 	typedef std::list<std::pair<void*, uint32> > param_list;
 	
 	duel* pduel;

script/c47297616.lua

@@ -62,14 +62,14 @@ function c47297616.opdisable(e,tp,eg,ep,ev,re,r,rp)
 	local e1=Effect.CreateEffect(c)
 	e1:SetType(EFFECT_TYPE_SINGLE)
 	e1:SetProperty(EFFECT_FLAG_COPY_INHERIT)
-	e1:SetReset(RESET_EVENT+RESET_LEAVE+RESET_DISABLE)
+	e1:SetReset(RESET_EVENT+0x1ff0000)
 	e1:SetCode(EFFECT_UPDATE_ATTACK)
 	e1:SetValue(-500)
 	c:RegisterEffect(e1)
 	local e2=Effect.CreateEffect(c)
 	e2:SetType(EFFECT_TYPE_SINGLE)
 	e2:SetProperty(EFFECT_FLAG_COPY_INHERIT)
-	e2:SetReset(RESET_EVENT+RESET_LEAVE+RESET_DISABLE)
+	e2:SetReset(RESET_EVENT+0x1ff0000)
 	e2:SetCode(EFFECT_UPDATE_DEFENCE)
 	e2:SetValue(-500)
 	c:RegisterEffect(e2)
@@ -78,7 +78,7 @@ function c47297616.cdspsum(e)
 	return e:GetHandler():IsReason(REASON_DESTROY)
 end
 function c47297616.tgspsum(e,tp,eg,ep,ev,re,r,rp,chk,chkc)
-	if chkc then return chkc:GetLocation()==LOCATION_GRAVE and chkc:GetControler()==tp
+	if chkc then return chkc:IsLocation(LOCATION_GRAVE) and chkc:IsControler(tp)
 		and chkc:IsCanBeSpecialSummoned(e,0,PLAYER_NONE,false,false,POS_FACEUP,tp) end
 	if chk==0 then return true end
 	Duel.Hint(HINT_SELECTMSG,tp,HINTMSG_SPSUMMON)
@@ -86,7 +86,7 @@ function c47297616.tgspsum(e,tp,eg,ep,ev,re,r,rp,chk,chkc)
 	Duel.SetOperationInfo(0,CATEGORY_SPECIAL_SUMMON,g,g:GetCount(),0,0)
 end
 function c47297616.opspsum(e,tp,eg,ep,ev,re,r,rp,chk)
-	local dg=Duel.GetMatchingGroup(aux.TRUE,tp,LOCATION_ONFIELD,0,nil)
+	local dg=Duel.GetMatchingGroup(nil,tp,LOCATION_ONFIELD,0,nil)
 	Duel.Destroy(dg,REASON_EFFECT)
 	local tc=Duel.GetFirstTarget()
 	if tc and tc:IsRelateToEffect(e) then

script/c72896720.lua

 --インフェルニティ·デス·ドラゴン
 function c72896720.initial_effect(c)
 	--synchro summon
-	aux.AddSynchroProcedure(c,c72896720.synfilter,aux.NonTuner(c72896720.synfilter),1)
+	aux.AddSynchroProcedure(c,aux.FilterBoolFunction(Card.IsAttribute,ATTRIBUTE_DARK),aux.NonTuner(nil),1)
 	c:EnableReviveLimit()
 	--destroy
 	local e1=Effect.CreateEffect(c)
@@ -17,9 +17,6 @@ function c72896720.initial_effect(c)
 	e1:SetOperation(c72896720.desop)
 	c:RegisterEffect(e1)
 end
-function c72896720.synfilter(c)
-	return c:IsAttribute(ATTRIBUTE_DARK)
-end
 function c72896720.descon(e,tp,eg,ep,ev,re,r,rp)
 	return Duel.GetFieldGroupCount(tp,LOCATION_HAND,0)==0
 end