sco/pokerth
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Server Umbau zwischenversion.

Browse Source
This commit is contained in:
lotodore
2014-07-13 13:48:01 +02:00
parent 171d05fdaf
commit 7eaa23b049
12 changed files with 33280 additions and 29816 deletions
Download Patch File Download Diff File Expand all files Collapse all files
gocode/src/gameserver/dispatcher.go
+19 -10
View File
@@ -32,21 +32,23 @@ package gameserver
import (
"log"
"pokerth"
"sync/atomic"
)
type Dispatcher struct {
handler PacketHandler
receiver chan SessionPacket
receiver chan SessionPokerTHMessage
authChan chan SessionAuthMessage
lobbyChan chan SessionLobbyMessage
lastSessionId uint32
}
func NewDispatcher(handler PacketHandler) *Dispatcher {
return &Dispatcher{handler, make(chan SessionPacket, RECV_DISPATCHER_NUM_PACKET_BUF), 0}
func NewDispatcher(authChan chan SessionAuthMessage, lobbyChan chan SessionLobbyMessage) *Dispatcher {
return &Dispatcher{make(chan SessionPokerTHMessage, RECV_DISPATCHER_NUM_PACKET_BUF), authChan, lobbyChan, 0}
}
func (d *Dispatcher) GetReceiver() *chan SessionPacket {
return &d.receiver
func (d *Dispatcher) GetReceiver() chan SessionPokerTHMessage {
return d.receiver
}
func (d *Dispatcher) GetNextSessionId() uint32 {
@@ -54,12 +56,19 @@ func (d *Dispatcher) GetNextSessionId() uint32 {
}
func (d *Dispatcher) Run() {
var sessionPacket SessionPacket
var sessionMsg SessionPokerTHMessage
for {
select {
case sessionPacket = <-d.receiver:
log.Printf("Packet in dispatcher session %d type %d", sessionPacket.session.id, sessionPacket.packet.GetMessageType())
d.handler.HandlePacket(sessionPacket.session, sessionPacket.packet)
case sessionMsg = <-d.receiver:
log.Printf("Packet in dispatcher session %d type %d", sessionMsg.session.id, sessionMsg.packet.GetMessageType())
switch sessionMsg.packet.GetMessageType() {
case pokerth.PokerTHMessage_Type_AuthMessage:
d.authChan <- SessionAuthMessage{sessionMsg.session, sessionMsg.packet.GetAuthMessage()}
case pokerth.PokerTHMessage_Type_LobbyMessage:
d.lobbyChan <- SessionLobbyMessage{sessionMsg.session, sessionMsg.packet.GetLobbyMessage()}
default:
log.Print("Unknown packet type")
}
}
}
}
gocode/src/gameserver/lobby.go
+14 -7
View File
@@ -37,16 +37,17 @@ import (
"pokerth"
)
type PacketHandler interface {
HandlePacket(session *Session, packet *pokerth.PokerTHMessage)
}
type Lobby struct {
receiver chan SessionLobbyMessage
sessions *list.List
}
func NewLobby() *Lobby {
return &Lobby{list.New()}
return &Lobby{make(chan SessionLobbyMessage, RECV_LOBBY_NUM_PACKET_BUF), list.New()}
}
func (l *Lobby) GetReceiver() chan SessionLobbyMessage {
return l.receiver
}
func (l *Lobby) AddSession(session *Session) {
@@ -71,6 +72,12 @@ func (l *Lobby) AddSession(session *Session) {
session.sender <- announce
}
func (l *Lobby) HandlePacket(session *Session, packet *pokerth.PokerTHMessage) {
log.Print("packet")
func (l *Lobby) Run() {
var lobbyMsg SessionLobbyMessage
for {
select {
case lobbyMsg = <-l.receiver:
log.Printf("Lobby packet %d", lobbyMsg.packet.GetMessageType())
}
}
}
gocode/src/gameserver/session.go
+20 -4
View File
@@ -47,21 +47,37 @@ const RECV_BUF_SIZE uint32 = 4 * MAX_PACKET_SIZE
const SEND_BUF_SIZE uint32 = 2 * MAX_PACKET_SIZE
const SEND_NUM_PACKET_BUF = 2048
const RECV_DISPATCHER_NUM_PACKET_BUF = 2048
const RECV_LOBBY_NUM_PACKET_BUF = 2048
type Session struct {
id uint32
PacketSerializer
Connection net.Conn
sender chan *pokerth.PokerTHMessage
receiver *chan SessionPacket
receiver chan SessionPokerTHMessage
}
type SessionPacket struct {
type SessionPokerTHMessage struct {
session *Session
packet *pokerth.PokerTHMessage
}
func NewSession(id uint32, serializer PacketSerializer, conn net.Conn, receiver *chan SessionPacket) *Session {
type SessionAuthMessage struct {
session *Session
packet *pokerth.AuthMessage
}
type SessionLobbyMessage struct {
session *Session
packet *pokerth.LobbyMessage
}
type SessionGameMessage struct {
session *Session
packet *pokerth.GameMessage
}
func NewSession(id uint32, serializer PacketSerializer, conn net.Conn, receiver chan SessionPokerTHMessage) *Session {
return &Session{id, serializer, conn, make(chan *pokerth.PokerTHMessage, SEND_NUM_PACKET_BUF), receiver}
}
@@ -93,7 +109,7 @@ func (s *Session) handleReceive() {
log.Print("Invalid packet")
} else {
log.Printf("Packet in: %d\n", packet.GetMessageType())
*s.receiver <- SessionPacket{s, packet}
s.receiver <- SessionPokerTHMessage{s, packet}
remainingBytes := bufPos - bytesScanned
if remainingBytes > 0 {
copy(buf[0:], buf[bytesScanned:remainingBytes])
gocode/src/main/main.go
+2 -1
View File
@@ -43,7 +43,8 @@ var dispatcher *gameserver.Dispatcher
func main() {
lobby = gameserver.NewLobby()
dispatcher = gameserver.NewDispatcher(lobby)
dispatcher = gameserver.NewDispatcher(nil, lobby.GetReceiver())
go lobby.Run()
go dispatcher.Run()
listener, err := net.Listen("tcp", ":7234")
pokerth.proto
+4 -10
View File
@@ -29,16 +29,10 @@
* as that of the covered work. *
*****************************************************************************/
import "src/third_party/gogoprotobuf/gogo.proto";
option java_package = "de.pokerth.protocol";
option java_outer_classname = "ProtoBuf";
option optimize_for = LITE_RUNTIME;
option (gogoproto.marshaler_all) = true;
option (gogoproto.unmarshaler_all) = true;
option (gogoproto.sizer_all) = true;
// Enumerations used by several messages.
enum NetGameMode {
@@ -166,6 +160,7 @@ message AuthClientRequestMessage {
optional string nickName = 5;
// Authenticated login data is according to SCRAM SHA-1
optional bytes clientUserData = 6;
optional bytes myLastSessionId = 7;
}
message AuthServerChallengeMessage {
@@ -183,14 +178,13 @@ message AuthServerVerificationMessage {
}
message InitMessage {
optional bytes myLastSessionId = 1;
// Ignored for guest login.
optional bytes avatarHash = 2;
optional bytes avatarHash = 1;
}
message InitAckMessage {
optional bytes yourAvatarHash = 3;
optional uint32 rejoinGameId = 4;
optional bytes yourAvatarHash = 1;
optional uint32 rejoinGameId = 2;
}
message AvatarRequestMessage {
src/core/common/avatarmanager.cpp
+19 -11
View File
@@ -195,13 +195,17 @@ AvatarManager::AvatarFileToNetPackets(const string &fileName, unsigned requestId
AvatarFileType fileType;
boost::shared_ptr<AvatarFileState> tmpState = OpenAvatarFileForChunkRead(fileName, fileSize, fileType);
if (tmpState.get() && fileSize && fileType != AVATAR_FILE_TYPE_UNKNOWN) {
boost::shared_ptr<NetPacket> avatarHeader(new NetPacket);
avatarHeader->GetMsg()->set_messagetype(PokerTHMessage::Type_AvatarHeaderMessage);
AvatarHeaderMessage *netHeader = avatarHeader->GetMsg()->mutable_avatarheadermessage();
netHeader->set_requestid(requestId);
netHeader->set_avatartype(static_cast<NetAvatarType>(fileType));
netHeader->set_avatarsize(fileSize);
packets.push_back(avatarHeader);
{
boost::shared_ptr<NetPacket> avatarHeader(new NetPacket);
avatarHeader->GetMsg()->set_messagetype(PokerTHMessage::Type_LobbyMessage);
LobbyMessage *netLobby = avatarHeader->GetMsg()->mutable_lobbymessage();
netLobby->set_messagetype(LobbyMessage::Type_AvatarHeaderMessage);
AvatarHeaderMessage *netHeader = netLobby->mutable_avatarheadermessage();
netHeader->set_requestid(requestId);
netHeader->set_avatartype(static_cast<NetAvatarType>(fileType));
netHeader->set_avatarsize(fileSize);
packets.push_back(avatarHeader);
}
unsigned numBytes = 0;
unsigned totalBytesRead = 0;
@@ -212,8 +216,10 @@ AvatarManager::AvatarFileToNetPackets(const string &fileName, unsigned requestId
totalBytesRead += numBytes;
boost::shared_ptr<NetPacket> avatarFile(new NetPacket);
avatarFile->GetMsg()->set_messagetype(PokerTHMessage::Type_AvatarDataMessage);
AvatarDataMessage *netFile = avatarFile->GetMsg()->mutable_avatardatamessage();
avatarFile->GetMsg()->set_messagetype(PokerTHMessage::Type_LobbyMessage);
LobbyMessage *netLobby = avatarFile->GetMsg()->mutable_lobbymessage();
netLobby->set_messagetype(LobbyMessage::Type_AvatarDataMessage);
AvatarDataMessage *netFile = netLobby->mutable_avatardatamessage();
netFile->set_requestid(requestId);
netFile->set_avatarblock((const char *)&tmpData[0], numBytes);
packets.push_back(avatarFile);
@@ -224,8 +230,10 @@ AvatarManager::AvatarFileToNetPackets(const string &fileName, unsigned requestId
retVal = ERR_NET_WRONG_AVATAR_SIZE;
else {
boost::shared_ptr<NetPacket> avatarEnd(new NetPacket);
avatarEnd->GetMsg()->set_messagetype(PokerTHMessage::Type_AvatarEndMessage);
AvatarEndMessage *netEnd = avatarEnd->GetMsg()->mutable_avatarendmessage();
avatarEnd->GetMsg()->set_messagetype(PokerTHMessage::Type_LobbyMessage);
LobbyMessage *netLobby = avatarEnd->GetMsg()->mutable_lobbymessage();
netLobby->set_messagetype(LobbyMessage::Type_AvatarEndMessage);
AvatarEndMessage *netEnd = netLobby->mutable_avatarendmessage();
netEnd->set_requestid(requestId);
packets.push_back(avatarEnd);
retVal = 0;
src/net/clientstate.h
+70 -19
View File
@@ -44,8 +44,11 @@ class ClientThread;
class ClientContext;
class ClientCallback;
class Game;
class NetPacket;
class DownloadHelper;
class AnnounceMessage;
class AuthMessage;
class LobbyMessage;
class GameMessage;
class ClientState
{
@@ -55,7 +58,10 @@ public:
virtual void Enter(boost::shared_ptr<ClientThread> client) = 0;
virtual void Exit(boost::shared_ptr<ClientThread> client) = 0;
virtual void HandlePacket(boost::shared_ptr<ClientThread> client, boost::shared_ptr<NetPacket> tmpPacket) = 0;
virtual void HandleAnnounceMsg(boost::shared_ptr<ClientThread> client, const AnnounceMessage &announceMsg) = 0;
virtual void HandleAuthMsg(boost::shared_ptr<ClientThread> client, const AuthMessage &authMsg) = 0;
virtual void HandleLobbyMsg(boost::shared_ptr<ClientThread> client, const LobbyMessage &lobbyMsg) = 0;
virtual void HandleGameMsg(boost::shared_ptr<ClientThread> client, const GameMessage &gameMsg) = 0;
};
// State: Initialization.
@@ -70,7 +76,10 @@ public:
virtual void Enter(boost::shared_ptr<ClientThread> client);
virtual void Exit(boost::shared_ptr<ClientThread> client);
virtual void HandlePacket(boost::shared_ptr<ClientThread> /*client*/, boost::shared_ptr<NetPacket> /*tmpPacket*/) {}
virtual void HandleAnnounceMsg(boost::shared_ptr<ClientThread> /*client*/, const AnnounceMessage &/*announceMsg*/) {}
virtual void HandleAuthMsg(boost::shared_ptr<ClientThread> /*client*/, const AuthMessage &/*authMsg*/) {}
virtual void HandleLobbyMsg(boost::shared_ptr<ClientThread> /*client*/, const LobbyMessage &/*lobbyMsg*/) {}
virtual void HandleGameMsg(boost::shared_ptr<ClientThread> /*client*/, const GameMessage &/*gameMsg*/) {}
protected:
// Protected constructor - this is a singleton.
@@ -89,7 +98,10 @@ public:
virtual void Enter(boost::shared_ptr<ClientThread> client);
virtual void Exit(boost::shared_ptr<ClientThread> client);
virtual void HandlePacket(boost::shared_ptr<ClientThread> /*client*/, boost::shared_ptr<NetPacket> /*tmpPacket*/) {}
virtual void HandleAnnounceMsg(boost::shared_ptr<ClientThread> /*client*/, const AnnounceMessage &/*announceMsg*/) {}
virtual void HandleAuthMsg(boost::shared_ptr<ClientThread> /*client*/, const AuthMessage &/*authMsg*/) {}
virtual void HandleLobbyMsg(boost::shared_ptr<ClientThread> /*client*/, const LobbyMessage &/*lobbyMsg*/) {}
virtual void HandleGameMsg(boost::shared_ptr<ClientThread> /*client*/, const GameMessage &/*gameMsg*/) {}
protected:
@@ -113,7 +125,10 @@ public:
virtual void Enter(boost::shared_ptr<ClientThread> client);
virtual void Exit(boost::shared_ptr<ClientThread> client);
virtual void HandlePacket(boost::shared_ptr<ClientThread> /*client*/, boost::shared_ptr<NetPacket> /*tmpPacket*/) {}
virtual void HandleAnnounceMsg(boost::shared_ptr<ClientThread> /*client*/, const AnnounceMessage &/*announceMsg*/) {}
virtual void HandleAuthMsg(boost::shared_ptr<ClientThread> /*client*/, const AuthMessage &/*authMsg*/) {}
virtual void HandleLobbyMsg(boost::shared_ptr<ClientThread> /*client*/, const LobbyMessage &/*lobbyMsg*/) {}
virtual void HandleGameMsg(boost::shared_ptr<ClientThread> /*client*/, const GameMessage &/*gameMsg*/) {}
protected:
@@ -132,7 +147,10 @@ public:
virtual void Enter(boost::shared_ptr<ClientThread> client);
virtual void Exit(boost::shared_ptr<ClientThread> client);
virtual void HandlePacket(boost::shared_ptr<ClientThread> /*client*/, boost::shared_ptr<NetPacket> /*tmpPacket*/) {}
virtual void HandleAnnounceMsg(boost::shared_ptr<ClientThread> /*client*/, const AnnounceMessage &/*announceMsg*/) {}
virtual void HandleAuthMsg(boost::shared_ptr<ClientThread> /*client*/, const AuthMessage &/*authMsg*/) {}
virtual void HandleLobbyMsg(boost::shared_ptr<ClientThread> /*client*/, const LobbyMessage &/*lobbyMsg*/) {}
virtual void HandleGameMsg(boost::shared_ptr<ClientThread> /*client*/, const GameMessage &/*gameMsg*/) {}
void SetDownloadHelper(boost::shared_ptr<DownloadHelper> helper);
@@ -159,7 +177,10 @@ public:
virtual void Enter(boost::shared_ptr<ClientThread> client);
virtual void Exit(boost::shared_ptr<ClientThread> client);
virtual void HandlePacket(boost::shared_ptr<ClientThread> /*client*/, boost::shared_ptr<NetPacket> /*tmpPacket*/) {}
virtual void HandleAnnounceMsg(boost::shared_ptr<ClientThread> /*client*/, const AnnounceMessage &/*announceMsg*/) {}
virtual void HandleAuthMsg(boost::shared_ptr<ClientThread> /*client*/, const AuthMessage &/*authMsg*/) {}
virtual void HandleLobbyMsg(boost::shared_ptr<ClientThread> /*client*/, const LobbyMessage &/*lobbyMsg*/) {}
virtual void HandleGameMsg(boost::shared_ptr<ClientThread> /*client*/, const GameMessage &/*gameMsg*/) {}
protected:
@@ -177,7 +198,10 @@ public:
virtual void Enter(boost::shared_ptr<ClientThread> client);
virtual void Exit(boost::shared_ptr<ClientThread> client);
virtual void HandlePacket(boost::shared_ptr<ClientThread> /*client*/, boost::shared_ptr<NetPacket> /*tmpPacket*/) {}
virtual void HandleAnnounceMsg(boost::shared_ptr<ClientThread> /*client*/, const AnnounceMessage &/*announceMsg*/) {}
virtual void HandleAuthMsg(boost::shared_ptr<ClientThread> /*client*/, const AuthMessage &/*authMsg*/) {}
virtual void HandleLobbyMsg(boost::shared_ptr<ClientThread> /*client*/, const LobbyMessage &/*lobbyMsg*/) {}
virtual void HandleGameMsg(boost::shared_ptr<ClientThread> /*client*/, const GameMessage &/*gameMsg*/) {}
protected:
@@ -199,7 +223,10 @@ public:
virtual void Enter(boost::shared_ptr<ClientThread> client);
virtual void Exit(boost::shared_ptr<ClientThread> client);
virtual void HandlePacket(boost::shared_ptr<ClientThread> /*client*/, boost::shared_ptr<NetPacket> /*tmpPacket*/) {}
virtual void HandleAnnounceMsg(boost::shared_ptr<ClientThread> /*client*/, const AnnounceMessage &/*announceMsg*/) {}
virtual void HandleAuthMsg(boost::shared_ptr<ClientThread> /*client*/, const AuthMessage &/*authMsg*/) {}
virtual void HandleLobbyMsg(boost::shared_ptr<ClientThread> /*client*/, const LobbyMessage &/*lobbyMsg*/) {}
virtual void HandleGameMsg(boost::shared_ptr<ClientThread> /*client*/, const GameMessage &/*gameMsg*/) {}
void SetRemoteEndpoint(boost::asio::ip::tcp::resolver::iterator endpointIterator);
@@ -224,12 +251,18 @@ class AbstractClientStateReceiving : public ClientState
public:
virtual ~AbstractClientStateReceiving();
virtual void HandlePacket(boost::shared_ptr<ClientThread> client, boost::shared_ptr<NetPacket> tmpPacket);
virtual void HandleAnnounceMsg(boost::shared_ptr<ClientThread> client, const AnnounceMessage &announceMsg);
virtual void HandleAuthMsg(boost::shared_ptr<ClientThread> client, const AuthMessage &authMsg);
virtual void HandleLobbyMsg(boost::shared_ptr<ClientThread> client, const LobbyMessage &lobbyMsg);
virtual void HandleGameMsg(boost::shared_ptr<ClientThread> client, const GameMessage &gameMsg);
protected:
AbstractClientStateReceiving();
virtual void InternalHandlePacket(boost::shared_ptr<ClientThread> client, boost::shared_ptr<NetPacket> tmpPacket) = 0;
virtual void InternalHandleAnnounceMsg(boost::shared_ptr<ClientThread> client, const AnnounceMessage &announceMsg) = 0;
virtual void InternalHandleAuthMsg(boost::shared_ptr<ClientThread> client, const AuthMessage &authMsg) = 0;
virtual void InternalHandleLobbyMsg(boost::shared_ptr<ClientThread> client, const LobbyMessage &lobbyMsg) = 0;
virtual void InternalHandleGameMsg(boost::shared_ptr<ClientThread> client, const GameMessage &gameMsg) = 0;
};
// State: Session init.
@@ -247,11 +280,14 @@ protected:
// Protected constructor - this is a singleton.
ClientStateStartSession();
virtual void InternalHandlePacket(boost::shared_ptr<ClientThread> client, boost::shared_ptr<NetPacket> tmpPacket);
virtual void InternalHandleAnnounceMsg(boost::shared_ptr<ClientThread> client, const AnnounceMessage &announceMsg);
virtual void InternalHandleAuthMsg(boost::shared_ptr<ClientThread> /*client*/, const AuthMessage &/*authMsg*/) {}
virtual void InternalHandleLobbyMsg(boost::shared_ptr<ClientThread> /*client*/, const LobbyMessage &/*lobbyMsg*/) {}
virtual void InternalHandleGameMsg(boost::shared_ptr<ClientThread> /*client*/, const GameMessage &/*gameMsg*/) {}
};
// State: Waiting for the user to enter login data.
class ClientStateWaitEnterLogin : public ClientState
class ClientStateWaitEnterLogin : public AbstractClientStateReceiving
{
public:
static ClientStateWaitEnterLogin &Instance();
@@ -260,14 +296,17 @@ public:
virtual void Enter(boost::shared_ptr<ClientThread> client);
virtual void Exit(boost::shared_ptr<ClientThread> client);
virtual void HandlePacket(boost::shared_ptr<ClientThread> client, boost::shared_ptr<NetPacket> tmpPacket);
protected:
// Protected constructor - this is a singleton.
ClientStateWaitEnterLogin();
void TimerLoop(const boost::system::error_code& ec, boost::shared_ptr<ClientThread> client);
virtual void InternalHandleAnnounceMsg(boost::shared_ptr<ClientThread> /*client*/, const AnnounceMessage &/*announceMsg*/) {}
virtual void InternalHandleAuthMsg(boost::shared_ptr<ClientThread> client, const AuthMessage &authMsg);
virtual void InternalHandleLobbyMsg(boost::shared_ptr<ClientThread> /*client*/, const LobbyMessage &/*lobbyMsg*/) {}
virtual void InternalHandleGameMsg(boost::shared_ptr<ClientThread> /*client*/, const GameMessage &/*gameMsg*/) {}
};
// State: Wait for Authentication Challenge.
@@ -285,7 +324,10 @@ protected:
// Protected constructor - this is a singleton.
ClientStateWaitAuthChallenge();
virtual void InternalHandlePacket(boost::shared_ptr<ClientThread> client, boost::shared_ptr<NetPacket> tmpPacket);
virtual void InternalHandleAnnounceMsg(boost::shared_ptr<ClientThread> /*client*/, const AnnounceMessage &/*announceMsg*/) {}
virtual void InternalHandleAuthMsg(boost::shared_ptr<ClientThread> client, const AuthMessage &authMsg);
virtual void InternalHandleLobbyMsg(boost::shared_ptr<ClientThread> /*client*/, const LobbyMessage &/*lobbyMsg*/) {}
virtual void InternalHandleGameMsg(boost::shared_ptr<ClientThread> /*client*/, const GameMessage &/*gameMsg*/) {}
};
// State: Wait for Authentication Verification.
@@ -303,7 +345,10 @@ protected:
// Protected constructor - this is a singleton.
ClientStateWaitAuthVerify();
virtual void InternalHandlePacket(boost::shared_ptr<ClientThread> client, boost::shared_ptr<NetPacket> tmpPacket);
virtual void InternalHandleAnnounceMsg(boost::shared_ptr<ClientThread> /*client*/, const AnnounceMessage &/*announceMsg*/) {}
virtual void InternalHandleAuthMsg(boost::shared_ptr<ClientThread> client, const AuthMessage &authMsg);
virtual void InternalHandleLobbyMsg(boost::shared_ptr<ClientThread> /*client*/, const LobbyMessage &/*lobbyMsg*/) {}
virtual void InternalHandleGameMsg(boost::shared_ptr<ClientThread> /*client*/, const GameMessage &/*gameMsg*/) {}
};
// State: Wait for Session ACK.
@@ -321,7 +366,10 @@ protected:
// Protected constructor - this is a singleton.
ClientStateWaitSession();
virtual void InternalHandlePacket(boost::shared_ptr<ClientThread> client, boost::shared_ptr<NetPacket> tmpPacket);
virtual void InternalHandleAnnounceMsg(boost::shared_ptr<ClientThread> /*client*/, const AnnounceMessage &/*announceMsg*/) {}
virtual void InternalHandleAuthMsg(boost::shared_ptr<ClientThread> /*client*/, const AuthMessage &/*authMsg*/) {}
virtual void InternalHandleLobbyMsg(boost::shared_ptr<ClientThread> client, const LobbyMessage &lobbyMsg);
virtual void InternalHandleGameMsg(boost::shared_ptr<ClientThread> /*client*/, const GameMessage &/*gameMsg*/) {}
};
// State: Wait for Join.
@@ -340,7 +388,10 @@ protected:
// Protected constructor - this is a singleton.
ClientStateWaitJoin();
virtual void InternalHandlePacket(boost::shared_ptr<ClientThread> client, boost::shared_ptr<NetPacket> tmpPacket);
virtual void InternalHandleAnnounceMsg(boost::shared_ptr<ClientThread> /*client*/, const AnnounceMessage &/*announceMsg*/) {}
virtual void InternalHandleAuthMsg(boost::shared_ptr<ClientThread> /*client*/, const AuthMessage &/*authMsg*/) {}
virtual void InternalHandleLobbyMsg(boost::shared_ptr<ClientThread> /*client*/, const LobbyMessage &/*lobbyMsg*/) {}
virtual void InternalHandleGameMsg(boost::shared_ptr<ClientThread> client, const GameMessage &gameMsg);
};
// State: Wait for start of the game or start info.
src/net/common/clientstate.cpp
+328 -267
View File
@@ -552,10 +552,22 @@ AbstractClientStateReceiving::~AbstractClientStateReceiving()
}
void
AbstractClientStateReceiving::HandlePacket(boost::shared_ptr<ClientThread> client, boost::shared_ptr<NetPacket> tmpPacket)
AbstractClientStateReceiving::HandleAnnounceMsg(boost::shared_ptr<ClientThread> client, const AnnounceMessage &announceMsg)
{
if (tmpPacket->GetMsg()->messagetype() == PokerTHMessage::Type_PlayerInfoReplyMessage) {
const PlayerInfoReplyMessage &infoReply = tmpPacket->GetMsg()->playerinforeplymessage();
InternalHandleAnnounceMsg(client, announceMsg);
}
void
AbstractClientStateReceiving::HandleAuthMsg(boost::shared_ptr<ClientThread> client, const AuthMessage &authMsg)
{
InternalHandleAuthMsg(client, authMsg);
}
void
AbstractClientStateReceiving::HandleLobbyMsg(boost::shared_ptr<ClientThread> client, const LobbyMessage &lobbyMsg)
{
if (lobbyMsg.messagetype() == LobbyMessage::Type_PlayerInfoReplyMessage) {
const PlayerInfoReplyMessage &infoReply = lobbyMsg.playerinforeplymessage();
unsigned playerId = infoReply.playerid();
if (infoReply.has_playerinfodata()) {
PlayerInfo tmpInfo;
@@ -575,105 +587,16 @@ AbstractClientStateReceiving::HandlePacket(boost::shared_ptr<ClientThread> clien
client->SetPlayerInfo(
playerId,
tmpInfo);
} else {
}
else {
client->SetUnknownPlayer(playerId);
}
} else if (tmpPacket->GetMsg()->messagetype() == PokerTHMessage::Type_RemovedFromGameMessage) {
const RemovedFromGameMessage &netRemoved = tmpPacket->GetMsg()->removedfromgamemessage();
client->ClearPlayerDataList();
// Resubscribe Lobby messages.
client->ResubscribeLobbyMsg();
// Show Lobby.
client->GetCallback().SignalNetClientWaitDialog();
int removeReason;
switch (netRemoved.removedfromgamereason()) {
case RemovedFromGameMessage::kickedFromGame :
removeReason = NTF_NET_REMOVED_KICKED;
break;
case RemovedFromGameMessage::gameIsFull :
removeReason = NTF_NET_REMOVED_GAME_FULL;
break;
case RemovedFromGameMessage::gameIsRunning :
removeReason = NTF_NET_REMOVED_ALREADY_RUNNING;
break;
case RemovedFromGameMessage::gameTimeout :
removeReason = NTF_NET_REMOVED_TIMEOUT;
break;
case RemovedFromGameMessage::removedStartFailed :
removeReason = NTF_NET_REMOVED_START_FAILED;
break;
case RemovedFromGameMessage::gameClosed :
removeReason = NTF_NET_REMOVED_GAME_CLOSED;
break;
default :
removeReason = NTF_NET_REMOVED_ON_REQUEST;
break;
}
client->GetCallback().SignalNetClientRemovedFromGame(removeReason);
client->SetState(ClientStateWaitJoin::Instance());
} else if (tmpPacket->GetMsg()->messagetype() == PokerTHMessage::Type_GamePlayerLeftMessage) {
// A player left the game.
const GamePlayerLeftMessage &netLeft = tmpPacket->GetMsg()->gameplayerleftmessage();
if (client->GetGame()) {
boost::shared_ptr<PlayerInterface> tmpPlayer = client->GetGame()->getPlayerByUniqueId(netLeft.playerid());
if (tmpPlayer) {
tmpPlayer->setIsKicked(netLeft.gameplayerleftreason() == GamePlayerLeftMessage::leftKicked);
}
}
// Signal to GUI and remove from data list.
int removeReason;
switch (netLeft.gameplayerleftreason()) {
case GamePlayerLeftMessage::leftKicked :
removeReason = NTF_NET_REMOVED_KICKED;
break;
default :
removeReason = NTF_NET_REMOVED_ON_REQUEST;
break;
}
client->RemovePlayerData(netLeft.playerid(), removeReason);
} else if (tmpPacket->GetMsg()->messagetype() == PokerTHMessage::Type_GameAdminChangedMessage) {
// New admin for the game.
const GameAdminChangedMessage &netChanged = tmpPacket->GetMsg()->gameadminchangedmessage();
// Set new game admin and signal to GUI.
client->SetNewGameAdmin(netChanged.newadminplayerid());
} else if (tmpPacket->GetMsg()->messagetype() == PokerTHMessage::Type_GamePlayerJoinedMessage) {
// Another player joined the network game.
const GamePlayerJoinedMessage &netPlayerJoined = tmpPacket->GetMsg()->gameplayerjoinedmessage();
boost::shared_ptr<PlayerData> playerData = client->CreatePlayerData(netPlayerJoined.playerid(), netPlayerJoined.isgameadmin());
client->AddPlayerData(playerData);
} else if (tmpPacket->GetMsg()->messagetype() == PokerTHMessage::Type_GameSpectatorJoinedMessage) {
// Another spectator joined the network game.
const GameSpectatorJoinedMessage &netSpectatorJoined = tmpPacket->GetMsg()->gamespectatorjoinedmessage();
// Request player info if needed.
PlayerInfo info;
if (!client->GetCachedPlayerInfo(netSpectatorJoined.playerid(), info)) {
client->RequestPlayerInfo(netSpectatorJoined.playerid());
}
client->ModifyGameInfoAddSpectatorDuringGame(netSpectatorJoined.playerid());
} else if (tmpPacket->GetMsg()->messagetype() == PokerTHMessage::Type_GameSpectatorLeftMessage) {
// A spectator left the network game.
const GameSpectatorLeftMessage &netSpectatorLeft = tmpPacket->GetMsg()->gamespectatorleftmessage();
// Signal to GUI and remove from data list.
int removeReason;
switch (netSpectatorLeft.gamespectatorleftreason()) {
case GamePlayerLeftMessage::leftKicked :
removeReason = NTF_NET_REMOVED_KICKED;
break;
default :
removeReason = NTF_NET_REMOVED_ON_REQUEST;
break;
}
client->ModifyGameInfoRemoveSpectatorDuringGame(netSpectatorLeft.playerid(), removeReason);
} else if (tmpPacket->GetMsg()->messagetype() == PokerTHMessage::Type_TimeoutWarningMessage) {
const TimeoutWarningMessage &tmpTimeout = tmpPacket->GetMsg()->timeoutwarningmessage();
} else if (lobbyMsg.messagetype() == LobbyMessage::Type_TimeoutWarningMessage) {
const TimeoutWarningMessage &tmpTimeout = lobbyMsg.timeoutwarningmessage();
client->GetCallback().SignalNetClientShowTimeoutDialog((NetTimeoutReason)tmpTimeout.timeoutreason(), tmpTimeout.remainingseconds());
} else if (tmpPacket->GetMsg()->messagetype() == PokerTHMessage::Type_ChatMessage) {
} else if (lobbyMsg.messagetype() == LobbyMessage::Type_ChatMessage) {
// Chat message - display it in the GUI.
const ChatMessage &netMessage = tmpPacket->GetMsg()->chatmessage();
const ChatMessage &netMessage = lobbyMsg.chatmessage();
string playerName;
if (netMessage.chattype() == ChatMessage::chatTypeBroadcast) {
@@ -682,14 +605,7 @@ AbstractClientStateReceiving::HandlePacket(boost::shared_ptr<ClientThread> clien
} else if (netMessage.chattype() == ChatMessage::chatTypeBot) {
client->GetCallback().SignalNetClientGameChatMsg("(chat bot)", netMessage.chattext());
client->GetCallback().SignalNetClientLobbyChatMsg("(chat bot)", netMessage.chattext());
} else if (netMessage.chattype() == ChatMessage::chatTypeGame) {
unsigned playerId = netMessage.playerid();
boost::shared_ptr<PlayerData> tmpPlayer = client->GetPlayerDataByUniqueId(playerId);
if (tmpPlayer.get())
playerName = tmpPlayer->GetName();
if (!playerName.empty())
client->GetCallback().SignalNetClientGameChatMsg(playerName, netMessage.chattext());
} else if (netMessage.chattype() == ChatMessage::chatTypeLobby) {
} else if (netMessage.chattype() == ChatMessage::chatTypeStandard) {
unsigned playerId = netMessage.playerid();
PlayerInfo info;
if (client->GetCachedPlayerInfo(playerId, info))
@@ -700,25 +616,25 @@ AbstractClientStateReceiving::HandlePacket(boost::shared_ptr<ClientThread> clien
if (client->GetCachedPlayerInfo(playerId, info))
client->GetCallback().SignalNetClientPrivateChatMsg(info.playerName, netMessage.chattext());
}
} else if (tmpPacket->GetMsg()->messagetype() == PokerTHMessage::Type_ChatRejectMessage) {
const ChatRejectMessage &netMessage = tmpPacket->GetMsg()->chatrejectmessage();
} else if (lobbyMsg.messagetype() == LobbyMessage::Type_ChatRejectMessage) {
const ChatRejectMessage &netMessage = lobbyMsg.chatrejectmessage();
client->GetCallback().SignalNetClientGameChatMsg("(notice)", "Chat rejected: " + netMessage.chattext());
client->GetCallback().SignalNetClientLobbyChatMsg("(notice)", "Chat rejected: " + netMessage.chattext());
} else if (tmpPacket->GetMsg()->messagetype() == PokerTHMessage::Type_DialogMessage) {
} else if (lobbyMsg.messagetype() == LobbyMessage::Type_DialogMessage) {
// Message box - display it in the GUI.
const DialogMessage &netDialog = tmpPacket->GetMsg()->dialogmessage();
const DialogMessage &netDialog = lobbyMsg.dialogmessage();
client->GetCallback().SignalNetClientMsgBox(netDialog.notificationtext());
} else if (tmpPacket->GetMsg()->messagetype() == PokerTHMessage::Type_PlayerListMessage) {
const PlayerListMessage &netPlayerList = tmpPacket->GetMsg()->playerlistmessage();
} else if (lobbyMsg.messagetype() == LobbyMessage::Type_PlayerListMessage) {
const PlayerListMessage &netPlayerList = lobbyMsg.playerlistmessage();
if (netPlayerList.playerlistnotification() == PlayerListMessage::playerListNew) {
client->GetCallback().SignalLobbyPlayerJoined(netPlayerList.playerid(), client->GetPlayerName(netPlayerList.playerid()));
} else if (netPlayerList.playerlistnotification() == PlayerListMessage::playerListLeft) {
client->GetCallback().SignalLobbyPlayerLeft(netPlayerList.playerid());
}
} else if (tmpPacket->GetMsg()->messagetype() == PokerTHMessage::Type_GameListNewMessage) {
} else if (lobbyMsg.messagetype() == LobbyMessage::Type_GameListNewMessage) {
// A new game was created on the server.
const GameListNewMessage &netListNew = tmpPacket->GetMsg()->gamelistnewmessage();
const GameListNewMessage &netListNew = lobbyMsg.gamelistnewmessage();
// Request player info for players if needed.
GameInfo tmpInfo;
@@ -751,15 +667,15 @@ AbstractClientStateReceiving::HandlePacket(boost::shared_ptr<ClientThread> clien
NetPacket::GetGameData(netListNew.gameinfo(), tmpInfo.data);
client->AddGameInfo(netListNew.gameid(), tmpInfo);
} else if (tmpPacket->GetMsg()->messagetype() == PokerTHMessage::Type_GameListUpdateMessage) {
} else if (lobbyMsg.messagetype() == LobbyMessage::Type_GameListUpdateMessage) {
// An existing game was updated on the server.
const GameListUpdateMessage &netListUpdate = tmpPacket->GetMsg()->gamelistupdatemessage();
const GameListUpdateMessage &netListUpdate = lobbyMsg.gamelistupdatemessage();
if (netListUpdate.gamemode() == netGameClosed)
client->RemoveGameInfo(netListUpdate.gameid());
else
client->UpdateGameInfoMode(netListUpdate.gameid(), static_cast<GameMode>(netListUpdate.gamemode()));
} else if (tmpPacket->GetMsg()->messagetype() == PokerTHMessage::Type_GameListPlayerJoinedMessage) {
const GameListPlayerJoinedMessage &netListJoined = tmpPacket->GetMsg()->gamelistplayerjoinedmessage();
} else if (lobbyMsg.messagetype() == LobbyMessage::Type_GameListPlayerJoinedMessage) {
const GameListPlayerJoinedMessage &netListJoined = lobbyMsg.gamelistplayerjoinedmessage();
client->ModifyGameInfoAddPlayer(netListJoined.gameid(), netListJoined.playerid());
// Request player info if needed.
@@ -767,12 +683,12 @@ AbstractClientStateReceiving::HandlePacket(boost::shared_ptr<ClientThread> clien
if (!client->GetCachedPlayerInfo(netListJoined.playerid(), info)) {
client->RequestPlayerInfo(netListJoined.playerid());
}
} else if (tmpPacket->GetMsg()->messagetype() == PokerTHMessage::Type_GameListPlayerLeftMessage) {
const GameListPlayerLeftMessage &netListLeft = tmpPacket->GetMsg()->gamelistplayerleftmessage();
} else if (lobbyMsg.messagetype() == LobbyMessage::Type_GameListPlayerLeftMessage) {
const GameListPlayerLeftMessage &netListLeft = lobbyMsg.gamelistplayerleftmessage();
client->ModifyGameInfoRemovePlayer(netListLeft.gameid(), netListLeft.playerid());
} else if (tmpPacket->GetMsg()->messagetype() == PokerTHMessage::Type_GameListSpectatorJoinedMessage) {
const GameListSpectatorJoinedMessage &netListJoined = tmpPacket->GetMsg()->gamelistspectatorjoinedmessage();
} else if (lobbyMsg.messagetype() == LobbyMessage::Type_GameListSpectatorJoinedMessage) {
const GameListSpectatorJoinedMessage &netListJoined = lobbyMsg.gamelistspectatorjoinedmessage();
client->ModifyGameInfoAddSpectator(netListJoined.gameid(), netListJoined.playerid());
// Request player info if needed.
@@ -780,41 +696,30 @@ AbstractClientStateReceiving::HandlePacket(boost::shared_ptr<ClientThread> clien
if (!client->GetCachedPlayerInfo(netListJoined.playerid(), info)) {
client->RequestPlayerInfo(netListJoined.playerid());
}
} else if (tmpPacket->GetMsg()->messagetype() == PokerTHMessage::Type_GameListSpectatorLeftMessage) {
const GameListSpectatorLeftMessage &netListLeft = tmpPacket->GetMsg()->gamelistspectatorleftmessage();
} else if (lobbyMsg.messagetype() == LobbyMessage::Type_GameListSpectatorLeftMessage) {
const GameListSpectatorLeftMessage &netListLeft = lobbyMsg.gamelistspectatorleftmessage();
client->ModifyGameInfoRemoveSpectator(netListLeft.gameid(), netListLeft.playerid());
} else if (tmpPacket->GetMsg()->messagetype() == PokerTHMessage::Type_GameListAdminChangedMessage) {
const GameListAdminChangedMessage &netListAdmin = tmpPacket->GetMsg()->gamelistadminchangedmessage();
} else if (lobbyMsg.messagetype() == LobbyMessage::Type_GameListAdminChangedMessage) {
const GameListAdminChangedMessage &netListAdmin = lobbyMsg.gamelistadminchangedmessage();
client->UpdateGameInfoAdmin(netListAdmin.gameid(), netListAdmin.newadminplayerid());
} else if (tmpPacket->GetMsg()->messagetype() == PokerTHMessage::Type_StartKickPetitionMessage) {
const StartKickPetitionMessage &netStartPetition = tmpPacket->GetMsg()->startkickpetitionmessage();
client->StartPetition(netStartPetition.petitionid(), netStartPetition.proposingplayerid(),
netStartPetition.kickplayerid(), netStartPetition.kicktimeoutsec(), netStartPetition.numvotesneededtokick());
} else if (tmpPacket->GetMsg()->messagetype() == PokerTHMessage::Type_KickPetitionUpdateMessage) {
const KickPetitionUpdateMessage &netPetitionUpdate = tmpPacket->GetMsg()->kickpetitionupdatemessage();
client->UpdatePetition(netPetitionUpdate.petitionid(), netPetitionUpdate.numvotesagainstkicking(),
netPetitionUpdate.numvotesinfavourofkicking(), netPetitionUpdate.numvotesneededtokick());
} else if (tmpPacket->GetMsg()->messagetype() == PokerTHMessage::Type_EndKickPetitionMessage) {
const EndKickPetitionMessage &netEndPetition = tmpPacket->GetMsg()->endkickpetitionmessage();
client->EndPetition(netEndPetition.petitionid());
} else if (tmpPacket->GetMsg()->messagetype() == PokerTHMessage::Type_AvatarHeaderMessage) {
const AvatarHeaderMessage &netAvatarHeader = tmpPacket->GetMsg()->avatarheadermessage();
} else if (lobbyMsg.messagetype() == LobbyMessage::Type_AvatarHeaderMessage) {
const AvatarHeaderMessage &netAvatarHeader = lobbyMsg.avatarheadermessage();
client->AddTempAvatarFile(netAvatarHeader.requestid(), netAvatarHeader.avatarsize(), static_cast<AvatarFileType>(netAvatarHeader.avatartype()));
} else if (tmpPacket->GetMsg()->messagetype() == PokerTHMessage::Type_AvatarDataMessage) {
const AvatarDataMessage &netAvatarData = tmpPacket->GetMsg()->avatardatamessage();
} else if (lobbyMsg.messagetype() == LobbyMessage::Type_AvatarDataMessage) {
const AvatarDataMessage &netAvatarData = lobbyMsg.avatardatamessage();
vector<unsigned char> fileData(netAvatarData.avatarblock().size());
memcpy(&fileData[0], netAvatarData.avatarblock().data(), netAvatarData.avatarblock().size());
client->StoreInTempAvatarFile(netAvatarData.requestid(), fileData);
} else if (tmpPacket->GetMsg()->messagetype() == PokerTHMessage::Type_AvatarEndMessage) {
const AvatarEndMessage &netAvatarEnd = tmpPacket->GetMsg()->avatarendmessage();
} else if (lobbyMsg.messagetype() == LobbyMessage::Type_AvatarEndMessage) {
const AvatarEndMessage &netAvatarEnd = lobbyMsg.avatarendmessage();
client->CompleteTempAvatarFile(netAvatarEnd.requestid());
} else if (tmpPacket->GetMsg()->messagetype() == PokerTHMessage::Type_UnknownAvatarMessage) {
const UnknownAvatarMessage &netUnknownAvatar = tmpPacket->GetMsg()->unknownavatarmessage();
} else if (lobbyMsg.messagetype() == LobbyMessage::Type_UnknownAvatarMessage) {
const UnknownAvatarMessage &netUnknownAvatar = lobbyMsg.unknownavatarmessage();
client->SetUnknownAvatar(netUnknownAvatar.requestid());
} else if (tmpPacket->GetMsg()->messagetype() == PokerTHMessage::Type_ReportAvatarAckMessage) {
const ReportAvatarAckMessage &netReportAck = tmpPacket->GetMsg()->reportavatarackmessage();
} else if (lobbyMsg.messagetype() == LobbyMessage::Type_ReportAvatarAckMessage) {
const ReportAvatarAckMessage &netReportAck = lobbyMsg.reportavatarackmessage();
unsigned msgCode;
switch (netReportAck.reportavatarresult()) {
case ReportAvatarAckMessage::avatarReportAccepted:
@@ -828,8 +733,9 @@ AbstractClientStateReceiving::HandlePacket(boost::shared_ptr<ClientThread> clien
break;
}
client->GetCallback().SignalNetClientMsgBox(msgCode);
} else if (tmpPacket->GetMsg()->messagetype() == PokerTHMessage::Type_ReportGameAckMessage) {
const ReportGameAckMessage &netReportAck = tmpPacket->GetMsg()->reportgameackmessage();
}
else if (lobbyMsg.messagetype() == LobbyMessage::Type_ReportGameAckMessage) {
const ReportGameAckMessage &netReportAck = lobbyMsg.reportgameackmessage();
unsigned msgCode;
switch (netReportAck.reportgameresult()) {
case ReportGameAckMessage::gameReportAccepted:
@@ -843,8 +749,8 @@ AbstractClientStateReceiving::HandlePacket(boost::shared_ptr<ClientThread> clien
break;
}
client->GetCallback().SignalNetClientMsgBox(msgCode);
} else if (tmpPacket->GetMsg()->messagetype() == PokerTHMessage::Type_AdminRemoveGameAckMessage) {
const AdminRemoveGameAckMessage &netRemoveAck = tmpPacket->GetMsg()->adminremovegameackmessage();
} else if (lobbyMsg.messagetype() == LobbyMessage::Type_AdminRemoveGameAckMessage) {
const AdminRemoveGameAckMessage &netRemoveAck = lobbyMsg.adminremovegameackmessage();
unsigned msgCode;
switch (netRemoveAck.removegameresult()) {
case AdminRemoveGameAckMessage::gameRemoveAccepted:
@@ -855,8 +761,8 @@ AbstractClientStateReceiving::HandlePacket(boost::shared_ptr<ClientThread> clien
break;
}
client->GetCallback().SignalNetClientMsgBox(msgCode);
} else if (tmpPacket->GetMsg()->messagetype() == PokerTHMessage::Type_AdminBanPlayerAckMessage) {
const AdminBanPlayerAckMessage &netBanAck = tmpPacket->GetMsg()->adminbanplayerackmessage();
} else if (lobbyMsg.messagetype() == LobbyMessage::Type_AdminBanPlayerAckMessage) {
const AdminBanPlayerAckMessage &netBanAck = lobbyMsg.adminbanplayerackmessage();
unsigned msgCode;
switch (netBanAck.banplayerresult()) {
case AdminBanPlayerAckMessage::banPlayerAccepted:
@@ -876,8 +782,8 @@ AbstractClientStateReceiving::HandlePacket(boost::shared_ptr<ClientThread> clien
break;
}
client->GetCallback().SignalNetClientMsgBox(msgCode);
} else if (tmpPacket->GetMsg()->messagetype() == PokerTHMessage::Type_StatisticsMessage) {
const StatisticsMessage &netStatistics = tmpPacket->GetMsg()->statisticsmessage();
} else if (lobbyMsg.messagetype() == LobbyMessage::Type_StatisticsMessage) {
const StatisticsMessage &netStatistics = lobbyMsg.statisticsmessage();
unsigned numStats = netStatistics.statisticsdata_size();
// Request player info for players if needed.
@@ -889,14 +795,167 @@ AbstractClientStateReceiving::HandlePacket(boost::shared_ptr<ClientThread> clien
}
client->UpdateStatData(tmpStats);
}
} else if (tmpPacket->GetMsg()->messagetype() == PokerTHMessage::Type_ErrorMessage) {
} else if (lobbyMsg.messagetype() == GameManagementMessage::Type_ErrorMessage) {
// Server reported an error.
const ErrorMessage &netError = tmpPacket->GetMsg()->errormessage();
const ErrorMessage &netError = lobbyMsg.errormessage();
// Show the error.
throw ClientException(__FILE__, __LINE__, NetPacket::NetErrorToGameError(netError.errorreason()), 0);
} else {
InternalHandleLobbyMsg(client, lobbyMsg);
}
}
InternalHandlePacket(client, tmpPacket);
void
AbstractClientStateReceiving::HandleGameMsg(boost::shared_ptr<ClientThread> client, const GameMessage &gameMsg)
{
if (gameMsg.messagetype() == GameMessage::Type_GameManagementMessage)
{
const GameManagementMessage &managementMsg = gameMsg.gamemanagementmessage();
if (managementMsg.messagetype() == GameManagementMessage::Type_RemovedFromGameMessage) {
const RemovedFromGameMessage &netRemoved = managementMsg.removedfromgamemessage();
client->ClearPlayerDataList();
// Resubscribe Lobby messages.
client->ResubscribeLobbyMsg();
// Show Lobby.
client->GetCallback().SignalNetClientWaitDialog();
int removeReason;
switch (netRemoved.removedfromgamereason()) {
case RemovedFromGameMessage::kickedFromGame:
removeReason = NTF_NET_REMOVED_KICKED;
break;
case RemovedFromGameMessage::gameIsFull:
removeReason = NTF_NET_REMOVED_GAME_FULL;
break;
case RemovedFromGameMessage::gameIsRunning:
removeReason = NTF_NET_REMOVED_ALREADY_RUNNING;
break;
case RemovedFromGameMessage::gameTimeout:
removeReason = NTF_NET_REMOVED_TIMEOUT;
break;
case RemovedFromGameMessage::removedStartFailed:
removeReason = NTF_NET_REMOVED_START_FAILED;
break;
case RemovedFromGameMessage::gameClosed:
removeReason = NTF_NET_REMOVED_GAME_CLOSED;
break;
default:
removeReason = NTF_NET_REMOVED_ON_REQUEST;
break;
}
client->GetCallback().SignalNetClientRemovedFromGame(removeReason);
client->SetState(ClientStateWaitJoin::Instance());
}
else if (managementMsg.messagetype() == GameManagementMessage::Type_GamePlayerLeftMessage) {
// A player left the game.
const GamePlayerLeftMessage &netLeft = managementMsg.gameplayerleftmessage();
if (client->GetGame()) {
boost::shared_ptr<PlayerInterface> tmpPlayer = client->GetGame()->getPlayerByUniqueId(netLeft.playerid());
if (tmpPlayer) {
tmpPlayer->setIsKicked(netLeft.gameplayerleftreason() == GamePlayerLeftMessage::leftKicked);
}
}
// Signal to GUI and remove from data list.
int removeReason;
switch (netLeft.gameplayerleftreason()) {
case GamePlayerLeftMessage::leftKicked:
removeReason = NTF_NET_REMOVED_KICKED;
break;
default:
removeReason = NTF_NET_REMOVED_ON_REQUEST;
break;
}
client->RemovePlayerData(netLeft.playerid(), removeReason);
}
else if (managementMsg.messagetype() == GameManagementMessage::Type_GameAdminChangedMessage) {
// New admin for the game.
const GameAdminChangedMessage &netChanged = managementMsg.gameadminchangedmessage();
// Set new game admin and signal to GUI.
client->SetNewGameAdmin(netChanged.newadminplayerid());
}
else if (managementMsg.messagetype() == GameManagementMessage::Type_GamePlayerJoinedMessage) {
// Another player joined the network game.
const GamePlayerJoinedMessage &netPlayerJoined = managementMsg.gameplayerjoinedmessage();
boost::shared_ptr<PlayerData> playerData = client->CreatePlayerData(netPlayerJoined.playerid(), netPlayerJoined.isgameadmin());
client->AddPlayerData(playerData);
}
else if (managementMsg.messagetype() == GameManagementMessage::Type_GameSpectatorJoinedMessage) {
// Another spectator joined the network game.
const GameSpectatorJoinedMessage &netSpectatorJoined = managementMsg.gamespectatorjoinedmessage();
// Request player info if needed.
PlayerInfo info;
if (!client->GetCachedPlayerInfo(netSpectatorJoined.playerid(), info)) {
client->RequestPlayerInfo(netSpectatorJoined.playerid());
}
client->ModifyGameInfoAddSpectatorDuringGame(netSpectatorJoined.playerid());
}
else if (managementMsg.messagetype() == GameManagementMessage::Type_GameSpectatorLeftMessage) {
// A spectator left the network game.
const GameSpectatorLeftMessage &netSpectatorLeft = managementMsg.gamespectatorleftmessage();
// Signal to GUI and remove from data list.
int removeReason;
switch (netSpectatorLeft.gamespectatorleftreason()) {
case GamePlayerLeftMessage::leftKicked:
removeReason = NTF_NET_REMOVED_KICKED;
break;
default:
removeReason = NTF_NET_REMOVED_ON_REQUEST;
break;
}
client->ModifyGameInfoRemoveSpectatorDuringGame(netSpectatorLeft.playerid(), removeReason);
} else if (managementMsg.messagetype() == GameManagementMessage::Type_ChatMessage) {
// Chat message - display it in the GUI.
const ChatMessage &netMessage = managementMsg.chatmessage();
string playerName;
if (netMessage.chattype() == ChatMessage::chatTypeBroadcast) {
client->GetCallback().SignalNetClientGameChatMsg("(global notice)", netMessage.chattext());
client->GetCallback().SignalNetClientLobbyChatMsg("(global notice)", netMessage.chattext());
} else if (netMessage.chattype() == ChatMessage::chatTypeBot) {
client->GetCallback().SignalNetClientGameChatMsg("(chat bot)", netMessage.chattext());
client->GetCallback().SignalNetClientLobbyChatMsg("(chat bot)", netMessage.chattext());
} else if (netMessage.chattype() == ChatMessage::chatTypeStandard) {
unsigned playerId = netMessage.playerid();
boost::shared_ptr<PlayerData> tmpPlayer = client->GetPlayerDataByUniqueId(playerId);
if (tmpPlayer.get())
playerName = tmpPlayer->GetName();
if (!playerName.empty())
client->GetCallback().SignalNetClientGameChatMsg(playerName, netMessage.chattext());
} else if (netMessage.chattype() == ChatMessage::chatTypePrivate) {
unsigned playerId = netMessage.playerid();
PlayerInfo info;
if (client->GetCachedPlayerInfo(playerId, info))
client->GetCallback().SignalNetClientPrivateChatMsg(info.playerName, netMessage.chattext());
}
} else if (managementMsg.messagetype() == GameManagementMessage::Type_ChatRejectMessage) {
const ChatRejectMessage &netMessage = managementMsg.chatrejectmessage();
client->GetCallback().SignalNetClientGameChatMsg("(notice)", "Chat rejected: " + netMessage.chattext());
client->GetCallback().SignalNetClientLobbyChatMsg("(notice)", "Chat rejected: " + netMessage.chattext());
} else if (managementMsg.messagetype() == GameManagementMessage::Type_StartKickPetitionMessage) {
const StartKickPetitionMessage &netStartPetition = managementMsg.startkickpetitionmessage();
client->StartPetition(netStartPetition.petitionid(), netStartPetition.proposingplayerid(),
netStartPetition.kickplayerid(), netStartPetition.kicktimeoutsec(), netStartPetition.numvotesneededtokick());
} else if (managementMsg.messagetype() == GameManagementMessage::Type_KickPetitionUpdateMessage) {
const KickPetitionUpdateMessage &netPetitionUpdate = managementMsg.kickpetitionupdatemessage();
client->UpdatePetition(netPetitionUpdate.petitionid(), netPetitionUpdate.numvotesagainstkicking(),
netPetitionUpdate.numvotesinfavourofkicking(), netPetitionUpdate.numvotesneededtokick());
} else if (managementMsg.messagetype() == GameManagementMessage::Type_EndKickPetitionMessage) {
const EndKickPetitionMessage &netEndPetition = managementMsg.endkickpetitionmessage();
client->EndPetition(netEndPetition.petitionid());
} else if (managementMsg.messagetype() == GameManagementMessage::Type_ErrorMessage) {
// Server reported an error.
const ErrorMessage &netError = managementMsg.errormessage();
// Show the error.
throw ClientException(__FILE__, __LINE__, NetPacket::NetErrorToGameError(netError.errorreason()), 0);
} else {
InternalHandleGameMsg(client, gameMsg);
}
} else {
InternalHandleGameMsg(client, gameMsg);
}
}
//-----------------------------------------------------------------------------
@@ -929,53 +988,42 @@ ClientStateStartSession::Exit(boost::shared_ptr<ClientThread> /*client*/)
}
void
ClientStateStartSession::InternalHandlePacket(boost::shared_ptr<ClientThread> client, boost::shared_ptr<NetPacket> tmpPacket)
ClientStateStartSession::InternalHandleAnnounceMsg(boost::shared_ptr<ClientThread> client, const AnnounceMessage &announceMsg)
{
if (tmpPacket->GetMsg()->messagetype() == PokerTHMessage::Type_AnnounceMessage) {
// Server has send announcement - check data.
const AnnounceMessage &netAnnounce = tmpPacket->GetMsg()->announcemessage();
// Check current game version.
if (netAnnounce.latestgameversion().majorversion() != POKERTH_VERSION_MAJOR
|| netAnnounce.latestgameversion().minorversion() != POKERTH_VERSION_MINOR) {
client->GetCallback().SignalNetClientNotification(NTF_NET_NEW_RELEASE_AVAILABLE);
} else if (POKERTH_BETA_REVISION && netAnnounce.latestbetarevision() != POKERTH_BETA_REVISION) {
client->GetCallback().SignalNetClientNotification(NTF_NET_OUTDATED_BETA);
}
ClientContext &context = client->GetContext();
// Server has send announcement - check data.
// Check current game version.
if (announceMsg.latestgameversion().majorversion() != POKERTH_VERSION_MAJOR
|| announceMsg.latestgameversion().minorversion() != POKERTH_VERSION_MINOR) {
client->GetCallback().SignalNetClientNotification(NTF_NET_NEW_RELEASE_AVAILABLE);
}
else if (POKERTH_BETA_REVISION && announceMsg.latestbetarevision() != POKERTH_BETA_REVISION) {
client->GetCallback().SignalNetClientNotification(NTF_NET_OUTDATED_BETA);
}
ClientContext &context = client->GetContext();
// CASE 1: Authenticated login (username, challenge/response for password).
if (netAnnounce.servertype() == AnnounceMessage::serverTypeInternetAuth) {
client->GetCallback().SignalNetClientLoginShow();
client->SetState(ClientStateWaitEnterLogin::Instance());
}
// CASE 2: Unauthenticated login (network game or dedicated server without auth backend).
else if (netAnnounce.servertype() == AnnounceMessage::serverTypeInternetNoAuth
|| netAnnounce.servertype() == AnnounceMessage::serverTypeLAN) {
boost::shared_ptr<NetPacket> init(new NetPacket);
init->GetMsg()->set_messagetype(PokerTHMessage::Type_InitMessage);
InitMessage *netInit = init->GetMsg()->mutable_initmessage();
netInit->mutable_requestedversion()->set_majorversion(NET_VERSION_MAJOR);
netInit->mutable_requestedversion()->set_minorversion(NET_VERSION_MINOR);
netInit->set_buildid(0);
if (!context.GetSessionGuid().empty()) {
netInit->set_mylastsessionid(context.GetSessionGuid());
}
if (!context.GetServerPassword().empty()) {
netInit->set_authserverpassword(context.GetServerPassword());
}
netInit->set_login(InitMessage::unauthenticatedLogin);
netInit->set_nickname(context.GetPlayerName());
string avatarFile = client->GetQtToolsInterface().stringFromUtf8(context.GetAvatarFile());
if (!avatarFile.empty()) {
MD5Buf tmpMD5;
if (client->GetAvatarManager().GetHashForAvatar(avatarFile, tmpMD5)) {
// Send MD5 hash of avatar.
netInit->set_avatarhash(tmpMD5.GetData(), MD5_DATA_SIZE);
}
}
client->GetSender().Send(context.GetSessionData(), init);
client->SetState(ClientStateWaitSession::Instance());
// CASE 1: Authenticated login (username, challenge/response for password).
if (announceMsg.servertype() == AnnounceMessage::serverTypeInternetAuth) {
client->GetCallback().SignalNetClientLoginShow();
client->SetState(ClientStateWaitEnterLogin::Instance());
}
// CASE 2: Unauthenticated login (network game or dedicated server without auth backend).
else if (announceMsg.servertype() == AnnounceMessage::serverTypeInternetNoAuth
|| announceMsg.servertype() == AnnounceMessage::serverTypeLAN) {
boost::shared_ptr<NetPacket> auth(new NetPacket);
auth->GetMsg()->set_messagetype(PokerTHMessage::Type_AuthMessage);
AuthMessage *netAuth = auth->GetMsg()->mutable_authmessage();
netAuth->set_messagetype(AuthMessage::Type_AuthClientRequestMessage);
AuthClientRequestMessage *authRequest = netAuth->mutable_authclientrequestmessage();
authRequest->mutable_requestedversion()->set_majorversion(NET_VERSION_MAJOR);
authRequest->mutable_requestedversion()->set_minorversion(NET_VERSION_MINOR);
authRequest->set_buildid(0);
if (!context.GetServerPassword().empty()) {
authRequest->set_authserverpassword(context.GetServerPassword());
}
authRequest->set_login(AuthClientRequestMessage::unauthenticatedLogin);
authRequest->set_nickname(context.GetPlayerName());
client->GetSender().Send(context.GetSessionData(), auth);
client->SetState(ClientStateWaitSession::Instance());
}
}
@@ -1013,11 +1061,11 @@ ClientStateWaitEnterLogin::Exit(boost::shared_ptr<ClientThread> client)
}
void
ClientStateWaitEnterLogin::HandlePacket(boost::shared_ptr<ClientThread> /*client*/, boost::shared_ptr<NetPacket> tmpPacket)
ClientStateWaitEnterLogin::InternalHandleAuthMsg(boost::shared_ptr<ClientThread> client, const AuthMessage &authMsg)
{
if (tmpPacket->GetMsg()->messagetype() == PokerTHMessage::Type_ErrorMessage) {
if (authMsg.messagetype() == AuthMessage::Type_ErrorMessage) {
// Server reported an error.
const ErrorMessage &netError = tmpPacket->GetMsg()->errormessage();
const ErrorMessage &netError = authMsg.errormessage();
// Show the error.
throw ClientException(__FILE__, __LINE__, NetPacket::NetErrorToGameError(netError.errorreason()), 0);
}
@@ -1030,51 +1078,44 @@ ClientStateWaitEnterLogin::TimerLoop(const boost::system::error_code& ec, boost:
ClientThread::LoginData loginData;
if (client->GetLoginData(loginData)) {
ClientContext &context = client->GetContext();
boost::shared_ptr<NetPacket> init(new NetPacket);
init->GetMsg()->set_messagetype(PokerTHMessage::Type_InitMessage);
InitMessage *netInit = init->GetMsg()->mutable_initmessage();
netInit->mutable_requestedversion()->set_majorversion(NET_VERSION_MAJOR);
netInit->mutable_requestedversion()->set_minorversion(NET_VERSION_MINOR);
netInit->set_buildid(0);
boost::shared_ptr<NetPacket> auth(new NetPacket);
auth->GetMsg()->set_messagetype(PokerTHMessage::Type_AuthMessage);
AuthMessage *netAuth = auth->GetMsg()->mutable_authmessage();
netAuth->set_messagetype(AuthMessage::Type_AuthClientRequestMessage);
AuthClientRequestMessage *authRequest = netAuth->mutable_authclientrequestmessage();
authRequest->mutable_requestedversion()->set_majorversion(NET_VERSION_MAJOR);
authRequest->mutable_requestedversion()->set_minorversion(NET_VERSION_MINOR);
authRequest->set_buildid(0);
if (!context.GetSessionGuid().empty()) {
netInit->set_mylastsessionid(context.GetSessionGuid());
authRequest->set_mylastsessionid(context.GetSessionGuid());
}
if (!context.GetServerPassword().empty()) {
netInit->set_authserverpassword(context.GetServerPassword());
authRequest->set_authserverpassword(context.GetServerPassword());
}
context.SetPlayerName(loginData.userName);
// Handle guest login first.
if (loginData.isGuest) {
context.SetPassword("");
context.SetPlayerRights(PLAYER_RIGHTS_GUEST);
netInit->set_login(InitMessage::guestLogin);
netInit->set_nickname(context.GetPlayerName());
authRequest->set_login(AuthClientRequestMessage::guestLogin);
authRequest->set_nickname(context.GetPlayerName());
client->GetSender().Send(context.GetSessionData(), init);
client->GetSender().Send(context.GetSessionData(), auth);
client->SetState(ClientStateWaitSession::Instance());
}
// If the player is not a guest, authenticate.
else {
context.SetPassword(loginData.password);
netInit->set_login(InitMessage::authenticatedLogin);
authRequest->set_login(AuthClientRequestMessage::authenticatedLogin);
// Send authentication user data for challenge/response in init.
boost::shared_ptr<SessionData> tmpSession = context.GetSessionData();
tmpSession->CreateClientAuthSession(client->GetAuthContext(), context.GetPlayerName(), context.GetPassword());
if (!tmpSession->AuthStep(1, ""))
throw ClientException(__FILE__, __LINE__, ERR_NET_INVALID_PASSWORD, 0);
string outUserData(tmpSession->AuthGetNextOutMsg());
netInit->set_clientuserdata(outUserData);
string avatarFile = client->GetQtToolsInterface().stringFromUtf8(context.GetAvatarFile());
if (!avatarFile.empty()) {
MD5Buf tmpMD5;
if (client->GetAvatarManager().GetHashForAvatar(avatarFile, tmpMD5)) {
// TODO: use sha1.
netInit->set_avatarhash(tmpMD5.GetData(), MD5_DATA_SIZE);
}
}
client->GetSender().Send(context.GetSessionData(), init);
authRequest->set_clientuserdata(outUserData);
client->GetSender().Send(context.GetSessionData(), auth);
client->SetState(ClientStateWaitAuthChallenge::Instance());
}
} else {
@@ -1115,10 +1156,10 @@ ClientStateWaitAuthChallenge::Exit(boost::shared_ptr<ClientThread> /*client*/)
}
void
ClientStateWaitAuthChallenge::InternalHandlePacket(boost::shared_ptr<ClientThread> client, boost::shared_ptr<NetPacket> tmpPacket)
ClientStateWaitAuthChallenge::InternalHandleAuthMsg(boost::shared_ptr<ClientThread> client, const AuthMessage &authMsg)
{
if (tmpPacket->GetMsg()->messagetype() == PokerTHMessage::Type_AuthServerChallengeMessage) {
const AuthServerChallengeMessage &netAuth = tmpPacket->GetMsg()->authserverchallengemessage();
if (authMsg.messagetype() == AuthMessage::Type_AuthServerChallengeMessage) {
const AuthServerChallengeMessage &netAuth = authMsg.authserverchallengemessage();
string challengeStr(netAuth.serverchallenge());
boost::shared_ptr<SessionData> tmpSession = client->GetContext().GetSessionData();
if (!tmpSession->AuthStep(2, challengeStr.c_str()))
@@ -1126,9 +1167,11 @@ ClientStateWaitAuthChallenge::InternalHandlePacket(boost::shared_ptr<ClientThrea
string outUserData(tmpSession->AuthGetNextOutMsg());
boost::shared_ptr<NetPacket> packet(new NetPacket);
packet->GetMsg()->set_messagetype(PokerTHMessage::Type_AuthClientResponseMessage);
AuthClientResponseMessage *outAuth = packet->GetMsg()->mutable_authclientresponsemessage();
outAuth->set_clientresponse(outUserData);
packet->GetMsg()->set_messagetype(PokerTHMessage::Type_AuthMessage);
AuthMessage *netAuthOut = packet->GetMsg()->mutable_authmessage();
netAuthOut->set_messagetype(AuthMessage::Type_AuthClientResponseMessage);
AuthClientResponseMessage *authResponse = netAuthOut->mutable_authclientresponsemessage();
authResponse->set_clientresponse(outUserData);
client->GetSender().Send(tmpSession, packet);
client->SetState(ClientStateWaitAuthVerify::Instance());
}
@@ -1162,16 +1205,33 @@ ClientStateWaitAuthVerify::Exit(boost::shared_ptr<ClientThread> /*client*/)
}
void
ClientStateWaitAuthVerify::InternalHandlePacket(boost::shared_ptr<ClientThread> client, boost::shared_ptr<NetPacket> tmpPacket)
ClientStateWaitAuthChallenge::InternalHandleAuthMsg(boost::shared_ptr<ClientThread> client, const AuthMessage &authMsg)
{
if (tmpPacket->GetMsg()->messagetype() == PokerTHMessage::Type_AuthServerVerificationMessage) {
if (authMsg.messagetype() == AuthMessage::Type_AuthServerVerificationMessage) {
// Check subtype.
const AuthServerVerificationMessage &netAuth = tmpPacket->GetMsg()->authserververificationmessage();
ClientContext &context = client->GetContext();
const AuthServerVerificationMessage &netAuth = authMsg.authserververificationmessage();
string verificationStr(netAuth.serververification());
boost::shared_ptr<SessionData> tmpSession = client->GetContext().GetSessionData();
boost::shared_ptr<SessionData> tmpSession = context.GetSessionData();
if (!tmpSession->AuthStep(3, verificationStr.c_str()))
throw ClientException(__FILE__, __LINE__, ERR_NET_INVALID_PASSWORD, 0);
client->SetGuiPlayerId(netAuth.yourplayerid());
context.SetSessionGuid(netAuth.yoursessionid());
boost::shared_ptr<NetPacket> init(new NetPacket);
init->GetMsg()->set_messagetype(PokerTHMessage::Type_LobbyMessage);
LobbyMessage *netLobby = init->GetMsg()->mutable_lobbymessage();
netLobby->set_messagetype(LobbyMessage::Type_InitMessage);
InitMessage *netInit = netLobby->mutable_initmessage();
string avatarFile = client->GetQtToolsInterface().stringFromUtf8(context.GetAvatarFile());
if (!avatarFile.empty()) {
MD5Buf tmpMD5;
if (client->GetAvatarManager().GetHashForAvatar(avatarFile, tmpMD5)) {
// Send MD5 hash of avatar.
netInit->set_avatarhash(tmpMD5.GetData(), MD5_DATA_SIZE);
}
}
client->GetSender().Send(context.GetSessionData(), init);
client->SetState(ClientStateWaitSession::Instance());
}
}
@@ -1204,24 +1264,20 @@ ClientStateWaitSession::Exit(boost::shared_ptr<ClientThread> /*client*/)
}
void
ClientStateWaitSession::InternalHandlePacket(boost::shared_ptr<ClientThread> client, boost::shared_ptr<NetPacket> tmpPacket)
ClientStateWaitSession::InternalHandleLobbyMsg(boost::shared_ptr<ClientThread> client, const LobbyMessage &lobbyMsg)
{
if (tmpPacket->GetMsg()->messagetype() == PokerTHMessage::Type_InitAckMessage) {
if (lobbyMsg.messagetype() == LobbyMessage::Type_InitAckMessage) {
// Everything is fine - we are in the lobby.
const InitAckMessage &netInitAck = tmpPacket->GetMsg()->initackmessage();
client->SetGuiPlayerId(netInitAck.yourplayerid());
client->GetContext().SetSessionGuid(netInitAck.yoursessionid());
const InitAckMessage &netInitAck = lobbyMsg.initackmessage();
client->SetSessionEstablished(true);
client->GetCallback().SignalNetClientConnect(MSG_SOCK_SESSION_DONE);
if (netInitAck.has_rejoingameid())
client->GetCallback().SignalNetClientRejoinPossible(netInitAck.rejoingameid());
client->SetState(ClientStateWaitJoin::Instance());
} else if (tmpPacket->GetMsg()->messagetype() == PokerTHMessage::Type_AvatarRequestMessage) {
} else if (lobbyMsg.messagetype() == LobbyMessage::Type_AvatarRequestMessage) {
// Before letting us join the lobby, the server requests our avatar.
const AvatarRequestMessage &netAvatarRequest = tmpPacket->GetMsg()->avatarrequestmessage();
const AvatarRequestMessage &netAvatarRequest = lobbyMsg.avatarrequestmessage();
// TODO compare SHA1.
NetPacketList tmpList;
int avatarError = client->GetAvatarManager().AvatarFileToNetPackets(
client->GetQtToolsInterface().stringFromUtf8(client->GetContext().GetAvatarFile()),
@@ -1367,28 +1423,33 @@ ClientStateWaitGame::Exit(boost::shared_ptr<ClientThread> /*client*/)
}
void
ClientStateWaitGame::InternalHandlePacket(boost::shared_ptr<ClientThread> client, boost::shared_ptr<NetPacket> tmpPacket)
ClientStateWaitGame::InternalHandleGameMsg(boost::shared_ptr<ClientThread> client, const GameMessage &gameMsg)
{
if (tmpPacket->GetMsg()->messagetype() == PokerTHMessage::Type_StartEventMessage) {
const StartEventMessage &netStartEvent = tmpPacket->GetMsg()->starteventmessage();
if (netStartEvent.starteventtype() == StartEventMessage::rejoinEvent) {
client->GetCallback().SignalNetClientGameInfo(MSG_NET_GAME_CLIENT_SYNCREJOIN);
} else {
client->GetCallback().SignalNetClientGameInfo(MSG_NET_GAME_CLIENT_SYNCSTART);
if (gameMsg.messagetype() == GameMessage::Type_GameManagementMessage)
{
const GameManagementMessage &managementMsg = gameMsg.gamemanagementmessage();
if (managementMsg.messagetype() == GameManagementMessage::Type_StartEventMessage) {
const StartEventMessage &netStartEvent = managementMsg.starteventmessage();
if (netStartEvent.starteventtype() == StartEventMessage::rejoinEvent) {
client->GetCallback().SignalNetClientGameInfo(MSG_NET_GAME_CLIENT_SYNCREJOIN);
}
else {
client->GetCallback().SignalNetClientGameInfo(MSG_NET_GAME_CLIENT_SYNCSTART);
}
client->SetState(ClientStateSynchronizeStart::Instance());
} else if (managementMsg.messagetype() == GameManagementMessage::Type_InviteNotifyMessage) {
const InviteNotifyMessage &netInvNotify = managementMsg.invitenotifymessage();
client->GetCallback().SignalPlayerGameInvitation(
netInvNotify.gameid(),
netInvNotify.playeridwho(),
netInvNotify.playeridbywhom());
} else if (managementMsg.messagetype() == GameManagementMessage::Type_RejectInvNotifyMessage) {
const RejectInvNotifyMessage &netRejNotify = tmpPacket->GetMsg()->rejectinvnotifymessage();
client->GetCallback().SignalRejectedGameInvitation(
netRejNotify.gameid(),
netRejNotify.playerid(),
static_cast<DenyGameInvitationReason>(netRejNotify.playerrejectreason()));
}
client->SetState(ClientStateSynchronizeStart::Instance());
} else if (tmpPacket->GetMsg()->messagetype() == PokerTHMessage::Type_InviteNotifyMessage) {
const InviteNotifyMessage &netInvNotify = tmpPacket->GetMsg()->invitenotifymessage();
client->GetCallback().SignalPlayerGameInvitation(
netInvNotify.gameid(),
netInvNotify.playeridwho(),
netInvNotify.playeridbywhom());
} else if (tmpPacket->GetMsg()->messagetype() == PokerTHMessage::Type_RejectInvNotifyMessage) {
const RejectInvNotifyMessage &netRejNotify = tmpPacket->GetMsg()->rejectinvnotifymessage();
client->GetCallback().SignalRejectedGameInvitation(
netRejNotify.gameid(),
netRejNotify.playerid(),
static_cast<DenyGameInvitationReason>(netRejNotify.playerrejectreason()));
}
}
src/net/common/netpacket.cpp
+13 -10
View File
@@ -72,17 +72,20 @@ bool
NetPacket::IsClientActivity() const
{
bool retVal = false;
bool isLobbyMsg = m_msg->messagetype() == PokerTHMessage::Type_LobbyMessage;
bool isGameManagementMsg = m_msg->messagetype() == PokerTHMessage::Type_GameMessage && m_msg->gamemessage().messagetype() == GameMessage::Type_GameManagementMessage;
bool isGameEngineMsg = m_msg->messagetype() == PokerTHMessage::Type_GameMessage && m_msg->gamemessage().messagetype() == GameMessage::Type_GameEngineMessage;
if (m_msg &&
(m_msg->messagetype() == PokerTHMessage::Type_InitMessage
|| m_msg->messagetype() == PokerTHMessage::Type_JoinNewGameMessage
|| m_msg->messagetype() == PokerTHMessage::Type_JoinExistingGameMessage
|| m_msg->messagetype() == PokerTHMessage::Type_RejoinExistingGameMessage
|| m_msg->messagetype() == PokerTHMessage::Type_KickPlayerRequestMessage
|| m_msg->messagetype() == PokerTHMessage::Type_LeaveGameRequestMessage
|| m_msg->messagetype() == PokerTHMessage::Type_StartEventMessage
|| m_msg->messagetype() == PokerTHMessage::Type_MyActionRequestMessage
|| m_msg->messagetype() == PokerTHMessage::Type_ResetTimeoutMessage
|| m_msg->messagetype() == PokerTHMessage::Type_ChatRequestMessage)) {
(isLobbyMsg && m_msg->lobbymessage().messagetype() == LobbyMessage::Type_InitMessage
|| isLobbyMsg && m_msg->lobbymessage().messagetype() == LobbyMessage::Type_CreateGameMessage
|| isLobbyMsg && m_msg->lobbymessage().messagetype() == LobbyMessage::Type_ResetTimeoutMessage
|| isGameManagementMsg && m_msg->gamemessage().gamemanagementmessage().messagetype() == GameManagementMessage::Type_JoinGameMessage
|| isGameManagementMsg && m_msg->gamemessage().gamemanagementmessage().messagetype() == GameManagementMessage::Type_RejoinGameMessage
|| isGameManagementMsg && m_msg->gamemessage().gamemanagementmessage().messagetype() == GameManagementMessage::Type_KickPlayerRequestMessage
|| isGameManagementMsg && m_msg->gamemessage().gamemanagementmessage().messagetype() == GameManagementMessage::Type_LeaveGameRequestMessage
|| isGameManagementMsg && m_msg->gamemessage().gamemanagementmessage().messagetype() == GameManagementMessage::Type_StartEventMessage
|| isGameManagementMsg && m_msg->gamemessage().gamemanagementmessage().messagetype() == GameManagementMessage::Type_ChatRequestMessage
|| isGameEngineMsg && m_msg->gamemessage().gameenginemessage().messagetype() == GameEngineMessage::Type_MyActionRequestMessage)) {
retVal = true;
}
return retVal;
src/third_party/protobuf/pokerth.pb.cc
Vendored
+6789 -5927
View File
File diff suppressed because it is too large Load Diff
src/third_party/protobuf/pokerth.pb.h
Vendored
+7536 -6872
View File
File diff suppressed because it is too large Load Diff
tests/src/de/pokerth/protocol/ProtoBuf.java
+18466 -16678
View File
File diff suppressed because it is too large Load Diff