Added new packet type as end of game notification. Now displaying dialogs at end of game, to start a new game. Server errors are displayed.

src/net/clientcallback.h

@@ -40,6 +40,7 @@ public:
 	virtual void SignalNetClientPlayerLeft(const std::string &playerName) = 0;
 
 	virtual void SignalNetClientChatMsg(const std::string &playerName, const std::string &msg) = 0;
+	virtual void SignalNetClientWaitDialog() = 0;
 };
 
 #endif

src/net/common/clientstate.cpp

@@ -568,6 +568,12 @@ ClientStateWaitHand::InternalProcess(ClientThread &client, boost::shared_ptr<Net
 
 		retVal = MSG_NET_GAME_CLIENT_HAND_START;
 	}
+	else if (packet->ToNetPacketEndOfGame())
+	{
+		client.GetCallback().SignalNetClientWaitDialog();
+		client.SetState(ClientStateWaitGame::Instance());
+		retVal = MSG_NET_GAME_CLIENT_END;
+	}
 
 	return MSG_SOCK_INTERNAL_PENDING;
 }
@@ -831,7 +837,7 @@ ClientStateRunHand::InternalProcess(ClientThread &client, boost::shared_ptr<NetP
 
 			// Wait for next Hand.
 			client.SetState(ClientStateWaitHand::Instance());
-			retVal = MSG_NET_GAME_SERVER_HAND_END;
+			retVal = MSG_NET_GAME_CLIENT_HAND_END;
 		}
 	}
 

src/net/common/netpacket.cpp

@@ -43,6 +43,7 @@ using namespace std;
 #define NET_TYPE_ALL_IN_SHOW_CARDS				0x000E
 #define NET_TYPE_END_OF_HAND_SHOW_CARDS			0x000F
 #define NET_TYPE_END_OF_HAND_HIDE_CARDS			0x0010
+#define NET_TYPE_END_OF_GAME					0x0011
 
 #define NET_TYPE_SEND_CHAT_TEXT					0x0200
 #define NET_TYPE_CHAT_TEXT						0x0201
@@ -244,6 +245,13 @@ struct GCC_PACKED NetPacketEndOfHandHideCardsData
 	u_int32_t			playerMoney;
 };
 
+struct GCC_PACKED NetPacketEndOfGameData
+{
+	NetPacketHeader		head;
+	u_int16_t			winnerPlayerId;
+	u_int16_t			reserved;
+};
+
 struct GCC_PACKED NetPacketSendChatTextData
 {
 	NetPacketHeader		head;
@@ -340,6 +348,9 @@ NetPacket::Create(char *data, unsigned &dataSize)
 				case NET_TYPE_END_OF_HAND_HIDE_CARDS:
 					tmpPacket = boost::shared_ptr<NetPacket>(new NetPacketEndOfHandHideCards);
 					break;
+				case NET_TYPE_END_OF_GAME:
+					tmpPacket = boost::shared_ptr<NetPacket>(new NetPacketEndOfGame);
+					break;
 				case NET_TYPE_SEND_CHAT_TEXT:
 					tmpPacket = boost::shared_ptr<NetPacket>(new NetPacketSendChatText);
 					break;
@@ -526,6 +537,12 @@ NetPacket::ToNetPacketEndOfHandHideCards() const
 	return NULL;
 }
 
+const NetPacketEndOfGame *
+NetPacket::ToNetPacketEndOfGame() const
+{
+	return NULL;
+}
+
 const NetPacketSendChatText *
 NetPacket::ToNetPacketSendChatText() const
 {
@@ -1873,6 +1890,67 @@ NetPacketEndOfHandHideCards::Check(const NetPacketHeader* data) const
 
 //-----------------------------------------------------------------------------
 
+NetPacketEndOfGame::NetPacketEndOfGame()
+: NetPacket(NET_TYPE_END_OF_GAME, sizeof(NetPacketEndOfGameData))
+{
+}
+
+NetPacketEndOfGame::~NetPacketEndOfGame()
+{
+}
+
+boost::shared_ptr<NetPacket>
+NetPacketEndOfGame::Clone() const
+{
+	boost::shared_ptr<NetPacket> newPacket(new NetPacketEndOfGame);
+	try
+	{
+		newPacket->SetRawData(GetRawData());
+	} catch (const NetException &)
+	{
+		// Need to return the new packet anyway.
+	}
+	return newPacket;
+}
+
+void
+NetPacketEndOfGame::SetData(const NetPacketEndOfGame::Data &inData)
+{
+	NetPacketEndOfGameData *tmpData = (NetPacketEndOfGameData *)GetRawData();
+	assert(tmpData);
+
+	tmpData->winnerPlayerId	= htons(inData.winnerPlayerId);
+}
+
+void
+NetPacketEndOfGame::GetData(NetPacketEndOfGame::Data &outData) const
+{
+	NetPacketEndOfGameData *tmpData = (NetPacketEndOfGameData *)GetRawData();
+	assert(tmpData);
+
+	outData.winnerPlayerId	= ntohs(tmpData->winnerPlayerId);
+}
+
+const NetPacketEndOfGame *
+NetPacketEndOfGame::ToNetPacketEndOfGame() const
+{
+	return this;
+}
+
+void
+NetPacketEndOfGame::Check(const NetPacketHeader* data) const
+{
+	assert(data);
+
+	u_int16_t dataLen = ntohs(data->length);
+	if (dataLen != sizeof(NetPacketEndOfGameData))
+	{
+		throw NetException(ERR_SOCK_INVALID_PACKET, 0);
+	}
+}
+
+//-----------------------------------------------------------------------------
+
 NetPacketSendChatText::NetPacketSendChatText()
 : NetPacket(NET_TYPE_SEND_CHAT_TEXT, sizeof(NetPacketSendChatTextData))
 {

src/net/common/serverrecvstate.cpp

@@ -34,6 +34,7 @@ using namespace std;
 
 #define SERVER_WAIT_TIMEOUT_MSEC				50
 #define SERVER_DELAY_NEXT_HAND_SEC				10
+#define SERVER_DELAY_NEXT_GAME_SEC				10
 #define SERVER_DEAL_FLOP_CARDS_DELAY_SEC		5
 #define SERVER_DEAL_TURN_CARD_DELAY_SEC			2
 #define SERVER_DEAL_RIVER_CARD_DELAY_SEC		2
@@ -642,11 +643,16 @@ ServerRecvStateStartRound::Process(ServerRecvThread &server)
 				if (curGame.getCurrentHand()->getPlayerArray()[i]->getMyCash() > 0) 
 					playersPositiveCashCounter++;
 			}
+			assert(playersPositiveCashCounter);
 			if (playersPositiveCashCounter == 1)
-				server.SetState(ServerRecvStateFinal::Instance()); // TODO
+			{
+				// View a dialog for a new game - delayed.
+				server.SetState(ServerRecvStateNextGameDelay::Instance());
+				retVal = MSG_NET_GAME_SERVER_END;
+			}
 			else
 			{
-				server.SetState(ServerRecvStateNextHand::Instance());
+				server.SetState(ServerRecvStateNextHandDelay::Instance());
 				retVal = MSG_NET_GAME_SERVER_HAND_END;
 			}
 		}
@@ -922,10 +928,9 @@ ServerRecvStateShowCardsDelay::Process(ServerRecvThread &server)
 {
 	int retVal = ServerRecvStateReceiving::Process(server);
 
-	Game &curGame = server.GetGame();
-
 	if (GetTimer().elapsed().seconds() >= SERVER_SHOW_CARDS_DELAY_SEC)
 	{
+		Game &curGame = server.GetGame();
 		SendNewRoundCards(server, curGame, curGame.getCurrentHand()->getActualRound());
 
 		server.SetState(ServerRecvStateDealCardsDelay::Instance());
@@ -943,23 +948,23 @@ ServerRecvStateShowCardsDelay::InternalProcess(ServerRecvThread &server, Session
 
 //-----------------------------------------------------------------------------
 
-ServerRecvStateNextHand &
-ServerRecvStateNextHand::Instance()
+ServerRecvStateNextHandDelay &
+ServerRecvStateNextHandDelay::Instance()
 {
-	static ServerRecvStateNextHand state;
+	static ServerRecvStateNextHandDelay state;
 	return state;
 }
 
-ServerRecvStateNextHand::ServerRecvStateNextHand()
+ServerRecvStateNextHandDelay::ServerRecvStateNextHandDelay()
 {
 }
 
-ServerRecvStateNextHand::~ServerRecvStateNextHand()
+ServerRecvStateNextHandDelay::~ServerRecvStateNextHandDelay()
 {
 }
 
 int
-ServerRecvStateNextHand::Process(ServerRecvThread &server)
+ServerRecvStateNextHandDelay::Process(ServerRecvThread &server)
 {
 	int retVal = ServerRecvStateReceiving::Process(server);
 
@@ -970,7 +975,65 @@ ServerRecvStateNextHand::Process(ServerRecvThread &server)
 }
 
 int
-ServerRecvStateNextHand::InternalProcess(ServerRecvThread &server, SessionWrapper session, boost::shared_ptr<NetPacket> packet)
+ServerRecvStateNextHandDelay::InternalProcess(ServerRecvThread &server, SessionWrapper session, boost::shared_ptr<NetPacket> packet)
+{
+	return MSG_SOCK_INTERNAL_PENDING;
+}
+
+//-----------------------------------------------------------------------------
+
+ServerRecvStateNextGameDelay &
+ServerRecvStateNextGameDelay::Instance()
+{
+	static ServerRecvStateNextGameDelay state;
+	return state;
+}
+
+ServerRecvStateNextGameDelay::ServerRecvStateNextGameDelay()
+{
+}
+
+ServerRecvStateNextGameDelay::~ServerRecvStateNextGameDelay()
+{
+}
+
+int
+ServerRecvStateNextGameDelay::Process(ServerRecvThread &server)
+{
+	int retVal = ServerRecvStateReceiving::Process(server);
+
+	if (GetTimer().elapsed().seconds() >= SERVER_DELAY_NEXT_GAME_SEC)
+	{
+		Game &curGame = server.GetGame();
+		// The game has ended. Notify all clients.
+		PlayerInterface *winnerPlayer = NULL;
+		for (int i = 0; i < curGame.getStartQuantityPlayers(); i++)
+		{
+			winnerPlayer = curGame.getCurrentHand()->getPlayerArray()[i];
+			if (winnerPlayer->getMyCash() > 0)
+				break;
+		}
+
+		boost::shared_ptr<NetPacket> endGame(new NetPacketEndOfGame);
+		NetPacketEndOfGame::Data endGameData;
+		endGameData.winnerPlayerId = winnerPlayer->getMyUniqueID();
+		static_cast<NetPacketEndOfGame *>(endGame.get())->SetData(endGameData);
+
+		server.SendToAllPlayers(endGame);
+
+		// Switch back to the GUI, wait for the start of a new game.
+		// Luckily, the names are still in the GUI dialog.
+		// We just need to show the proper dialog, and people can
+		// join or leave as usual.
+		server.GetCallback().SignalNetServerStartDialog();
+		server.SetState(ServerRecvStateInit::Instance());
+	}
+
+	return retVal;
+}
+
+int
+ServerRecvStateNextGameDelay::InternalProcess(ServerRecvThread &server, SessionWrapper session, boost::shared_ptr<NetPacket> packet)
 {
 	return MSG_SOCK_INTERNAL_PENDING;
 }

src/net/common/serverrecvthread.cpp

@@ -119,9 +119,9 @@ ServerRecvThread::Main()
 			// Close sessions.
 			CloseSessionLoop();
 		}
-	} catch (const NetException &)
+	} catch (const NetException &e)
 	{
-		// TODO
+		GetCallback().SignalNetServerError(e.GetErrorId(), e.GetOsErrorCode());
 	}
 	GetSender().SignalTermination();
 	GetSender().Join(SENDER_THREAD_TERMINATE_TIMEOUT);

src/net/netpacket.h

@@ -56,6 +56,7 @@ class NetPacketDealRiverCard;
 class NetPacketAllInShowCards;
 class NetPacketEndOfHandShowCards;
 class NetPacketEndOfHandHideCards;
+class NetPacketEndOfGame;
 class NetPacketSendChatText;
 class NetPacketChatText;
 class NetPacketError;
@@ -93,6 +94,7 @@ public:
 	virtual const NetPacketAllInShowCards *ToNetPacketAllInShowCards() const;
 	virtual const NetPacketEndOfHandShowCards *ToNetPacketEndOfHandShowCards() const;
 	virtual const NetPacketEndOfHandHideCards *ToNetPacketEndOfHandHideCards() const;
+	virtual const NetPacketEndOfGame *ToNetPacketEndOfGame() const;
 	virtual const NetPacketSendChatText *ToNetPacketSendChatText() const;
 	virtual const NetPacketChatText *ToNetPacketChatText() const;
 	virtual const NetPacketError *ToNetPacketError() const;
@@ -216,7 +218,6 @@ public:
 	struct Data
 	{
 		StartData	startData;
-		u_int16_t	reserved;
 	};
 
 	NetPacketGameStart();
@@ -520,6 +521,29 @@ protected:
 	virtual void Check(const NetPacketHeader* data) const;
 };
 
+class NetPacketEndOfGame : public NetPacket
+{
+public:
+	struct Data
+	{
+		u_int16_t	winnerPlayerId;
+	};
+
+	NetPacketEndOfGame();
+	virtual ~NetPacketEndOfGame();
+
+	virtual boost::shared_ptr<NetPacket> Clone() const;
+
+	void SetData(const Data &inData);
+	void GetData(Data &outData) const;
+
+	virtual const NetPacketEndOfGame *ToNetPacketEndOfGame() const;
+
+protected:
+
+	virtual void Check(const NetPacketHeader* data) const;
+};
+
 class NetPacketSendChatText : public NetPacket
 {
 public:

src/net/servercallback.h

@@ -33,6 +33,8 @@ public:
 
 	virtual void SignalNetServerPlayerJoined(const std::string &playerName) = 0;
 	virtual void SignalNetServerPlayerLeft(const std::string &playerName) = 0;
+
+	virtual void SignalNetServerStartDialog() = 0;
 };
 
 #endif

src/net/serverrecvstate.h

@@ -253,13 +253,13 @@ protected:
 };
 
 // State: Delay before next hand.
-class ServerRecvStateNextHand : public ServerRecvStateReceiving, public ServerRecvStateRunning, public ServerRecvStateTimer
+class ServerRecvStateNextHandDelay : public ServerRecvStateReceiving, public ServerRecvStateRunning, public ServerRecvStateTimer
 {
 public:
 	// Access the state singleton.
-	static ServerRecvStateNextHand &Instance();
+	static ServerRecvStateNextHandDelay &Instance();
 
-	virtual ~ServerRecvStateNextHand();
+	virtual ~ServerRecvStateNextHandDelay();
 
 	// Overwrite default processing
 	virtual int Process(ServerRecvThread &server);
@@ -267,11 +267,30 @@ public:
 protected:
 
 	// Protected constructor - this is a singleton.
-	ServerRecvStateNextHand();
+	ServerRecvStateNextHandDelay();
 
 	virtual int InternalProcess(ServerRecvThread &server, SessionWrapper session, boost::shared_ptr<NetPacket> packet);
 };
 
+// State: Delay before next hand.
+class ServerRecvStateNextGameDelay : public ServerRecvStateReceiving, public ServerRecvStateRunning, public ServerRecvStateTimer
+{
+public:
+	// Access the state singleton.
+	static ServerRecvStateNextGameDelay &Instance();
+
+	virtual ~ServerRecvStateNextGameDelay();
+
+	// Overwrite default processing
+	virtual int Process(ServerRecvThread &server);
+
+protected:
+
+	// Protected constructor - this is a singleton.
+	ServerRecvStateNextGameDelay();
+
+	virtual int InternalProcess(ServerRecvThread &server, SessionWrapper session, boost::shared_ptr<NetPacket> packet);
+};
 
 // State: Final.
 class ServerRecvStateFinal : public ServerRecvStateReceiving, public ServerRecvStateRunning

src/net/serverrecvthread.h

@@ -173,7 +173,8 @@ friend class ServerRecvStateStartRound;
 friend class ServerRecvStateWaitPlayerAction;
 friend class ServerRecvStateShowCardsDelay;
 friend class ServerRecvStateDealCardsDelay;
-friend class ServerRecvStateNextHand;
+friend class ServerRecvStateNextHandDelay;
+friend class ServerRecvStateNextGameDelay;
 };
 
 #endif

src/net/socket_msg.h

@@ -69,14 +69,17 @@
 
 // The following messages are game messages.
 #define MSG_NET_GAME_CLIENT_START		5
-#define MSG_NET_GAME_SERVER_START		6
 #define MSG_NET_GAME_CLIENT_HAND_START	7
 #define MSG_NET_GAME_CLIENT_HAND_END	8
-#define MSG_NET_GAME_SERVER_HAND_START	9
-#define MSG_NET_GAME_SERVER_HAND_END	10
-#define MSG_NET_GAME_SERVER_ROUND		11
-#define MSG_NET_GAME_SERVER_ACTION		12
-#define MSG_NET_GAME_SERVER_CARDS_DELAY	13
+#define MSG_NET_GAME_CLIENT_END			9
+
+#define MSG_NET_GAME_SERVER_START		10
+#define MSG_NET_GAME_SERVER_HAND_START	11
+#define MSG_NET_GAME_SERVER_HAND_END	12
+#define MSG_NET_GAME_SERVER_ROUND		13
+#define MSG_NET_GAME_SERVER_ACTION		14
+#define MSG_NET_GAME_SERVER_CARDS_DELAY	15
+#define MSG_NET_GAME_SERVER_END			16
 
 #endif