Merge https://github.com/Fluorohydride/ygopro into server

.gitmodules

+[submodule "ocgcore"]
+	path = ocgcore
+	url = git@github.com:Fluorohydride/ygopro-core.git
+[submodule "script"]
+	path = script
+	url = git@github.com:Fluorohydride/ygopro-scripts.git

README.md

+## ygopro
+A script engine for "yu-gi-oh!" and sample gui
+
+[中文说明](https://github.com/Fluorohydride/ygopro/wiki/%E4%B8%AD%E6%96%87%E8%AF%B4%E6%98%8E)
+
+###Keys:
+* ESC: Minimize the window.
+* A: Holding down this button will let the system stop at every timing.
+* S: Holding down this button will let the system skip every timing.
+* R: Fix the font error.
+* F1~F4: Show the cards in your grave, banished zone, extra deck, xyz materials.
+* F5~F8: Show the cards in your opponent's grave, banished zone, extra deck, xyz materials.
+
+###Color:
+* Background: 
+* White = your card, Grey = your opponent's card
+* Text: 
+* Black = default, Blue = the owner of the xyz material is different from its controller
+
+###Sequence:
+* Monster Zone: 1~5, starting from the left hand side.
+* Spell & Trap Zone: 1~5, starting from the left hand side.
+* Field Zone: 6
+* Pendulum Zone: 7~8, starting from the left hand side.
+* The others: 1~n, starting from the bottom.
+
+###Deck edit page:
+* All numeric textboxs: They support >, =, <, >=, <= signs.
+* Card name: Search card names and texts by default, $foo will only search foo in card names, and @foo will search cards of "foo" archetype(due to translation, card name contains "foo" does not mean that card is "foo" card).
+
+### Command-line options:
+* -j: Join the host in system.conf file.
+* -d: Enter the deck edit page.
+* -r: Enter the replay mode page.
+* -s: Enter the single mode page.
+* -efoo: Load foo as the extra database.
+
+### Directories:
+* pics: .jpg card images(177*254).
+* pics\thumbnail: .jpg thumbnail images(44*64).
+* script: .lua script files.
+* textures: Other image files.
+* deck: .ydk deck files.
+* replay: .yrp replay files.
+* expansions: *.cdb will be loaded as extra databases.

gframe/client_card.cpp

@@ -18,8 +18,10 @@ ClientCard::ClientCard() {
 	is_highlighting = false;
 	is_disabled = false;
 	is_reversed = false;
+	is_conti = false;
 	cmdFlag = 0;
 	code = 0;
+	chain_code = 0;
 	type = 0;
 	alias = 0;
 	level = 0;

gframe/client_card.h

@@ -63,7 +63,9 @@ public:
 	bool is_showtarget;
 	bool is_highlighting;
 	bool is_reversed;
+	bool is_conti;
 	u32 code;
+	u32 chain_code;
 	u32 alias;
 	u32 type;
 	u32 level;

gframe/client_field.h

@@ -36,9 +36,11 @@ public:
 	std::vector<ClientCard*> reposable_cards;
 	std::vector<ClientCard*> activatable_cards;
 	std::vector<ClientCard*> attackable_cards;
+	std::vector<ClientCard*> conti_cards;
 	std::vector<int> activatable_descs;
 	std::vector<int> select_options;
 	std::vector<ChainInfo> chains;
+	int extra_p_count[2];
 	
 	size_t selected_option;
 	ClientCard* attacker;
@@ -48,17 +50,20 @@ public:
 	int selected_field;
 	int select_min;
 	int select_max;
+	int must_select_count;
 	int select_sumval;
 	int select_cancelable;
 	int select_mode;
 	bool select_ready;
 	int announce_count;
+	int declarable_type;
 	int select_counter_count;
 	int select_counter_type;
 	std::vector<ClientCard*> selectable_cards;
 	std::vector<ClientCard*> selected_cards;
 	std::set<ClientCard*> selectsum_cards;
 	std::vector<ClientCard*> selectsum_all;
+	std::vector<ClientCard*> display_cards;
 	std::vector<int> sort_list;
 	bool grave_act;
 	bool remove_act;
@@ -81,8 +86,9 @@ public:
 	void ClearCommandFlag();
 	void ClearSelect();
 	void ClearChainSelect();
-	void ShowSelectCard(bool buttonok = false);
+	void ShowSelectCard(bool buttonok = false, bool chain = false);
 	void ShowChainCard();
+	void ShowLocationCard();
 	void ReplaySwap();
 	void RefreshAllCards();
 	
@@ -92,10 +98,12 @@ public:
 	void FadeCard(ClientCard* pcard, int alpha, int frame);
 	bool CheckSelectSum();
 	bool check_min(std::set<ClientCard*>& left, std::set<ClientCard*>::iterator index, int min, int max);
-	bool check_sel_sum_s(std::set<ClientCard*>& left, int index, int acc);
-	void check_sel_sum_t(std::set<ClientCard*>& left, int acc);
-	bool check_sum(std::set<ClientCard*>& testlist, std::set<ClientCard*>::iterator index, int acc, int count);
+	bool check_sel_sum_s(const std::set<ClientCard*>& left, int index, int acc);
+	void check_sel_sum_t(const std::set<ClientCard*>& left, int acc);
+	bool check_sum(std::set<ClientCard*>::const_iterator index, std::set<ClientCard*>::const_iterator end, int acc, int count);
 	
+	void UpdateDeclarableCode();
+
 	irr::gui::IGUIElement* panel;
 	std::vector<int> ancard;
 	int hovered_controler;
@@ -114,8 +122,13 @@ public:
 	virtual bool OnEvent(const irr::SEvent& event);
 	void GetHoverField(int x, int y);
 	void ShowMenu(int flag, int x, int y);
+	void SetResponseSelectedCards() const;
 };
 
 }
 
+//special cards
+#define CARD_MARINE_DOLPHIN	78734254
+#define CARD_TWINKLE_MOSS	13857930
+
 #endif //CLIENT_FIELD_H

gframe/data_manager.cpp

@@ -85,23 +85,29 @@ bool DataManager::LoadStrings(const char* file) {
 			continue;
 		sscanf(linebuf, "!%s", strbuf);
 		if(!strcmp(strbuf, "system")) {
-			sscanf(&linebuf[7], "%d %s", &value, strbuf);
+			sscanf(&linebuf[7], "%d %240[^\n]", &value, strbuf);
 			int len = BufferIO::DecodeUTF8(strbuf, strBuffer);
 			wchar_t* pbuf = new wchar_t[len + 1];
 			wcscpy(pbuf, strBuffer);
 			_sysStrings[value] = pbuf;
 		} else if(!strcmp(strbuf, "victory")) {
-			sscanf(&linebuf[8], "%x %s", &value, strbuf);
+			sscanf(&linebuf[8], "%x %240[^\n]", &value, strbuf);
 			int len = BufferIO::DecodeUTF8(strbuf, strBuffer);
 			wchar_t* pbuf = new wchar_t[len + 1];
 			wcscpy(pbuf, strBuffer);
 			_victoryStrings[value] = pbuf;
 		} else if(!strcmp(strbuf, "counter")) {
-			sscanf(&linebuf[8], "%x %s", &value, strbuf);
+			sscanf(&linebuf[8], "%x %240[^\n]", &value, strbuf);
 			int len = BufferIO::DecodeUTF8(strbuf, strBuffer);
 			wchar_t* pbuf = new wchar_t[len + 1];
 			wcscpy(pbuf, strBuffer);
 			_counterStrings[value] = pbuf;
+		} else if(!strcmp(strbuf, "setname")) {
+			sscanf(&linebuf[8], "%x %240[^\t\n]", &value, strbuf);//using tab for comment
+			int len = BufferIO::DecodeUTF8(strbuf, strBuffer);
+			wchar_t* pbuf = new wchar_t[len + 1];
+			wcscpy(pbuf, strBuffer);
+			_setnameStrings[value] = pbuf;
 		}
 	}
 	fclose(fp);
@@ -182,8 +188,27 @@ const wchar_t* DataManager::GetCounterName(int code) {
 		return unknown_string;
 	return csit->second;
 }
-const wchar_t* DataManager::GetNumString(int num) {
-	return numStrings[num];
+const wchar_t* DataManager::GetSetName(int code) {
+	auto csit = _setnameStrings.find(code);
+	if(csit == _setnameStrings.end())
+		return NULL;
+	return csit->second;
+}
+unsigned int DataManager::GetSetCode(const wchar_t* setname) {
+	for(auto csit = _setnameStrings.begin(); csit != _setnameStrings.end(); ++csit)
+		if(wcscmp(csit->second, setname) == 0)
+			return csit->first;
+	return 0;
+}
+const wchar_t* DataManager::GetNumString(int num, bool bracket) {
+	if(!bracket)
+		return numStrings[num];
+	wchar_t* p = numBuffer;
+	*p++ = L'(';
+	BufferIO::CopyWStrRef(numStrings[num], p, 4);
+	*p = L')';
+	*++p = 0;
+	return numBuffer;
 }
 const wchar_t* DataManager::FormatLocation(int location, int sequence) {
 	if(location == 0x8) {
@@ -252,6 +277,22 @@ const wchar_t* DataManager::FormatType(int type) {
 		return unknown_string;
 	return tpBuffer;
 }
+const wchar_t* DataManager::FormatSetName(unsigned long long setcode) {
+	wchar_t* p = scBuffer;
+	for(int i = 0; i < 4; ++i) {
+		const wchar_t* setname = GetSetName((setcode >> i * 16) & 0xffff);
+		if(setname) {
+			BufferIO::CopyWStrRef(setname, p, 16);
+			*p = L'|';
+			*++p = 0;
+		}
+	}
+	if(p != scBuffer)
+		*(p - 1) = 0;
+	else
+		return unknown_string;
+	return scBuffer;
+}
 int DataManager::CardReader(int code, void* pData) {
 	if(!dataManager.GetData(code, (CardData*)pData))
 		memset(pData, 0, sizeof(CardData));

gframe/data_manager.h

@@ -23,22 +23,28 @@ public:
 	const wchar_t* GetSysString(int code);
 	const wchar_t* GetVictoryString(int code);
 	const wchar_t* GetCounterName(int code);
-	const wchar_t* GetNumString(int num);
+	const wchar_t* GetSetName(int code);
+	unsigned int GetSetCode(const wchar_t* setname);
+	const wchar_t* GetNumString(int num, bool bracket = false);
 	const wchar_t* FormatLocation(int location, int sequence);
 	const wchar_t* FormatAttribute(int attribute);
 	const wchar_t* FormatRace(int race);
 	const wchar_t* FormatType(int type);
+	const wchar_t* FormatSetName(unsigned long long setcode);
 
 	std::unordered_map<unsigned int, CardDataC> _datas;
 	std::unordered_map<unsigned int, CardString> _strings;
 	std::unordered_map<unsigned int, wchar_t*> _counterStrings;
 	std::unordered_map<unsigned int, wchar_t*> _victoryStrings;
+	std::unordered_map<unsigned int, wchar_t*> _setnameStrings;
 
 	wchar_t* _sysStrings[2048];
 	wchar_t numStrings[256][4];
+	wchar_t numBuffer[6];
 	wchar_t attBuffer[128];
 	wchar_t racBuffer[128];
 	wchar_t tpBuffer[128];
+	wchar_t scBuffer[128];
 
 	static wchar_t strBuffer[2048];
 	static const wchar_t* unknown_string;

gframe/deck_con.cpp

@@ -336,6 +336,8 @@ 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())
+				break;
 			unsigned int limitcode = draging_pointer->second.alias ? draging_pointer->second.alias : draging_pointer->first;
 			if(hovered_pos == 4) {
 				int limit = 3;
@@ -438,6 +440,8 @@ bool DeckBuilder::OnEvent(const irr::SEvent& event) {
 				if(hovered_pos == 0 || hovered_seq == -1)
 					break;
 				draging_pointer = dataManager.GetCodePointer(hovered_code);
+				if(draging_pointer == dataManager._datas.end())
+					break;
 				if(hovered_pos == 1) {
 					if(deckManager.current_deck.side.size() < 20) {
 						deckManager.current_deck.main.erase(deckManager.current_deck.main.begin() + hovered_seq);
@@ -464,8 +468,11 @@ bool DeckBuilder::OnEvent(const irr::SEvent& event) {
 				break;
 			if(hovered_pos == 0 || hovered_seq == -1)
 				break;
-			if(!is_draging)
+			if(!is_draging) {
 				draging_pointer = dataManager.GetCodePointer(hovered_code);
+				if(draging_pointer == dataManager._datas.end())
+					break;
+			}
 			if(hovered_pos == 1) {
 				if(!is_draging)
 					deckManager.current_deck.main.erase(deckManager.current_deck.main.begin() + hovered_seq);
@@ -621,12 +628,13 @@ bool DeckBuilder::OnEvent(const irr::SEvent& event) {
 	case irr::EET_KEY_INPUT_EVENT: {
 		switch(event.KeyInput.Key) {
 		case irr::KEY_KEY_R: {
-			if(!event.KeyInput.PressedDown)
+			if(!event.KeyInput.PressedDown && !mainGame->HasFocus(EGUIET_EDIT_BOX))
 				mainGame->textFont->setTransparency(true);
 			break;
 		}
 		case irr::KEY_ESCAPE: {
-			mainGame->device->minimizeWindow();
+			if(!mainGame->HasFocus(EGUIET_EDIT_BOX))
+				mainGame->device->minimizeWindow();
 			break;
 		}
 		default: break;
@@ -642,14 +650,17 @@ void DeckBuilder::FilterCards() {
 	const wchar_t* pstr = mainGame->ebCardName->getText();
 	int trycode = BufferIO::GetVal(pstr);
 	if(dataManager.GetData(trycode, 0)) {
-		auto ptr = dataManager.GetCodePointer(trycode);
+		auto ptr = dataManager.GetCodePointer(trycode);	// verified by GetData()
 		results.push_back(ptr);
 		mainGame->scrFilter->setVisible(false);
 		mainGame->scrFilter->setPos(0);
 		myswprintf(result_string, L"%d", results.size());
 		return;
 	}
-	if(pstr[0] == 0)
+	unsigned int set_code = 0;
+	if(pstr[0] == L'@')
+		set_code = dataManager.GetSetCode(&pstr[1]);
+	if(pstr[0] == 0 || (pstr[0] == L'$' && pstr[1] == 0) || (pstr[0] == L'@' && pstr[1] == 0))
 		pstr = 0;
 	auto strpointer = dataManager._strings.begin();
 	for(code_pointer ptr = dataManager._datas.begin(); ptr != dataManager._datas.end(); ++ptr, ++strpointer) {
@@ -659,8 +670,7 @@ void DeckBuilder::FilterCards() {
 			continue;
 		switch(filter_type) {
 		case 1: {
-			int type2 = data.type & 0xe03ef1;
-			if(!(data.type & TYPE_MONSTER) || (filter_type2 == 0x21 && type2 != 0x21) || (data.type & filter_type2) != filter_type2)
+			if(!(data.type & TYPE_MONSTER) || (data.type & filter_type2) != filter_type2)
 				continue;
 			if(filter_race && data.race != filter_race)
 				continue;
@@ -712,8 +722,29 @@ void DeckBuilder::FilterCards() {
 				continue;
 		}
 		if(pstr) {
-			if(wcsstr(text.name, pstr) == 0 && wcsstr(text.text, pstr) == 0)
-				continue;
+			if(pstr[0] == L'$') {
+				if(wcsstr(text.name, &pstr[1]) == 0)
+					continue;
+			} else if(pstr[0] == L'@' && set_code) {
+				unsigned long long sc = data.setcode;
+				if(data.alias) {
+					auto aptr = dataManager._datas.find(data.alias);
+					if(aptr != dataManager._datas.end())
+						sc = aptr->second.setcode;
+				}
+				bool res = false;
+				int settype = set_code & 0xfff;
+				int setsubtype = set_code & 0xf000;
+				while(sc) {
+					if ((sc & 0xfff) == settype && (sc & 0xf000 & setsubtype) == setsubtype)
+						res = true;
+					sc = sc >> 16;
+				}
+				if(!res) continue;
+			} else {
+				if(wcsstr(text.name, pstr) == 0 && wcsstr(text.text, pstr) == 0)
+					continue;
+			}
 		}
 		results.push_back(ptr);
 	}

gframe/deck_manager.cpp

@@ -128,7 +128,7 @@ void DeckManager::LoadDeck(Deck& deck, int* dbuf, int mainc, int sidec) {
 		if(cd.type & TYPE_TOKEN)
 			continue;
 		else if(cd.type & 0x802040 && deck.extra.size() < 15) {
-			deck.extra.push_back(dataManager.GetCodePointer(code));
+			deck.extra.push_back(dataManager.GetCodePointer(code));	//verified by GetData()
 		} else if(deck.main.size() < 60) {
 			deck.main.push_back(dataManager.GetCodePointer(code));
 		}
@@ -140,7 +140,7 @@ void DeckManager::LoadDeck(Deck& deck, int* dbuf, int mainc, int sidec) {
 		if(cd.type & TYPE_TOKEN)
 			continue;
 		if(deck.side.size() < 15)
-			deck.side.push_back(dataManager.GetCodePointer(code));
+			deck.side.push_back(dataManager.GetCodePointer(code));	//verified by GetData()
 	}
 }
 bool DeckManager::LoadSide(Deck& deck, int* dbuf, int mainc, int sidec) {

gframe/drawing.cpp

@@ -423,8 +423,11 @@ void Game::DrawMisc() {
 		adFont->draw(pcard->rscstring, recti(464, 246, 496, 266), 0xffffffff, true, false, 0);
 	}
 	if(dField.extra[0].size()) {
-		numFont->draw(dataManager.GetNumString(dField.extra[0].size()), recti(330, 562, 381, 552), 0xff000000, true, false, 0);
-		numFont->draw(dataManager.GetNumString(dField.extra[0].size()), recti(330, 563, 383, 553), 0xffffff00, true, false, 0);
+		int offset = (dField.extra[0].size() >= 10) ? 0 : mainGame->textFont->getDimension(dataManager.GetNumString(1)).Width;
+		numFont->draw(dataManager.GetNumString(dField.extra[0].size()), recti(320 + offset, 562, 371, 552), 0xff000000, true, false, 0);
+		numFont->draw(dataManager.GetNumString(dField.extra[0].size()), recti(320 + offset, 563, 373, 553), 0xffffff00, true, false, 0);
+		numFont->draw(dataManager.GetNumString(dField.extra_p_count[0], true), recti(340, 562, 391, 552), 0xff000000, true, false, 0);
+		numFont->draw(dataManager.GetNumString(dField.extra_p_count[0], true), recti(340, 563, 393, 553), 0xffffff00, true, false, 0);
 	}
 	if(dField.deck[0].size()) {
 		numFont->draw(dataManager.GetNumString(dField.deck[0].size()), recti(907, 562, 1021, 552), 0xff000000, true, false, 0);
@@ -439,8 +442,11 @@ void Game::DrawMisc() {
 		numFont->draw(dataManager.GetNumString(dField.remove[0].size()), recti(1015, 376, 959, 381), 0xffffff00, true, false, 0);
 	}
 	if(dField.extra[1].size()) {
-		numFont->draw(dataManager.GetNumString(dField.extra[1].size()), recti(818, 207, 908, 232), 0xff000000, true, false, 0);
-		numFont->draw(dataManager.GetNumString(dField.extra[1].size()), recti(818, 208, 910, 233), 0xffffff00, true, false, 0);
+		int offset = (dField.extra[1].size() >= 10) ? 0 : mainGame->textFont->getDimension(dataManager.GetNumString(1)).Width;
+		numFont->draw(dataManager.GetNumString(dField.extra[1].size()), recti(808 + offset, 207, 898, 232), 0xff000000, true, false, 0);
+		numFont->draw(dataManager.GetNumString(dField.extra[1].size()), recti(808 + offset, 208, 900, 233), 0xffffff00, true, false, 0);
+		numFont->draw(dataManager.GetNumString(dField.extra_p_count[1], true), recti(828, 207, 918, 232), 0xff000000, true, false, 0);
+		numFont->draw(dataManager.GetNumString(dField.extra_p_count[1], true), recti(828, 208, 920, 233), 0xffffff00, true, false, 0);
 	}
 	if(dField.deck[1].size()) {
 		numFont->draw(dataManager.GetNumString(dField.deck[1].size()), recti(465, 207, 481, 232), 0xff000000, true, false, 0);
@@ -489,6 +495,10 @@ void Game::DrawGUI() {
 							for(int i = 0; i < 5; ++i)
 								btnCardSelect[i]->setDrawImage(true);
 						}
+						if(fu.guiFading == wCardDisplay) {
+							for(int i = 0; i < 5; ++i)
+								btnCardDisplay[i]->setDrawImage(true);
+						}
 						env->setFocus(fu.guiFading);
 					} else
 						fu.guiFading->setRelativePosition(irr::core::recti(fu.fadingUL, fu.fadingLR));
@@ -516,6 +526,10 @@ void Game::DrawGUI() {
 							for(int i = 0; i < 5; ++i)
 								btnCardSelect[i]->setDrawImage(true);
 						}
+						if(fu.guiFading == wCardDisplay) {
+							for(int i = 0; i < 5; ++i)
+								btnCardDisplay[i]->setDrawImage(true);
+						}
 					} else
 						fu.guiFading->setRelativePosition(irr::core::recti(fu.fadingUL, fu.fadingLR));
 				}
@@ -755,6 +769,10 @@ void Game::ShowElement(irr::gui::IGUIElement * win, int autoframe) {
 		for(int i = 0; i < 5; ++i)
 			btnCardSelect[i]->setDrawImage(false);
 	}
+	if(win == wCardDisplay) {
+		for(int i = 0; i < 5; ++i)
+			btnCardDisplay[i]->setDrawImage(false);
+	}
 	win->setRelativePosition(irr::core::recti(center.X, center.Y, 0, 0));
 	fadingList.push_back(fu);
 }
@@ -783,6 +801,10 @@ void Game::HideElement(irr::gui::IGUIElement * win, bool set_action) {
 		for(int i = 0; i < 5; ++i)
 			btnCardSelect[i]->setDrawImage(false);
 	}
+	if(win == wCardDisplay) {
+		for(int i = 0; i < 5; ++i)
+			btnCardDisplay[i]->setDrawImage(false);
+	}
 	fadingList.push_back(fu);
 }
 void Game::PopupElement(irr::gui::IGUIElement * element, int hideframe) {
@@ -898,10 +920,12 @@ void Game::DrawDeckBd() {
 			driver->draw2DRectangle(0x80000000, recti(806, 164 + i * 66, 1019, 230 + i * 66));
 		DrawThumb(ptr, position2di(810, 165 + i * 66), deckBuilder.filterList);
 		if(ptr->second.type & TYPE_MONSTER) {
+			int form = 0x2605;
+			if(ptr->second.type & TYPE_XYZ) ++form;
 			myswprintf(textBuffer, L"%ls", dataManager.GetName(ptr->first));
 			textFont->draw(textBuffer, recti(859, 164 + i * 66, 955, 185 + i * 66), 0xff000000, false, false);
 			textFont->draw(textBuffer, recti(860, 165 + i * 66, 955, 185 + i * 66), 0xffffffff, false, false);
-			myswprintf(textBuffer, L"%ls/%ls \x2605%d", dataManager.FormatAttribute(ptr->second.attribute), dataManager.FormatRace(ptr->second.race), ptr->second.level);
+			myswprintf(textBuffer, L"%ls/%ls %c%d", dataManager.FormatAttribute(ptr->second.attribute), dataManager.FormatRace(ptr->second.race), form, ptr->second.level);
 			textFont->draw(textBuffer, recti(859, 186 + i * 66, 955, 207 + i * 66), 0xff000000, false, false);
 			textFont->draw(textBuffer, recti(860, 187 + i * 66, 955, 207 + i * 66), 0xffffffff, false, false);
 			if(ptr->second.attack < 0 && ptr->second.defence < 0)
@@ -920,6 +944,8 @@ void Game::DrawDeckBd() {
 				wcscat(textBuffer, L" [OCG]");
 			else if((ptr->second.ot & 0x3) == 2)
 				wcscat(textBuffer, L" [TCG]");
+			else if((ptr->second.ot & 0x7) == 4)
+				wcscat(textBuffer, L" [Custom]");
 			textFont->draw(textBuffer, recti(859, 208 + i * 66, 955, 229 + i * 66), 0xff000000, false, false);
 			textFont->draw(textBuffer, recti(860, 209 + i * 66, 955, 229 + i * 66), 0xffffffff, false, false);
 		} else {
@@ -934,6 +960,8 @@ void Game::DrawDeckBd() {
 				wcscat(textBuffer, L"[OCG]");
 			else if((ptr->second.ot & 0x3) == 2)
 				wcscat(textBuffer, L"[TCG]");
+			else if((ptr->second.ot & 0x7) == 4)
+				wcscat(textBuffer, L"[Custom]");
 			textFont->draw(textBuffer, recti(859, 208 + i * 66, 955, 229 + i * 66), 0xff000000, false, false);
 			textFont->draw(textBuffer, recti(860, 209 + i * 66, 955, 229 + i * 66), 0xffffffff, false, false);
 		}

gframe/game.h

@@ -24,6 +24,15 @@ struct Config {
 	wchar_t textfont[256];
 	wchar_t numfont[256];
 	wchar_t roompass[20];
+	//settings
+	int chkAutoPos;
+	int chkRandomPos;
+	int chkAutoChain;
+	int chkWaitChain;
+	int chkIgnore1;
+	int chkIgnore2;
+	int chkHideSetname;
+	int control_mode;
 };
 
 struct DuelInfo {
@@ -72,6 +81,7 @@ public:
 	void BuildProjectionMatrix(irr::core::matrix4& mProjection, f32 left, f32 right, f32 bottom, f32 top, f32 znear, f32 zfar);
 	void InitStaticText(irr::gui::IGUIStaticText* pControl, u32 cWidth, u32 cHeight, irr::gui::CGUITTFont* font, const wchar_t* text);
 	void SetStaticText(irr::gui::IGUIStaticText* pControl, u32 cWidth, irr::gui::CGUITTFont* font, const wchar_t* text, u32 pos = 0);
+	void RefreshExpansionDB();
 	void RefreshDeck(irr::gui::IGUIComboBox* cbDeck);
 	void RefreshReplay();
 	void RefreshSingleplay();
@@ -98,6 +108,11 @@ public:
 	int LocalPlayer(int player);
 	const wchar_t* LocalName(int local_player);
 
+	bool HasFocus(EGUI_ELEMENT_TYPE type) const {
+		irr::gui::IGUIElement* focus = env->getFocus();
+		return focus && focus->hasType(type);
+	}
+
 	Mutex gMutex;
 	Mutex gBuffer;
 	Signal frameSignal;
@@ -168,12 +183,14 @@ public:
 	irr::gui::IGUIStaticText* stName;
 	irr::gui::IGUIStaticText* stInfo;
 	irr::gui::IGUIStaticText* stDataInfo;
+	irr::gui::IGUIStaticText* stSetName;
 	irr::gui::IGUIStaticText* stText;
 	irr::gui::IGUIScrollBar* scrCardText;
 	irr::gui::IGUICheckBox* chkAutoPos;
 	irr::gui::IGUICheckBox* chkRandomPos;
 	irr::gui::IGUICheckBox* chkAutoChain;
 	irr::gui::IGUICheckBox* chkWaitChain;
+	irr::gui::IGUICheckBox* chkHideSetname;
 	irr::gui::IGUIListBox* lstLog;
 	irr::gui::IGUIButton* btnClearLog;
 	irr::gui::IGUIButton* btnSaveLog;
@@ -274,6 +291,12 @@ public:
 	irr::gui::IGUIStaticText *stCardPos[5];
 	irr::gui::IGUIScrollBar *scrCardList;
 	irr::gui::IGUIButton* btnSelectOK;
+	//card display
+	irr::gui::IGUIWindow* wCardDisplay;
+	irr::gui::CGUIImageButton* btnCardDisplay[5];
+	irr::gui::IGUIStaticText *stDisplayPos[5];
+	irr::gui::IGUIScrollBar *scrDisplayList;
+	irr::gui::IGUIButton* btnDisplayOK;
 	//announce number
 	irr::gui::IGUIWindow* wANNumber;
 	irr::gui::IGUIComboBox* cbANNumber;
@@ -453,6 +476,13 @@ extern unsigned char draw_count;
 #define BUTTON_CLEAR_LOG			270
 #define LISTBOX_LOG					271
 #define SCROLL_CARDTEXT				280
+#define BUTTON_DISPLAY_0			290
+#define BUTTON_DISPLAY_1			291
+#define BUTTON_DISPLAY_2			292
+#define BUTTON_DISPLAY_3			293
+#define BUTTON_DISPLAY_4			294
+#define SCROLL_CARD_DISPLAY			295
+#define BUTTON_CARD_DISP_OK			296
 #define BUTTON_CATEGORY_OK			300
 #define COMBOBOX_DBLFLIST			301
 #define COMBOBOX_DBDECKS			302

gframe/gframe.cpp

@@ -64,9 +64,7 @@ int main(int argc, char* argv[]) {
 			event.EventType = irr::EET_GUI_EVENT;
 			event.GUIEvent.EventType = irr::gui::EGET_BUTTON_CLICKED;
 			if(!strcmp(argv[i], "-j")) {
-				event.GUIEvent.Caller = ygo::mainGame->btnLanMode;
-				ygo::mainGame->device->postEventFromUser(event);
-				//TODO: wait for wLanWindow show. if network connection faster than wLanWindow, wLanWindow will still show on duel scene.
+				ygo::mainGame->HideElement(ygo::mainGame->wMainMenu);
 				event.GUIEvent.Caller = ygo::mainGame->btnJoinHost;
 				ygo::mainGame->device->postEventFromUser(event);
 			} else if(!strcmp(argv[i], "-d")) {

gframe/menu_handler.cpp

@@ -54,7 +54,6 @@ bool MenuHandler::OnEvent(const irr::SEvent& event) {
 					inet_ntop(AF_INET, &(((struct sockaddr_in *)servinfo->ai_addr)->sin_addr), ip, 20);
 				freeaddrinfo(servinfo);
 			#else
-				//int status;
 				char hostname[100];
 				char ip[20];
 				const wchar_t* pstr = mainGame->ebJoinIP->getText();
@@ -172,6 +171,7 @@ bool MenuHandler::OnEvent(const irr::SEvent& event) {
 				mainGame->stName->setText(L"");
 				mainGame->stInfo->setText(L"");
 				mainGame->stDataInfo->setText(L"");
+				mainGame->stSetName->setText(L"");
 				mainGame->stText->setText(L"");
 				mainGame->scrCardText->setVisible(false);
 				mainGame->wReplayControl->setVisible(true);
@@ -307,7 +307,7 @@ bool MenuHandler::OnEvent(const irr::SEvent& event) {
 						break;
 					}
 					BufferIO::CopyWStr(mainGame->cbDeckSelect->getItem(mainGame->cbDeckSelect->getSelected()),
-					                   mainGame->gameConf.lastdeck, 20);
+					                   mainGame->gameConf.lastdeck, 64);
 					char deckbuf[1024];
 					char* pdeck = deckbuf;
 					BufferIO::WriteInt32(pdeck, deckManager.current_deck.main.size() + deckManager.current_deck.extra.size());
@@ -364,12 +364,13 @@ bool MenuHandler::OnEvent(const irr::SEvent& event) {
 	case irr::EET_KEY_INPUT_EVENT: {
 		switch(event.KeyInput.Key) {
 		case irr::KEY_KEY_R: {
-			if(!event.KeyInput.PressedDown)
+			if(!event.KeyInput.PressedDown && !mainGame->HasFocus(EGUIET_EDIT_BOX))
 				mainGame->textFont->setTransparency(true);
 			break;
 		}
 		case irr::KEY_ESCAPE: {
-			mainGame->device->minimizeWindow();
+			if(!mainGame->HasFocus(EGUIET_EDIT_BOX))
+				mainGame->device->minimizeWindow();
 			break;
 		}
 		default: break;

gframe/replay_mode.cpp

@@ -16,7 +16,6 @@ bool ReplayMode::is_paused = false;
 bool ReplayMode::is_swaping = false;
 bool ReplayMode::exit_pending = false;
 int ReplayMode::skip_turn = 0;
-wchar_t ReplayMode::event_string[256];
 
 bool ReplayMode::StartReplay(int skipturn) {
 	skip_turn = skipturn;
@@ -86,25 +85,25 @@ int ReplayMode::ReplayThread(void* param) {
 	if(!(opt & DUEL_TAG_MODE)) {
 		int main = cur_replay.ReadInt32();
 		for(int i = 0; i < main; ++i)
-			new_card(pduel, cur_replay.ReadInt32(), 0, 0, LOCATION_DECK, 0, 0);
+			new_card(pduel, cur_replay.ReadInt32(), 0, 0, LOCATION_DECK, 0, POS_FACEDOWN_DEFENCE);
 		int extra = cur_replay.ReadInt32();
 		for(int i = 0; i < extra; ++i)
-			new_card(pduel, cur_replay.ReadInt32(), 0, 0, LOCATION_EXTRA, 0, 0);
+			new_card(pduel, cur_replay.ReadInt32(), 0, 0, LOCATION_EXTRA, 0, POS_FACEDOWN_DEFENCE);
 		mainGame->dField.Initial(0, main, extra);
 		main = cur_replay.ReadInt32();
 		for(int i = 0; i < main; ++i)
-			new_card(pduel, cur_replay.ReadInt32(), 1, 1, LOCATION_DECK, 0, 0);
+			new_card(pduel, cur_replay.ReadInt32(), 1, 1, LOCATION_DECK, 0, POS_FACEDOWN_DEFENCE);
 		extra = cur_replay.ReadInt32();
 		for(int i = 0; i < extra; ++i)
-			new_card(pduel, cur_replay.ReadInt32(), 1, 1, LOCATION_EXTRA, 0, 0);
+			new_card(pduel, cur_replay.ReadInt32(), 1, 1, LOCATION_EXTRA, 0, POS_FACEDOWN_DEFENCE);
 		mainGame->dField.Initial(1, main, extra);
 	} else {
 		int main = cur_replay.ReadInt32();
 		for(int i = 0; i < main; ++i)
-			new_card(pduel, cur_replay.ReadInt32(), 0, 0, LOCATION_DECK, 0, 0);
+			new_card(pduel, cur_replay.ReadInt32(), 0, 0, LOCATION_DECK, 0, POS_FACEDOWN_DEFENCE);
 		int extra = cur_replay.ReadInt32();
 		for(int i = 0; i < extra; ++i)
-			new_card(pduel, cur_replay.ReadInt32(), 0, 0, LOCATION_EXTRA, 0, 0);
+			new_card(pduel, cur_replay.ReadInt32(), 0, 0, LOCATION_EXTRA, 0, POS_FACEDOWN_DEFENCE);
 		mainGame->dField.Initial(0, main, extra);
 		main = cur_replay.ReadInt32();
 		for(int i = 0; i < main; ++i)
@@ -114,10 +113,10 @@ int ReplayMode::ReplayThread(void* param) {
 			new_tag_card(pduel, cur_replay.ReadInt32(), 0, LOCATION_EXTRA);
 		main = cur_replay.ReadInt32();
 		for(int i = 0; i < main; ++i)
-			new_card(pduel, cur_replay.ReadInt32(), 1, 1, LOCATION_DECK, 0, 0);
+			new_card(pduel, cur_replay.ReadInt32(), 1, 1, LOCATION_DECK, 0, POS_FACEDOWN_DEFENCE);
 		extra = cur_replay.ReadInt32();
 		for(int i = 0; i < extra; ++i)
-			new_card(pduel, cur_replay.ReadInt32(), 1, 1, LOCATION_EXTRA, 0, 0);
+			new_card(pduel, cur_replay.ReadInt32(), 1, 1, LOCATION_EXTRA, 0, POS_FACEDOWN_DEFENCE);
 		mainGame->dField.Initial(1, main, extra);
 		main = cur_replay.ReadInt32();
 		for(int i = 0; i < main; ++i)
@@ -308,6 +307,8 @@ bool ReplayMode::ReplayAnalyze(char* msg, unsigned int len) {
 			pbuf += 6;
 			count = BufferIO::ReadInt8(pbuf);
 			pbuf += count * 11;
+			count = BufferIO::ReadInt8(pbuf);
+			pbuf += count * 11;
 			return ReadReplayResponse();
 		}
 		case MSG_SORT_CARD:
@@ -384,7 +385,7 @@ bool ReplayMode::ReplayAnalyze(char* msg, unsigned int len) {
 			break;
 		}
 		case MSG_NEW_PHASE: {
-			pbuf++;
+			pbuf += 2;
 			DuelClient::ClientAnalyze(offset, pbuf - offset);
 			ReplayRefresh();
 			break;
@@ -566,12 +567,12 @@ bool ReplayMode::ReplayAnalyze(char* msg, unsigned int len) {
 			break;
 		}
 		case MSG_ADD_COUNTER: {
-			pbuf += 6;
+			pbuf += 7;
 			DuelClient::ClientAnalyze(offset, pbuf - offset);
 			break;
 		}
 		case MSG_REMOVE_COUNTER: {
-			pbuf += 6;
+			pbuf += 7;
 			DuelClient::ClientAnalyze(offset, pbuf - offset);
 			break;
 		}
@@ -634,6 +635,7 @@ bool ReplayMode::ReplayAnalyze(char* msg, unsigned int len) {
 		}
 		case MSG_ANNOUNCE_CARD: {
 			player = BufferIO::ReadInt8(pbuf);
+			pbuf += 4;
 			return ReadReplayResponse();
 		}
 		case MSG_ANNOUNCE_NUMBER: {
@@ -653,7 +655,7 @@ bool ReplayMode::ReplayAnalyze(char* msg, unsigned int len) {
 		}
 		case MSG_TAG_SWAP: {
 			player = pbuf[0];
-			pbuf += pbuf[3] * 4 + 8;
+			pbuf += pbuf[2] * 4 + pbuf[4] * 4 + 9;
 			DuelClient::ClientAnalyze(offset, pbuf - offset);
 			ReplayRefreshDeck(player);
 			ReplayRefreshExtra(player);
@@ -670,7 +672,7 @@ bool ReplayMode::ReplayAnalyze(char* msg, unsigned int len) {
 	return true;
 }
 void ReplayMode::ReplayRefresh(int flag) {
-	unsigned char queryBuffer[0x1000];
+	unsigned char queryBuffer[0x2000];
 	/*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);
@@ -685,27 +687,27 @@ void ReplayMode::ReplayRefresh(int flag) {
 	mainGame->dField.UpdateFieldCard(mainGame->LocalPlayer(1), LOCATION_HAND, (char*)queryBuffer);
 }
 void  ReplayMode::ReplayRefreshHand(int player, int flag) {
-	unsigned char queryBuffer[0x1000];
+	unsigned char queryBuffer[0x2000];
 	/*int len = */query_field_card(pduel, player, LOCATION_HAND, flag, queryBuffer, 0);
 	mainGame->dField.UpdateFieldCard(mainGame->LocalPlayer(player), LOCATION_HAND, (char*)queryBuffer);
 }
 void ReplayMode::ReplayRefreshGrave(int player, int flag) {
-	unsigned char queryBuffer[0x1000];
+	unsigned char queryBuffer[0x2000];
 	/*int len = */query_field_card(pduel, player, LOCATION_GRAVE, flag, queryBuffer, 0);
 	mainGame->dField.UpdateFieldCard(mainGame->LocalPlayer(player), LOCATION_GRAVE, (char*)queryBuffer);
 }
 void ReplayMode::ReplayRefreshDeck(int player, int flag) {
-	unsigned char queryBuffer[0x1000];
+	unsigned char queryBuffer[0x2000];
 	/*int len = */query_field_card(pduel, player, LOCATION_DECK, flag, queryBuffer, 0);
 	mainGame->dField.UpdateFieldCard(mainGame->LocalPlayer(player), LOCATION_DECK, (char*)queryBuffer);
 }
 void ReplayMode::ReplayRefreshExtra(int player, int flag) {
-	unsigned char queryBuffer[0x1000];
+	unsigned char queryBuffer[0x2000];
 	/*int len = */query_field_card(pduel, player, LOCATION_EXTRA, flag, queryBuffer, 0);
 	mainGame->dField.UpdateFieldCard(mainGame->LocalPlayer(player), LOCATION_EXTRA, (char*)queryBuffer);
 }
 void ReplayMode::ReplayRefreshSingle(int player, int location, int sequence, int flag) {
-	unsigned char queryBuffer[0x1000];
+	unsigned char queryBuffer[0x2000];
 	/*int len = */query_card(pduel, player, location, sequence, flag, queryBuffer, 0);
 	mainGame->dField.UpdateCard(mainGame->LocalPlayer(player), location, sequence, (char*)queryBuffer);
 }

gframe/replay_mode.h

@@ -19,7 +19,7 @@ private:
 	static bool is_swaping;
 	static bool exit_pending;
 	static int skip_turn;
-	static wchar_t event_string[256];
+
 public:
 	static Replay cur_replay;
 	

gframe/single_duel.cpp

@@ -458,22 +458,22 @@ void SingleDuel::TPResult(DuelPlayer* dp, unsigned char tp) {
 	last_replay.Flush();
 	last_replay.WriteInt32(pdeck[0].main.size(), false);
 	for(int32 i = (int32)pdeck[0].main.size() - 1; i >= 0; --i) {
-		new_card(pduel, pdeck[0].main[i]->first, 0, 0, LOCATION_DECK, 0, 0);
+		new_card(pduel, pdeck[0].main[i]->first, 0, 0, LOCATION_DECK, 0, POS_FACEDOWN_DEFENCE);
 		last_replay.WriteInt32(pdeck[0].main[i]->first, false);
 	}
 	last_replay.WriteInt32(pdeck[0].extra.size(), false);
 	for(int32 i = (int32)pdeck[0].extra.size() - 1; i >= 0; --i) {
-		new_card(pduel, pdeck[0].extra[i]->first, 0, 0, LOCATION_EXTRA, 0, 0);
+		new_card(pduel, pdeck[0].extra[i]->first, 0, 0, LOCATION_EXTRA, 0, POS_FACEDOWN_DEFENCE);
 		last_replay.WriteInt32(pdeck[0].extra[i]->first, false);
 	}
 	last_replay.WriteInt32(pdeck[1].main.size(), false);
 	for(int32 i = (int32)pdeck[1].main.size() - 1; i >= 0; --i) {
-		new_card(pduel, pdeck[1].main[i]->first, 1, 1, LOCATION_DECK, 0, 0);
+		new_card(pduel, pdeck[1].main[i]->first, 1, 1, LOCATION_DECK, 0, POS_FACEDOWN_DEFENCE);
 		last_replay.WriteInt32(pdeck[1].main[i]->first, false);
 	}
 	last_replay.WriteInt32(pdeck[1].extra.size(), false);
 	for(int32 i = (int32)pdeck[1].extra.size() - 1; i >= 0; --i) {
-		new_card(pduel, pdeck[1].extra[i]->first, 1, 1, LOCATION_EXTRA, 0, 0);
+		new_card(pduel, pdeck[1].extra[i]->first, 1, 1, LOCATION_EXTRA, 0, POS_FACEDOWN_DEFENCE);
 		last_replay.WriteInt32(pdeck[1].extra[i]->first, false);
 	}
 	last_replay.Flush();
@@ -764,6 +764,8 @@ int SingleDuel::Analyze(char* msgbuffer, unsigned int len) {
 			pbuf += 6;
 			count = BufferIO::ReadInt8(pbuf);
 			pbuf += count * 11;
+			count = BufferIO::ReadInt8(pbuf);
+			pbuf += count * 11;
 			WaitforResponse(player);
 			NetServer::SendBufferToPlayer(players[player], STOC_GAME_MSG, offset, pbuf - offset);
 			return 1;
@@ -882,7 +884,7 @@ int SingleDuel::Analyze(char* msgbuffer, unsigned int len) {
 			break;
 		}
 		case MSG_NEW_PHASE: {
-			pbuf++;
+			pbuf += 2;
 			NetServer::SendBufferToPlayer(players[0], STOC_GAME_MSG, offset, pbuf - offset);
 			NetServer::ReSendToPlayer(players[1]);
 			for(auto oit = observers.begin(); oit != observers.end(); ++oit)
@@ -1194,7 +1196,7 @@ int SingleDuel::Analyze(char* msgbuffer, unsigned int len) {
 			break;
 		}
 		case MSG_ADD_COUNTER: {
-			pbuf += 6;
+			pbuf += 7;
 			NetServer::SendBufferToPlayer(players[0], STOC_GAME_MSG, offset, pbuf - offset);
 			NetServer::ReSendToPlayer(players[1]);
 			for(auto oit = observers.begin(); oit != observers.end(); ++oit)
@@ -1202,7 +1204,7 @@ int SingleDuel::Analyze(char* msgbuffer, unsigned int len) {
 			break;
 		}
 		case MSG_REMOVE_COUNTER: {
-			pbuf += 6;
+			pbuf += 7;
 			NetServer::SendBufferToPlayer(players[0], STOC_GAME_MSG, offset, pbuf - offset);
 			NetServer::ReSendToPlayer(players[1]);
 			for(auto oit = observers.begin(); oit != observers.end(); ++oit)
@@ -1293,6 +1295,7 @@ int SingleDuel::Analyze(char* msgbuffer, unsigned int len) {
 		case MSG_ANNOUNCE_CARD: {
 			player = BufferIO::ReadInt8(pbuf);
 			WaitforResponse(player);
+			pbuf += 4;
 			NetServer::SendBufferToPlayer(players[player], STOC_GAME_MSG, offset, pbuf - offset);
 			return 1;
 		}
@@ -1382,7 +1385,7 @@ void SingleDuel::TimeConfirm(DuelPlayer* dp) {
 	event_add(etimer, &timeout);
 }
 void SingleDuel::RefreshMzone(int player, int flag, int use_cache) {
-	char query_buffer[0x1000];
+	char query_buffer[0x2000];
 	char* qbuf = query_buffer;
 	BufferIO::WriteInt8(qbuf, MSG_UPDATE_DATA);
 	BufferIO::WriteInt8(qbuf, player);
@@ -1402,7 +1405,7 @@ void SingleDuel::RefreshMzone(int player, int flag, int use_cache) {
 		NetServer::ReSendToPlayer(*pit);
 }
 void SingleDuel::RefreshSzone(int player, int flag, int use_cache) {
-	char query_buffer[0x1000];
+	char query_buffer[0x2000];
 	char* qbuf = query_buffer;
 	BufferIO::WriteInt8(qbuf, MSG_UPDATE_DATA);
 	BufferIO::WriteInt8(qbuf, player);
@@ -1422,7 +1425,7 @@ void SingleDuel::RefreshSzone(int player, int flag, int use_cache) {
 		NetServer::ReSendToPlayer(*pit);
 }
 void SingleDuel::RefreshHand(int player, int flag, int use_cache) {
-	char query_buffer[0x1000];
+	char query_buffer[0x2000];
 	char* qbuf = query_buffer;
 	BufferIO::WriteInt8(qbuf, MSG_UPDATE_DATA);
 	BufferIO::WriteInt8(qbuf, player);
@@ -1448,7 +1451,7 @@ void SingleDuel::RefreshHand(int player, int flag, int use_cache) {
 		NetServer::ReSendToPlayer(*pit);
 }
 void SingleDuel::RefreshGrave(int player, int flag, int use_cache) {
-	char query_buffer[0x1000];
+	char query_buffer[0x2000];
 	char* qbuf = query_buffer;
 	BufferIO::WriteInt8(qbuf, MSG_UPDATE_DATA);
 	BufferIO::WriteInt8(qbuf, player);
@@ -1460,7 +1463,7 @@ void SingleDuel::RefreshGrave(int player, int flag, int use_cache) {
 		NetServer::ReSendToPlayer(*pit);
 }
 void SingleDuel::RefreshExtra(int player, int flag, int use_cache) {
-	char query_buffer[0x1000];
+	char query_buffer[0x2000];
 	char* qbuf = query_buffer;
 	BufferIO::WriteInt8(qbuf, MSG_UPDATE_DATA);
 	BufferIO::WriteInt8(qbuf, player);
@@ -1469,7 +1472,7 @@ void SingleDuel::RefreshExtra(int player, int flag, int use_cache) {
 	NetServer::SendBufferToPlayer(players[player], STOC_GAME_MSG, query_buffer, len + 3);
 }
 void SingleDuel::RefreshSingle(int player, int location, int sequence, int flag) {
-	char query_buffer[0x1000];
+	char query_buffer[0x2000];
 	char* qbuf = query_buffer;
 	BufferIO::WriteInt8(qbuf, MSG_UPDATE_CARD);
 	BufferIO::WriteInt8(qbuf, player);

gframe/single_mode.cpp

@@ -10,7 +10,6 @@ namespace ygo {
 long SingleMode::pduel = 0;
 bool SingleMode::is_closing = false;
 bool SingleMode::is_continuing = false;
-wchar_t SingleMode::event_string[256];
 
 bool SingleMode::StartPlay() {
 	Thread::NewThread(SinglePlayThread, 0);
@@ -62,6 +61,7 @@ int SingleMode::SinglePlayThread(void* param) {
 	mainGame->stName->setText(L"");
 	mainGame->stInfo->setText(L"");
 	mainGame->stDataInfo->setText(L"");
+	mainGame->stSetName->setText(L"");
 	mainGame->stText->setText(L"");
 	mainGame->scrCardText->setVisible(false);
 	mainGame->wPhase->setVisible(true);
@@ -256,6 +256,8 @@ bool SingleMode::SinglePlayAnalyze(char* msg, unsigned int len) {
 			pbuf += 6;
 			count = BufferIO::ReadInt8(pbuf);
 			pbuf += count * 11;
+			count = BufferIO::ReadInt8(pbuf);
+			pbuf += count * 11;
 			if(!DuelClient::ClientAnalyze(offset, pbuf - offset)) {
 				mainGame->singleSignal.Reset();
 				mainGame->singleSignal.Wait();
@@ -332,7 +334,7 @@ bool SingleMode::SinglePlayAnalyze(char* msg, unsigned int len) {
 			break;
 		}
 		case MSG_NEW_PHASE: {
-			pbuf++;
+			pbuf += 2;
 			DuelClient::ClientAnalyze(offset, pbuf - offset);
 			SinglePlayRefresh();
 			break;
@@ -503,12 +505,12 @@ bool SingleMode::SinglePlayAnalyze(char* msg, unsigned int len) {
 			break;
 		}
 		case MSG_ADD_COUNTER: {
-			pbuf += 6;
+			pbuf += 7;
 			DuelClient::ClientAnalyze(offset, pbuf - offset);
 			break;
 		}
 		case MSG_REMOVE_COUNTER: {
-			pbuf += 6;
+			pbuf += 7;
 			DuelClient::ClientAnalyze(offset, pbuf - offset);
 			break;
 		}
@@ -575,6 +577,7 @@ bool SingleMode::SinglePlayAnalyze(char* msg, unsigned int len) {
 		}
 		case MSG_ANNOUNCE_CARD: {
 			player = BufferIO::ReadInt8(pbuf);
+			pbuf += 4;
 			if(!DuelClient::ClientAnalyze(offset, pbuf - offset)) {
 				mainGame->singleSignal.Reset();
 				mainGame->singleSignal.Wait();
@@ -598,7 +601,7 @@ bool SingleMode::SinglePlayAnalyze(char* msg, unsigned int len) {
 		}
 		case MSG_TAG_SWAP: {
 			player = pbuf[0];
-			pbuf += pbuf[3] * 4 + 8;
+			pbuf += pbuf[2] * 4 + pbuf[4] * 4 + 9;
 			DuelClient::ClientAnalyze(offset, pbuf - offset);
 			SinglePlayRefreshDeck(player);
 			SinglePlayRefreshExtra(player);
@@ -667,6 +670,8 @@ bool SingleMode::SinglePlayAnalyze(char* msg, unsigned int len) {
 					ClientCard* ccard = new ClientCard;
 					mainGame->dField.AddCard(ccard, p, LOCATION_EXTRA, seq);
 				}
+				val = BufferIO::ReadInt8(pbuf);
+				mainGame->dField.extra_p_count[p] = val;
 			}
 			BufferIO::ReadInt8(pbuf); //chain count, always 0
 			SinglePlayReload();
@@ -706,7 +711,7 @@ bool SingleMode::SinglePlayAnalyze(char* msg, unsigned int len) {
 	return is_continuing;
 }
 void SingleMode::SinglePlayRefresh(int flag) {
-	unsigned char queryBuffer[0x1000];
+	unsigned char queryBuffer[0x2000];
 	/*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);
@@ -721,32 +726,32 @@ void SingleMode::SinglePlayRefresh(int flag) {
 	mainGame->dField.UpdateFieldCard(mainGame->LocalPlayer(1), LOCATION_HAND, (char*)queryBuffer);
 }
 void SingleMode::SinglePlayRefreshHand(int player, int flag) {
-	unsigned char queryBuffer[0x1000];
+	unsigned char queryBuffer[0x2000];
 	/*int len = */query_field_card(pduel, player, LOCATION_HAND, flag, queryBuffer, 0);
 	mainGame->dField.UpdateFieldCard(mainGame->LocalPlayer(player), LOCATION_HAND, (char*)queryBuffer);
 }
 void SingleMode::SinglePlayRefreshGrave(int player, int flag) {
-	unsigned char queryBuffer[0x1000];
+	unsigned char queryBuffer[0x2000];
 	/*int len = */query_field_card(pduel, player, LOCATION_GRAVE, flag, queryBuffer, 0);
 	mainGame->dField.UpdateFieldCard(mainGame->LocalPlayer(player), LOCATION_GRAVE, (char*)queryBuffer);
 }
 void SingleMode::SinglePlayRefreshDeck(int player, int flag) {
-	unsigned char queryBuffer[0x1000];
+	unsigned char queryBuffer[0x2000];
 	/*int len = */query_field_card(pduel, player, LOCATION_DECK, flag, queryBuffer, 0);
 	mainGame->dField.UpdateFieldCard(mainGame->LocalPlayer(player), LOCATION_DECK, (char*)queryBuffer);
 }
 void SingleMode::SinglePlayRefreshExtra(int player, int flag) {
-	unsigned char queryBuffer[0x1000];
+	unsigned char queryBuffer[0x2000];
 	/*int len = */query_field_card(pduel, player, LOCATION_EXTRA, flag, queryBuffer, 0);
 	mainGame->dField.UpdateFieldCard(mainGame->LocalPlayer(player), LOCATION_EXTRA, (char*)queryBuffer);
 }
 void SingleMode::SinglePlayRefreshSingle(int player, int location, int sequence, int flag) {
-	unsigned char queryBuffer[0x1000];
+	unsigned char queryBuffer[0x2000];
 	/*int len = */query_card(pduel, player, location, sequence, flag, queryBuffer, 0);
 	mainGame->dField.UpdateCard(mainGame->LocalPlayer(player), location, sequence, (char*)queryBuffer);
 }
 void SingleMode::SinglePlayReload() {
-	unsigned char queryBuffer[0x1000];
+	unsigned char queryBuffer[0x2000];
 	unsigned int flag = 0x7fdfff;
 	/*int len = */query_field_card(pduel, 0, LOCATION_MZONE, flag, queryBuffer, 0);
 	mainGame->dField.UpdateFieldCard(mainGame->LocalPlayer(0), LOCATION_MZONE, (char*)queryBuffer);

gframe/single_mode.h

@@ -13,8 +13,7 @@ private:
 	static long pduel;
 	static bool is_closing;
 	static bool is_continuing;
-	static wchar_t event_string[256];
-	
+
 public:
 	static bool StartPlay();
 	static void StopPlay(bool is_exiting = false);

gframe/tag_duel.cpp

@@ -428,12 +428,12 @@ void TagDuel::TPResult(DuelPlayer* dp, unsigned char tp) {
 	//
 	last_replay.WriteInt32(pdeck[0].main.size(), false);
 	for(int32 i = (int32)pdeck[0].main.size() - 1; i >= 0; --i) {
-		new_card(pduel, pdeck[0].main[i]->first, 0, 0, LOCATION_DECK, 0, 0);
+		new_card(pduel, pdeck[0].main[i]->first, 0, 0, LOCATION_DECK, 0, POS_FACEDOWN_DEFENCE);
 		last_replay.WriteInt32(pdeck[0].main[i]->first, false);
 	}
 	last_replay.WriteInt32(pdeck[0].extra.size(), false);
 	for(int32 i = (int32)pdeck[0].extra.size() - 1; i >= 0; --i) {
-		new_card(pduel, pdeck[0].extra[i]->first, 0, 0, LOCATION_EXTRA, 0, 0);
+		new_card(pduel, pdeck[0].extra[i]->first, 0, 0, LOCATION_EXTRA, 0, POS_FACEDOWN_DEFENCE);
 		last_replay.WriteInt32(pdeck[0].extra[i]->first, false);
 	}
 	//
@@ -450,12 +450,12 @@ void TagDuel::TPResult(DuelPlayer* dp, unsigned char tp) {
 	//
 	last_replay.WriteInt32(pdeck[3].main.size(), false);
 	for(int32 i = (int32)pdeck[3].main.size() - 1; i >= 0; --i) {
-		new_card(pduel, pdeck[3].main[i]->first, 1, 1, LOCATION_DECK, 0, 0);
+		new_card(pduel, pdeck[3].main[i]->first, 1, 1, LOCATION_DECK, 0, POS_FACEDOWN_DEFENCE);
 		last_replay.WriteInt32(pdeck[3].main[i]->first, false);
 	}
 	last_replay.WriteInt32(pdeck[3].extra.size(), false);
 	for(int32 i = (int32)pdeck[3].extra.size() - 1; i >= 0; --i) {
-		new_card(pduel, pdeck[3].extra[i]->first, 1, 1, LOCATION_EXTRA, 0, 0);
+		new_card(pduel, pdeck[3].extra[i]->first, 1, 1, LOCATION_EXTRA, 0, POS_FACEDOWN_DEFENCE);
 		last_replay.WriteInt32(pdeck[3].extra[i]->first, false);
 	}
 	//
@@ -695,6 +695,8 @@ int TagDuel::Analyze(char* msgbuffer, unsigned int len) {
 			pbuf += 6;
 			count = BufferIO::ReadInt8(pbuf);
 			pbuf += count * 11;
+			count = BufferIO::ReadInt8(pbuf);
+			pbuf += count * 11;
 			WaitforResponse(player);
 			NetServer::SendBufferToPlayer(cur_player[player], STOC_GAME_MSG, offset, pbuf - offset);
 			return 1;
@@ -841,7 +843,7 @@ int TagDuel::Analyze(char* msgbuffer, unsigned int len) {
 			break;
 		}
 		case MSG_NEW_PHASE: {
-			pbuf++;
+			pbuf += 2;
 			NetServer::SendBufferToPlayer(players[0], STOC_GAME_MSG, offset, pbuf - offset);
 			NetServer::ReSendToPlayer(players[1]);
 			NetServer::ReSendToPlayer(players[2]);
@@ -1213,7 +1215,7 @@ int TagDuel::Analyze(char* msgbuffer, unsigned int len) {
 			break;
 		}
 		case MSG_ADD_COUNTER: {
-			pbuf += 6;
+			pbuf += 7;
 			NetServer::SendBufferToPlayer(players[0], STOC_GAME_MSG, offset, pbuf - offset);
 			NetServer::ReSendToPlayer(players[1]);
 			NetServer::ReSendToPlayer(players[2]);
@@ -1223,7 +1225,7 @@ int TagDuel::Analyze(char* msgbuffer, unsigned int len) {
 			break;
 		}
 		case MSG_REMOVE_COUNTER: {
-			pbuf += 6;
+			pbuf += 7;
 			NetServer::SendBufferToPlayer(players[0], STOC_GAME_MSG, offset, pbuf - offset);
 			NetServer::ReSendToPlayer(players[1]);
 			NetServer::ReSendToPlayer(players[2]);
@@ -1329,6 +1331,7 @@ int TagDuel::Analyze(char* msgbuffer, unsigned int len) {
 		}
 		case MSG_ANNOUNCE_CARD: {
 			player = BufferIO::ReadInt8(pbuf);
+			pbuf += 4;
 			WaitforResponse(player);
 			NetServer::SendBufferToPlayer(cur_player[player], STOC_GAME_MSG, offset, pbuf - offset);
 			return 1;
@@ -1354,10 +1357,11 @@ int TagDuel::Analyze(char* msgbuffer, unsigned int len) {
 		case MSG_TAG_SWAP: {
 			player = BufferIO::ReadInt8(pbuf);
 			/*int mcount = */BufferIO::ReadInt8(pbuf);
-			/*int ecount = */BufferIO::ReadInt8(pbuf);
+			int ecount = BufferIO::ReadInt8(pbuf);
+			/*int pcount = */BufferIO::ReadInt8(pbuf);
 			int hcount = BufferIO::ReadInt8(pbuf);
 			pbufw = pbuf + 4;
-			pbuf += hcount * 4 + 4;
+			pbuf += hcount * 4 + ecount * 4 + 4;
 			NetServer::SendBufferToPlayer(cur_player[player], STOC_GAME_MSG, offset, pbuf - offset);
 			for (int i = 0; i < hcount; ++i) {
 				if(!(pbufw[3] & 0x80))
@@ -1365,6 +1369,12 @@ int TagDuel::Analyze(char* msgbuffer, unsigned int len) {
 				else
 					pbufw += 4;
 			}
+			for (int i = 0; i < ecount; ++i) {
+				if(!(pbufw[3] & 0x80))
+					BufferIO::WriteInt32(pbufw, 0);
+				else
+					pbufw += 4;
+			}
 			for(int i = 0; i < 4; ++i)
 				if(players[i] != cur_player[player])
 					NetServer::SendBufferToPlayer(players[i], STOC_GAME_MSG, offset, pbuf - offset);
@@ -1449,7 +1459,7 @@ void TagDuel::TimeConfirm(DuelPlayer* dp) {
 	event_add(etimer, &timeout);
 }
 void TagDuel::RefreshMzone(int player, int flag, int use_cache) {
-	char query_buffer[0x1000];
+	char query_buffer[0x2000];
 	char* qbuf = query_buffer;
 	BufferIO::WriteInt8(qbuf, MSG_UPDATE_DATA);
 	BufferIO::WriteInt8(qbuf, player);
@@ -1473,7 +1483,7 @@ void TagDuel::RefreshMzone(int player, int flag, int use_cache) {
 		NetServer::ReSendToPlayer(*pit);
 }
 void TagDuel::RefreshSzone(int player, int flag, int use_cache) {
-	char query_buffer[0x1000];
+	char query_buffer[0x2000];
 	char* qbuf = query_buffer;
 	BufferIO::WriteInt8(qbuf, MSG_UPDATE_DATA);
 	BufferIO::WriteInt8(qbuf, player);
@@ -1497,7 +1507,7 @@ void TagDuel::RefreshSzone(int player, int flag, int use_cache) {
 		NetServer::ReSendToPlayer(*pit);
 }
 void TagDuel::RefreshHand(int player, int flag, int use_cache) {
-	char query_buffer[0x1000];
+	char query_buffer[0x2000];
 	char* qbuf = query_buffer;
 	BufferIO::WriteInt8(qbuf, MSG_UPDATE_DATA);
 	BufferIO::WriteInt8(qbuf, player);
@@ -1525,7 +1535,7 @@ void TagDuel::RefreshHand(int player, int flag, int use_cache) {
 		NetServer::ReSendToPlayer(*pit);
 }
 void TagDuel::RefreshGrave(int player, int flag, int use_cache) {
-	char query_buffer[0x1000];
+	char query_buffer[0x2000];
 	char* qbuf = query_buffer;
 	BufferIO::WriteInt8(qbuf, MSG_UPDATE_DATA);
 	BufferIO::WriteInt8(qbuf, player);
@@ -1539,7 +1549,7 @@ void TagDuel::RefreshGrave(int player, int flag, int use_cache) {
 		NetServer::ReSendToPlayer(*pit);
 }
 void TagDuel::RefreshExtra(int player, int flag, int use_cache) {
-	char query_buffer[0x1000];
+	char query_buffer[0x2000];
 	char* qbuf = query_buffer;
 	BufferIO::WriteInt8(qbuf, MSG_UPDATE_DATA);
 	BufferIO::WriteInt8(qbuf, player);
@@ -1548,7 +1558,7 @@ void TagDuel::RefreshExtra(int player, int flag, int use_cache) {
 	NetServer::SendBufferToPlayer(cur_player[player], STOC_GAME_MSG, query_buffer, len + 3);
 }
 void TagDuel::RefreshSingle(int player, int location, int sequence, int flag) {
-	char query_buffer[0x1000];
+	char query_buffer[0x2000];
 	char* qbuf = query_buffer;
 	BufferIO::WriteInt8(qbuf, MSG_UPDATE_CARD);
 	BufferIO::WriteInt8(qbuf, player);

ocgcore @ 0a34f5dc

+Subproject commit 0a34f5dcb88617fb60902377193403947059ca90

ocgcore/common.h

-/*
- * common.h
- *
- *  Created on: 2009-1-7
- *      Author: Argon.Sun
- */
-
-#ifndef COMMON_H_
-#define COMMON_H_
-
-#ifdef _MSC_VER
-#pragma warning(disable: 4244)
-#endif
-
-typedef unsigned long uptr;
-typedef unsigned long long uint64;
-typedef unsigned int uint32;
-typedef unsigned short uint16;
-typedef unsigned char uint8;
-typedef unsigned char byte;
-typedef long ptr;
-typedef long long int64;
-typedef int int32;
-typedef short int16;
-typedef char int8;
-typedef int BOOL;
-
-#define MATCH_ALL(x,y) (((x)&(y))==(y))
-#define MATCH_ANY(x,y) ((x)&(y))
-#define ADD_BIT(x,y) ((x)|=(y))
-#define REMOVE_BIT(x,y) ((x)&=~(y))
-
-#define OPERATION_SUCCESS 1
-#define OPERATION_FAIL 0
-#define OPERATION_CANCELED -1
-#define TRUE 1
-#define FALSE 0
-#ifndef NULL
-#define NULL 0
-#endif
-struct card_sort {
-	bool operator()(void* const & c1, void* const & c2) const;
-};
-
-#endif /* COMMON_H_ */

ocgcore/duel.cpp

-/*
- * duel.cpp
- *
- *  Created on: 2010-5-2
- *      Author: Argon
- */
-
-#include "duel.h"
-#include "interpreter.h"
-#include "field.h"
-#include "card.h"
-#include "effect.h"
-#include "group.h"
-#include "ocgapi.h"
-#include <memory.h>
-
-duel::duel() {
-	lua = new interpreter(this);
-	game_field = new field(this);
-	game_field->temp_card = new_card(0);
-	clear_buffer();
-}
-duel::~duel() {
-	for(std::set<card*>::iterator cit = cards.begin(); cit != cards.end(); ++cit)
-		delete *cit;
-	for(std::set<group*>::iterator git = groups.begin(); git != groups.end(); ++git)
-		delete *git;
-	for(std::set<effect*>::iterator eit = effects.begin(); eit != effects.end(); ++eit)
-		delete *eit;
-	delete lua;
-	delete game_field;
-}
-void duel::clear() {
-	for(std::set<card*>::iterator cit = cards.begin(); cit != cards.end(); ++cit)
-		delete *cit;
-	for(std::set<group*>::iterator git = groups.begin(); git != groups.end(); ++git)
-		delete *git;
-	for(std::set<effect*>::iterator eit = effects.begin(); eit != effects.end(); ++eit)
-		delete *eit;
-	delete game_field;
-	cards.clear();
-	groups.clear();
-	effects.clear();
-	game_field = new field(this);
-	game_field->temp_card = new_card(0);
-}
-card* duel::new_card(uint32 code) {
-	card* pcard = new card(this);
-	cards.insert(pcard);
-	if(code)
-		::read_card(code, &(pcard->data));
-	pcard->data.code = code;
-	lua->register_card(pcard);
-	return pcard;
-}
-group* duel::register_group(group* pgroup) {
-	groups.insert(pgroup);
-	if(lua->call_depth)
-		sgroups.insert(pgroup);
-	lua->register_group(pgroup);
-	return pgroup;
-}
-group* duel::new_group() {
-	group* pgroup = new group(this);
-	return register_group(pgroup);
-}
-group* duel::new_group(card* pcard) {
-	group* pgroup = new group(this, pcard);
-	return register_group(pgroup);
-}
-group* duel::new_group(const card_set& cset) {
-	group* pgroup = new group(this, cset);
-	return register_group(pgroup);
-}
-effect* duel::new_effect() {
-	effect* peffect = new effect(this);
-	effects.insert(peffect);
-	lua->register_effect(peffect);
-	return peffect;
-}
-void duel::delete_card(card* pcard) {
-	cards.erase(pcard);
-	delete pcard;
-}
-void duel::delete_group(group* pgroup) {
-	lua->unregister_group(pgroup);
-	groups.erase(pgroup);
-	sgroups.erase(pgroup);
-	delete pgroup;
-}
-void duel::delete_effect(effect* peffect) {
-	lua->unregister_effect(peffect);
-	effects.erase(peffect);
-	delete peffect;
-}
-int32 duel::read_buffer(byte* buf) {
-	memcpy(buf, buffer, bufferlen);
-	return bufferlen;
-}
-void duel::release_script_group() {
-	std::set<group*>::iterator sit;
-	for(sit = sgroups.begin(); sit != sgroups.end(); ++sit) {
-		group* pgroup = *sit;
-		if(pgroup->is_readonly == 0) {
-			lua->unregister_group(pgroup);
-			groups.erase(pgroup);
-			delete pgroup;
-		}
-	}
-	sgroups.clear();
-}
-void duel::restore_assumes() {
-	std::set<card*>::iterator sit;
-	for(sit = assumes.begin(); sit != assumes.end(); ++sit)
-		(*sit)->assume_type = 0;
-	assumes.clear();
-}
-void duel::write_buffer32(uint32 value) {
-	*((uint32*)bufferp) = value;
-	bufferp += 4;
-	bufferlen += 4;
-}
-void duel::write_buffer16(uint16 value) {
-	*((uint16*)bufferp) = value;
-	bufferp += 2;
-	bufferlen += 2;
-}
-void duel::write_buffer8(uint8 value) {
-	*((uint8*)bufferp) = value;
-	bufferp += 1;
-	bufferlen += 1;
-}
-void duel::clear_buffer() {
-	bufferlen = 0;
-	bufferp = buffer;
-}
-void duel::set_responsei(uint32 resp) {
-	game_field->returns.ivalue[0] = resp;
-}
-void duel::set_responseb(byte* resp) {
-	memcpy(game_field->returns.bvalue, resp, 64);
-}
-int32 duel::get_next_integer(int32 l, int32 h) {
-	return (int32) (random.real() * (h - l + 1)) + l;
-}

ocgcore/duel.h

-/*
- * duel.h
- *
- *  Created on: 2010-4-8
- *      Author: Argon
- */
-
-#ifndef DUEL_H_
-#define DUEL_H_
-
-#include "common.h"
-#include "mtrandom.h"
-#include <set>
-
-class card;
-class group;
-class effect;
-class field;
-class interpreter;
-
-struct duel_arg {
-	int16 start_lp;
-	int8 start_hand;
-	int8 draw_count;
-};
-class duel {
-public:
-	typedef std::set<card*, card_sort> card_set;
-	char strbuffer[256];
-	byte buffer[0x1000];
-	uint32 bufferlen;
-	byte* bufferp;
-	interpreter* lua;
-	field* game_field;
-	mtrandom random;
-	std::set<card*> cards;
-	std::set<card*> assumes;
-	std::set<group*> groups;
-	std::set<group*> sgroups;
-	std::set<effect*> effects;
-	std::set<effect*> uncopy;
-	
-	duel();
-	~duel();
-	void clear();
-	
-	card* new_card(uint32 code);
-	group* new_group();
-	group* new_group(card* pcard);
-	group* new_group(const card_set& cset);
-	effect* new_effect();
-	void delete_card(card* pcard);
-	void delete_group(group* pgroup);
-	void delete_effect(effect* peffect);
-	void release_script_group();
-	void restore_assumes();
-	int32 read_buffer(byte* buf);
-	void write_buffer32(uint32 value);
-	void write_buffer16(uint16 value);
-	void write_buffer8(uint8 value);
-	void clear_buffer();
-	void set_responsei(uint32 resp);
-	void set_responseb(byte* resp);
-	int32 get_next_integer(int32 l, int32 h);
-private:
-	group* register_group(group* pgroup);
-};
-
-//Player
-#define PLAYER_NONE		2	//
-#define PLAYER_ALL		3	//
-//Phase
-#define PHASE_DRAW			0x01	//
-#define PHASE_STANDBY		0x02	//
-#define PHASE_MAIN1			0x04	//
-#define PHASE_BATTLE		0x08	//
-#define PHASE_DAMAGE		0x10	//
-#define PHASE_DAMAGE_CAL	0x20	//
-#define PHASE_MAIN2			0x40	//
-#define PHASE_END			0x80	//
-//Options
-#define DUEL_TEST_MODE			0x01
-#define DUEL_ATTACK_FIRST_TURN	0x02
-#define DUEL_NO_CHAIN_HINT		0x04
-#define DUEL_OBSOLETE_RULING	0x08
-#define DUEL_PSEUDO_SHUFFLE		0x10
-#define DUEL_TAG_MODE			0x20
-#define DUEL_SIMPLE_AI			0x40
-#endif /* DUEL_H_ */

ocgcore/effectset.h

-/*
- * effectset.h
- *
- *  Created on: 2011-10-8
- *      Author: Argon
- */
-
-#ifndef EFFECTSET_H_
-#define EFFECTSET_H_
-
-#include <stdlib.h>
-#include <array>
-#include <vector>
-#include <algorithm>
-
-class effect;
-
-bool effect_sort_id(const effect* e1, const effect* e2);
-
-struct effect_set {
-	effect_set(): count(0) {}
-	void add_item(effect* peffect) {
-		if(count >= 64) return;
-		container[count++] = peffect;
-	}
-	void remove_item(int index) {
-		if(index >= count)
-			return;
-		if(index == count - 1) {
-			count--;
-			return;
-		}
-		for(int i = index; i < count - 1; ++i)
-			container[i] = container[i + 1];
-		count--;
-	}
-	void clear() {
-		count = 0;
-	}
-	int size() const {
-		return count;
-	}
-	void sort() {
-		if(count < 2)
-			return;
-		std::sort(container.begin(), container.begin() + count, effect_sort_id);
-	}
-	effect* const& get_last() const {
-		return container[count - 1];
-	}
-	effect*& get_last() {
-		return container[count - 1];
-	}
-	effect* const& operator[] (int index) const {
-		return container[index];
-	}
-	effect*& operator[] (int index) {
-		return container[index];
-	}
-	effect* const& at(int index) const {
-		return container[index];
-	}
-	effect*& at(int index) {
-		return container[index];
-	}
-private:
-	std::array<effect*, 64> container;
-	int count;
-};
-
-struct effect_set_v {
-	effect_set_v(): count(0) {}
-	void add_item(effect* peffect) {
-		container.push_back(peffect);
-		count++;
-	}
-	void remove_item(int index) {
-		if(index >= count)
-			return;
-		container.erase(container.begin() + index);
-		count--;
-	}
-	void clear() {
-		container.clear();
-		count = 0;
-	}
-	void sort() {
-		if(count < 2)
-			return;
-		std::sort(container.begin(), container.begin() + count, effect_sort_id);
-	}
-	effect*& get_last() {
-		return container[count - 1];
-	}
-	effect*& operator[] (int index) {
-		return container[index];
-	}
-	effect*& at(int index) {
-		return container[index];
-	}
-	std::vector<effect*> container;
-	int count;
-};
-
-#endif //EFFECTSET_H_

ocgcore/premake4.lua

-project "ocgcore"
-    kind "StaticLib"
-
-    files { "**.cc", "**.cpp", "**.c", "**.h" }
-    configuration "windows"
-        includedirs { ".." }
-    configuration "not vs*"
-        buildoptions { "-std=gnu++0x" }
-    configuration "not windows"
-        includedirs { "/usr/include/lua", "/usr/include/lua5.2", "/usr/include/lua/5.2" }

script @ 3db99b98

+Subproject commit 3db99b98ee425d02691e5db948adfc114f861b98