Added relay duel mode

gframe/drawing.cpp

@@ -512,11 +512,17 @@ void Game::DrawMisc() {
 
 	recti p1size = mainGame->Resize(335, 31, 629, 50);
 	recti p2size = mainGame->Resize(986, 31, 986, 50);
-	if(!dInfo.isTag || !dInfo.tag_player[0])
+	if (dInfo.isRelay)
+		textFont->draw(dInfo.hostname_relay[dInfo.relay_player[0]], p1size, 0xffffffff, false, false, 0);
+	else if(!dInfo.isTag || !dInfo.tag_player[0])
 		textFont->draw(dInfo.hostname, p1size, 0xffffffff, false, false, 0);
 	else
 		textFont->draw(dInfo.hostname_tag, p1size, 0xffffffff, false, false, 0);
-	if(!dInfo.isTag || !dInfo.tag_player[1]) {
+	if (dInfo.isRelay) {
+		auto cld = textFont->getDimension(dInfo.clientname_relay[dInfo.relay_player[1]]);
+		p2size.UpperLeftCorner.X -= cld.Width;
+		textFont->draw(dInfo.clientname_relay[dInfo.relay_player[1]], p2size, 0xffffffff, false, false, 0);
+	} else if(!dInfo.isTag || !dInfo.tag_player[1]) {
 		auto cld = textFont->getDimension(dInfo.clientname);
 		p2size.UpperLeftCorner.X -= cld.Width;
 		textFont->draw(dInfo.clientname, p2size, 0xffffffff, false, false, 0);

gframe/event_handler.cpp

@@ -1848,12 +1848,16 @@ bool ClientField::OnEvent(const irr::SEvent& event) {
 				if(mplayer >= 0) {
 					const wchar_t* player_name;
 					if(mplayer == 0) {
-						if(!mainGame->dInfo.isTag || !mainGame->dInfo.tag_player[0])
+						if(mainGame->dInfo.isRelay)
+							player_name = mainGame->dInfo.hostname_relay[mainGame->dInfo.relay_player[0]];
+						else if(!mainGame->dInfo.isTag || !mainGame->dInfo.tag_player[0])
 							player_name = mainGame->dInfo.hostname;
 						else
 							player_name = mainGame->dInfo.hostname_tag;
 					} else {
-						if(!mainGame->dInfo.isTag || !mainGame->dInfo.tag_player[1])
+						if (mainGame->dInfo.isRelay)
+							player_name = mainGame->dInfo.clientname_relay[mainGame->dInfo.relay_player[1]];
+						else if(!mainGame->dInfo.isTag || !mainGame->dInfo.tag_player[1])
 							player_name = mainGame->dInfo.clientname;
 						else
 							player_name = mainGame->dInfo.clientname_tag;

gframe/game.cpp

@@ -155,6 +155,7 @@ bool Game::Initialize() {
 	cbMatchMode->addItem(dataManager.GetSysString(1244));
 	cbMatchMode->addItem(dataManager.GetSysString(1245));
 	cbMatchMode->addItem(dataManager.GetSysString(1246));
+	cbMatchMode->addItem(dataManager.GetSysString(1247));
 	env->addStaticText(dataManager.GetSysString(1237), rect<s32>(20, 120, 320, 140), false, false, wCreateHost);
 	myswprintf(strbuf, L"%d", 180);
 	ebTimeLimit = env->addEditBox(strbuf, rect<s32>(140, 115, 220, 140), true, wCreateHost);
@@ -237,23 +238,17 @@ bool Game::Initialize() {
 	wHostPrepare2->setVisible(false);
 	stHostPrepRule2 = env->addStaticText(L"", rect<s32>(10, 30, 460, 350), false, true, wHostPrepare2);
 	btnHostPrepDuelist = env->addButton(rect<s32>(10, 30, 110, 55), wHostPrepare, BUTTON_HP_DUELIST, dataManager.GetSysString(1251));
-	for(int i = 0; i < 2; ++i) {
+	for(int i = 0; i < 6; ++i) {
 		stHostPrepDuelist[i] = env->addStaticText(L"", rect<s32>(40, 65 + i * 25, 240, 85 + i * 25), true, false, wHostPrepare);
 		btnHostPrepKick[i] = env->addButton(rect<s32>(10, 65 + i * 25, 30, 85 + i * 25), wHostPrepare, BUTTON_HP_KICK, L"X");
 		chkHostPrepReady[i] = env->addCheckBox(false, rect<s32>(250, 65 + i * 25, 270, 85 + i * 25), wHostPrepare, CHECKBOX_HP_READY, L"");
 		chkHostPrepReady[i]->setEnabled(false);
 	}
-	for(int i = 2; i < 4; ++i) {
-		stHostPrepDuelist[i] = env->addStaticText(L"", rect<s32>(40, 75 + i * 25, 240, 95 + i * 25), true, false, wHostPrepare);
-		btnHostPrepKick[i] = env->addButton(rect<s32>(10, 75 + i * 25, 30, 95 + i * 25), wHostPrepare, BUTTON_HP_KICK, L"X");
-		chkHostPrepReady[i] = env->addCheckBox(false, rect<s32>(250, 75 + i * 25, 270, 95 + i * 25), wHostPrepare, CHECKBOX_HP_READY, L"");
-		chkHostPrepReady[i]->setEnabled(false);
-	}
 	btnHostPrepOB = env->addButton(rect<s32>(10, 180, 110, 205), wHostPrepare, BUTTON_HP_OBSERVER, dataManager.GetSysString(1252));
 	myswprintf(dataManager.strBuffer, L"%ls%d", dataManager.GetSysString(1253), 0);
 	stHostPrepOB = env->addStaticText(dataManager.strBuffer, rect<s32>(10, 210, 270, 230), false, false, wHostPrepare);
 	stHostPrepRule = env->addStaticText(L"", rect<s32>(280, 30, 460, 230), false, true, wHostPrepare);
-	env->addStaticText(dataManager.GetSysString(1254), rect<s32>(10, 235, 110, 255), false, false, wHostPrepare);
+	stDeckSelect = env->addStaticText(dataManager.GetSysString(1254), rect<s32>(10, 235, 110, 255), false, false, wHostPrepare);
 	cbDeckSelect = env->addComboBox(rect<s32>(120, 230, 270, 255), wHostPrepare);
 	cbDeckSelect->setMaxSelectionRows(10);
 	cbDeckSelect2 = env->addComboBox(rect<s32>(280, 230, 430, 255), wHostPrepare);
@@ -1362,22 +1357,22 @@ void Game::AddChatMsg(wchar_t* msg, int player) {
 	chatType[0] = player;
 	switch(player) {
 	case 0: //from host
-		chatMsg[0].append(dInfo.hostname);
+		chatMsg[0].append((dInfo.isRelay) ? dInfo.hostname_relay[0] : dInfo.hostname);
 		chatMsg[0].append(L": ");
 		break;
 	case 1: //from client
 		PlaySoundEffect("./sound/chatmessage.wav");
-		chatMsg[0].append(dInfo.clientname);
+		chatMsg[0].append((dInfo.isRelay) ? dInfo.clientname_relay[0] : dInfo.clientname);
 		chatMsg[0].append(L": ");
 		break;
 	case 2: //host tag
 		PlaySoundEffect("./sound/chatmessage.wav");
-		chatMsg[0].append(dInfo.hostname_tag);
+		chatMsg[0].append((dInfo.isRelay) ? dInfo.hostname_relay[1] : dInfo.hostname_tag);
 		chatMsg[0].append(L": ");
 		break;
 	case 3: //client tag
 		PlaySoundEffect("./sound/chatmessage.wav");
-		chatMsg[0].append(dInfo.clientname_tag);
+		chatMsg[0].append((dInfo.isRelay) ? dInfo.clientname_relay[1] : dInfo.clientname_tag);
 		chatMsg[0].append(L": ");
 		break;
 	case 7: //local name
@@ -1662,8 +1657,13 @@ void Game::OnResize() {
 
 	wLanWindow->setRelativePosition(ResizeWin(220, 100, 800, 520));
 	wCreateHost->setRelativePosition(ResizeWin(320, 100, 700, 520));
+	if (dInfo.isRelay) {
+		wHostPrepare->setRelativePosition(ResizeWin(270, 120, 750, 500));
+		wHostPrepare2->setRelativePosition(ResizeWin(750, 120, 950, 500));
+	} else {
 		wHostPrepare->setRelativePosition(ResizeWin(270, 120, 750, 440));
 		wHostPrepare2->setRelativePosition(ResizeWin(750, 120, 950, 440));
+	}
 	wRules->setRelativePosition(ResizeWin(630, 100, 1000, 310));
 	wCustomRules->setRelativePosition(ResizeWin(700, 100, 910, 410));
 	wReplay->setRelativePosition(ResizeWin(220, 100, 800, 520));

gframe/game.h

@@ -52,10 +52,12 @@ struct DuelInfo {
 	bool isReplaySkiping;
 	bool isFirst;
 	bool isTag;
+	bool isRelay;
 	bool isSingleMode;
 	bool lua64;
 	bool is_shuffling;
 	bool tag_player[2];
+	int relay_player[2];
 	int lp[2];
 	int startlp;
 	int duel_field;
@@ -66,6 +68,8 @@ struct DuelInfo {
 	wchar_t clientname[20];
 	wchar_t hostname_tag[20];
 	wchar_t clientname_tag[20];
+	wchar_t clientname_relay[3][20];
+	wchar_t hostname_relay[3][20];
 	wchar_t strLP[2][16];
 	wchar_t* vic_string;
 	unsigned char player_type;
@@ -301,14 +305,15 @@ public:
 	irr::gui::IGUIStaticText* stHostCardRule;
 	irr::gui::IGUIButton* btnHostPrepDuelist;
 	irr::gui::IGUIButton* btnHostPrepOB;
-	irr::gui::IGUIStaticText* stHostPrepDuelist[4];
-	irr::gui::IGUICheckBox* chkHostPrepReady[4];
-	irr::gui::IGUIButton* btnHostPrepKick[4];
+	irr::gui::IGUIStaticText* stHostPrepDuelist[6];
+	irr::gui::IGUICheckBox* chkHostPrepReady[6];
+	irr::gui::IGUIButton* btnHostPrepKick[6];
 	irr::gui::IGUIComboBox* cbDeckSelect;
 	irr::gui::IGUIComboBox* cbDeckSelect2;
 	irr::gui::IGUIStaticText* stHostPrepRule;
 	irr::gui::IGUIStaticText* stHostPrepRule2;
 	irr::gui::IGUIStaticText* stHostPrepOB;
+	irr::gui::IGUIStaticText* stDeckSelect;
 	irr::gui::IGUIButton* btnHostPrepReady;
 	irr::gui::IGUIButton* btnHostPrepNotReady;
 	irr::gui::IGUIButton* btnHostPrepStart;

gframe/menu_handler.cpp

@@ -226,11 +226,17 @@ bool MenuHandler::OnEvent(const irr::SEvent& event) {
 				UpdateDeck();
 				DuelClient::SendPacketToServer(CTOS_HS_READY);
 				mainGame->cbDeckSelect->setEnabled(false);
+				mainGame->cbDeckSelect2->setEnabled(false);
+				if(mainGame->dInfo.isTag || mainGame->dInfo.isRelay)
+					mainGame->btnHostPrepDuelist->setEnabled(false);
 				break;
 			}
 			case BUTTON_HP_NOTREADY: {
 				DuelClient::SendPacketToServer(CTOS_HS_NOTREADY);
 				mainGame->cbDeckSelect->setEnabled(true);
+				mainGame->cbDeckSelect2->setEnabled(true);
+				if(mainGame->dInfo.isTag || mainGame->dInfo.isRelay)
+					mainGame->btnHostPrepDuelist->setEnabled(true);
 				break;
 			}
 			case BUTTON_HP_START: {
@@ -425,10 +431,14 @@ bool MenuHandler::OnEvent(const irr::SEvent& event) {
 					DuelClient::SendPacketToServer(CTOS_HS_READY);
 					mainGame->cbDeckSelect->setEnabled(false);
 					mainGame->cbDeckSelect2->setEnabled(false);
+					if(mainGame->dInfo.isTag || mainGame->dInfo.isRelay)
+						mainGame->btnHostPrepDuelist->setEnabled(false);
 				} else {
 					DuelClient::SendPacketToServer(CTOS_HS_NOTREADY);
 					mainGame->cbDeckSelect->setEnabled(true);
 					mainGame->cbDeckSelect2->setEnabled(true);
+					if(mainGame->dInfo.isTag || mainGame->dInfo.isRelay)
+						mainGame->btnHostPrepDuelist->setEnabled(true);
 				}
 				break;
 			}

gframe/netserver.cpp

 #include "netserver.h"
 #include "single_duel.h"
 #include "tag_duel.h"
+#include "relay_duel.h"
 
 namespace ygo {
 std::unordered_map<bufferevent*, DuelPlayer> NetServer::users;
@@ -232,10 +233,13 @@ void NetServer::HandleCTOSPacket(DuelPlayer* dp, char* data, unsigned int len) {
 		} else if(pkt->info.mode == MODE_TAG) {
 			duel_mode = new TagDuel();
 			duel_mode->etimer = event_new(net_evbase, 0, EV_TIMEOUT | EV_PERSIST, TagDuel::TagTimer, duel_mode);
+		} else if(pkt->info.mode == MODE_RELAY) {
+			duel_mode = new RelayDuel();
+			duel_mode->etimer = event_new(net_evbase, 0, EV_TIMEOUT | EV_PERSIST, RelayDuel::RelayTimer, duel_mode);
 		}
 		if(pkt->info.rule > 3)
 			pkt->info.rule = 0;
-		if(pkt->info.mode > 2)
+		if(pkt->info.mode > 3)
 			pkt->info.mode = 0;
 		unsigned int hash = 1;
 		for(auto lfit = deckManager._lfList.begin(); lfit != deckManager._lfList.end(); ++lfit) {

gframe/network.h

@@ -241,4 +241,5 @@ public:
 #define MODE_SINGLE		0x0
 #define MODE_MATCH		0x1
 #define MODE_TAG		0x2
+#define MODE_RELAY		0x3
 #endif //NETWORK_H

gframe/relay_duel.h

+#ifndef RELAY_DUEL_H
+#define RELAY_DUEL_H
+
+#include "config.h"
+#include "network.h"
+#include "replay.h"
+
+namespace ygo {
+
+class RelayDuel: public DuelMode {
+public:
+	RelayDuel();
+	virtual ~RelayDuel();
+	virtual void Chat(DuelPlayer* dp, void* pdata, int len);
+	virtual void JoinGame(DuelPlayer* dp, void* 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, void* pdata);
+	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(char* msgbuffer, unsigned int len);
+	virtual void GetResponse(DuelPlayer* dp, void* pdata, unsigned int len);
+	virtual void TimeConfirm(DuelPlayer* dp);
+	virtual void EndDuel();
+	
+	void DuelEndProc();
+	void WaitforResponse(int playerid);
+	void RefreshMzone(int player, int flag = 0x881fff, int use_cache = 1);
+	void RefreshSzone(int player, int flag = 0x681fff, int use_cache = 1);
+	void RefreshHand(int player, int flag = 0x781fff, int use_cache = 1);
+	void RefreshGrave(int player, int flag = 0x81fff, int use_cache = 1);
+	void RefreshExtra(int player, int flag = 0x81fff, int use_cache = 1);
+	void RefreshSingle(int player, int location, int sequence, int flag = 0xf81fff);
+	
+	static int MessageHandler(long fduel, int type);
+	static void RelayTimer(evutil_socket_t fd, short events, void* arg);
+
+	void PseudoRefreshDeck(int player, int flag = 0x181fff);
+	static std::vector<ReplayPacket> replay_stream;
+	
+protected:
+	class duelist {
+		public:
+		DuelPlayer* player;
+		bool ready;
+		Deck pdeck;
+		int deck_error;
+		duelist() : player(0), ready(false), deck_error(0) {}
+		duelist(DuelPlayer* _player) : player(_player), ready(false), deck_error(0) {}
+	};
+	duelist players[6];
+	unsigned char startp[2];
+	DuelPlayer* cur_player[2];
+	std::set<DuelPlayer*> observers;
+	unsigned char hand_result[2];
+	unsigned char last_response;
+	Replay last_replay;
+	Replay new_replay;
+	bool game_started;
+	unsigned char turn_count;
+	unsigned short time_limit[2];
+	unsigned short time_elapsed;
+};
+
+}
+
+#endif //RELAY_DUEL_H
+

strings.conf

@@ -295,6 +295,7 @@
 !system 1244 Single Duel
 !system 1245 Match
 !system 1246 Tag
+!system 1247 Relay
 !system 1250 Host
 !system 1251 →Duel
 !system 1252 →Spectate