Merge remote-tracking branch 'upstream/master' into develop-nanahira

gframe/client_field.cpp

@@ -1572,10 +1572,10 @@ void ClientField::UpdateDeclarableList() {
 		if(ancard.size())
 			return;
 	}
-	for(auto cit = dataManager.strings_begin; cit != dataManager.strings_end; ++cit) {
+	for(auto cit = dataManager.strings_begin(); cit != dataManager.strings_end(); ++cit) {
 		if(cit->second.name.find(pname) != std::wstring::npos) {
 			auto cp = dataManager.GetCodePointer(cit->first);
-			if (cp == dataManager.datas_end)
+			if (cp == dataManager.datas_end())
 				continue;
 			//datas.alias can be double card names or alias
 			if(is_declarable(cp->second, declare_opcodes)) {

gframe/data_manager.cpp

 #include "data_manager.h"
 #include "game.h"
 #include <stdio.h>
+#include "spmemvfs/spmemvfs.h"
 
 namespace ygo {
 
@@ -9,47 +10,23 @@ byte DataManager::scriptBuffer[0x20000];
 IFileSystem* DataManager::FileSystem;
 DataManager dataManager;
 
-DataManager::DataManager() : _datas(16384), _strings(16384) {
-	datas_begin = _datas.begin();
-	datas_end = _datas.end();
-	strings_begin = _strings.begin();
-	strings_end = _strings.end();
+DataManager::DataManager() : _datas(32768), _strings(32768) {
 	extra_setcode = { {8512558u, {0x8f, 0x54, 0x59, 0x82, 0x13a}}, };
 }
-bool DataManager::LoadDB(const wchar_t* wfile) {
-	char file[256];
-	BufferIO::EncodeUTF8(wfile, file);
-#ifdef _WIN32
-	IReadFile* reader = FileSystem->createAndOpenFile(wfile);
-#else
-	IReadFile* reader = FileSystem->createAndOpenFile(file);
-#endif
-	if(reader == NULL)
-		return false;
-	spmemvfs_db_t db;
-	spmembuffer_t* mem = (spmembuffer_t*)calloc(sizeof(spmembuffer_t), 1);
-	spmemvfs_env_init();
-	mem->total = mem->used = reader->getSize();
-	mem->data = (char*)malloc(mem->total + 1);
-	reader->read(mem->data, mem->total);
-	reader->drop();
-	(mem->data)[mem->total] = '\0';
-	if(spmemvfs_open_db(&db, file, mem) != SQLITE_OK)
-		return Error(&db);
-	sqlite3* pDB = db.handle;
-	sqlite3_stmt* pStmt;
+bool DataManager::ReadDB(sqlite3* pDB) {
+	sqlite3_stmt* pStmt{};
 	const char* sql = "select * from datas,texts where datas.id=texts.id";
-	if(sqlite3_prepare_v2(pDB, sql, -1, &pStmt, 0) != SQLITE_OK)
-		return Error(&db);
+	if (sqlite3_prepare_v2(pDB, sql, -1, &pStmt, 0) != SQLITE_OK)
+		return Error(pDB);
 	wchar_t strBuffer[4096];
 	int step = 0;
 	do {
 		CardDataC cd;
 		CardString cs;
 		step = sqlite3_step(pStmt);
-		if(step == SQLITE_BUSY || step == SQLITE_ERROR || step == SQLITE_MISUSE)
-			return Error(&db, pStmt);
-		else if(step == SQLITE_ROW) {
+		if (step == SQLITE_BUSY || step == SQLITE_ERROR || step == SQLITE_MISUSE)
+			return Error(pDB, pStmt);
+		else if (step == SQLITE_ROW) {
 			cd.code = sqlite3_column_int(pStmt, 0);
 			cd.ot = sqlite3_column_int(pStmt, 1);
 			cd.alias = sqlite3_column_int(pStmt, 2);
@@ -69,10 +46,11 @@ bool DataManager::LoadDB(const wchar_t* wfile) {
 			cd.type = sqlite3_column_int(pStmt, 4);
 			cd.attack = sqlite3_column_int(pStmt, 5);
 			cd.defense = sqlite3_column_int(pStmt, 6);
-			if(cd.type & TYPE_LINK) {
+			if (cd.type & TYPE_LINK) {
 				cd.link_marker = cd.defense;
 				cd.defense = 0;
-			} else
+			}
+			else
 				cd.link_marker = 0;
 			unsigned int level = sqlite3_column_int(pStmt, 7);
 			cd.level = level & 0xff;
@@ -82,31 +60,52 @@ bool DataManager::LoadDB(const wchar_t* wfile) {
 			cd.attribute = sqlite3_column_int(pStmt, 9);
 			cd.category = sqlite3_column_int(pStmt, 10);
 			_datas[cd.code] = cd;
-			if(const char* text = (const char*)sqlite3_column_text(pStmt, 12)) {
+			if (const char* text = (const char*)sqlite3_column_text(pStmt, 12)) {
 				BufferIO::DecodeUTF8(text, strBuffer);
 				cs.name = strBuffer;
 			}
-			if(const char* text = (const char*)sqlite3_column_text(pStmt, 13)) {
+			if (const char* text = (const char*)sqlite3_column_text(pStmt, 13)) {
 				BufferIO::DecodeUTF8(text, strBuffer);
 				cs.text = strBuffer;
 			}
-			for(int i = 0; i < 16; ++i) {
-				if(const char* text = (const char*)sqlite3_column_text(pStmt, i + 14)) {
+			for (int i = 0; i < 16; ++i) {
+				if (const char* text = (const char*)sqlite3_column_text(pStmt, i + 14)) {
 					BufferIO::DecodeUTF8(text, strBuffer);
 					cs.desc[i] = strBuffer;
 				}
 			}
 			_strings[cd.code] = cs;
 		}
-	} while(step != SQLITE_DONE);
+	} while (step != SQLITE_DONE);
 	sqlite3_finalize(pStmt);
+	return true;
+}
+bool DataManager::LoadDB(const wchar_t* wfile) {
+	char file[256];
+	BufferIO::EncodeUTF8(wfile, file);
+#ifdef _WIN32
+	IReadFile* reader = FileSystem->createAndOpenFile(wfile);
+#else
+	IReadFile* reader = FileSystem->createAndOpenFile(file);
+#endif
+	if(reader == NULL)
+		return false;
+	spmemvfs_db_t db;
+	spmembuffer_t* mem = (spmembuffer_t*)calloc(sizeof(spmembuffer_t), 1);
+	spmemvfs_env_init();
+	mem->total = mem->used = reader->getSize();
+	mem->data = (char*)malloc(mem->total + 1);
+	reader->read(mem->data, mem->total);
+	reader->drop();
+	(mem->data)[mem->total] = '\0';
+	bool ret{};
+	if (spmemvfs_open_db(&db, file, mem) != SQLITE_OK)
+		ret = Error(db.handle);
+	else
+		ret = ReadDB(db.handle);
 	spmemvfs_close_db(&db);
 	spmemvfs_env_fini();
-	datas_begin = _datas.begin();
-	datas_end = _datas.end();
-	strings_begin = _strings.begin();
-	strings_end = _strings.end();
-	return true;
+	return ret;
 }
 bool DataManager::LoadStrings(const char* file) {
 	FILE* fp = fopen(file, "r");
@@ -167,43 +166,41 @@ void DataManager::ReadStringConfLine(const char* linebuf) {
 		_setnameStrings[value] = strBuffer;
 	}
 }
-bool DataManager::Error(spmemvfs_db_t* pDB, sqlite3_stmt* pStmt) {
-	wchar_t strBuffer[4096];
-	BufferIO::DecodeUTF8(sqlite3_errmsg(pDB->handle), strBuffer);
+bool DataManager::Error(sqlite3* pDB, sqlite3_stmt* pStmt) {
+	errmsg[0] = '\0';
+	std::strncat(errmsg, sqlite3_errmsg(pDB), sizeof errmsg - 1);
 	if(pStmt)
 		sqlite3_finalize(pStmt);
-	spmemvfs_close_db(pDB);
-	spmemvfs_env_fini();
 	return false;
 }
-bool DataManager::GetData(unsigned int code, CardData* pData) {
-	code_pointer cdit = _datas.find(code);
-	if(cdit == _datas.end())
-		return false;
-	auto& data = cdit->second;
-	if (pData) {
-		pData->code = data.code;
-		pData->alias = data.alias;
-		std::memcpy(pData->setcode, data.setcode, SIZE_SETCODE);
-		pData->type = data.type;
-		pData->level = data.level;
-		pData->attribute = data.attribute;
-		pData->race = data.race;
-		pData->attack = data.attack;
-		pData->defense = data.defense;
-		pData->lscale = data.lscale;
-		pData->rscale = data.rscale;
-		pData->link_marker = data.link_marker;
-	}
-	return true;
-}
 code_pointer DataManager::GetCodePointer(unsigned int code) const {
 	return _datas.find(code);
 }
 string_pointer DataManager::GetStringPointer(unsigned int code) const {
 	return _strings.find(code);
 }
-bool DataManager::GetString(unsigned int code, CardString* pStr) {
+code_pointer DataManager::datas_begin() {
+	return _datas.cbegin();
+}
+code_pointer DataManager::datas_end() {
+	return _datas.cend();
+}
+string_pointer DataManager::strings_begin() {
+	return _strings.cbegin();
+}
+string_pointer DataManager::strings_end() {
+	return _strings.cend();
+}
+bool DataManager::GetData(unsigned int code, CardData* pData) const {
+	auto cdit = _datas.find(code);
+	if(cdit == _datas.end())
+		return false;
+	if (pData) {
+		*pData = cdit->second;
+	}
+	return true;
+}
+bool DataManager::GetString(unsigned int code, CardString* pStr) const {
 	auto csit = _strings.find(code);
 	if(csit == _strings.end()) {
 		pStr->name = unknown_string;
@@ -213,7 +210,7 @@ bool DataManager::GetString(unsigned int code, CardString* pStr) {
 	*pStr = csit->second;
 	return true;
 }
-const wchar_t* DataManager::GetName(unsigned int code) {
+const wchar_t* DataManager::GetName(unsigned int code) const {
 	auto csit = _strings.find(code);
 	if(csit == _strings.end())
 		return unknown_string;
@@ -221,7 +218,7 @@ const wchar_t* DataManager::GetName(unsigned int code) {
 		return csit->second.name.c_str();
 	return unknown_string;
 }
-const wchar_t* DataManager::GetText(unsigned int code) {
+const wchar_t* DataManager::GetText(unsigned int code) const {
 	auto csit = _strings.find(code);
 	if(csit == _strings.end())
 		return unknown_string;
@@ -229,7 +226,7 @@ const wchar_t* DataManager::GetText(unsigned int code) {
 		return csit->second.text.c_str();
 	return unknown_string;
 }
-const wchar_t* DataManager::GetDesc(unsigned int strCode) {
+const wchar_t* DataManager::GetDesc(unsigned int strCode) const {
 	if (strCode < (MIN_CARD_ID << 4))
 		return GetSysString(strCode);
 	unsigned int code = (strCode >> 4) & 0x0fffffff;
@@ -241,7 +238,7 @@ const wchar_t* DataManager::GetDesc(unsigned int strCode) {
 		return csit->second.desc[offset].c_str();
 	return unknown_string;
 }
-const wchar_t* DataManager::GetSysString(int code) {
+const wchar_t* DataManager::GetSysString(int code) const {
 	if (code < 0 || code > MAX_STRING_ID)
 		return unknown_string;
 	auto csit = _sysStrings.find(code);
@@ -249,25 +246,25 @@ const wchar_t* DataManager::GetSysString(int code) {
 		return unknown_string;
 	return csit->second.c_str();
 }
-const wchar_t* DataManager::GetVictoryString(int code) {
+const wchar_t* DataManager::GetVictoryString(int code) const {
 	auto csit = _victoryStrings.find(code);
 	if(csit == _victoryStrings.end())
 		return unknown_string;
 	return csit->second.c_str();
 }
-const wchar_t* DataManager::GetCounterName(int code) {
+const wchar_t* DataManager::GetCounterName(int code) const {
 	auto csit = _counterStrings.find(code);
 	if(csit == _counterStrings.end())
 		return unknown_string;
 	return csit->second.c_str();
 }
-const wchar_t* DataManager::GetSetName(int code) {
+const wchar_t* DataManager::GetSetName(int code) const {
 	auto csit = _setnameStrings.find(code);
 	if(csit == _setnameStrings.end())
-		return NULL;
+		return nullptr;
 	return csit->second.c_str();
 }
-std::vector<unsigned int> DataManager::GetSetCodes(std::wstring setname) {
+std::vector<unsigned int> DataManager::GetSetCodes(std::wstring setname) const {
 	std::vector<unsigned int> matchingCodes;
 	for(auto csit = _setnameStrings.begin(); csit != _setnameStrings.end(); ++csit) {
 		auto xpos = csit->second.find_first_of(L'|');//setname|another setname or extra info
@@ -297,8 +294,8 @@ const wchar_t* DataManager::GetNumString(int num, bool bracket) {
 	*++p = 0;
 	return numBuffer;
 }
-const wchar_t* DataManager::FormatLocation(int location, int sequence) {
-	if(location == 0x8) {
+const wchar_t* DataManager::FormatLocation(int location, int sequence) const {
+	if(location == LOCATION_SZONE) {
 		if(sequence < 5)
 			return GetSysString(1003);
 		else if(sequence == 5)
@@ -306,12 +303,16 @@ const wchar_t* DataManager::FormatLocation(int location, int sequence) {
 		else
 			return GetSysString(1009);
 	}
-	unsigned filter = 1;
 	int i = 1000;
-	for(; filter != 0x100 && filter != location; filter <<= 1)
-		++i;
-	if(filter == location)
-		return GetSysString(i);
+	int string_id = 0;
+	for (unsigned filter = LOCATION_DECK; filter <= LOCATION_PZONE; filter <<= 1, ++i) {
+		if (filter == location) {
+			string_id = i;
+			break;
+		}
+	}
+	if (string_id)
+		return GetSysString(string_id);
 	else
 		return unknown_string;
 }

gframe/data_manager.h

@@ -2,10 +2,9 @@
 #define DATAMANAGER_H
 
 #include "config.h"
-#include "sqlite3.h"
-#include "spmemvfs/spmemvfs.h"
-#include "client_card.h"
 #include <unordered_map>
+#include <sqlite3.h>
+#include "client_card.h"
 
 namespace ygo {
 	constexpr int MAX_STRING_ID = 0x7ff;
@@ -14,25 +13,31 @@ namespace ygo {
 class DataManager {
 public:
 	DataManager();
+	bool ReadDB(sqlite3* pDB);
 	bool LoadDB(const wchar_t* wfile);
 	bool LoadStrings(const char* file);
 	bool LoadStrings(IReadFile* reader);
 	void ReadStringConfLine(const char* linebuf);
-	bool Error(spmemvfs_db_t* pDB, sqlite3_stmt* pStmt = 0);
-	bool GetData(unsigned int code, CardData* pData);
+	bool Error(sqlite3* pDB, sqlite3_stmt* pStmt = nullptr);
+
 	code_pointer GetCodePointer(unsigned int code) const;
 	string_pointer GetStringPointer(unsigned int code) const;
-	bool GetString(unsigned int code, CardString* pStr);
-	const wchar_t* GetName(unsigned int code);
-	const wchar_t* GetText(unsigned int code);
-	const wchar_t* GetDesc(unsigned int strCode);
-	const wchar_t* GetSysString(int code);
-	const wchar_t* GetVictoryString(int code);
-	const wchar_t* GetCounterName(int code);
-	const wchar_t* GetSetName(int code);
-	std::vector<unsigned int> GetSetCodes(std::wstring setname);
+	code_pointer datas_begin();
+	code_pointer datas_end();
+	string_pointer strings_begin();
+	string_pointer strings_end();
+	bool GetData(unsigned int code, CardData* pData) const;
+	bool GetString(unsigned int code, CardString* pStr) const;
+	const wchar_t* GetName(unsigned int code) const;
+	const wchar_t* GetText(unsigned int code) const;
+	const wchar_t* GetDesc(unsigned int strCode) const;
+	const wchar_t* GetSysString(int code) const;
+	const wchar_t* GetVictoryString(int code) const;
+	const wchar_t* GetCounterName(int code) const;
+	const wchar_t* GetSetName(int code) const;
+	std::vector<unsigned int> GetSetCodes(std::wstring setname) const;
 	const wchar_t* GetNumString(int num, bool bracket = false);
-	const wchar_t* FormatLocation(int location, int sequence);
+	const wchar_t* FormatLocation(int location, int sequence) const;
 	const wchar_t* FormatAttribute(int attribute);
 	const wchar_t* FormatRace(int race);
 	const wchar_t* FormatType(int type);
@@ -43,10 +48,7 @@ public:
 	std::unordered_map<unsigned int, std::wstring> _victoryStrings;
 	std::unordered_map<unsigned int, std::wstring> _setnameStrings;
 	std::unordered_map<unsigned int, std::wstring> _sysStrings;
-	code_pointer datas_begin;
-	code_pointer datas_end;
-	string_pointer strings_begin;
-	string_pointer strings_end;
+	char errmsg[512]{};
 
 	wchar_t numStrings[301][4]{};
 	wchar_t numBuffer[6]{};

gframe/deck_con.cpp

@@ -1058,7 +1058,7 @@ bool DeckBuilder::OnEvent(const irr::SEvent& event) {
 			dragx = event.MouseInput.X;
 			dragy = event.MouseInput.Y;
 			draging_pointer = dataManager.GetCodePointer(hovered_code);
-			if(draging_pointer == dataManager.datas_end)
+			if(draging_pointer == dataManager.datas_end())
 				break;
 			if(hovered_pos == 4) {
 				if(!check_limit(draging_pointer))
@@ -1112,7 +1112,7 @@ bool DeckBuilder::OnEvent(const irr::SEvent& event) {
 				if(hovered_pos == 0 || hovered_seq == -1)
 					break;
 				auto pointer = dataManager.GetCodePointer(hovered_code);
-				if(pointer == dataManager.datas_end)
+				if(pointer == dataManager.datas_end())
 					break;
 				soundManager.PlaySoundEffect(SOUND_CARD_DROP);
 				if(hovered_pos == 1) {
@@ -1147,7 +1147,7 @@ bool DeckBuilder::OnEvent(const irr::SEvent& event) {
 					pop_side(hovered_seq);
 				} else {
 					auto pointer = dataManager.GetCodePointer(hovered_code);
-					if(pointer == dataManager.datas_end)
+					if(pointer == dataManager.datas_end())
 						break;
 					if(!check_limit(pointer))
 						break;
@@ -1182,7 +1182,7 @@ bool DeckBuilder::OnEvent(const irr::SEvent& event) {
 			if (is_draging)
 				break;
 			auto pointer = dataManager.GetCodePointer(hovered_code);
-			if (pointer == dataManager.datas_end)
+			if (pointer == dataManager.datas_end())
 				break;
 			if(!check_limit(pointer))
 				break;
@@ -1452,10 +1452,10 @@ void DeckBuilder::FilterCards() {
 			query_elements.push_back(element);
 		}
 	}
-	for(code_pointer ptr = dataManager.datas_begin; ptr != dataManager.datas_end; ++ptr) {
+	for(code_pointer ptr = dataManager.datas_begin(); ptr != dataManager.datas_end(); ++ptr) {
 		const CardDataC& data = ptr->second;
 		auto strpointer = dataManager.GetStringPointer(ptr->first);
-		if (strpointer == dataManager.strings_end)
+		if (strpointer == dataManager.strings_end())
 			continue;
 		const CardString& text = strpointer->second;
 		if(data.type & TYPE_TOKEN)

gframe/event_handler.cpp

@@ -2586,11 +2586,14 @@ void ClientField::ShowCardInfoInList(ClientCard* pcard, irr::gui::IGUIElement* e
 	}
 }
 void ClientField::SetResponseSelectedCards() const {
-	unsigned char respbuf[SIZE_RETURN_VALUE];
-	respbuf[0] = selected_cards.size();
-	for (size_t i = 0; i < selected_cards.size(); ++i)
+	unsigned char respbuf[SIZE_RETURN_VALUE]{};
+	int len = (int)selected_cards.size();
+	if (len > UINT8_MAX)
+		len = UINT8_MAX;
+	respbuf[0] = (unsigned char)len;
+	for (int i = 0; i < len; ++i)
 		respbuf[i + 1] = selected_cards[i]->select_seq;
-	DuelClient::SetResponseB(respbuf, selected_cards.size() + 1);
+	DuelClient::SetResponseB(respbuf, len + 1);
 }
 void ClientField::SetResponseSelectedOption() const {
 	if(mainGame->dInfo.curMsg == MSG_SELECT_OPTION) {

gframe/game.cpp

@@ -1823,7 +1823,7 @@ void Game::ShowCardInfo(int code, bool resize) {
 		return;
 	wchar_t formatBuffer[256];
 	auto cit = dataManager.GetCodePointer(code);
-	bool is_valid = (cit != dataManager.datas_end);
+	bool is_valid = (cit != dataManager.datas_end());
 	imgCard->setImage(imageManager.GetTexture(code, true));
 	if (is_valid) {
 		auto& cd = cit->second;
@@ -1840,7 +1840,7 @@ void Game::ShowCardInfo(int code, bool resize) {
 	if (is_valid && !gameConf.hide_setname) {
 		auto& cd = cit->second;
 		auto target = cit;
-		if (cd.alias && dataManager.GetCodePointer(cd.alias) != dataManager.datas_end) {
+		if (cd.alias && dataManager.GetCodePointer(cd.alias) != dataManager.datas_end()) {
 			target = dataManager.GetCodePointer(cd.alias);
 		}
 		if (target->second.setcode[0]) {

gframe/network.h

@@ -208,26 +208,25 @@ inline unsigned int GetPosition(unsigned char* qbuf, int offset) {
 
 class DuelMode {
 public:
-	virtual ~DuelMode() {}
-	virtual void Chat(DuelPlayer* dp, unsigned char* pdata, int len) {}
-	virtual void JoinGame(DuelPlayer* dp, unsigned char* 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, unsigned char* pdata, int len) {}
-	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) {
-		return 0;
-	}
-	virtual void Surrender(DuelPlayer* dp) {}
-	virtual void GetResponse(DuelPlayer* dp, unsigned char* pdata, unsigned int len) {}
-	virtual void TimeConfirm(DuelPlayer* dp) {}
-	virtual void EndDuel() {}
+	DuelMode() = default;
+	virtual ~DuelMode() = default;
+	virtual void Chat(DuelPlayer* dp, unsigned char* pdata, int len) = 0;
+	virtual void JoinGame(DuelPlayer* dp, unsigned char* 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, unsigned char* pdata, int len) = 0;
+	virtual void StartDuel(DuelPlayer* dp) = 0;
+	virtual void HandResult(DuelPlayer* dp, unsigned char res) = 0;
+	virtual void TPResult(DuelPlayer* dp, unsigned char tp) = 0;
+	virtual void Process() = 0;
+	virtual int Analyze(unsigned char* msgbuffer, unsigned int len) = 0;
+	virtual void Surrender(DuelPlayer* dp) = 0;
+	virtual void GetResponse(DuelPlayer* dp, unsigned char* pdata, unsigned int len) = 0;
+	virtual void TimeConfirm(DuelPlayer* dp) = 0;
+	virtual void EndDuel() = 0;
 
 public:
 	event* etimer { nullptr };

gframe/replay_mode.cpp

@@ -236,7 +236,7 @@ bool ReplayMode::StartDuel() {
 		}
 		cur_replay.ReadData(filename, slen);
 		filename[slen] = 0;
-		if(!preload_script(pduel, filename, 0)) {
+		if(!preload_script(pduel, filename)) {
 			return false;
 		}
 	}

gframe/single_duel.h

@@ -10,24 +10,24 @@ namespace ygo {
 class SingleDuel: public DuelMode {
 public:
 	SingleDuel(bool is_match);
-	virtual ~SingleDuel();
-	virtual void Chat(DuelPlayer* dp, unsigned char* pdata, int len);
-	virtual void JoinGame(DuelPlayer* dp, unsigned char* 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 ready);
-	virtual void PlayerKick(DuelPlayer* dp, unsigned char pos);
-	virtual void UpdateDeck(DuelPlayer* dp, unsigned char* pdata, int len);
-	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 void Surrender(DuelPlayer* dp);
-	virtual int Analyze(unsigned char* msgbuffer, unsigned int len);
-	virtual void GetResponse(DuelPlayer* dp, unsigned char* pdata, unsigned int len);
-	virtual void TimeConfirm(DuelPlayer* dp);
-	virtual void EndDuel();
+	~SingleDuel() override;
+	void Chat(DuelPlayer* dp, unsigned char* pdata, int len) override;
+	void JoinGame(DuelPlayer* dp, unsigned char* pdata, bool is_creater) override;
+	void LeaveGame(DuelPlayer* dp) override;
+	void ToDuelist(DuelPlayer* dp) override;
+	void ToObserver(DuelPlayer* dp) override;
+	void PlayerReady(DuelPlayer* dp, bool ready) override;
+	void PlayerKick(DuelPlayer* dp, unsigned char pos) override;
+	void UpdateDeck(DuelPlayer* dp, unsigned char* pdata, int len) override;
+	void StartDuel(DuelPlayer* dp) override;
+	void HandResult(DuelPlayer* dp, unsigned char res) override;
+	void TPResult(DuelPlayer* dp, unsigned char tp) override;
+	void Process() override;
+	void Surrender(DuelPlayer* dp) override;
+	int Analyze(unsigned char* msgbuffer, unsigned int len) override;
+	void GetResponse(DuelPlayer* dp, unsigned char* pdata, unsigned int len) override;
+	void TimeConfirm(DuelPlayer* dp) override;
+	void EndDuel() override;
 	
 	void DuelEndProc();
 	void WaitforResponse(int playerid);

gframe/single_mode.cpp

@@ -63,11 +63,11 @@ int SingleMode::SinglePlayThread() {
 	if(open_file) {
 		open_file = false;
 		slen = BufferIO::EncodeUTF8(open_file_name, filename);
-		if(!preload_script(pduel, filename, 0)) {
+		if(!preload_script(pduel, filename)) {
 			wchar_t fname[256];
 			myswprintf(fname, L"./single/%ls", open_file_name);
 			slen = BufferIO::EncodeUTF8(fname, filename);
-			if(!preload_script(pduel, filename, 0))
+			if(!preload_script(pduel, filename))
 				slen = 0;
 		}
 	} else {
@@ -75,7 +75,7 @@ int SingleMode::SinglePlayThread() {
 		wchar_t fname[256];
 		myswprintf(fname, L"./single/%ls", name);
 		slen = BufferIO::EncodeUTF8(fname, filename);
-		if(!preload_script(pduel, filename, 0))
+		if(!preload_script(pduel, filename))
 			slen = 0;
 	}
 	if(slen == 0) {

gframe/tag_duel.h

@@ -10,24 +10,24 @@ namespace ygo {
 class TagDuel: public DuelMode {
 public:
 	TagDuel();
-	virtual ~TagDuel();
-	virtual void Chat(DuelPlayer* dp, unsigned char* pdata, int len);
-	virtual void JoinGame(DuelPlayer* dp, unsigned char* 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 ready);
-	virtual void PlayerKick(DuelPlayer* dp, unsigned char pos);
-	virtual void UpdateDeck(DuelPlayer* dp, unsigned char* pdata, int len);
-	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 void Surrender(DuelPlayer* dp);
-	virtual int Analyze(unsigned char* msgbuffer, unsigned int len);
-	virtual void GetResponse(DuelPlayer* dp, unsigned char* pdata, unsigned int len);
-	virtual void TimeConfirm(DuelPlayer* dp);
-	virtual void EndDuel();
+	~TagDuel() override;
+	void Chat(DuelPlayer* dp, unsigned char* pdata, int len) override;
+	void JoinGame(DuelPlayer* dp, unsigned char* pdata, bool is_creater) override;
+	void LeaveGame(DuelPlayer* dp) override;
+	void ToDuelist(DuelPlayer* dp) override;
+	void ToObserver(DuelPlayer* dp) override;
+	void PlayerReady(DuelPlayer* dp, bool ready) override;
+	void PlayerKick(DuelPlayer* dp, unsigned char pos) override;
+	void UpdateDeck(DuelPlayer* dp, unsigned char* pdata, int len) override;
+	void StartDuel(DuelPlayer* dp) override;
+	void HandResult(DuelPlayer* dp, unsigned char res) override;
+	void TPResult(DuelPlayer* dp, unsigned char tp) override;
+	void Process() override;
+	void Surrender(DuelPlayer* dp) override;
+	int Analyze(unsigned char* msgbuffer, unsigned int len) override;
+	void GetResponse(DuelPlayer* dp, unsigned char* pdata, unsigned int len) override;
+	void TimeConfirm(DuelPlayer* dp) override;
+	void EndDuel() override;
 	
 	void DuelEndProc();
 	void WaitforResponse(int playerid);