add replay function in single mode

gframe/duelclient.cpp

@@ -3311,7 +3311,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;
@@ -3465,7 +3464,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/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.cpp

 #include "replay_mode.h"
 #include "duelclient.h"
 #include "game.h"
+#include "single_mode.h"
 #include "../ocgcore/duel.h"
 #include "../ocgcore/field.h"
 #include "../ocgcore/mtrandom.h"
@@ -22,6 +23,8 @@ int ReplayMode::skip_step = 0;
 
 bool ReplayMode::StartReplay(int skipturn) {
 	skip_turn = skipturn;
+	if(skip_turn < 0)
+		skip_turn = 0;
 	Thread::NewThread(ReplayThread, 0);
 	return true;
 }
@@ -71,10 +74,19 @@ int ReplayMode::ReplayThread(void* param) {
 	} else {
 		cur_replay.ReadName(mainGame->dInfo.hostname);
 		cur_replay.ReadName(mainGame->dInfo.clientname);
+		mainGame->dInfo.isTag = false;
 	}
+	if(rh.flag & REPLAY_SINGLE_MODE) {
+		set_script_reader((script_reader)SingleMode::ScriptReader);
+		set_card_reader((card_reader)DataManager::CardReader);
+		set_message_handler((message_handler)MessageHandler);
+		mainGame->dInfo.isSingleMode = true;
+	} else {
 		set_script_reader(default_script_reader);
 		set_card_reader((card_reader)DataManager::CardReader);
 		set_message_handler((message_handler)MessageHandler);
+		mainGame->dInfo.isSingleMode = false;
+	}
 	pduel = create_duel(rnd.rand());
 	int start_lp = cur_replay.ReadInt32();
 	int start_hand = cur_replay.ReadInt32();
@@ -86,9 +98,7 @@ int ReplayMode::ReplayThread(void* param) {
 	set_player_info(pduel, 1, start_lp, start_hand, draw_count);
 	mainGame->dInfo.lp[0] = start_lp;
 	mainGame->dInfo.lp[1] = start_lp;
-	myswprintf(mainGame->dInfo.strLP[0], L"%d", mainGame->dInfo.lp[0]);
-	myswprintf(mainGame->dInfo.strLP[1], L"%d", mainGame->dInfo.lp[1]);
-	mainGame->dInfo.turn = 0;
+	if(!mainGame->dInfo.isSingleMode) {
 		if(!(opt & DUEL_TAG_MODE)) {
 			int main = cur_replay.ReadInt32();
 			for(int i = 0; i < main; ++i)
@@ -132,29 +142,43 @@ int ReplayMode::ReplayThread(void* param) {
 			for(int i = 0; i < extra; ++i)
 				new_tag_card(pduel, cur_replay.ReadInt32(), 1, LOCATION_EXTRA);
 		}
+	} else {
+		char filename[256];
+		size_t slen = cur_replay.ReadInt16();
+		cur_replay.ReadData(filename, slen);
+		filename[slen] = 0;
+		if(!preload_script(pduel, filename, slen)) {
+			end_duel(pduel);
+			return 0;
+		}
+	}
+	myswprintf(mainGame->dInfo.strLP[0], L"%d", mainGame->dInfo.lp[0]);
+	myswprintf(mainGame->dInfo.strLP[1], L"%d", mainGame->dInfo.lp[1]);
+	mainGame->dInfo.turn = 0;
 	start_duel(pduel, opt);
-	ReplayRefreshDeck(0);
-	ReplayRefreshDeck(1);
-	ReplayRefreshExtra(0);
-	ReplayRefreshExtra(1);
 	mainGame->dInfo.isStarted = true;
 	mainGame->dInfo.isReplay = true;
+	mainGame->dInfo.isReplaySkiping = (skip_turn > 0);
 	char engineBuffer[0x1000];
 	is_continuing = true;
+	if(mainGame->dInfo.isSingleMode) {
+		int len = get_message(pduel, (byte*)engineBuffer);
+		if (len > 0)
+			is_continuing = ReplayAnalyze(engineBuffer, len);
+	} else {
+		ReplayRefreshDeck(0);
+		ReplayRefreshDeck(1);
+		ReplayRefreshExtra(0);
+		ReplayRefreshExtra(1);
+	}
 	exit_pending = false;
 	current_step = 0;
 	skip_step = 0;
-	if(skip_turn < 0)
-		skip_turn = 0;
-	if(skip_turn) {
-		mainGame->dInfo.isReplaySkiping = true;
+	if(mainGame->dInfo.isReplaySkiping)
 		mainGame->gMutex.Lock();
-	} else
-		mainGame->dInfo.isReplaySkiping = false;
-	int len = 0;
 	while (is_continuing && !exit_pending) {
 		int result = process(pduel);
-		len = result & 0xffff;
+		int len = result & 0xffff;
 		/*int flag = result >> 16;*/
 		if (len > 0) {
 			get_message(pduel, (byte*)engineBuffer);
@@ -230,6 +254,7 @@ void ReplayMode::Restart(bool refresh) {
 	myswprintf(mainGame->dInfo.strLP[0], L"%d", mainGame->dInfo.lp[0]);
 	myswprintf(mainGame->dInfo.strLP[1], L"%d", mainGame->dInfo.lp[1]);
 	mainGame->dInfo.turn = 0;
+	if(!mainGame->dInfo.isSingleMode) {
 		if(!(opt & DUEL_TAG_MODE)) {
 			int main = cur_replay.ReadInt32();
 			for(int i = 0; i < main; ++i)
@@ -273,6 +298,16 @@ void ReplayMode::Restart(bool refresh) {
 			for(int i = 0; i < extra; ++i)
 				new_tag_card(pduel, cur_replay.ReadInt32(), 1, LOCATION_EXTRA);
 		}
+	} else {
+		char filename[256];
+		size_t slen = cur_replay.ReadInt16();
+		cur_replay.ReadData(filename, slen);
+		filename[slen] = 0;
+		if(!preload_script(pduel, filename, slen)) {
+			end_duel(pduel);
+			return;
+		}
+	}
 	start_duel(pduel, opt);
 	if(refresh) {
 		mainGame->dField.RefreshAllCards();
@@ -796,6 +831,39 @@ bool ReplayMode::ReplayAnalyze(char* msg, unsigned int len) {
 			ReplayRefreshExtra(player);
 			break;
 		}
+		case MSG_RELOAD_FIELD: {
+			pbuf++;
+			for(int p = 0; p < 2; ++p) {
+				pbuf += 4;
+				for(int seq = 0; seq < 7; ++seq) {
+					int val = BufferIO::ReadInt8(pbuf);
+					if(val)
+						pbuf += 2;
+				}
+				for(int seq = 0; seq < 8; ++seq) {
+					int val = BufferIO::ReadInt8(pbuf);
+					if(val)
+						pbuf++;
+				}
+				pbuf += 6;
+			}
+			pbuf++;
+			DuelClient::ClientAnalyze(offset, pbuf - offset);
+			ReplayReload();
+			mainGame->dField.RefreshAllCards();
+			break;
+		}
+		case MSG_AI_NAME: {
+			char namebuf[128];
+			wchar_t wname[128];
+			int len = BufferIO::ReadInt16(pbuf);
+			char* begin = pbuf;
+			pbuf += len + 1;
+			memcpy(namebuf, begin, len + 1);
+			BufferIO::DecodeUTF8(namebuf, wname);
+			BufferIO::CopyWStr(wname, mainGame->dInfo.clientname, 20);
+			break;
+		}
 		}
 		if(pauseable) {
 			if(skip_step) {
@@ -859,6 +927,38 @@ void ReplayMode::ReplayRefreshSingle(int player, int location, int sequence, int
 	/*int len = */query_card(pduel, player, location, sequence, flag, queryBuffer, 0);
 	mainGame->dField.UpdateCard(mainGame->LocalPlayer(player), location, sequence, (char*)queryBuffer);
 }
+void ReplayMode::ReplayReload() {
+	unsigned char queryBuffer[0x4000];
+	unsigned int flag = 0xffdfff;
+	/*int len = */query_field_card(pduel, 0, LOCATION_MZONE, flag, queryBuffer, 0);
+	mainGame->dField.UpdateFieldCard(mainGame->LocalPlayer(0), LOCATION_MZONE, (char*)queryBuffer);
+	/*len = */query_field_card(pduel, 1, LOCATION_MZONE, flag, queryBuffer, 0);
+	mainGame->dField.UpdateFieldCard(mainGame->LocalPlayer(1), LOCATION_MZONE, (char*)queryBuffer);
+	/*len = */query_field_card(pduel, 0, LOCATION_SZONE, flag, queryBuffer, 0);
+	mainGame->dField.UpdateFieldCard(mainGame->LocalPlayer(0), LOCATION_SZONE, (char*)queryBuffer);
+	/*len = */query_field_card(pduel, 1, LOCATION_SZONE, flag, queryBuffer, 0);
+	mainGame->dField.UpdateFieldCard(mainGame->LocalPlayer(1), LOCATION_SZONE, (char*)queryBuffer);
+	/*len = */query_field_card(pduel, 0, LOCATION_HAND, flag, queryBuffer, 0);
+	mainGame->dField.UpdateFieldCard(mainGame->LocalPlayer(0), LOCATION_HAND, (char*)queryBuffer);
+	/*len = */query_field_card(pduel, 1, LOCATION_HAND, flag, queryBuffer, 0);
+	mainGame->dField.UpdateFieldCard(mainGame->LocalPlayer(1), LOCATION_HAND, (char*)queryBuffer);
+	/*len = */query_field_card(pduel, 0, LOCATION_DECK, flag, queryBuffer, 0);
+	mainGame->dField.UpdateFieldCard(mainGame->LocalPlayer(0), LOCATION_DECK, (char*)queryBuffer);
+	/*len = */query_field_card(pduel, 1, LOCATION_DECK, flag, queryBuffer, 0);
+	mainGame->dField.UpdateFieldCard(mainGame->LocalPlayer(1), LOCATION_DECK, (char*)queryBuffer);
+	/*len = */query_field_card(pduel, 0, LOCATION_EXTRA, flag, queryBuffer, 0);
+	mainGame->dField.UpdateFieldCard(mainGame->LocalPlayer(0), LOCATION_EXTRA, (char*)queryBuffer);
+	/*len = */query_field_card(pduel, 1, LOCATION_EXTRA, flag, queryBuffer, 0);
+	mainGame->dField.UpdateFieldCard(mainGame->LocalPlayer(1), LOCATION_EXTRA, (char*)queryBuffer);
+	/*len = */query_field_card(pduel, 0, LOCATION_GRAVE, flag, queryBuffer, 0);
+	mainGame->dField.UpdateFieldCard(mainGame->LocalPlayer(0), LOCATION_GRAVE, (char*)queryBuffer);
+	/*len = */query_field_card(pduel, 1, LOCATION_GRAVE, flag, queryBuffer, 0);
+	mainGame->dField.UpdateFieldCard(mainGame->LocalPlayer(1), LOCATION_GRAVE, (char*)queryBuffer);
+	/*len = */query_field_card(pduel, 0, LOCATION_REMOVED, flag, queryBuffer, 0);
+	mainGame->dField.UpdateFieldCard(mainGame->LocalPlayer(0), LOCATION_REMOVED, (char*)queryBuffer);
+	/*len = */query_field_card(pduel, 1, LOCATION_REMOVED, flag, queryBuffer, 0);
+	mainGame->dField.UpdateFieldCard(mainGame->LocalPlayer(1), LOCATION_REMOVED, (char*)queryBuffer);
+}
 int ReplayMode::MessageHandler(long fduel, int type) {
 	if(!enable_log)
 		return 0;

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_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);
@@ -47,24 +43,44 @@ int SingleMode::SinglePlayThread(void* param) {
 	set_card_reader((card_reader)DataManager::CardReader);
 	set_message_handler((message_handler)MessageHandler);
 	pduel = create_duel(rnd.rand());
-	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;
+	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;
 	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)) {
+	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, fname2);
-		if(!preload_script(pduel, fname2, slen)) {
+			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);
@@ -84,11 +100,24 @@ 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);
+	last_replay.WriteData(mainGame->dInfo.hostname, 40, false);
+	last_replay.WriteData(mainGame->dInfo.clientname, 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;
@@ -98,6 +127,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;
 };
 
 }