Merge remote-tracking branch 'refs/remotes/Fluorohydride/master'

gframe/deck_con.cpp

@@ -69,6 +69,9 @@ void DeckBuilder::Initialize() {
 	mainGame->btnLeaveGame->setVisible(true);
 	mainGame->btnLeaveGame->setText(dataManager.GetSysString(1306));
 	mainGame->btnSideOK->setVisible(false);
+	mainGame->btnSideShuffle->setVisible(false);
+	mainGame->btnSideSort->setVisible(false);
+	mainGame->btnSideReload->setVisible(false);
 	filterList = deckManager._lfList[0].content;
 	mainGame->cbDBLFList->setSelected(0);
 	ClearSearch();
@@ -222,6 +225,10 @@ bool DeckBuilder::OnEvent(const irr::SEvent& event) {
 				DuelClient::SendBufferToServer(CTOS_UPDATE_DECK, deckbuf, pdeck - deckbuf);
 				break;
 			}
+			case BUTTON_SIDE_RELOAD: {
+				deckManager.LoadDeck(mainGame->cbDeckSelect->getItem(mainGame->cbDeckSelect->getSelected()));
+				break;
+			}
 			case BUTTON_MSG_OK: {
 				mainGame->HideElement(mainGame->wMessage);
 				mainGame->actionSignal.Set();

gframe/deck_manager.cpp

 #include "deck_manager.h"
 #include "data_manager.h"
+#include "network.h"
 #include "game.h"
 #include <algorithm>
 
@@ -70,7 +71,7 @@ int DeckManager::TypeCount(std::vector<code_pointer> cards, int type) {
 	}
 	return count;
 }
-int DeckManager::CheckLFList(Deck& deck, int lfhash, bool allow_ocg, bool allow_tcg, bool doubled, int forbiddentypes) {
+int DeckManager::CheckDeck(Deck& deck, int lfhash, bool allow_ocg, bool allow_tcg, bool doubled, int forbiddentypes) {
 	std::unordered_map<int, int> ccount;
 	std::unordered_map<int, int>* list = 0;
 	for(size_t i = 0; i < _lfList.size(); ++i) {
@@ -82,61 +83,103 @@ int DeckManager::CheckLFList(Deck& deck, int lfhash, bool allow_ocg, bool allow_
 	if(!list)
 		return 0;
 	int dc = 0;
-	if ((mainGame->dInfo.extraval & 0x1) && (deck.main.size() != 20 || deck.extra.size() > 5))
-		return 1;
-	if (TypeCount(deck.main, forbiddentypes) > 0 || TypeCount(deck.extra, forbiddentypes) > 0 || TypeCount(deck.side, forbiddentypes) > 0)
-		return 1;
-	if (!(mainGame->dInfo.extraval & 0x1) && deck.main.size() < 40 || (!doubled && (deck.main.size() > 60 || deck.extra.size() > 15 || deck.side.size() > 15))
-		|| (doubled && (deck.main.size() != 100 || deck.extra.size() > 30 || deck.side.size() > 30)))
-		return 1;
+	bool speed = mainGame->dInfo.extraval & 0x1;
+	if(doubled){
+		if(speed){
+			if(deck.main.size() < 40 || deck.main.size() > 60)
+				return (DECKERROR_MAINCOUNT << 28) + deck.main.size();
+			if(deck.extra.size() > 10)
+				return (DECKERROR_EXTRACOUNT << 28) + deck.extra.size();
+			if(deck.side.size())
+				return (DECKERROR_SIDECOUNT << 28) + deck.side.size();
+		} else {
+			if(deck.main.size() != 100)
+				return (DECKERROR_MAINCOUNT << 28) + deck.main.size();
+			if(deck.extra.size() > 30)
+				return (DECKERROR_EXTRACOUNT << 28) + deck.extra.size();
+			if(deck.side.size() > 30)
+				return (DECKERROR_SIDECOUNT << 28) + deck.side.size();
+		}
+	} else {
+		if(speed){
+			if(deck.main.size() < 20 || deck.main.size() > 30)
+				return (DECKERROR_MAINCOUNT << 28) + deck.main.size();
+			if(deck.extra.size() > 5)
+				return (DECKERROR_EXTRACOUNT << 28) + deck.extra.size();
+			if(deck.side.size())
+				return (DECKERROR_SIDECOUNT << 28) + deck.side.size();
+		} else {
+			if(deck.main.size() < 40 || deck.main.size() > 60)
+				return (DECKERROR_MAINCOUNT << 28) + deck.main.size();
+			if(deck.extra.size() > 15)
+				return (DECKERROR_EXTRACOUNT << 28) + deck.extra.size();
+			if(deck.side.size() > 15)
+				return (DECKERROR_SIDECOUNT << 28) + deck.side.size();
+		}
+	}
 	for(size_t i = 0; i < deck.main.size(); ++i) {
 		code_pointer cit = deck.main[i];
-		if((!allow_ocg && (cit->second.ot == 0x1)) || (!allow_tcg && (cit->second.ot == 0x2)))
-			return cit->first;
+		if(!allow_ocg && (cit->second.ot == 0x1))
+			return (DECKERROR_OCGONLY << 28) + cit->first;
+		if(!allow_tcg && (cit->second.ot == 0x2))
+			return (DECKERROR_TCGONLY << 28) + cit->first;
 		if(cit->second.type & (TYPE_FUSION | TYPE_SYNCHRO | TYPE_XYZ | TYPE_TOKEN | TYPE_LINK))
-			return 1;
+			return (DECKERROR_EXTRACOUNT << 28);
 		int code = cit->second.alias ? cit->second.alias : cit->first;
 		ccount[code]++;
 		dc = ccount[code];
+		if(dc > 3)
+			return (DECKERROR_CARDCOUNT << 28) + cit->first;
 		auto it = list->find(code);
-		if(dc > 3 || (it != list->end() && dc > it->second))
-			return cit->first;
+		if(it != list->end() && dc > it->second)
+			return (DECKERROR_LFLIST << 28) + cit->first;
 	}
 	for(size_t i = 0; i < deck.extra.size(); ++i) {
 		code_pointer cit = deck.extra[i];
-		if((!allow_ocg && (cit->second.ot == 0x1)) || (!allow_tcg && (cit->second.ot == 0x2)))
-			return cit->first;
+		if(!allow_ocg && (cit->second.ot == 0x1))
+			return (DECKERROR_OCGONLY << 28) + cit->first;
+		if(!allow_tcg && (cit->second.ot == 0x2))
+			return (DECKERROR_TCGONLY << 28) + cit->first;
 		int code = cit->second.alias ? cit->second.alias : cit->first;
 		ccount[code]++;
 		dc = ccount[code];
+		if(dc > 3)
+			return (DECKERROR_CARDCOUNT << 28) + cit->first;
 		auto it = list->find(code);
-		if(dc > 3 || (it != list->end() && dc > it->second))
-			return cit->first;
+		if(it != list->end() && dc > it->second)
+			return (DECKERROR_LFLIST << 28) + cit->first;
 	}
 	for(size_t i = 0; i < deck.side.size(); ++i) {
 		code_pointer cit = deck.side[i];
-		if((!allow_ocg && (cit->second.ot == 0x1)) || (!allow_tcg && (cit->second.ot == 0x2)))
-			return cit->first;
+		if(!allow_ocg && (cit->second.ot == 0x1))
+			return (DECKERROR_OCGONLY << 28) + cit->first;
+		if(!allow_tcg && (cit->second.ot == 0x2))
+			return (DECKERROR_TCGONLY << 28) + cit->first;
 		int code = cit->second.alias ? cit->second.alias : cit->first;
 		ccount[code]++;
 		dc = ccount[code];
+		if(dc > 3)
+			return (DECKERROR_CARDCOUNT << 28) + cit->first;
 		auto it = list->find(code);
-		if(dc > 3 || (it != list->end() && dc > it->second))
-			return cit->first;
+		if(it != list->end() && dc > it->second)
+			return (DECKERROR_LFLIST << 28) + cit->first;
 	}
 	return 0;
 }
-void DeckManager::LoadDeck(Deck& deck, int* dbuf, int mainc, int sidec, int mainc2, int sidec2, bool doubled) {
+int DeckManager::LoadDeck(Deck& deck, int* dbuf, int mainc, int sidec, int mainc2, int sidec2, bool doubled) {
 	deck.clear();
 	int code;
 	int d = 1;
 	if (doubled)
 		d = 2;
+	int errorcode = 0;
 	CardData cd;
 	for(int i = 0; i < mainc; ++i) {
 		code = dbuf[i];
-		if(!dataManager.GetData(code, &cd))
+		if(!dataManager.GetData(code, &cd)) {
+			errorcode = code;
 			continue;
+		}
 		if(cd.type & TYPE_TOKEN)
 			continue;
 		else if(cd.type & (TYPE_FUSION | TYPE_SYNCHRO | TYPE_XYZ | TYPE_LINK) && deck.extra.size() < 15*d) {
@@ -147,8 +190,10 @@ void DeckManager::LoadDeck(Deck& deck, int* dbuf, int mainc, int sidec, int main
 	}
 	for(int i = 0; i < sidec; ++i) {
 		code = dbuf[mainc + i];
-		if(!dataManager.GetData(code, &cd))
+		if(!dataManager.GetData(code, &cd)) {
+			errorcode = code;
 			continue;
+		}
 		if(cd.type & TYPE_TOKEN)
 			continue;
 		if(deck.side.size() < 15*d)
@@ -175,6 +220,7 @@ void DeckManager::LoadDeck(Deck& deck, int* dbuf, int mainc, int sidec, int main
 		if(deck.side.size() < 30)
 			deck.side.push_back(dataManager.GetCodePointer(code));	//verified by GetData()
 	}
+	return errorcode;
 }
 bool DeckManager::LoadSide(Deck& deck, int* dbuf, int mainc, int sidec) {
 	std::unordered_map<int, int> pcount;

gframe/deck_manager.h

@@ -37,9 +37,9 @@ public:
 
 	void LoadLFList();
 	wchar_t* GetLFListName(int lfhash);
-	int CheckLFList(Deck& deck, int lfhash, bool allow_ocg, bool allow_tcg, bool doubled, int forbiddentypes = 0);
+	int CheckDeck(Deck& deck, int lfhash, bool allow_ocg, bool allow_tcg, bool doubled, int forbiddentypes = 0);
 	int TypeCount(std::vector<code_pointer> cards, int type);
-	void LoadDeck(Deck& deck, int* dbuf, int mainc, int sidec, int mainc2 = 0, int sidec2 = 0, bool doubled = false);
+	int LoadDeck(Deck& deck, int* dbuf, int mainc, int sidec, int mainc2 = 0, int sidec2 = 0, bool doubled = false);
 	bool LoadSide(Deck& deck, int* dbuf, int mainc, int sidec);
 	FILE* OpenDeckFile(const wchar_t * file, const char * mode);
 	bool LoadDeck(const wchar_t* file);

gframe/duelclient.cpp

@@ -253,13 +253,52 @@ void DuelClient::HandleSTOCPacketLan(char* data, unsigned int len) {
 		}
 		case ERRMSG_DECKERROR: {
 			mainGame->gMutex.Lock();
-			if(pkt->code == 1)
-				mainGame->env->addMessageBox(L"", dataManager.GetSysString(1406));
-			else {
-				wchar_t msgbuf[256];
-				myswprintf(msgbuf, dataManager.GetSysString(1407), dataManager.GetName(pkt->code));
-				mainGame->env->addMessageBox(L"", msgbuf);
+			unsigned int code = pkt->code & 0xFFFFFFF;
+			int flag = pkt->code >> 28;
+			wchar_t msgbuf[256];
+			switch(flag)
+			{
+			case DECKERROR_LFLIST: {
+				myswprintf(msgbuf, dataManager.GetSysString(1407), dataManager.GetName(code));
+				break;
+			}
+			case DECKERROR_OCGONLY: {
+				myswprintf(msgbuf, dataManager.GetSysString(1413), dataManager.GetName(code));
+				break;
+			}
+			case DECKERROR_TCGONLY: {
+				myswprintf(msgbuf, dataManager.GetSysString(1414), dataManager.GetName(code));
+				break;
+			}
+			case DECKERROR_UNKNOWNCARD: {
+				myswprintf(msgbuf, dataManager.GetSysString(1415), dataManager.GetName(code), code);
+				break;
+			}
+			case DECKERROR_CARDCOUNT: {
+				myswprintf(msgbuf, dataManager.GetSysString(1416), dataManager.GetName(code));
+				break;
+			}
+			case DECKERROR_MAINCOUNT: {
+				myswprintf(msgbuf, dataManager.GetSysString(1417), code);
+				break;
+			}
+			case DECKERROR_EXTRACOUNT: {
+				if(code>0)
+					myswprintf(msgbuf, dataManager.GetSysString(1418), code);
+				else
+					myswprintf(msgbuf, dataManager.GetSysString(1420));
+				break;
 			}
+			case DECKERROR_SIDECOUNT: {
+				myswprintf(msgbuf, dataManager.GetSysString(1419), code);
+				break;
+			}
+			default: {
+				myswprintf(msgbuf, dataManager.GetSysString(1406));
+				break;
+			}
+			}
+			mainGame->env->addMessageBox(L"", msgbuf);
 			mainGame->cbDeckSelect->setEnabled(true);
 			mainGame->cbDeckSelect2->setEnabled(true);
 			mainGame->gMutex.Unlock();
@@ -329,6 +368,9 @@ void DuelClient::HandleSTOCPacketLan(char* data, unsigned int len) {
 		mainGame->wSort->setVisible(false);
 		mainGame->stTip->setVisible(false);
 		mainGame->btnSideOK->setVisible(true);
+		mainGame->btnSideShuffle->setVisible(true);
+		mainGame->btnSideSort->setVisible(true);
+		mainGame->btnSideReload->setVisible(true);
 		if(mainGame->dInfo.player_type < 7)
 			mainGame->btnLeaveGame->setVisible(false);
 		mainGame->btnSpectatorSwap->setVisible(false);
@@ -642,6 +684,9 @@ void DuelClient::HandleSTOCPacketLan(char* data, unsigned int len) {
 		mainGame->btnM2->setVisible(false);
 		mainGame->btnEP->setVisible(false);
 		mainGame->btnShuffle->setVisible(false);
+		mainGame->btnSideShuffle->setVisible(false);
+		mainGame->btnSideSort->setVisible(false);
+		mainGame->btnSideReload->setVisible(false);
 		mainGame->wChat->setVisible(true);
 		mainGame->device->setEventReceiver(&mainGame->dField);
 		// reset master rule 4 phase button position
@@ -3700,7 +3745,6 @@ int DuelClient::ClientAnalyze(char * msg, unsigned int len) {
 							ClientCard* xcard = new ClientCard;
 							ccard->overlayed.push_back(xcard);
 							mainGame->dField.overlay_cards.insert(xcard);
-							mainGame->gMutex.Unlock();
 							xcard->overlayTarget = ccard;
 							xcard->location = 0x80;
 							xcard->sequence = ccard->overlayed.size() - 1;
@@ -3864,7 +3908,7 @@ void DuelClient::SendResponse() {
 	}
 	}
 	if(mainGame->dInfo.isSingleMode) {
-		SingleMode::SetResponse(response_buf);
+		SingleMode::SetResponse(response_buf, response_len);
 		mainGame->singleSignal.Set();
 	} else {
 		mainGame->dInfo.time_player = 2;

gframe/game.cpp

@@ -17,7 +17,7 @@
 #include <dirent.h>
 #endif
 
-unsigned short PRO_VERSION = 0x1340;
+unsigned short PRO_VERSION = 0x1341;
 
 namespace ygo {
 
@@ -504,6 +504,12 @@ bool Game::Initialize() {
 	btnClearDeck = env->addButton(rect<s32>(115, 99, 165, 120), wDeckEdit, BUTTON_CLEAR_DECK, dataManager.GetSysString(1304));
 	btnSideOK = env->addButton(rect<s32>(510, 40, 820, 80), 0, BUTTON_SIDE_OK, dataManager.GetSysString(1334));
 	btnSideOK->setVisible(false);
+	btnSideShuffle = env->addButton(rect<s32>(310, 100, 370, 130), 0, BUTTON_SHUFFLE_DECK, dataManager.GetSysString(1307));
+	btnSideShuffle->setVisible(false);
+	btnSideSort = env->addButton(rect<s32>(375, 100, 435, 130), 0, BUTTON_SORT_DECK, dataManager.GetSysString(1305));
+	btnSideSort->setVisible(false);
+	btnSideReload = env->addButton(rect<s32>(440, 100, 500, 130), 0, BUTTON_SIDE_RELOAD, dataManager.GetSysString(1309));
+	btnSideReload->setVisible(false);
 	//
 	scrFilter = env->addScrollBar(false, recti(999, 161, 1019, 629), 0, SCROLL_FILTER);
 	scrFilter->setLargeStep(10);
@@ -1596,6 +1602,9 @@ void Game::OnResize()
 	stSearch->setRelativePosition(ResizeWin(205, 74, 280, 94));
 	stScale->setRelativePosition(ResizeWin(110, 74, 150, 94));
 	btnSideOK->setRelativePosition(Resize(510, 40, 820, 80));
+	btnSideShuffle->setRelativePosition(Resize(310, 100, 370, 130));
+	btnSideSort->setRelativePosition(Resize(375, 100, 435, 130));
+	btnSideReload->setRelativePosition(Resize(440, 100, 500, 130));
 	btnDeleteDeck->setRelativePosition(Resize(225, 95, 290, 120));
 
 	wLanWindow->setRelativePosition(ResizeWin(220, 100, 800, 520));

gframe/game.h

@@ -414,6 +414,9 @@ public:
 	irr::gui::IGUIButton* btnDeleteDeck;
 	irr::gui::IGUIButton* btnSaveDeckAs;
 	irr::gui::IGUIButton* btnSideOK;
+	irr::gui::IGUIButton* btnSideShuffle;
+	irr::gui::IGUIButton* btnSideSort;
+	irr::gui::IGUIButton* btnSideReload;
 	irr::gui::IGUIEditBox* ebDeckname;
 	irr::gui::IGUIStaticText* stBanlist;
 	irr::gui::IGUIStaticText* stDeck;
@@ -600,7 +603,7 @@ extern Game* mainGame;
 #define BUTTON_SAVE_DECK			304
 #define BUTTON_SAVE_DECK_AS			305
 #define BUTTON_DELETE_DECK			306
-//#define BUTTON_DBEXIT				307
+#define BUTTON_SIDE_RELOAD			307
 #define BUTTON_SORT_DECK			308
 #define BUTTON_SIDE_OK				309
 #define BUTTON_SHUFFLE_DECK			310

gframe/network.h

@@ -225,6 +225,15 @@ public:
 #define ERRMSG_SIDEERROR	0x3
 #define ERRMSG_VERERROR		0x4
 
+#define DECKERROR_LFLIST		0x1
+#define DECKERROR_OCGONLY		0x2
+#define DECKERROR_TCGONLY		0x3
+#define DECKERROR_UNKNOWNCARD	0x4
+#define DECKERROR_CARDCOUNT		0x5
+#define DECKERROR_MAINCOUNT		0x6
+#define DECKERROR_EXTRACOUNT	0x7
+#define DECKERROR_SIDECOUNT		0x8
+
 #define MODE_SINGLE		0x0
 #define MODE_MATCH		0x1
 #define MODE_TAG		0x2

gframe/replay.cpp

@@ -226,7 +226,7 @@ short Replay::ReadInt16() {
 	if(!is_replaying)
 		return -1;
 	short ret = *((short*)pdata);
-	pdata += 4;
+	pdata += 2;
 	return ret;
 }
 char Replay::ReadInt8() {

gframe/replay.h

@@ -9,6 +9,7 @@ namespace ygo {
 #define REPLAY_COMPRESSED	0x1
 #define REPLAY_TAG			0x2
 #define REPLAY_DECODED		0x4
+#define REPLAY_SINGLE_MODE	0x8
 
 struct ReplayHeader {
 	unsigned int id;

gframe/replay_mode.h

@@ -43,6 +43,7 @@ public:
 	static void ReplayRefreshDeck(int player, int flag = 0x181fff);
 	static void ReplayRefreshExtra(int player, int flag = 0x181fff);
 	static void ReplayRefreshSingle(int player, int location, int sequence, int flag = 0xf81fff);
+	static void ReplayReload();
 
 	static int MessageHandler(long fduel, int type);
 };

gframe/single_duel.cpp

@@ -252,16 +252,23 @@ void SingleDuel::PlayerReady(DuelPlayer* dp, bool is_ready) {
 	if(ready[dp->type] == is_ready)
 		return;
 	if(is_ready) {
-		bool allow_ocg = host_info.rule == 0 || host_info.rule == 2;
-		bool allow_tcg = host_info.rule == 1 || host_info.rule == 2;
-		int res = host_info.no_check_deck ? false : deckManager.CheckLFList(pdeck[dp->type], host_info.lflist, allow_ocg, allow_tcg, host_info.doubled, host_info.forbiddentypes);
-		if(res) {
+		unsigned int deckerror = 0;
+		if(!host_info.no_check_deck) {
+			if(deck_error[dp->type]) {
+				deckerror = (DECKERROR_UNKNOWNCARD << 28) + deck_error[dp->type];
+			} else {
+				bool allow_ocg = host_info.rule == 0 || host_info.rule == 2;
+				bool allow_tcg = host_info.rule == 1 || host_info.rule == 2;
+				deckerror = deckManager.CheckDeck(pdeck[dp->type], host_info.lflist, allow_ocg, allow_tcg, host_info.doubled, host_info.forbiddentypes);
+			}
+		}
+		if(deckerror) {
 			STOC_HS_PlayerChange scpc;
 			scpc.status = (dp->type << 4) | PLAYERCHANGE_NOTREADY;
 			NetServer::SendPacketToPlayer(dp, STOC_HS_PLAYER_CHANGE, scpc);
 			STOC_ErrorMsg scem;
 			scem.msg = ERRMSG_DECKERROR;
-			scem.code = res;
+			scem.code = deckerror;
 			NetServer::SendPacketToPlayer(dp, STOC_ERROR_MSG, scem);
 			return;
 		}
@@ -287,7 +294,7 @@ void SingleDuel::UpdateDeck(DuelPlayer* dp, void* pdata) {
 	int mainc = BufferIO::ReadInt32(deckbuf);
 	int sidec = BufferIO::ReadInt32(deckbuf);
 	if(duel_count == 0) {
-		deckManager.LoadDeck(pdeck[dp->type], (int*)deckbuf, mainc, sidec,0,0, host_info.doubled);
+		deck_error[dp->type] = deckManager.LoadDeck(pdeck[dp->type], (int*)deckbuf, mainc, sidec,0,0, host_info.doubled);
 	} else {
 		if(deckManager.LoadSide(pdeck[dp->type], (int*)deckbuf, mainc, sidec)) {
 			ready[dp->type] = true;

gframe/single_duel.h

@@ -46,6 +46,7 @@ protected:
 	DuelPlayer* pplayer[2];
 	bool ready[2];
 	Deck pdeck[2];
+	int deck_error[2];
 	unsigned char hand_result[2];
 	unsigned char last_response;
 	std::set<DuelPlayer*> observers;

gframe/single_mode.cpp

@@ -10,6 +10,7 @@ namespace ygo {
 long SingleMode::pduel = 0;
 bool SingleMode::is_closing = false;
 bool SingleMode::is_continuing = false;
+Replay SingleMode::last_replay;
 
 static byte buffer[0x20000];
 
@@ -23,23 +24,18 @@ void SingleMode::StopPlay(bool is_exiting) {
 	mainGame->actionSignal.Set();
 	mainGame->singleSignal.Set();
 }
-void SingleMode::SetResponse(unsigned char* resp) {
+void SingleMode::SetResponse(unsigned char* resp, unsigned int len) {
 	if(!pduel)
 		return;
+	last_replay.WriteInt8(len);
+	last_replay.WriteData(resp, len);
 	set_responseb(pduel, resp);
 }
 int SingleMode::SinglePlayThread(void* param) {
-	char fname2[256];
-	size_t slen;
-	if(open_file) {
-		slen = BufferIO::EncodeUTF8(open_file_name, fname2);
-		open_file = false;
-	} else {
-		const wchar_t* name = mainGame->lstSinglePlayList->getListItem(mainGame->lstSinglePlayList->getSelected());
-		wchar_t fname[256];
-		myswprintf(fname, L"./single/%ls", name);
-		slen = BufferIO::EncodeUTF8(fname, fname2);
-	}
+	const int start_lp = 8000;
+	const int start_hand = 5;
+	const int draw_count = 1;
+	const int opt = 0;
 	mtrandom rnd;
 	time_t seed = time(0);
 	rnd.reset(seed);
@@ -48,25 +44,45 @@ int SingleMode::SinglePlayThread(void* param) {
 	set_message_handler((message_handler)MessageHandler);
 	pduel = create_duel(rnd.rand());
 	mainGame->dInfo.lua64 = true;
-	set_player_info(pduel, 0, 8000, 5, 1);
-	set_player_info(pduel, 1, 8000, 5, 1);
-	mainGame->dInfo.lp[0] = 8000;
-	mainGame->dInfo.lp[1] = 8000;
-	mainGame->dInfo.startlp = 8000;
+	set_player_info(pduel, 0, start_lp, start_hand, draw_count);
+	set_player_info(pduel, 1, start_lp, start_hand, draw_count);
+	mainGame->dInfo.lp[0] = start_lp;
+	mainGame->dInfo.lp[1] = start_lp;
+	mainGame->dInfo.startlp = start_lp;
 	myswprintf(mainGame->dInfo.strLP[0], L"%d", mainGame->dInfo.lp[0]);
 	myswprintf(mainGame->dInfo.strLP[1], L"%d", mainGame->dInfo.lp[1]);
 	BufferIO::CopyWStr(mainGame->ebNickName->getText(), mainGame->dInfo.hostname, 20);
 	mainGame->dInfo.clientname[0] = 0;
 	mainGame->dInfo.turn = 0;
-	if(!preload_script(pduel, fname2, slen)) {
-		wchar_t fname[256];
-		myswprintf(fname, L"./single/%ls", open_file_name);
-		slen = BufferIO::EncodeUTF8(fname, fname2);
-		if(!preload_script(pduel, fname2, slen)) {
-			end_duel(pduel);
-			return 0;
+	char filename[256];
+	size_t slen = 0;
+	if(open_file) {
+		open_file = false;
+		slen = BufferIO::EncodeUTF8(open_file_name, filename);
+		if(!preload_script(pduel, filename, slen)) {
+			wchar_t fname[256];
+			myswprintf(fname, L"./single/%ls", open_file_name);
+			slen = BufferIO::EncodeUTF8(fname, filename);
+			if(!preload_script(pduel, filename, slen))
+				slen = 0;
 		}
+	} else {
+		const wchar_t* name = mainGame->lstSinglePlayList->getListItem(mainGame->lstSinglePlayList->getSelected());
+		wchar_t fname[256];
+		myswprintf(fname, L"./single/%ls", name);
+		slen = BufferIO::EncodeUTF8(fname, filename);
+		if(!preload_script(pduel, filename, slen))
+			slen = 0;
+	}
+	if(slen == 0) {
+		end_duel(pduel);
+		return 0;
 	}
+	ReplayHeader rh;
+	rh.id = 0x31707279;
+	rh.version = PRO_VERSION;
+	rh.flag = REPLAY_SINGLE_MODE;
+	rh.seed = seed;
 	mainGame->gMutex.Lock();
 	mainGame->HideElement(mainGame->wSinglePlay);
 	mainGame->wCardImg->setVisible(true);
@@ -87,11 +103,27 @@ int SingleMode::SinglePlayThread(void* param) {
 	mainGame->dInfo.isSingleMode = true;
 	mainGame->device->setEventReceiver(&mainGame->dField);
 	mainGame->gMutex.Unlock();
-	start_duel(pduel, 0);
 	char engineBuffer[0x1000];
 	is_closing = false;
 	is_continuing = true;
-	int len = 0;
+	int len = get_message(pduel, (byte*)engineBuffer);
+	if (len > 0)
+		is_continuing = SinglePlayAnalyze(engineBuffer, len);
+	last_replay.BeginRecord();
+	last_replay.WriteHeader(rh);
+	unsigned short buffer[20];
+	BufferIO::CopyWStr(mainGame->dInfo.hostname, buffer, 20);
+	last_replay.WriteData(buffer, 40, false);
+	BufferIO::CopyWStr(mainGame->dInfo.clientname, buffer, 20);
+	last_replay.WriteData(buffer, 40, false);
+	last_replay.WriteInt32(start_lp, false);
+	last_replay.WriteInt32(start_hand, false);
+	last_replay.WriteInt32(draw_count, false);
+	last_replay.WriteInt32(opt, false);
+	last_replay.WriteInt16(slen, false);
+	last_replay.WriteData(filename, slen, false);
+	last_replay.Flush();
+	start_duel(pduel, opt);
 	while (is_continuing) {
 		int result = process(pduel);
 		len = result & 0xffff;
@@ -101,6 +133,21 @@ int SingleMode::SinglePlayThread(void* param) {
 			is_continuing = SinglePlayAnalyze(engineBuffer, len);
 		}
 	}
+	last_replay.EndRecord();
+	time_t nowtime = time(NULL);
+	struct tm *localedtime = localtime(&nowtime);
+	char timebuf[40];
+	strftime(timebuf, 40, "%Y-%m-%d %H-%M-%S", localedtime);
+	size_t size = strlen(timebuf) + 1;
+	wchar_t timetext[80];
+	mbstowcs(timetext, timebuf, size);
+	mainGame->ebRSName->setText(timetext);
+	mainGame->PopupElement(mainGame->wReplaySave);
+	mainGame->gMutex.Unlock();
+	mainGame->replaySignal.Reset();
+	mainGame->replaySignal.Wait();
+	if(mainGame->actionParam)
+		last_replay.SaveReplay(mainGame->ebRSName->getText());
 	end_duel(pduel);
 	if(!is_closing) {
 		mainGame->gMutex.Lock();

gframe/single_mode.h

 #ifndef SINGLE_MODE_H
 #define SINGLE_MODE_H
 
-#include "config.h"
-#include "data_manager.h"
-#include "deck_manager.h"
-#include "../ocgcore/mtrandom.h"
+#include "replay.h"
 
 namespace ygo {
 
@@ -17,7 +14,7 @@ private:
 public:
 	static bool StartPlay();
 	static void StopPlay(bool is_exiting = false);
-	static void SetResponse(unsigned char* resp);
+	static void SetResponse(unsigned char* resp, unsigned int len);
 	static int SinglePlayThread(void* param);
 	static bool SinglePlayAnalyze(char* msg, unsigned int len);
 	
@@ -31,6 +28,9 @@ public:
 
 	static byte* ScriptReader(const char* script_name, int* slen);
 	static int MessageHandler(long fduel, int type);
+
+protected:
+	static Replay last_replay;
 };
 
 }

gframe/tag_duel.cpp

@@ -222,16 +222,23 @@ void TagDuel::PlayerReady(DuelPlayer* dp, bool is_ready) {
 	if(dp->type > 3 || ready[dp->type] == is_ready)
 		return;
 	if(is_ready) {
-		bool allow_ocg = host_info.rule == 0 || host_info.rule == 2;
-		bool allow_tcg = host_info.rule == 1 || host_info.rule == 2;
-		int res = host_info.no_check_deck ? false : deckManager.CheckLFList(pdeck[dp->type], host_info.lflist, allow_ocg, allow_tcg, host_info.doubled, host_info.forbiddentypes);
-		if(res) {
+		unsigned int deckerror = 0;
+		if(!host_info.no_check_deck) {
+			if(deck_error[dp->type]) {
+				deckerror = (DECKERROR_UNKNOWNCARD << 28) + deck_error[dp->type];
+			} else {
+				bool allow_ocg = host_info.rule == 0 || host_info.rule == 2;
+				bool allow_tcg = host_info.rule == 1 || host_info.rule == 2;
+				deckerror = deckManager.CheckDeck(pdeck[dp->type], host_info.lflist, allow_ocg, allow_tcg, host_info.doubled, host_info.forbiddentypes);
+			}
+		}
+		if(deckerror) {
 			STOC_HS_PlayerChange scpc;
 			scpc.status = (dp->type << 4) | PLAYERCHANGE_NOTREADY;
 			NetServer::SendPacketToPlayer(dp, STOC_HS_PLAYER_CHANGE, scpc);
 			STOC_ErrorMsg scem;
 			scem.msg = ERRMSG_DECKERROR;
-			scem.code = res;
+			scem.code = deckerror;
 			NetServer::SendPacketToPlayer(dp, STOC_ERROR_MSG, scem);
 			return;
 		}
@@ -256,7 +263,7 @@ void TagDuel::UpdateDeck(DuelPlayer* dp, void* pdata) {
 	char* deckbuf = (char*)pdata;
 	int mainc = BufferIO::ReadInt32(deckbuf);
 	int sidec = BufferIO::ReadInt32(deckbuf);
-	deckManager.LoadDeck(pdeck[dp->type], (int*)deckbuf, mainc, sidec, 0, 0, host_info.doubled);
+	deck_error[dp->type] = deckManager.LoadDeck(pdeck[dp->type], (int*)deckbuf, mainc, sidec, 0, 0, host_info.doubled);
 }
 void TagDuel::StartDuel(DuelPlayer* dp) {
 	if(dp != host_player)

gframe/tag_duel.h

@@ -48,6 +48,7 @@ protected:
 	std::set<DuelPlayer*> observers;
 	bool ready[4];
 	Deck pdeck[4];
+	int deck_error[4];
 	unsigned char hand_result[2];
 	unsigned char last_response;
 	Replay last_replay;