Merge branch 'server' into server-develop

gframe/client_field.cpp

@@ -465,7 +465,7 @@ void ClientField::ShowSelectCard(bool buttonok, bool chain) {
 			// text
 			wchar_t formatBuffer[2048];
 			if(conti_selecting)
-				myswprintf(formatBuffer, L"%ls", DataManager::unknown_string);
+				myswprintf(formatBuffer, L"%ls", dataManager.unknown_string);
 			else if(cant_check_grave && selectable_cards[i]->location == LOCATION_GRAVE)
 				myswprintf(formatBuffer, L"%ls", dataManager.FormatLocation(selectable_cards[i]->location, 0));
 			else if(selectable_cards[i]->location == LOCATION_OVERLAY)
@@ -1569,7 +1569,8 @@ void ClientField::UpdateDeclarableList() {
 	int trycode = BufferIO::GetVal(pname);
 	CardData cd;
 	if (dataManager.GetData(trycode, &cd) && is_declarable(cd, declare_opcodes)) {
-		auto it = dataManager.GetStringPointer(trycode);
+		auto& _strings = dataManager.GetStringTable();
+		auto it = _strings.find(trycode);
 		mainGame->lstANCard->clear();
 		ancard.clear();
 		mainGame->lstANCard->addItem(it->second.name.c_str());
@@ -1590,19 +1591,23 @@ void ClientField::UpdateDeclarableList() {
 		// if(ancard.size())
 		// return;
 	}
-	for(auto cit = dataManager.strings_begin(); cit != dataManager.strings_end(); ++cit) {
-		if(cit->second.name.find(pname) != std::wstring::npos || mainGame->CheckRegEx(cit->second.name, pname)) {
-			auto cp = dataManager.GetCodePointer(cit->first);
-			if (cp == dataManager.datas_end())
+	auto& _datas = dataManager.GetDataTable();
+	auto& _strings = dataManager.GetStringTable();
+	for(auto& entry : _strings) {
+		auto& code = entry.first;
+		auto& str = entry.second;
+		if(str.name.find(pname) != std::wstring::npos) {
+			auto cp = _datas.find(code);
+			if (cp == _datas.end())
 				continue;
 			//datas.alias can be double card names or alias
 			if(is_declarable(cp->second, declare_opcodes)) {
-				if(pname == cit->second.name) { //exact match
-					mainGame->lstANCard->insertItem(0, cit->second.name.c_str(), -1);
-					ancard.insert(ancard.begin(), cit->first);
+				if(pname == str.name) { //exact match
+					mainGame->lstANCard->insertItem(0, str.name.c_str(), -1);
+					ancard.insert(ancard.begin(), code);
 				} else {
-					mainGame->lstANCard->addItem(cit->second.name.c_str());
-					ancard.push_back(cit->first);
+					mainGame->lstANCard->addItem(str.name.c_str());
+					ancard.push_back(code);
 				}
 			}
 		}

gframe/config.h

@@ -108,7 +108,7 @@ extern bool auto_watch_mode;
 extern bool open_file;
 extern wchar_t open_file_name[256];
 extern bool bot_mode;
-extern bool expansions_specified;
 extern std::vector<std::wstring> expansions_list;
+extern std::vector<std::wstring> extra_script_list;
 
 #endif

gframe/data_manager.cpp

@@ -6,11 +6,7 @@
 
 namespace ygo {
 
-const wchar_t* DataManager::unknown_string = L"???";
 unsigned char DataManager::scriptBuffer[0x100000] = {};
-#if !defined(YGOPRO_SERVER_MODE) || defined(SERVER_ZIP_SUPPORT)
-irr::io::IFileSystem* DataManager::FileSystem = nullptr;
-#endif
 DataManager dataManager;
 
 DataManager::DataManager() : _datas(32768), _strings(32768) {
@@ -614,9 +610,9 @@ unsigned char* DataManager::ReadScriptFromIrrFS(const char* script_name, int* sl
 #ifdef _WIN32
 	wchar_t fname[256]{};
 	BufferIO::DecodeUTF8(script_name, fname);
-	auto reader = FileSystem->createAndOpenFile(fname);
+	auto reader = dataManager.FileSystem->createAndOpenFile(fname);
 #else
-	auto reader = FileSystem->createAndOpenFile(script_name);
+	auto reader = dataManager.FileSystem->createAndOpenFile(script_name);
 #endif
 	if (!reader)
 		return nullptr;
@@ -639,6 +635,13 @@ unsigned char* DataManager::ReadScriptFromFile(const char* script_name, int* sle
 	*slen = (int)len;
 	return scriptBuffer;
 }
+void DataManager::LoadExtraScripts(intptr_t pduel) {
+	char sname[1024];
+	for(auto name : extra_script_list) {
+		BufferIO::EncodeUTF8(name.c_str(), sname);
+		preload_script(pduel, sname);
+	}
+}
 #ifndef YGOPRO_SERVER_MODE
 bool DataManager::deck_sort_lv(code_pointer p1, code_pointer p2) {
 	if ((p1->second.type & 0x7) != (p2->second.type & 0x7))

gframe/data_manager.h

@@ -85,17 +85,13 @@ public:
 	code_pointer GetCodePointer(uint32_t code) const;
 #ifndef YGOPRO_SERVER_MODE
 	string_pointer GetStringPointer(uint32_t code) const;
-	code_pointer datas_begin() const noexcept {
-		return _datas.cbegin();
-	}
-	code_pointer datas_end() const noexcept {
-		return _datas.cend();
-	}
-	string_pointer strings_begin() const noexcept {
-		return _strings.cbegin();
+#endif //YGOPRO_SERVER_MODE
+	const std::unordered_map<uint32_t, CardDataC>& GetDataTable() const {
+		return _datas;
 	}
-	string_pointer strings_end() const noexcept {
-		return _strings.cend();
+#ifndef YGOPRO_SERVER_MODE
+	const std::unordered_map<uint32_t, CardString>& GetStringTable() const {
+		return _strings;
 	}
 #endif //YGOPRO_SERVER_MODE
 	bool GetData(uint32_t code, CardData* pData) const;
@@ -123,13 +119,17 @@ public:
 	std::unordered_map<unsigned int, std::wstring> _sysStrings;
 	std::vector<std::pair<std::wstring, std::wstring>> _serverStrings;
 #endif
+	const wchar_t* unknown_string{ L"???" };
 	char errmsg[512]{};
+#if !defined(YGOPRO_SERVER_MODE) || defined(SERVER_ZIP_SUPPORT)
+	irr::io::IFileSystem* FileSystem{};
+#endif
 
 	static unsigned char scriptBuffer[0x100000];
-	static const wchar_t* unknown_string;
 	static uint32_t CardReader(uint32_t, card_data*);
 	static unsigned char* ScriptReaderEx(const char* script_name, int* slen);
 	static unsigned char* ScriptReaderExSingle(const char* path, const char* script_name, int* slen, int pre_len = 2, unsigned int use_irr = FALSE);
+		void LoadExtraScripts(intptr_t pduel);
 
 #if !defined(YGOPRO_SERVER_MODE) || defined(SERVER_ZIP_SUPPORT)
 	//read by IFileSystem
@@ -137,10 +137,6 @@ public:
 #endif
 	//read by fread
 	static unsigned char* ReadScriptFromFile(const char* script_name, int* slen);
-	
-#if !defined(YGOPRO_SERVER_MODE) || defined(SERVER_ZIP_SUPPORT)
-	static irr::io::IFileSystem* FileSystem;
-#endif
 
 #ifndef YGOPRO_SERVER_MODE
 	static bool deck_sort_lv(code_pointer l1, code_pointer l2);

gframe/deck_con.cpp

@@ -141,6 +141,7 @@ void DeckBuilder::Terminate() {
 bool DeckBuilder::OnEvent(const irr::SEvent& event) {
 	if(mainGame->dField.OnCommonEvent(event))
 		return false;
+	auto& _datas = dataManager.GetDataTable();
 	switch(event.EventType) {
 	case irr::EET_GUI_EVENT: {
 		irr::s32 id = event.GUIEvent.Caller->getID();
@@ -472,7 +473,7 @@ bool DeckBuilder::OnEvent(const irr::SEvent& event) {
 						mainGame->lstCategories->addItem(catename);
 						catesel = mainGame->lstCategories->getItemCount() - 1;
 					} else {
-						for(int i = 3; i < (int)mainGame->lstCategories->getItemCount(); i++) {
+						for(int i = DECK_CATEGORY_CUSTOM; i < (int)mainGame->lstCategories->getItemCount(); i++) {
 							if(!mywcsncasecmp(mainGame->lstCategories->getListItem(i), catename, 256)) {
 								catesel = i;
 								mainGame->stACMessage->setText(dataManager.GetSysString(1474));
@@ -492,6 +493,8 @@ bool DeckBuilder::OnEvent(const irr::SEvent& event) {
 				}
 				case BUTTON_RENAME_CATEGORY: {
 					int catesel = mainGame->lstCategories->getSelected();
+					if (catesel < DECK_CATEGORY_CUSTOM)
+						break;
 					const wchar_t* oldcatename = mainGame->lstCategories->getListItem(catesel);
 					const wchar_t* newcatename = mainGame->ebDMName->getText();
 					if(DeckManager::RenameCategory(oldcatename, newcatename)) {
@@ -502,7 +505,7 @@ bool DeckBuilder::OnEvent(const irr::SEvent& event) {
 						catesel = mainGame->lstCategories->getItemCount() - 1;
 					} else {
 						catesel = 0;
-						for(int i = 3; i < (int)mainGame->lstCategories->getItemCount(); i++) {
+						for(int i = DECK_CATEGORY_CUSTOM; i < (int)mainGame->lstCategories->getItemCount(); i++) {
 							if(!mywcsncasecmp(mainGame->lstCategories->getListItem(i), newcatename, 256)) {
 								catesel = i;
 								mainGame->stACMessage->setText(dataManager.GetSysString(1474));
@@ -522,11 +525,13 @@ bool DeckBuilder::OnEvent(const irr::SEvent& event) {
 				}
 				case BUTTON_DELETE_CATEGORY: {
 					int catesel = mainGame->lstCategories->getSelected();
+					if (catesel < DECK_CATEGORY_CUSTOM)
+						break;
 					const wchar_t* catename = mainGame->lstCategories->getListItem(catesel);
 					if(DeckManager::DeleteCategory(catename)) {
 						mainGame->cbDBCategory->removeItem(catesel);
 						mainGame->lstCategories->removeItem(catesel);
-						catesel = 2;
+						catesel = DECK_CATEGORY_NONE;
 						mainGame->lstCategories->setSelected(catesel);
 						RefreshDeckList();
 						mainGame->lstDecks->setSelected(0);
@@ -1118,8 +1123,8 @@ bool DeckBuilder::OnEvent(const irr::SEvent& event) {
 				break;
 			dragx = event.MouseInput.X;
 			dragy = event.MouseInput.Y;
-			draging_pointer = dataManager.GetCodePointer(hovered_code);
-			if(draging_pointer == dataManager.datas_end())
+			draging_pointer = _datas.find(hovered_code);
+			if (draging_pointer == _datas.end())
 				break;
 			if(hovered_pos == 4) {
 				if(!check_limit(draging_pointer))
@@ -1172,8 +1177,8 @@ bool DeckBuilder::OnEvent(const irr::SEvent& event) {
 					break;
 				if(hovered_pos == 0 || hovered_seq == -1)
 					break;
-				auto pointer = dataManager.GetCodePointer(hovered_code);
-				if(pointer == dataManager.datas_end())
+				auto pointer = _datas.find(hovered_code);
+				if (pointer == _datas.end())
 					break;
 				soundManager.PlaySoundEffect(SOUND_CARD_DROP);
 				if(hovered_pos == 1) {
@@ -1207,8 +1212,8 @@ bool DeckBuilder::OnEvent(const irr::SEvent& event) {
 				} else if(hovered_pos == 3) {
 					pop_side(hovered_seq);
 				} else {
-					auto pointer = dataManager.GetCodePointer(hovered_code);
-					if(pointer == dataManager.datas_end())
+					auto pointer = _datas.find(hovered_code);
+					if (pointer == _datas.end())
 						break;
 					if(!check_limit(pointer))
 						break;
@@ -1242,8 +1247,8 @@ bool DeckBuilder::OnEvent(const irr::SEvent& event) {
 				break;
 			if (is_draging)
 				break;
-			auto pointer = dataManager.GetCodePointer(hovered_code);
-			if (pointer == dataManager.datas_end())
+			auto pointer = _datas.find(hovered_code);
+			if (pointer == _datas.end())
 				break;
 			if(!check_limit(pointer))
 				break;
@@ -1512,10 +1517,13 @@ void DeckBuilder::FilterCards() {
 			query_elements.push_back(element);
 		}
 	}
-	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())
+	auto& _datas = dataManager.GetDataTable();
+	auto& _strings = dataManager.GetStringTable();
+	for (code_pointer ptr = _datas.begin(); ptr != _datas.end(); ++ptr) {
+		auto& code = ptr->first;
+		auto& data = ptr->second;
+		auto strpointer = _strings.find(code);
+		if (strpointer == _strings.end())
 			continue;
 		const CardString& strings = strpointer->second;
 		if(data.type & TYPE_TOKEN)
@@ -1924,16 +1932,16 @@ bool DeckBuilder::check_limit(code_pointer pointer) {
 	auto flit = filterList->content.find(limitcode);
 	if(flit != filterList->content.end())
 		limit = flit->second;
-	for(auto it = deckManager.current_deck.main.begin(); it != deckManager.current_deck.main.end(); ++it) {
-		if((*it)->first == limitcode || (*it)->second.alias == limitcode)
+	for (auto& card : deckManager.current_deck.main) {
+		if (card->first == limitcode || card->second.alias == limitcode)
 			limit--;
 	}
-	for(auto it = deckManager.current_deck.extra.begin(); it != deckManager.current_deck.extra.end(); ++it) {
-		if((*it)->first == limitcode || (*it)->second.alias == limitcode)
+	for (auto& card : deckManager.current_deck.extra) {
+		if (card->first == limitcode || card->second.alias == limitcode)
 			limit--;
 	}
-	for(auto it = deckManager.current_deck.side.begin(); it != deckManager.current_deck.side.end(); ++it) {
-		if((*it)->first == limitcode || (*it)->second.alias == limitcode)
+	for (auto& card : deckManager.current_deck.side) {
+		if (card->first == limitcode || card->second.alias == limitcode)
 			limit--;
 	}
 	return limit > 0;

gframe/deck_manager.cpp

@@ -6,9 +6,6 @@
 
 namespace ygo {
 
-#ifndef YGOPRO_SERVER_MODE
-char DeckManager::deckBuffer[0x10000]{};
-#endif
 DeckManager deckManager;
 
 void DeckManager::LoadLFListSingle(const char* path, bool insert) {
@@ -154,42 +151,46 @@ unsigned int DeckManager::CheckDeck(const Deck& deck, unsigned int lfhash, int r
 uint32_t DeckManager::LoadDeck(Deck& deck, uint32_t dbuf[], int mainc, int sidec, bool is_packlist) {
 	deck.clear();
 	uint32_t errorcode = 0;
-	CardData cd;
+	auto& _datas = dataManager.GetDataTable();
 	for(int i = 0; i < mainc; ++i) {
 		auto code = dbuf[i];
-		if(!dataManager.GetData(code, &cd)) {
+		auto it = _datas.find(code);
+		if(it == _datas.end()) {
 			errorcode = code;
 			continue;
 		}
+		auto& cd = it->second;
 		if (cd.type & TYPE_TOKEN) {
 			errorcode = code;
 			continue;
 		}
 		if(is_packlist) {
-			deck.main.push_back(dataManager.GetCodePointer(code));
+			deck.main.push_back(it);
 			continue;
 		}
 		if (cd.type & TYPES_EXTRA_DECK) {
 			if (deck.extra.size() < EXTRA_MAX_SIZE)
-				deck.extra.push_back(dataManager.GetCodePointer(code));
+				deck.extra.push_back(it);
 		}
 		else {
 			if (deck.main.size() < DECK_MAX_SIZE)
-				deck.main.push_back(dataManager.GetCodePointer(code));
+				deck.main.push_back(it);
 		}
 	}
 	for(int i = 0; i < sidec; ++i) {
 		auto code = dbuf[mainc + i];
-		if(!dataManager.GetData(code, &cd)) {
+		auto it = _datas.find(code);
+		if(it == _datas.end()) {
 			errorcode = code;
 			continue;
 		}
+		auto& cd = it->second;
 		if (cd.type & TYPE_TOKEN) {
 			errorcode = code;
 			continue;
 		}
 		if(deck.side.size() < SIDE_MAX_SIZE)
-			deck.side.push_back(dataManager.GetCodePointer(code));
+			deck.side.push_back(it);
 	}
 	return errorcode;
 }
@@ -253,15 +254,15 @@ bool DeckManager::LoadSide(Deck& deck, uint32_t dbuf[], int mainc, int sidec) {
 void DeckManager::GetCategoryPath(wchar_t* ret, int index, const wchar_t* text) {
 	wchar_t catepath[256];
 	switch(index) {
-	case 0:
+	case DECK_CATEGORY_PACK:
 		myswprintf(catepath, L"./pack");
 		break;
-	case 1:
+	case DECK_CATEGORY_BOT:
 		BufferIO::CopyWideString(mainGame->gameConf.bot_deck_path, catepath);
 		break;
 	case -1:
-	case 2:
-	case 3:
+	case DECK_CATEGORY_NONE:
+	case DECK_CATEGORY_SEPARATOR:
 		myswprintf(catepath, L"./deck");
 		break;
 	default:
@@ -287,11 +288,11 @@ FILE* DeckManager::OpenDeckFile(const wchar_t* file, const char* mode) {
 }
 irr::io::IReadFile* DeckManager::OpenDeckReader(const wchar_t* file) {
 #ifdef _WIN32
-	auto reader = DataManager::FileSystem->createAndOpenFile(file);
+	auto reader = dataManager.FileSystem->createAndOpenFile(file);
 #else
 	char file2[256];
 	BufferIO::EncodeUTF8(file, file2);
-	auto reader = DataManager::FileSystem->createAndOpenFile(file2);
+	auto reader = dataManager.FileSystem->createAndOpenFile(file2);
 #endif
 	return reader;
 }
@@ -301,6 +302,9 @@ bool DeckManager::LoadCurrentDeck(std::istringstream& deckStream, bool is_packli
 }
 bool DeckManager::LoadCurrentDeck(const wchar_t* file, bool is_packlist) {
 	current_deck.clear();
+	if (!file[0])
+		return false;
+	char deckBuffer[MAX_YDK_SIZE]{};
 	auto reader = OpenDeckReader(file);
 	if(!reader) {
 		wchar_t localfile[256];
@@ -327,11 +331,12 @@ bool DeckManager::LoadCurrentDeck(const wchar_t* file, bool is_packlist) {
 bool DeckManager::LoadCurrentDeck(int category_index, const wchar_t* category_name, const wchar_t* deckname) {
 	wchar_t filepath[256];
 	GetDeckFile(filepath, category_index, category_name, deckname);
-	bool is_packlist = (category_index == 0);
-	bool res = LoadCurrentDeck(filepath, is_packlist);
-	if (res && mainGame->is_building)
+	bool is_packlist = (category_index == DECK_CATEGORY_PACK);
+	if(!LoadCurrentDeck(filepath, is_packlist))
+		return false;
+	if (mainGame->is_building)
 		mainGame->deckBuilder.RefreshPackListScroll();
-	return res;
+	return true;
 }
 void DeckManager::SaveDeck(const Deck& deck, std::stringstream& deckStream) {
 	deckStream << "#created by ..." << std::endl;

gframe/deck_manager.h

@@ -33,6 +33,12 @@ namespace ygo {
 	constexpr int MAINC_MAX = 250;	// the limit of card_state
 	constexpr int SIDEC_MAX = MAINC_MAX;
 
+	constexpr int DECK_CATEGORY_PACK = 0;
+	constexpr int DECK_CATEGORY_BOT = 1;
+	constexpr int DECK_CATEGORY_NONE = 2;
+	constexpr int DECK_CATEGORY_SEPARATOR = 3;
+	constexpr int DECK_CATEGORY_CUSTOM = 4;
+
 struct LFList {
 	unsigned int hash{};
 	std::wstring listName;
@@ -68,6 +74,7 @@ public:
 
 #ifndef YGOPRO_SERVER_MODE
 	static char deckBuffer[0x10000];
+	static constexpr int MAX_YDK_SIZE = 0x10000;
 #endif
 
 	void LoadLFListSingle(const char* path, bool insert = false);

gframe/event_handler.cpp

@@ -921,7 +921,7 @@ bool ClientField::OnEvent(const irr::SEvent& event) {
 							myswprintf(formatBuffer, L"");
 					} else {
 						if(conti_selecting)
-							myswprintf(formatBuffer, L"%ls", DataManager::unknown_string);
+							myswprintf(formatBuffer, L"%ls", dataManager.unknown_string);
 						else if(cant_check_grave && selectable_cards[i]->location == LOCATION_GRAVE)
 							myswprintf(formatBuffer, L"%ls", dataManager.FormatLocation(selectable_cards[i]->location, 0));
 						else if(selectable_cards[i + pos]->location == LOCATION_OVERLAY)

gframe/game.cpp

@@ -93,16 +93,16 @@ HostInfo game_info;
 
 void Game::MainServerLoop() {
 #ifdef SERVER_ZIP_SUPPORT
-	DataManager::FileSystem = new irr::io::CFileSystem();
+	deckManager.FileSystem = new irr::io::CFileSystem();
 #endif
 	initUtils();
 	deckManager.LoadLFList();
 	dataManager.LoadDB(L"cards.cdb");
 	LoadExpansionsAll();
 #ifdef SERVER_PRO2_SUPPORT
-	DataManager::FileSystem->addFileArchive("data/script.zip", true, false, irr::io::EFAT_ZIP);
+	deckManager.FileSystem->addFileArchive("data/script.zip", true, false, irr::io::EFAT_ZIP);
 #elif defined(SERVER_PRO3_SUPPORT)
-	DataManager::FileSystem->addFileArchive("Data/script.zip", true, false, irr::io::EFAT_ZIP);
+	deckManager.FileSystem->addFileArchive("Data/script.zip", true, false, irr::io::EFAT_ZIP);
 #endif
 
 	server_port = NetServer::StartServer(server_port);
@@ -168,7 +168,7 @@ bool Game::Initialize() {
 		ErrorLog("Failed to load textures!");
 		return false;
 	}
-	DataManager::FileSystem = device->getFileSystem();
+	dataManager.FileSystem = device->getFileSystem();
 	if(dataManager.LoadDB(GetLocaleDirWide("cards.cdb"))) {} else
 	if(!dataManager.LoadDB(L"cards.cdb")) {
 		ErrorLog("Failed to load card database (cards.cdb)!");
@@ -1337,19 +1337,19 @@ void Game::LoadExpansions(const wchar_t* expansions_path) {
 #if defined(SERVER_ZIP_SUPPORT) || !defined(YGOPRO_SERVER_MODE)
 		if (IsExtension(name, L".zip") || IsExtension(name, L".ypk")) {
 #ifdef _WIN32
-			DataManager::FileSystem->addFileArchive(fpath, true, false, irr::io::EFAT_ZIP);
+			dataManager.FileSystem->addFileArchive(fpath, true, false, irr::io::EFAT_ZIP);
 #else
 			char upath[1024];
 			BufferIO::EncodeUTF8(fpath, upath);
-			DataManager::FileSystem->addFileArchive(upath, true, false, irr::io::EFAT_ZIP);
+			dataManager.FileSystem->addFileArchive(upath, true, false, irr::io::EFAT_ZIP);
 #endif
 			return;
 		}
 #endif //SERVER_ZIP_SUPPORT
 	});
 #if defined(SERVER_ZIP_SUPPORT) || !defined(YGOPRO_SERVER_MODE)
-	for(irr::u32 i = 0; i < DataManager::FileSystem->getFileArchiveCount(); ++i) {
-		auto archiveObj = DataManager::FileSystem->getFileArchive(i);
+	for(irr::u32 i = 0; i < dataManager.FileSystem->getFileArchiveCount(); ++i) {
+		auto archiveObj = dataManager.FileSystem->getFileArchive(i);
 		auto archive = archiveObj->getFileList();
 		for(irr::u32 j = 0; j < archive->getFileCount(); ++j) {
 #ifdef _WIN32
@@ -2001,8 +2001,9 @@ void Game::ShowCardInfo(int code, bool resize) {
 	if(showingcode == code && !resize)
 		return;
 	wchar_t formatBuffer[256];
-	auto cit = dataManager.GetCodePointer(code);
-	bool is_valid = (cit != dataManager.datas_end());
+	auto& _datas = dataManager.GetDataTable();
+	auto cit = _datas.find(code);
+	bool is_valid = (cit != _datas.end());
 	imgCard->setImage(imageManager.GetTexture(code, true));
 	if (is_valid) {
 		auto& cd = cit->second;
@@ -2023,8 +2024,8 @@ 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()) {
-			target = dataManager.GetCodePointer(cd.alias);
+		if (cd.alias && _datas.find(cd.alias) != _datas.end()) {
+			target = _datas.find(cd.alias);
 		}
 		if (target->second.setcode[0]) {
 			offset = 23;// *yScale;

gframe/gframe.cpp

@@ -21,8 +21,8 @@
 #endif
 
 unsigned int enable_log = 0x3;
-bool expansions_specified = false;
 std::vector<std::wstring> expansions_list;
+std::vector<std::wstring> extra_script_list;
 #ifndef YGOPRO_SERVER_MODE
 bool exit_on_return = false;
 bool auto_watch_mode = false;
@@ -85,36 +85,59 @@ int main(int argc, char* argv[]) {
 	ygo::Game _game;
 #ifdef YGOPRO_SERVER_MODE
 	enable_log = 1;
-	bool expansions_specified = false;
 
-	wchar_t* expansions_env_val = nullptr;
+	auto trim = [](std::wstring& s) {
+		const wchar_t* ws = L" \t\r\n";
+		auto b = s.find_first_not_of(ws);
+		auto e = s.find_last_not_of(ws);
+		if (b == std::wstring::npos) { s.clear(); return; }
+		s = s.substr(b, e - b + 1);
+	};
+
+	auto parse_wcsv = [&](const std::wstring& wcsv, std::vector<std::wstring>& out) {
+		if (wcsv.empty()) return;
+		std::wstringstream ss(wcsv);
+		std::wstring item;
+		while (std::getline(ss, item, L',')) {
+			trim(item);
+			if (!item.empty()) out.push_back(item);
+		}
+	};
 
+	auto get_env_wstr = [&](const char* env_name) -> std::wstring {
 #ifdef _WIN32
-	expansions_env_val = _wgetenv(L"YGOPRO_EXPANSIONS");
+		auto envname_w_len = std::strlen(env_name) + 1;
+		wchar_t* envname_w = new wchar_t[envname_w_len];
+		BufferIO::DecodeUTF8String(env_name, envname_w, envname_w_len);
+		const wchar_t* wval = _wgetenv(envname_w);
+		delete[] envname_w;
+		return (wval && wval[0]) ? std::wstring(wval) : std::wstring();
 #else
-	const char* env_utf8 = std::getenv("YGOPRO_EXPANSIONS");
-	if(env_utf8) {
-		expansions_env_val = (wchar_t*)malloc(1024 * sizeof(wchar_t));
-		BufferIO::DecodeUTF8String(env_utf8, expansions_env_val, 1024);
-	}
+		const char* env_utf8 = std::getenv(env_name);
+		if (!env_utf8 || !env_utf8[0]) return {};
+		auto env_w_len = std::strlen(env_utf8) + 1;
+		wchar_t* env_w = new wchar_t[env_w_len];
+		BufferIO::DecodeUTF8String(env_utf8, env_w, env_w_len);
+		auto res = std::wstring(env_w);
+		delete[] env_w;
+		return res;
 #endif
+	};
 
-	if (expansions_env_val && expansions_env_val[0] != L'\0') {
-		expansions_specified = true;
-		std::wstringstream ss(expansions_env_val);
-		std::wstring item;
-		while (std::getline(ss, item, L',')) {
-			if (!item.empty()) {
-				expansions_list.push_back(item);
-			}
-		}
-	} else {
-		expansions_specified = false;
+	auto load_env_list = [&](const char* env_name, std::vector<std::wstring>& out) {
+		std::wstring val = get_env_wstr(env_name);
+		parse_wcsv(val, out);
+	};
+
+	load_env_list("YGOPRO_EXPANSIONS", expansions_list);
+	if (expansions_list.empty()) {
 		expansions_list.push_back(L"./expansions");
 #if defined(SERVER_PRO3_SUPPORT) && !defined(_WIN32) && !defined(__APPLE__)
 		expansions_list.push_back(L"./Expansions");
 #endif
 	}
+	load_env_list("YGOPRO_EXTRA_SCRIPT", extra_script_list);
+
 	ygo::server_port = 7911;
 	ygo::replay_mode = 0;
 	ygo::duel_flags = 0;
@@ -219,6 +242,7 @@ int main(int argc, char* argv[]) {
 
 	bool keep_on_return = false;
 	bool deckCategorySpecified = false;
+	bool expansions_specified = false;
 	expansions_list.push_back(L"./expansions");
 	for(int i = 1; i < wargc; ++i) {
 		if (wargc == 2 && std::wcslen(wargv[1]) >= 4) {
@@ -354,6 +378,12 @@ int main(int argc, char* argv[]) {
 				expansions_list.push_back(wargv[i]);
 			}
 			continue;
+		} else if (!std::wcscmp(wargv[i], L"--extra-script")) { // specify extra script
+			++i;
+			if(i < wargc) {
+				extra_script_list.push_back(wargv[i]);
+			}
+			continue;
 		}
 	}
 	ygo::mainGame->MainLoop();

gframe/menu_handler.cpp

@@ -470,7 +470,7 @@ bool MenuHandler::OnEvent(const irr::SEvent& event) {
 				if(prev_operation == BUTTON_RENAME_REPLAY) {
 					wchar_t newname[256];
 					BufferIO::CopyWideString(mainGame->ebRSName->getText(), newname);
-					if(mywcsncasecmp(newname + std::wcslen(newname) - 4, L".yrp", 4)) {
+					if (!IsExtension(newname, L".yrp")) {
 						myswprintf(newname, L"%ls.yrp", mainGame->ebRSName->getText());
 					}
 					if(Replay::RenameReplay(mainGame->lstReplayList->getListItem(prev_sel), newname)) {

gframe/myfilesystem.h

@@ -21,7 +21,7 @@ class FileSystem {
 public:
 	static void SafeFileName(wchar_t* wfile) {
 		while((wfile = std::wcspbrk(wfile, L"<>:\"/\\|?*")) != nullptr)
-			*wfile++ = '_';
+			*wfile++ = L'_';
 	}
 
 	static bool IsFileExists(const wchar_t* wfile) {
@@ -125,7 +125,7 @@ class FileSystem {
 public:
 	static void SafeFileName(wchar_t* wfile) {
 		while((wfile = std::wcspbrk(wfile, L"/")) != nullptr)
-			*wfile++ = '_';
+			*wfile++ = L'_';
 	}
 
 	static bool IsFileExists(const char* file) {

gframe/replay_mode.cpp

@@ -192,6 +192,7 @@ bool ReplayMode::StartDuel() {
 	preload_script(pduel, "./script/patches/entry.lua");
 	preload_script(pduel, "./script/special.lua");
 	preload_script(pduel, "./script/init.lua");
+	dataManager.LoadExtraScripts(pduel);
 	mainGame->dInfo.lp[0] = cur_replay.params.start_lp;
 	mainGame->dInfo.lp[1] = cur_replay.params.start_lp;
 	mainGame->dInfo.start_lp = cur_replay.params.start_lp;

gframe/single_duel.cpp

@@ -620,6 +620,7 @@ void SingleDuel::TPResult(DuelPlayer* dp, unsigned char tp) {
 	preload_script(pduel, "./script/patches/entry.lua");
 	preload_script(pduel, "./script/special.lua");
 	preload_script(pduel, "./script/init.lua");
+	dataManager.LoadExtraScripts(pduel);
 	unsigned int opt = (unsigned int)host_info.duel_rule << 16;
 	if(host_info.no_shuffle_deck)
 		opt |= DUEL_PSEUDO_SHUFFLE;

gframe/single_mode.cpp

@@ -64,6 +64,7 @@ int SingleMode::SinglePlayThread() {
 	preload_script(pduel, "./script/patches/entry.lua");
 	preload_script(pduel, "./script/special.lua");
 	preload_script(pduel, "./script/init.lua");
+	dataManager.LoadExtraScripts(pduel);
 	mainGame->dInfo.lp[0] = start_lp;
 	mainGame->dInfo.lp[1] = start_lp;
 	mainGame->dInfo.start_lp = start_lp;

gframe/tag_duel.cpp

@@ -596,6 +596,7 @@ void TagDuel::TPResult(DuelPlayer* dp, unsigned char tp) {
 	preload_script(pduel, "./script/patches/entry.lua");
 	preload_script(pduel, "./script/special.lua");
 	preload_script(pduel, "./script/init.lua");
+	dataManager.LoadExtraScripts(pduel);
 	unsigned int opt = (unsigned int)host_info.duel_rule << 16;
 	if(host_info.no_shuffle_deck)
 		opt |= DUEL_PSEUDO_SHUFFLE;