recon

gframe/config.h

@@ -14,6 +14,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <memory.h>
+#include <sys/time.h>
 #include "bufferio.h"
 #include "mymutex.h"
 #include "mysignal.h"

gframe/data_manager.cpp

@@ -232,4 +232,9 @@ const wchar_t* DataManager::FormatType(int type) {
 		*(p - 1) = 0;
 	return tpBuffer;
 }
+int DataManager::CardReader(int code, void* pData) {
+	dataManager.GetData(code, (CardData*)pData);
+	return 0;
+}
+
 }

gframe/data_manager.h

@@ -40,6 +40,7 @@ public:
 
 	static wchar_t strBuffer[2048];
 	static const wchar_t* unknown_string;
+	static int CardReader(int, void*);
 	
 };
 

gframe/drawing.cpp

@@ -706,6 +706,13 @@ void Game::DrawDeckBd() {
 			const wchar_t* ptype = dataManager.FormatType(ptr->second.type);
 			textFont->draw(ptype, recti(859, 186 + i * 66, 955, 207 + i * 66), 0xff000000, false, false);
 			textFont->draw(ptype, recti(860, 187 + i * 66, 955, 207 + i * 66), 0xffffffff, false, false);
+			textBuffer[0] = 0;
+			if((ptr->second.ot & 0x3) == 1)
+				wcscat(textBuffer, L"[OCG]");
+			else if((ptr->second.ot & 0x3) == 2)
+				wcscat(textBuffer, L"[TCG]");
+			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);
 		}
 	}
 	if(deckBuilder.is_draging) {

gframe/duelclient.cpp

@@ -243,6 +243,10 @@ void DuelClient::HandleSTOCPacketLan(char* data, unsigned int len) {
 		break;
 	}
 	case STOC_GAME_START: {
+		mainGame->gMutex.Lock();
+		mainGame->dField.Clear();
+		mainGame->dInfo.isStarted = true;
+		mainGame->gMutex.Unlock();
 		break;
 	}
 	case STOC_HS_PLAYER_ENTER: {

gframe/game.cpp

@@ -11,7 +11,6 @@
 #ifndef WIN32
 #include <sys/types.h>
 #include <dirent.h>
-#include "replay.h"
 #endif
 
 const unsigned short PRO_VERSION = 0x1020;

gframe/game.h

@@ -2,12 +2,9 @@
 #define GAME_H
 
 #include "config.h"
-#include "client_card.h"
 #include "client_field.h"
 #include "deck_con.h"
 #include "menu_handler.h"
-#include <string>
-#include "../ocgcore/mtrandom.h"
 #include <unordered_map>
 
 namespace ygo {
@@ -80,19 +77,13 @@ public:
 	
 	int LocalPlayer(int player);
 	const wchar_t* LocalName(int local_player);
-/*	bool RefreshMzone(int player, int flag = 0x181fff, int use_cache = 1);
-	bool RefreshSzone(int player, int flag = 0x181fff, int use_cache = 1);
-	bool RefreshHand(int player, int flag = 0x181fff, int use_cache = 1);
-	bool RefreshGrave(int player, int flag = 0x181fff, int use_cache = 1);
-	bool RefreshExtra(int player, int flag = 0x181fff, int use_cache = 1);
-	bool RefreshSingle(int player, int location, int sequence, int flag = 0x181fff);
+	
+/*	
 	void ReplayRefresh(int flag = 0x181fff);
 	void ReplayRefreshHand(int player, int flag = 0x181fff);
 	void ReplayRefreshGrave(int player, int flag = 0x181fff);
 	void ReplayRefreshSingle(int player, int location, int sequence, int flag = 0x181fff);
 
-	static int CardReader(int, void*);
-	static int MessageHandler(long, int);
 	static int EngineThread(void*);
 	static void Proceed(void*);
 	static void Analyze(void*, char*);
@@ -101,12 +92,8 @@ public:
 	static bool SolveMessage(void*, char*, int);
 	static int ReplayThread(void* pd);
 	static bool AnalyzeReplay(void*, char*);*/
-
 	//
-	char msgBuffer[0x1000];
-	char queryBuffer[0x1000];
-
-	mtrandom rnd;
+	
 	Mutex gMutex;
 	Mutex gBuffer;
 	Signal frameSignal;

gframe/message.cpp

@@ -3,7 +3,7 @@
 #include "../ocgcore/card.h"
 #include "../ocgcore/duel.h"
 #include "../ocgcore/field.h"
-#include <sys/time.h>
+
 #include <algorithm>
 
 #define MSG_REPLAY 		0xf0
@@ -18,90 +18,6 @@ const wchar_t* Game::LocalName(int local_player) {
 	return local_player == 0 ? dInfo.hostname : dInfo.clientname;
 }
 /*
-bool Game::RefreshMzone(int player, int flag, int use_cache) {
-	int len = query_field_card(dInfo.pDuel, player, LOCATION_MZONE, flag, (unsigned char*)queryBuffer, use_cache);
-	char* pbuf = netManager.send_buffer_ptr;
-	NetManager::WriteInt8(pbuf, MSG_UPDATE_DATA);
-	NetManager::WriteInt8(pbuf, player);
-	NetManager::WriteInt8(pbuf, LOCATION_MZONE);
-	memcpy(pbuf, queryBuffer, len);
-	if(!SendGameMessage(player, netManager.send_buffer_ptr, len + 3))
-		return false;
-	pbuf = netManager.send_buffer_ptr + 3;
-	for (int i = 0; i < 5; ++i) {
-		int clen = NetManager::ReadInt32(pbuf);
-		if (clen == 4)
-			continue;
-		if (pbuf[11] & POS_FACEDOWN)
-			memset(pbuf, 0, clen - 4);
-		pbuf += clen - 4;
-	}
-	return SendGameMessage(1 - player, netManager.send_buffer_ptr, len + 3);
-}
-bool Game::RefreshSzone(int player, int flag, int use_cache) {
-	int len = query_field_card(dInfo.pDuel, player, LOCATION_SZONE, flag, (unsigned char*)queryBuffer, use_cache);
-	char* pbuf = netManager.send_buffer_ptr;
-	NetManager::WriteInt8(pbuf, MSG_UPDATE_DATA);
-	NetManager::WriteInt8(pbuf, player);
-	NetManager::WriteInt8(pbuf, LOCATION_SZONE);
-	memcpy(pbuf, queryBuffer, len);
-	if(!SendGameMessage(player, netManager.send_buffer_ptr, len + 3))
-		return false;
-	pbuf = netManager.send_buffer_ptr + 3;
-	for (int i = 0; i < 6; ++i) {
-		int clen = NetManager::ReadInt32(pbuf);
-		if (clen == 4)
-			continue;
-		if (pbuf[11] & POS_FACEDOWN)
-			memset(pbuf, 0, clen - 4);
-		pbuf += clen - 4;
-	}
-	return SendGameMessage(1 - player, netManager.send_buffer_ptr, len + 3);
-}
-bool Game::RefreshHand(int player, int flag, int use_cache) {
-	int len = query_field_card(dInfo.pDuel, player, LOCATION_HAND, flag, (unsigned char*)queryBuffer, use_cache);
-	char* pbuf = netManager.send_buffer_ptr;
-	NetManager::WriteInt8(pbuf, MSG_UPDATE_DATA);
-	NetManager::WriteInt8(pbuf, player);
-	NetManager::WriteInt8(pbuf, LOCATION_HAND);
-	memcpy(pbuf, queryBuffer, len);
-	return SendGameMessage(player, netManager.send_buffer_ptr, len + 3);
-}
-bool Game::RefreshGrave(int player, int flag, int use_cache) {
-	int len = query_field_card(dInfo.pDuel, player, LOCATION_GRAVE, flag, (unsigned char*)queryBuffer, use_cache);
-	char* pbuf = netManager.send_buffer_ptr;
-	NetManager::WriteInt8(pbuf, MSG_UPDATE_DATA);
-	NetManager::WriteInt8(pbuf, player);
-	NetManager::WriteInt8(pbuf, LOCATION_GRAVE);
-	memcpy(pbuf, queryBuffer, len);
-	return SendGameMessage(0, netManager.send_buffer_ptr, len + 3)
-	       && SendGameMessage(1, netManager.send_buffer_ptr, len + 3);
-}
-bool Game::RefreshExtra(int player, int flag, int use_cache) {
-	int len = query_field_card(dInfo.pDuel, player, LOCATION_EXTRA, flag, (unsigned char*)queryBuffer, use_cache);
-	char* pbuf = netManager.send_buffer_ptr;
-	NetManager::WriteInt8(pbuf, MSG_UPDATE_DATA);
-	NetManager::WriteInt8(pbuf, player);
-	NetManager::WriteInt8(pbuf, LOCATION_EXTRA);
-	memcpy(pbuf, queryBuffer, len);
-	return SendGameMessage(player, netManager.send_buffer_ptr, len + 3);
-}
-bool Game::RefreshSingle(int player, int location, int sequence, int flag) {
-	int len = query_card(dInfo.pDuel, player, location, sequence, flag, (unsigned char*)queryBuffer, 0);
-	char* pbuf = netManager.send_buffer_ptr;
-	if(location == LOCATION_REMOVED && (queryBuffer[15] & POS_FACEDOWN))
-		return true;
-	NetManager::WriteInt8(pbuf, MSG_UPDATE_CARD);
-	NetManager::WriteInt8(pbuf, player);
-	NetManager::WriteInt8(pbuf, location);
-	NetManager::WriteInt8(pbuf, sequence);
-	memcpy(pbuf, queryBuffer, len);
-	if(!SendGameMessage(player, netManager.send_buffer_ptr, len + 4))
-		return false;
-	if ((location & 0x90) || ((location & 0x2c) && (queryBuffer[15] & POS_FACEUP)))
-		return SendGameMessage(1 - player, netManager.send_buffer_ptr, len + 4);
-	return true;
-}
 void Game::ReplayRefresh(int flag) {
 	int len = query_field_card(dInfo.pDuel, 0, LOCATION_MZONE, flag, (unsigned char*)queryBuffer, 0);
 	dField.UpdateFieldCard(mainGame->LocalPlayer(0), LOCATION_MZONE, queryBuffer);
@@ -128,18 +44,6 @@ void Game::ReplayRefreshSingle(int player, int location, int sequence, int flag)
 	int len = query_card(dInfo.pDuel, player, location, sequence, flag, (unsigned char*)queryBuffer, 0);
 	dField.UpdateCard(mainGame->LocalPlayer(player), location, sequence, queryBuffer);
 }
-int Game::CardReader(int code, void* pData) {
-	mainGame->dataManager.GetData(code, (CardData*)pData);
-	return 0;
-}
-int Game::MessageHandler(long fduel, int type) {
-	char msgbuf[256];
-	get_log_message(fduel, (byte*)msgbuf);
-	FILE* fp = fopen("error.log", "at+");
-	fprintf(fp, "[Script error:] %s\n", msgbuf);
-	fclose(fp);
-	return 0;
-}
 int Game::EngineThread(void* pd) {
 	DuelInfo* pdInfo = (DuelInfo*)pd;
 	ReplayHeader rh;

gframe/netserver.cpp

@@ -37,6 +37,9 @@ void NetServer::StopServer() {
 		return;
 	event_base_loopexit(net_evbase, NULL);
 }
+void NetServer::StopListen() {
+	evconnlistener_disable(listener);
+}
 void NetServer::ServerAccept(evconnlistener* listener, evutil_socket_t fd, sockaddr* address, int socklen, void* ctx) {
 	bufferevent* bev = bufferevent_socket_new(net_evbase, fd, BEV_OPT_CLOSE_ON_FREE);
 	DuelPlayer dp;
@@ -187,7 +190,7 @@ void NetServer::HandleCTOSPacket(DuelPlayer* dp, char* data, unsigned int len) {
 	case CTOS_HS_START: {
 		if(!duel_mode || duel_mode->pduel)
 			break;
-		evconnlistener_disable(listener);
+		duel_mode->StartDuel(dp);
 		break;
 	}
 	}

gframe/netserver.h

@@ -22,6 +22,7 @@ private:
 public:
 	static bool StartServer(unsigned short port);
 	static void StopServer();
+	static void StopListen();
 	static void ServerAccept(evconnlistener* listener, evutil_socket_t fd, sockaddr* address, int socklen, void* ctx);
 	static void ServerAcceptError(evconnlistener *listener, void* ctx);
 	static void ServerEchoRead(bufferevent* bev, void* ctx);

gframe/network.h

@@ -112,7 +112,7 @@ public:
 	virtual void StartDuel(DuelPlayer* dp) = 0;
 	virtual void Process() = 0;
 	virtual void EndDuel() = 0;
-
+	
 public:
 	DuelPlayer* players[6];
 	bool ready[6];

gframe/single_duel.cpp

 #include "single_duel.h"
 #include "netserver.h"
+#include "../ocgcore/ocgapi.h"
+#include "../ocgcore/card.h"
+#include "../ocgcore/duel.h"
+#include "../ocgcore/field.h"
 
 namespace ygo {
 
@@ -217,10 +221,109 @@ void SingleDuel::UpdateDeck(DuelPlayer* dp, void* pdata) {
 void SingleDuel::StartDuel(DuelPlayer* dp) {
 	if(dp != host_player)
 		return;
+	if(!ready[0] || !ready[1])
+		return;
+	NetServer::StopListen();
 }
 void SingleDuel::Process() {
 }
 void SingleDuel::EndDuel() {
 }
+void SingleDuel::RefreshMzone(int player, int flag, int use_cache) {
+	char query_buffer[0x1000];
+	char* qbuf = query_buffer;
+	BufferIO::WriteInt8(qbuf, MSG_UPDATE_DATA);
+	BufferIO::WriteInt8(qbuf, player);
+	BufferIO::WriteInt8(qbuf, LOCATION_MZONE);
+	int len = query_field_card(pduel, player, LOCATION_MZONE, flag, (unsigned char*)qbuf, use_cache);
+	NetServer::SendBufferToPlayer(players[player_mapping[player]], STOC_GAME_MSG, query_buffer, len + 3);
+	for (int i = 0; i < 5; ++i) {
+		int clen = BufferIO::ReadInt32(qbuf);
+		if (clen == 4)
+			continue;
+		if (qbuf[11] & POS_FACEDOWN)
+			memset(qbuf, 0, clen - 4);
+		qbuf += clen - 4;
+	}
+	NetServer::SendBufferToPlayer(players[player_mapping[1 - player]], STOC_GAME_MSG, query_buffer, len + 3);
+	for(auto pit = observers.begin(); pit != observers.end(); ++pit)
+		NetServer::ReSendToPlayer(*pit);
+}
+void SingleDuel::RefreshSzone(int player, int flag, int use_cache) {
+	char query_buffer[0x1000];
+	char* qbuf = query_buffer;
+	BufferIO::WriteInt8(qbuf, MSG_UPDATE_DATA);
+	BufferIO::WriteInt8(qbuf, player);
+	BufferIO::WriteInt8(qbuf, LOCATION_SZONE);
+	int len = query_field_card(pduel, player, LOCATION_SZONE, flag, (unsigned char*)qbuf, use_cache);
+	NetServer::SendBufferToPlayer(players[player_mapping[player]], STOC_GAME_MSG, query_buffer, len + 3);
+	for (int i = 0; i < 6; ++i) {
+		int clen = BufferIO::ReadInt32(qbuf);
+		if (clen == 4)
+			continue;
+		if (qbuf[11] & POS_FACEDOWN)
+			memset(qbuf, 0, clen - 4);
+		qbuf += clen - 4;
+	}
+	NetServer::SendBufferToPlayer(players[player_mapping[1 - player]], STOC_GAME_MSG, query_buffer, len + 3);
+	for(auto pit = observers.begin(); pit != observers.end(); ++pit)
+		NetServer::ReSendToPlayer(*pit);
+}
+void SingleDuel::RefreshHand(int player, int flag, int use_cache) {
+	char query_buffer[0x1000];
+	char* qbuf = query_buffer;
+	BufferIO::WriteInt8(qbuf, MSG_UPDATE_DATA);
+	BufferIO::WriteInt8(qbuf, player);
+	BufferIO::WriteInt8(qbuf, LOCATION_HAND);
+	int len = query_field_card(pduel, player, LOCATION_HAND, flag, (unsigned char*)qbuf, use_cache);
+	NetServer::SendBufferToPlayer(players[player_mapping[player]], STOC_GAME_MSG, query_buffer, len + 3);
+}
+void SingleDuel::RefreshGrave(int player, int flag, int use_cache) {
+	char query_buffer[0x1000];
+	char* qbuf = query_buffer;
+	BufferIO::WriteInt8(qbuf, MSG_UPDATE_DATA);
+	BufferIO::WriteInt8(qbuf, player);
+	BufferIO::WriteInt8(qbuf, LOCATION_GRAVE);
+	int len = query_field_card(pduel, player, LOCATION_GRAVE, flag, (unsigned char*)qbuf, use_cache);
+	NetServer::SendBufferToPlayer(players[0], STOC_GAME_MSG, query_buffer, len + 3);
+	NetServer::ReSendToPlayer(players[1]);
+	for(auto pit = observers.begin(); pit != observers.end(); ++pit)
+		NetServer::ReSendToPlayer(*pit);
+}
+void SingleDuel::RefreshExtra(int player, int flag, int use_cache) {
+	char query_buffer[0x1000];
+	char* qbuf = query_buffer;
+	BufferIO::WriteInt8(qbuf, MSG_UPDATE_DATA);
+	BufferIO::WriteInt8(qbuf, player);
+	BufferIO::WriteInt8(qbuf, LOCATION_EXTRA);
+	int len = query_field_card(pduel, player, LOCATION_EXTRA, flag, (unsigned char*)qbuf, use_cache);
+	NetServer::SendBufferToPlayer(players[player_mapping[player]], STOC_GAME_MSG, query_buffer, len + 3);
+}
+void SingleDuel::RefreshSingle(int player, int location, int sequence, int flag) {
+	char query_buffer[0x1000];
+	char* qbuf = query_buffer;
+	BufferIO::WriteInt8(qbuf, MSG_UPDATE_CARD);
+	BufferIO::WriteInt8(qbuf, player);
+	BufferIO::WriteInt8(qbuf, location);
+	BufferIO::WriteInt8(qbuf, sequence);
+	int len = query_card(pduel, player, location, sequence, flag, (unsigned char*)qbuf, 0);
+	if(location == LOCATION_REMOVED && (qbuf[15] & POS_FACEDOWN))
+		return;
+	NetServer::SendBufferToPlayer(players[player_mapping[player]], STOC_GAME_MSG, query_buffer, len + 4);
+	if ((location & 0x90) || ((location & 0x2c) && (qbuf[15] & POS_FACEUP))) {
+		NetServer::ReSendToPlayer(players[player_mapping[1 - player]]);
+		for(auto pit = observers.begin(); pit != observers.end(); ++pit)
+			NetServer::ReSendToPlayer(*pit);
+	}
+}
+int SingleDuel::MessageHandler(long fduel, int type) {
+	char msgbuf[1024];
+	get_log_message(fduel, (byte*)msgbuf);
+	FILE* fp = fopen("error.log", "at+");
+	msgbuf[1023] = 0;
+	fprintf(fp, "[Script error:] %s\n", msgbuf);
+	fclose(fp);
+	return 0;
+}
 
 }

gframe/single_duel.h

@@ -18,6 +18,17 @@ public:
 	virtual void StartDuel(DuelPlayer* dp);
 	virtual void Process();
 	virtual void EndDuel();
+	
+	void RefreshMzone(int player, int flag = 0x181fff, int use_cache = 1);
+	void RefreshSzone(int player, int flag = 0x181fff, int use_cache = 1);
+	void RefreshHand(int player, int flag = 0x181fff, int use_cache = 1);
+	void RefreshGrave(int player, int flag = 0x181fff, int use_cache = 1);
+	void RefreshExtra(int player, int flag = 0x181fff, int use_cache = 1);
+	void RefreshSingle(int player, int location, int sequence, int flag = 0x181fff);
+	
+	static int MessageHandler(long fduel, int type);
+protected:
+	unsigned char player_mapping[2];
 };
 
 }