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 ( import (
"log" "log"
"pokerth"
"sync/atomic" "sync/atomic"
) )
type Dispatcher struct { type Dispatcher struct {
handler PacketHandler receiver chan SessionPokerTHMessage
receiver chan SessionPacket authChan chan SessionAuthMessage
lobbyChan chan SessionLobbyMessage
lastSessionId uint32 lastSessionId uint32
} }
func NewDispatcher(handler PacketHandler) *Dispatcher { func NewDispatcher(authChan chan SessionAuthMessage, lobbyChan chan SessionLobbyMessage) *Dispatcher {
return &Dispatcher{handler, make(chan SessionPacket, RECV_DISPATCHER_NUM_PACKET_BUF), 0} return &Dispatcher{make(chan SessionPokerTHMessage, RECV_DISPATCHER_NUM_PACKET_BUF), authChan, lobbyChan, 0}
} }
func (d *Dispatcher) GetReceiver() *chan SessionPacket { func (d *Dispatcher) GetReceiver() chan SessionPokerTHMessage {
return &d.receiver return d.receiver
} }
func (d *Dispatcher) GetNextSessionId() uint32 { func (d *Dispatcher) GetNextSessionId() uint32 {
@@ -54,12 +56,19 @@ func (d *Dispatcher) GetNextSessionId() uint32 {
} }
func (d *Dispatcher) Run() { func (d *Dispatcher) Run() {
var sessionPacket SessionPacket var sessionMsg SessionPokerTHMessage
for { for {
select { select {
case sessionPacket = <-d.receiver: case sessionMsg = <-d.receiver:
log.Printf("Packet in dispatcher session %d type %d", sessionPacket.session.id, sessionPacket.packet.GetMessageType()) log.Printf("Packet in dispatcher session %d type %d", sessionMsg.session.id, sessionMsg.packet.GetMessageType())
d.handler.HandlePacket(sessionPacket.session, sessionPacket.packet) 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" "pokerth"
) )
type PacketHandler interface {
HandlePacket(session *Session, packet *pokerth.PokerTHMessage)
}
type Lobby struct { type Lobby struct {
receiver chan SessionLobbyMessage
sessions *list.List sessions *list.List
} }
func NewLobby() *Lobby { 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) { func (l *Lobby) AddSession(session *Session) {
@@ -71,6 +72,12 @@ func (l *Lobby) AddSession(session *Session) {
session.sender <- announce session.sender <- announce
} }
func (l *Lobby) HandlePacket(session *Session, packet *pokerth.PokerTHMessage) { func (l *Lobby) Run() {
log.Print("packet") 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_BUF_SIZE uint32 = 2 * MAX_PACKET_SIZE
const SEND_NUM_PACKET_BUF = 2048 const SEND_NUM_PACKET_BUF = 2048
const RECV_DISPATCHER_NUM_PACKET_BUF = 2048 const RECV_DISPATCHER_NUM_PACKET_BUF = 2048
const RECV_LOBBY_NUM_PACKET_BUF = 2048
type Session struct { type Session struct {
id uint32 id uint32
PacketSerializer PacketSerializer
Connection net.Conn Connection net.Conn
sender chan *pokerth.PokerTHMessage sender chan *pokerth.PokerTHMessage
receiver *chan SessionPacket receiver chan SessionPokerTHMessage
} }
type SessionPacket struct { type SessionPokerTHMessage struct {
session *Session session *Session
packet *pokerth.PokerTHMessage 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} 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") log.Print("Invalid packet")
} else { } else {
log.Printf("Packet in: %d\n", packet.GetMessageType()) log.Printf("Packet in: %d\n", packet.GetMessageType())
*s.receiver <- SessionPacket{s, packet} s.receiver <- SessionPokerTHMessage{s, packet}
remainingBytes := bufPos - bytesScanned remainingBytes := bufPos - bytesScanned
if remainingBytes > 0 { if remainingBytes > 0 {
copy(buf[0:], buf[bytesScanned:remainingBytes]) 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() { func main() {
lobby = gameserver.NewLobby() lobby = gameserver.NewLobby()
dispatcher = gameserver.NewDispatcher(lobby) dispatcher = gameserver.NewDispatcher(nil, lobby.GetReceiver())
go lobby.Run()
go dispatcher.Run() go dispatcher.Run()
listener, err := net.Listen("tcp", ":7234") listener, err := net.Listen("tcp", ":7234")
pokerth.proto
+4 -10
View File
@@ -29,16 +29,10 @@
* as that of the covered work. * * as that of the covered work. *
*****************************************************************************/ *****************************************************************************/
import "src/third_party/gogoprotobuf/gogo.proto";
option java_package = "de.pokerth.protocol"; option java_package = "de.pokerth.protocol";
option java_outer_classname = "ProtoBuf"; option java_outer_classname = "ProtoBuf";
option optimize_for = LITE_RUNTIME; 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. // Enumerations used by several messages.
enum NetGameMode { enum NetGameMode {
@@ -166,6 +160,7 @@ message AuthClientRequestMessage {
optional string nickName = 5; optional string nickName = 5;
// Authenticated login data is according to SCRAM SHA-1 // Authenticated login data is according to SCRAM SHA-1
optional bytes clientUserData = 6; optional bytes clientUserData = 6;
optional bytes myLastSessionId = 7;
} }
message AuthServerChallengeMessage { message AuthServerChallengeMessage {
@@ -183,14 +178,13 @@ message AuthServerVerificationMessage {
} }
message InitMessage { message InitMessage {
optional bytes myLastSessionId = 1;
// Ignored for guest login. // Ignored for guest login.
optional bytes avatarHash = 2; optional bytes avatarHash = 1;
} }
message InitAckMessage { message InitAckMessage {
optional bytes yourAvatarHash = 3; optional bytes yourAvatarHash = 1;
optional uint32 rejoinGameId = 4; optional uint32 rejoinGameId = 2;
} }
message AvatarRequestMessage { message AvatarRequestMessage {
src/core/common/avatarmanager.cpp
+14 -6
View File
@@ -195,13 +195,17 @@ AvatarManager::AvatarFileToNetPackets(const string &fileName, unsigned requestId
AvatarFileType fileType; AvatarFileType fileType;
boost::shared_ptr<AvatarFileState> tmpState = OpenAvatarFileForChunkRead(fileName, fileSize, fileType); boost::shared_ptr<AvatarFileState> tmpState = OpenAvatarFileForChunkRead(fileName, fileSize, fileType);
if (tmpState.get() && fileSize && fileType != AVATAR_FILE_TYPE_UNKNOWN) { if (tmpState.get() && fileSize && fileType != AVATAR_FILE_TYPE_UNKNOWN) {
{
boost::shared_ptr<NetPacket> avatarHeader(new NetPacket); boost::shared_ptr<NetPacket> avatarHeader(new NetPacket);
avatarHeader->GetMsg()->set_messagetype(PokerTHMessage::Type_AvatarHeaderMessage); avatarHeader->GetMsg()->set_messagetype(PokerTHMessage::Type_LobbyMessage);
AvatarHeaderMessage *netHeader = avatarHeader->GetMsg()->mutable_avatarheadermessage(); LobbyMessage *netLobby = avatarHeader->GetMsg()->mutable_lobbymessage();
netLobby->set_messagetype(LobbyMessage::Type_AvatarHeaderMessage);
AvatarHeaderMessage *netHeader = netLobby->mutable_avatarheadermessage();
netHeader->set_requestid(requestId); netHeader->set_requestid(requestId);
netHeader->set_avatartype(static_cast<NetAvatarType>(fileType)); netHeader->set_avatartype(static_cast<NetAvatarType>(fileType));
netHeader->set_avatarsize(fileSize); netHeader->set_avatarsize(fileSize);
packets.push_back(avatarHeader); packets.push_back(avatarHeader);
}
unsigned numBytes = 0; unsigned numBytes = 0;
unsigned totalBytesRead = 0; unsigned totalBytesRead = 0;
@@ -212,8 +216,10 @@ AvatarManager::AvatarFileToNetPackets(const string &fileName, unsigned requestId
totalBytesRead += numBytes; totalBytesRead += numBytes;
boost::shared_ptr<NetPacket> avatarFile(new NetPacket); boost::shared_ptr<NetPacket> avatarFile(new NetPacket);
avatarFile->GetMsg()->set_messagetype(PokerTHMessage::Type_AvatarDataMessage); avatarFile->GetMsg()->set_messagetype(PokerTHMessage::Type_LobbyMessage);
AvatarDataMessage *netFile = avatarFile->GetMsg()->mutable_avatardatamessage(); LobbyMessage *netLobby = avatarFile->GetMsg()->mutable_lobbymessage();
netLobby->set_messagetype(LobbyMessage::Type_AvatarDataMessage);
AvatarDataMessage *netFile = netLobby->mutable_avatardatamessage();
netFile->set_requestid(requestId); netFile->set_requestid(requestId);
netFile->set_avatarblock((const char *)&tmpData[0], numBytes); netFile->set_avatarblock((const char *)&tmpData[0], numBytes);
packets.push_back(avatarFile); packets.push_back(avatarFile);
@@ -224,8 +230,10 @@ AvatarManager::AvatarFileToNetPackets(const string &fileName, unsigned requestId
retVal = ERR_NET_WRONG_AVATAR_SIZE; retVal = ERR_NET_WRONG_AVATAR_SIZE;
else { else {
boost::shared_ptr<NetPacket> avatarEnd(new NetPacket); boost::shared_ptr<NetPacket> avatarEnd(new NetPacket);
avatarEnd->GetMsg()->set_messagetype(PokerTHMessage::Type_AvatarEndMessage); avatarEnd->GetMsg()->set_messagetype(PokerTHMessage::Type_LobbyMessage);
AvatarEndMessage *netEnd = avatarEnd->GetMsg()->mutable_avatarendmessage(); LobbyMessage *netLobby = avatarEnd->GetMsg()->mutable_lobbymessage();
netLobby->set_messagetype(LobbyMessage::Type_AvatarEndMessage);
AvatarEndMessage *netEnd = netLobby->mutable_avatarendmessage();
netEnd->set_requestid(requestId); netEnd->set_requestid(requestId);
packets.push_back(avatarEnd); packets.push_back(avatarEnd);
retVal = 0; retVal = 0;
src/net/clientstate.h
+70 -19
View File
@@ -44,8 +44,11 @@ class ClientThread;
class ClientContext; class ClientContext;
class ClientCallback; class ClientCallback;
class Game; class Game;
class NetPacket;
class DownloadHelper; class DownloadHelper;
class AnnounceMessage;
class AuthMessage;
class LobbyMessage;
class GameMessage;
class ClientState class ClientState
{ {
@@ -55,7 +58,10 @@ public:
virtual void Enter(boost::shared_ptr<ClientThread> client) = 0; virtual void Enter(boost::shared_ptr<ClientThread> client) = 0;
virtual void Exit(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. // State: Initialization.
@@ -70,7 +76,10 @@ public:
virtual void Enter(boost::shared_ptr<ClientThread> client); virtual void Enter(boost::shared_ptr<ClientThread> client);
virtual void Exit(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:
// Protected constructor - this is a singleton. // Protected constructor - this is a singleton.
@@ -89,7 +98,10 @@ public:
virtual void Enter(boost::shared_ptr<ClientThread> client); virtual void Enter(boost::shared_ptr<ClientThread> client);
virtual void Exit(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:
@@ -113,7 +125,10 @@ public:
virtual void Enter(boost::shared_ptr<ClientThread> client); virtual void Enter(boost::shared_ptr<ClientThread> client);
virtual void Exit(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:
@@ -132,7 +147,10 @@ public:
virtual void Enter(boost::shared_ptr<ClientThread> client); virtual void Enter(boost::shared_ptr<ClientThread> client);
virtual void Exit(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); void SetDownloadHelper(boost::shared_ptr<DownloadHelper> helper);
@@ -159,7 +177,10 @@ public:
virtual void Enter(boost::shared_ptr<ClientThread> client); virtual void Enter(boost::shared_ptr<ClientThread> client);
virtual void Exit(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:
@@ -177,7 +198,10 @@ public:
virtual void Enter(boost::shared_ptr<ClientThread> client); virtual void Enter(boost::shared_ptr<ClientThread> client);
virtual void Exit(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:
@@ -199,7 +223,10 @@ public:
virtual void Enter(boost::shared_ptr<ClientThread> client); virtual void Enter(boost::shared_ptr<ClientThread> client);
virtual void Exit(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); void SetRemoteEndpoint(boost::asio::ip::tcp::resolver::iterator endpointIterator);
@@ -224,12 +251,18 @@ class AbstractClientStateReceiving : public ClientState
public: public:
virtual ~AbstractClientStateReceiving(); 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: protected:
AbstractClientStateReceiving(); 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. // State: Session init.
@@ -247,11 +280,14 @@ protected:
// Protected constructor - this is a singleton. // Protected constructor - this is a singleton.
ClientStateStartSession(); 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. // State: Waiting for the user to enter login data.
class ClientStateWaitEnterLogin : public ClientState class ClientStateWaitEnterLogin : public AbstractClientStateReceiving
{ {
public: public:
static ClientStateWaitEnterLogin &Instance(); static ClientStateWaitEnterLogin &Instance();
@@ -260,14 +296,17 @@ public:
virtual void Enter(boost::shared_ptr<ClientThread> client); virtual void Enter(boost::shared_ptr<ClientThread> client);
virtual void Exit(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:
// Protected constructor - this is a singleton. // Protected constructor - this is a singleton.
ClientStateWaitEnterLogin(); ClientStateWaitEnterLogin();
void TimerLoop(const boost::system::error_code& ec, boost::shared_ptr<ClientThread> client); 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. // State: Wait for Authentication Challenge.
@@ -285,7 +324,10 @@ protected:
// Protected constructor - this is a singleton. // Protected constructor - this is a singleton.
ClientStateWaitAuthChallenge(); 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. // State: Wait for Authentication Verification.
@@ -303,7 +345,10 @@ protected:
// Protected constructor - this is a singleton. // Protected constructor - this is a singleton.
ClientStateWaitAuthVerify(); 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. // State: Wait for Session ACK.
@@ -321,7 +366,10 @@ protected:
// Protected constructor - this is a singleton. // Protected constructor - this is a singleton.
ClientStateWaitSession(); 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. // State: Wait for Join.
@@ -340,7 +388,10 @@ protected:
// Protected constructor - this is a singleton. // Protected constructor - this is a singleton.
ClientStateWaitJoin(); 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. // State: Wait for start of the game or start info.
src/net/common/clientstate.cpp
+302 -241
View File
@@ -552,10 +552,22 @@ AbstractClientStateReceiving::~AbstractClientStateReceiving()
} }
void 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) { InternalHandleAnnounceMsg(client, announceMsg);
const PlayerInfoReplyMessage &infoReply = tmpPacket->GetMsg()->playerinforeplymessage(); }
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(); unsigned playerId = infoReply.playerid();
if (infoReply.has_playerinfodata()) { if (infoReply.has_playerinfodata()) {
PlayerInfo tmpInfo; PlayerInfo tmpInfo;
@@ -575,105 +587,16 @@ AbstractClientStateReceiving::HandlePacket(boost::shared_ptr<ClientThread> clien
client->SetPlayerInfo( client->SetPlayerInfo(
playerId, playerId,
tmpInfo); tmpInfo);
} else { }
else {
client->SetUnknownPlayer(playerId); client->SetUnknownPlayer(playerId);
} }
} else if (tmpPacket->GetMsg()->messagetype() == PokerTHMessage::Type_RemovedFromGameMessage) { } else if (lobbyMsg.messagetype() == LobbyMessage::Type_TimeoutWarningMessage) {
const RemovedFromGameMessage &netRemoved = tmpPacket->GetMsg()->removedfromgamemessage(); const TimeoutWarningMessage &tmpTimeout = lobbyMsg.timeoutwarningmessage();
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();
client->GetCallback().SignalNetClientShowTimeoutDialog((NetTimeoutReason)tmpTimeout.timeoutreason(), tmpTimeout.remainingseconds()); 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. // Chat message - display it in the GUI.
const ChatMessage &netMessage = tmpPacket->GetMsg()->chatmessage(); const ChatMessage &netMessage = lobbyMsg.chatmessage();
string playerName; string playerName;
if (netMessage.chattype() == ChatMessage::chatTypeBroadcast) { if (netMessage.chattype() == ChatMessage::chatTypeBroadcast) {
@@ -682,14 +605,7 @@ AbstractClientStateReceiving::HandlePacket(boost::shared_ptr<ClientThread> clien
} else if (netMessage.chattype() == ChatMessage::chatTypeBot) { } else if (netMessage.chattype() == ChatMessage::chatTypeBot) {
client->GetCallback().SignalNetClientGameChatMsg("(chat bot)", netMessage.chattext()); client->GetCallback().SignalNetClientGameChatMsg("(chat bot)", netMessage.chattext());
client->GetCallback().SignalNetClientLobbyChatMsg("(chat bot)", netMessage.chattext()); client->GetCallback().SignalNetClientLobbyChatMsg("(chat bot)", netMessage.chattext());
} else if (netMessage.chattype() == ChatMessage::chatTypeGame) { } 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::chatTypeLobby) {
unsigned playerId = netMessage.playerid(); unsigned playerId = netMessage.playerid();
PlayerInfo info; PlayerInfo info;
if (client->GetCachedPlayerInfo(playerId, info)) if (client->GetCachedPlayerInfo(playerId, info))
@@ -700,25 +616,25 @@ AbstractClientStateReceiving::HandlePacket(boost::shared_ptr<ClientThread> clien
if (client->GetCachedPlayerInfo(playerId, info)) if (client->GetCachedPlayerInfo(playerId, info))
client->GetCallback().SignalNetClientPrivateChatMsg(info.playerName, netMessage.chattext()); client->GetCallback().SignalNetClientPrivateChatMsg(info.playerName, netMessage.chattext());
} }
} else if (tmpPacket->GetMsg()->messagetype() == PokerTHMessage::Type_ChatRejectMessage) { } else if (lobbyMsg.messagetype() == LobbyMessage::Type_ChatRejectMessage) {
const ChatRejectMessage &netMessage = tmpPacket->GetMsg()->chatrejectmessage(); const ChatRejectMessage &netMessage = lobbyMsg.chatrejectmessage();
client->GetCallback().SignalNetClientGameChatMsg("(notice)", "Chat rejected: " + netMessage.chattext()); client->GetCallback().SignalNetClientGameChatMsg("(notice)", "Chat rejected: " + netMessage.chattext());
client->GetCallback().SignalNetClientLobbyChatMsg("(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. // Message box - display it in the GUI.
const DialogMessage &netDialog = tmpPacket->GetMsg()->dialogmessage(); const DialogMessage &netDialog = lobbyMsg.dialogmessage();
client->GetCallback().SignalNetClientMsgBox(netDialog.notificationtext()); client->GetCallback().SignalNetClientMsgBox(netDialog.notificationtext());
} else if (tmpPacket->GetMsg()->messagetype() == PokerTHMessage::Type_PlayerListMessage) { } else if (lobbyMsg.messagetype() == LobbyMessage::Type_PlayerListMessage) {
const PlayerListMessage &netPlayerList = tmpPacket->GetMsg()->playerlistmessage(); const PlayerListMessage &netPlayerList = lobbyMsg.playerlistmessage();
if (netPlayerList.playerlistnotification() == PlayerListMessage::playerListNew) { if (netPlayerList.playerlistnotification() == PlayerListMessage::playerListNew) {
client->GetCallback().SignalLobbyPlayerJoined(netPlayerList.playerid(), client->GetPlayerName(netPlayerList.playerid())); client->GetCallback().SignalLobbyPlayerJoined(netPlayerList.playerid(), client->GetPlayerName(netPlayerList.playerid()));
} else if (netPlayerList.playerlistnotification() == PlayerListMessage::playerListLeft) { } else if (netPlayerList.playerlistnotification() == PlayerListMessage::playerListLeft) {
client->GetCallback().SignalLobbyPlayerLeft(netPlayerList.playerid()); 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. // 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. // Request player info for players if needed.
GameInfo tmpInfo; GameInfo tmpInfo;
@@ -751,15 +667,15 @@ AbstractClientStateReceiving::HandlePacket(boost::shared_ptr<ClientThread> clien
NetPacket::GetGameData(netListNew.gameinfo(), tmpInfo.data); NetPacket::GetGameData(netListNew.gameinfo(), tmpInfo.data);
client->AddGameInfo(netListNew.gameid(), tmpInfo); 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. // An existing game was updated on the server.
const GameListUpdateMessage &netListUpdate = tmpPacket->GetMsg()->gamelistupdatemessage(); const GameListUpdateMessage &netListUpdate = lobbyMsg.gamelistupdatemessage();
if (netListUpdate.gamemode() == netGameClosed) if (netListUpdate.gamemode() == netGameClosed)
client->RemoveGameInfo(netListUpdate.gameid()); client->RemoveGameInfo(netListUpdate.gameid());
else else
client->UpdateGameInfoMode(netListUpdate.gameid(), static_cast<GameMode>(netListUpdate.gamemode())); client->UpdateGameInfoMode(netListUpdate.gameid(), static_cast<GameMode>(netListUpdate.gamemode()));
} else if (tmpPacket->GetMsg()->messagetype() == PokerTHMessage::Type_GameListPlayerJoinedMessage) { } else if (lobbyMsg.messagetype() == LobbyMessage::Type_GameListPlayerJoinedMessage) {
const GameListPlayerJoinedMessage &netListJoined = tmpPacket->GetMsg()->gamelistplayerjoinedmessage(); const GameListPlayerJoinedMessage &netListJoined = lobbyMsg.gamelistplayerjoinedmessage();
client->ModifyGameInfoAddPlayer(netListJoined.gameid(), netListJoined.playerid()); client->ModifyGameInfoAddPlayer(netListJoined.gameid(), netListJoined.playerid());
// Request player info if needed. // Request player info if needed.
@@ -767,12 +683,12 @@ AbstractClientStateReceiving::HandlePacket(boost::shared_ptr<ClientThread> clien
if (!client->GetCachedPlayerInfo(netListJoined.playerid(), info)) { if (!client->GetCachedPlayerInfo(netListJoined.playerid(), info)) {
client->RequestPlayerInfo(netListJoined.playerid()); client->RequestPlayerInfo(netListJoined.playerid());
} }
} else if (tmpPacket->GetMsg()->messagetype() == PokerTHMessage::Type_GameListPlayerLeftMessage) { } else if (lobbyMsg.messagetype() == LobbyMessage::Type_GameListPlayerLeftMessage) {
const GameListPlayerLeftMessage &netListLeft = tmpPacket->GetMsg()->gamelistplayerleftmessage(); const GameListPlayerLeftMessage &netListLeft = lobbyMsg.gamelistplayerleftmessage();
client->ModifyGameInfoRemovePlayer(netListLeft.gameid(), netListLeft.playerid()); client->ModifyGameInfoRemovePlayer(netListLeft.gameid(), netListLeft.playerid());
} else if (tmpPacket->GetMsg()->messagetype() == PokerTHMessage::Type_GameListSpectatorJoinedMessage) { } else if (lobbyMsg.messagetype() == LobbyMessage::Type_GameListSpectatorJoinedMessage) {
const GameListSpectatorJoinedMessage &netListJoined = tmpPacket->GetMsg()->gamelistspectatorjoinedmessage(); const GameListSpectatorJoinedMessage &netListJoined = lobbyMsg.gamelistspectatorjoinedmessage();
client->ModifyGameInfoAddSpectator(netListJoined.gameid(), netListJoined.playerid()); client->ModifyGameInfoAddSpectator(netListJoined.gameid(), netListJoined.playerid());
// Request player info if needed. // Request player info if needed.
@@ -780,41 +696,30 @@ AbstractClientStateReceiving::HandlePacket(boost::shared_ptr<ClientThread> clien
if (!client->GetCachedPlayerInfo(netListJoined.playerid(), info)) { if (!client->GetCachedPlayerInfo(netListJoined.playerid(), info)) {
client->RequestPlayerInfo(netListJoined.playerid()); client->RequestPlayerInfo(netListJoined.playerid());
} }
} else if (tmpPacket->GetMsg()->messagetype() == PokerTHMessage::Type_GameListSpectatorLeftMessage) { } else if (lobbyMsg.messagetype() == LobbyMessage::Type_GameListSpectatorLeftMessage) {
const GameListSpectatorLeftMessage &netListLeft = tmpPacket->GetMsg()->gamelistspectatorleftmessage(); const GameListSpectatorLeftMessage &netListLeft = lobbyMsg.gamelistspectatorleftmessage();
client->ModifyGameInfoRemoveSpectator(netListLeft.gameid(), netListLeft.playerid()); client->ModifyGameInfoRemoveSpectator(netListLeft.gameid(), netListLeft.playerid());
} else if (tmpPacket->GetMsg()->messagetype() == PokerTHMessage::Type_GameListAdminChangedMessage) { } else if (lobbyMsg.messagetype() == LobbyMessage::Type_GameListAdminChangedMessage) {
const GameListAdminChangedMessage &netListAdmin = tmpPacket->GetMsg()->gamelistadminchangedmessage(); const GameListAdminChangedMessage &netListAdmin = lobbyMsg.gamelistadminchangedmessage();
client->UpdateGameInfoAdmin(netListAdmin.gameid(), netListAdmin.newadminplayerid()); client->UpdateGameInfoAdmin(netListAdmin.gameid(), netListAdmin.newadminplayerid());
} else if (tmpPacket->GetMsg()->messagetype() == PokerTHMessage::Type_StartKickPetitionMessage) { } else if (lobbyMsg.messagetype() == LobbyMessage::Type_AvatarHeaderMessage) {
const StartKickPetitionMessage &netStartPetition = tmpPacket->GetMsg()->startkickpetitionmessage(); const AvatarHeaderMessage &netAvatarHeader = lobbyMsg.avatarheadermessage();
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();
client->AddTempAvatarFile(netAvatarHeader.requestid(), netAvatarHeader.avatarsize(), static_cast<AvatarFileType>(netAvatarHeader.avatartype())); client->AddTempAvatarFile(netAvatarHeader.requestid(), netAvatarHeader.avatarsize(), static_cast<AvatarFileType>(netAvatarHeader.avatartype()));
} else if (tmpPacket->GetMsg()->messagetype() == PokerTHMessage::Type_AvatarDataMessage) { } else if (lobbyMsg.messagetype() == LobbyMessage::Type_AvatarDataMessage) {
const AvatarDataMessage &netAvatarData = tmpPacket->GetMsg()->avatardatamessage(); const AvatarDataMessage &netAvatarData = lobbyMsg.avatardatamessage();
vector<unsigned char> fileData(netAvatarData.avatarblock().size()); vector<unsigned char> fileData(netAvatarData.avatarblock().size());
memcpy(&fileData[0], netAvatarData.avatarblock().data(), netAvatarData.avatarblock().size()); memcpy(&fileData[0], netAvatarData.avatarblock().data(), netAvatarData.avatarblock().size());
client->StoreInTempAvatarFile(netAvatarData.requestid(), fileData); client->StoreInTempAvatarFile(netAvatarData.requestid(), fileData);
} else if (tmpPacket->GetMsg()->messagetype() == PokerTHMessage::Type_AvatarEndMessage) { } else if (lobbyMsg.messagetype() == LobbyMessage::Type_AvatarEndMessage) {
const AvatarEndMessage &netAvatarEnd = tmpPacket->GetMsg()->avatarendmessage(); const AvatarEndMessage &netAvatarEnd = lobbyMsg.avatarendmessage();
client->CompleteTempAvatarFile(netAvatarEnd.requestid()); client->CompleteTempAvatarFile(netAvatarEnd.requestid());
} else if (tmpPacket->GetMsg()->messagetype() == PokerTHMessage::Type_UnknownAvatarMessage) { } else if (lobbyMsg.messagetype() == LobbyMessage::Type_UnknownAvatarMessage) {
const UnknownAvatarMessage &netUnknownAvatar = tmpPacket->GetMsg()->unknownavatarmessage(); const UnknownAvatarMessage &netUnknownAvatar = lobbyMsg.unknownavatarmessage();
client->SetUnknownAvatar(netUnknownAvatar.requestid()); client->SetUnknownAvatar(netUnknownAvatar.requestid());
} else if (tmpPacket->GetMsg()->messagetype() == PokerTHMessage::Type_ReportAvatarAckMessage) { } else if (lobbyMsg.messagetype() == LobbyMessage::Type_ReportAvatarAckMessage) {
const ReportAvatarAckMessage &netReportAck = tmpPacket->GetMsg()->reportavatarackmessage(); const ReportAvatarAckMessage &netReportAck = lobbyMsg.reportavatarackmessage();
unsigned msgCode; unsigned msgCode;
switch (netReportAck.reportavatarresult()) { switch (netReportAck.reportavatarresult()) {
case ReportAvatarAckMessage::avatarReportAccepted: case ReportAvatarAckMessage::avatarReportAccepted:
@@ -828,8 +733,9 @@ AbstractClientStateReceiving::HandlePacket(boost::shared_ptr<ClientThread> clien
break; break;
} }
client->GetCallback().SignalNetClientMsgBox(msgCode); 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; unsigned msgCode;
switch (netReportAck.reportgameresult()) { switch (netReportAck.reportgameresult()) {
case ReportGameAckMessage::gameReportAccepted: case ReportGameAckMessage::gameReportAccepted:
@@ -843,8 +749,8 @@ AbstractClientStateReceiving::HandlePacket(boost::shared_ptr<ClientThread> clien
break; break;
} }
client->GetCallback().SignalNetClientMsgBox(msgCode); client->GetCallback().SignalNetClientMsgBox(msgCode);
} else if (tmpPacket->GetMsg()->messagetype() == PokerTHMessage::Type_AdminRemoveGameAckMessage) { } else if (lobbyMsg.messagetype() == LobbyMessage::Type_AdminRemoveGameAckMessage) {
const AdminRemoveGameAckMessage &netRemoveAck = tmpPacket->GetMsg()->adminremovegameackmessage(); const AdminRemoveGameAckMessage &netRemoveAck = lobbyMsg.adminremovegameackmessage();
unsigned msgCode; unsigned msgCode;
switch (netRemoveAck.removegameresult()) { switch (netRemoveAck.removegameresult()) {
case AdminRemoveGameAckMessage::gameRemoveAccepted: case AdminRemoveGameAckMessage::gameRemoveAccepted:
@@ -855,8 +761,8 @@ AbstractClientStateReceiving::HandlePacket(boost::shared_ptr<ClientThread> clien
break; break;
} }
client->GetCallback().SignalNetClientMsgBox(msgCode); client->GetCallback().SignalNetClientMsgBox(msgCode);
} else if (tmpPacket->GetMsg()->messagetype() == PokerTHMessage::Type_AdminBanPlayerAckMessage) { } else if (lobbyMsg.messagetype() == LobbyMessage::Type_AdminBanPlayerAckMessage) {
const AdminBanPlayerAckMessage &netBanAck = tmpPacket->GetMsg()->adminbanplayerackmessage(); const AdminBanPlayerAckMessage &netBanAck = lobbyMsg.adminbanplayerackmessage();
unsigned msgCode; unsigned msgCode;
switch (netBanAck.banplayerresult()) { switch (netBanAck.banplayerresult()) {
case AdminBanPlayerAckMessage::banPlayerAccepted: case AdminBanPlayerAckMessage::banPlayerAccepted:
@@ -876,8 +782,8 @@ AbstractClientStateReceiving::HandlePacket(boost::shared_ptr<ClientThread> clien
break; break;
} }
client->GetCallback().SignalNetClientMsgBox(msgCode); client->GetCallback().SignalNetClientMsgBox(msgCode);
} else if (tmpPacket->GetMsg()->messagetype() == PokerTHMessage::Type_StatisticsMessage) { } else if (lobbyMsg.messagetype() == LobbyMessage::Type_StatisticsMessage) {
const StatisticsMessage &netStatistics = tmpPacket->GetMsg()->statisticsmessage(); const StatisticsMessage &netStatistics = lobbyMsg.statisticsmessage();
unsigned numStats = netStatistics.statisticsdata_size(); unsigned numStats = netStatistics.statisticsdata_size();
// Request player info for players if needed. // Request player info for players if needed.
@@ -889,14 +795,167 @@ AbstractClientStateReceiving::HandlePacket(boost::shared_ptr<ClientThread> clien
} }
client->UpdateStatData(tmpStats); client->UpdateStatData(tmpStats);
} }
} else if (tmpPacket->GetMsg()->messagetype() == PokerTHMessage::Type_ErrorMessage) { } else if (lobbyMsg.messagetype() == GameManagementMessage::Type_ErrorMessage) {
// Server reported an error. // Server reported an error.
const ErrorMessage &netError = tmpPacket->GetMsg()->errormessage(); const ErrorMessage &netError = lobbyMsg.errormessage();
// Show the error. // Show the error.
throw ClientException(__FILE__, __LINE__, NetPacket::NetErrorToGameError(netError.errorreason()), 0); 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,54 +988,43 @@ ClientStateStartSession::Exit(boost::shared_ptr<ClientThread> /*client*/)
} }
void 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. // Server has send announcement - check data.
const AnnounceMessage &netAnnounce = tmpPacket->GetMsg()->announcemessage();
// Check current game version. // Check current game version.
if (netAnnounce.latestgameversion().majorversion() != POKERTH_VERSION_MAJOR if (announceMsg.latestgameversion().majorversion() != POKERTH_VERSION_MAJOR
|| netAnnounce.latestgameversion().minorversion() != POKERTH_VERSION_MINOR) { || announceMsg.latestgameversion().minorversion() != POKERTH_VERSION_MINOR) {
client->GetCallback().SignalNetClientNotification(NTF_NET_NEW_RELEASE_AVAILABLE); client->GetCallback().SignalNetClientNotification(NTF_NET_NEW_RELEASE_AVAILABLE);
} else if (POKERTH_BETA_REVISION && netAnnounce.latestbetarevision() != POKERTH_BETA_REVISION) { }
else if (POKERTH_BETA_REVISION && announceMsg.latestbetarevision() != POKERTH_BETA_REVISION) {
client->GetCallback().SignalNetClientNotification(NTF_NET_OUTDATED_BETA); client->GetCallback().SignalNetClientNotification(NTF_NET_OUTDATED_BETA);
} }
ClientContext &context = client->GetContext(); ClientContext &context = client->GetContext();
// CASE 1: Authenticated login (username, challenge/response for password). // CASE 1: Authenticated login (username, challenge/response for password).
if (netAnnounce.servertype() == AnnounceMessage::serverTypeInternetAuth) { if (announceMsg.servertype() == AnnounceMessage::serverTypeInternetAuth) {
client->GetCallback().SignalNetClientLoginShow(); client->GetCallback().SignalNetClientLoginShow();
client->SetState(ClientStateWaitEnterLogin::Instance()); client->SetState(ClientStateWaitEnterLogin::Instance());
} }
// CASE 2: Unauthenticated login (network game or dedicated server without auth backend). // CASE 2: Unauthenticated login (network game or dedicated server without auth backend).
else if (netAnnounce.servertype() == AnnounceMessage::serverTypeInternetNoAuth else if (announceMsg.servertype() == AnnounceMessage::serverTypeInternetNoAuth
|| netAnnounce.servertype() == AnnounceMessage::serverTypeLAN) { || announceMsg.servertype() == AnnounceMessage::serverTypeLAN) {
boost::shared_ptr<NetPacket> init(new NetPacket); boost::shared_ptr<NetPacket> auth(new NetPacket);
init->GetMsg()->set_messagetype(PokerTHMessage::Type_InitMessage); auth->GetMsg()->set_messagetype(PokerTHMessage::Type_AuthMessage);
InitMessage *netInit = init->GetMsg()->mutable_initmessage(); AuthMessage *netAuth = auth->GetMsg()->mutable_authmessage();
netInit->mutable_requestedversion()->set_majorversion(NET_VERSION_MAJOR); netAuth->set_messagetype(AuthMessage::Type_AuthClientRequestMessage);
netInit->mutable_requestedversion()->set_minorversion(NET_VERSION_MINOR); AuthClientRequestMessage *authRequest = netAuth->mutable_authclientrequestmessage();
netInit->set_buildid(0); authRequest->mutable_requestedversion()->set_majorversion(NET_VERSION_MAJOR);
if (!context.GetSessionGuid().empty()) { authRequest->mutable_requestedversion()->set_minorversion(NET_VERSION_MINOR);
netInit->set_mylastsessionid(context.GetSessionGuid()); authRequest->set_buildid(0);
}
if (!context.GetServerPassword().empty()) { if (!context.GetServerPassword().empty()) {
netInit->set_authserverpassword(context.GetServerPassword()); authRequest->set_authserverpassword(context.GetServerPassword());
} }
netInit->set_login(InitMessage::unauthenticatedLogin); authRequest->set_login(AuthClientRequestMessage::unauthenticatedLogin);
netInit->set_nickname(context.GetPlayerName()); authRequest->set_nickname(context.GetPlayerName());
string avatarFile = client->GetQtToolsInterface().stringFromUtf8(context.GetAvatarFile()); client->GetSender().Send(context.GetSessionData(), auth);
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()); client->SetState(ClientStateWaitSession::Instance());
} }
}
} }
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
@@ -1013,11 +1061,11 @@ ClientStateWaitEnterLogin::Exit(boost::shared_ptr<ClientThread> client)
} }
void 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. // Server reported an error.
const ErrorMessage &netError = tmpPacket->GetMsg()->errormessage(); const ErrorMessage &netError = authMsg.errormessage();
// Show the error. // Show the error.
throw ClientException(__FILE__, __LINE__, NetPacket::NetErrorToGameError(netError.errorreason()), 0); 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; ClientThread::LoginData loginData;
if (client->GetLoginData(loginData)) { if (client->GetLoginData(loginData)) {
ClientContext &context = client->GetContext(); ClientContext &context = client->GetContext();
boost::shared_ptr<NetPacket> init(new NetPacket); boost::shared_ptr<NetPacket> auth(new NetPacket);
init->GetMsg()->set_messagetype(PokerTHMessage::Type_InitMessage); auth->GetMsg()->set_messagetype(PokerTHMessage::Type_AuthMessage);
InitMessage *netInit = init->GetMsg()->mutable_initmessage(); AuthMessage *netAuth = auth->GetMsg()->mutable_authmessage();
netInit->mutable_requestedversion()->set_majorversion(NET_VERSION_MAJOR); netAuth->set_messagetype(AuthMessage::Type_AuthClientRequestMessage);
netInit->mutable_requestedversion()->set_minorversion(NET_VERSION_MINOR); AuthClientRequestMessage *authRequest = netAuth->mutable_authclientrequestmessage();
netInit->set_buildid(0); authRequest->mutable_requestedversion()->set_majorversion(NET_VERSION_MAJOR);
authRequest->mutable_requestedversion()->set_minorversion(NET_VERSION_MINOR);
authRequest->set_buildid(0);
if (!context.GetSessionGuid().empty()) { if (!context.GetSessionGuid().empty()) {
netInit->set_mylastsessionid(context.GetSessionGuid()); authRequest->set_mylastsessionid(context.GetSessionGuid());
} }
if (!context.GetServerPassword().empty()) { if (!context.GetServerPassword().empty()) {
netInit->set_authserverpassword(context.GetServerPassword()); authRequest->set_authserverpassword(context.GetServerPassword());
} }
context.SetPlayerName(loginData.userName); context.SetPlayerName(loginData.userName);
// Handle guest login first. // Handle guest login first.
if (loginData.isGuest) { if (loginData.isGuest) {
context.SetPassword(""); context.SetPassword("");
context.SetPlayerRights(PLAYER_RIGHTS_GUEST); context.SetPlayerRights(PLAYER_RIGHTS_GUEST);
netInit->set_login(InitMessage::guestLogin); authRequest->set_login(AuthClientRequestMessage::guestLogin);
netInit->set_nickname(context.GetPlayerName()); authRequest->set_nickname(context.GetPlayerName());
client->GetSender().Send(context.GetSessionData(), init); client->GetSender().Send(context.GetSessionData(), auth);
client->SetState(ClientStateWaitSession::Instance()); client->SetState(ClientStateWaitSession::Instance());
} }
// If the player is not a guest, authenticate. // If the player is not a guest, authenticate.
else { else {
context.SetPassword(loginData.password); context.SetPassword(loginData.password);
netInit->set_login(InitMessage::authenticatedLogin); authRequest->set_login(AuthClientRequestMessage::authenticatedLogin);
// Send authentication user data for challenge/response in init. // Send authentication user data for challenge/response in init.
boost::shared_ptr<SessionData> tmpSession = context.GetSessionData(); boost::shared_ptr<SessionData> tmpSession = context.GetSessionData();
tmpSession->CreateClientAuthSession(client->GetAuthContext(), context.GetPlayerName(), context.GetPassword()); tmpSession->CreateClientAuthSession(client->GetAuthContext(), context.GetPlayerName(), context.GetPassword());
if (!tmpSession->AuthStep(1, "")) if (!tmpSession->AuthStep(1, ""))
throw ClientException(__FILE__, __LINE__, ERR_NET_INVALID_PASSWORD, 0); throw ClientException(__FILE__, __LINE__, ERR_NET_INVALID_PASSWORD, 0);
string outUserData(tmpSession->AuthGetNextOutMsg()); string outUserData(tmpSession->AuthGetNextOutMsg());
netInit->set_clientuserdata(outUserData); authRequest->set_clientuserdata(outUserData);
string avatarFile = client->GetQtToolsInterface().stringFromUtf8(context.GetAvatarFile()); client->GetSender().Send(context.GetSessionData(), auth);
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);
client->SetState(ClientStateWaitAuthChallenge::Instance()); client->SetState(ClientStateWaitAuthChallenge::Instance());
} }
} else { } else {
@@ -1115,10 +1156,10 @@ ClientStateWaitAuthChallenge::Exit(boost::shared_ptr<ClientThread> /*client*/)
} }
void 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) { if (authMsg.messagetype() == AuthMessage::Type_AuthServerChallengeMessage) {
const AuthServerChallengeMessage &netAuth = tmpPacket->GetMsg()->authserverchallengemessage(); const AuthServerChallengeMessage &netAuth = authMsg.authserverchallengemessage();
string challengeStr(netAuth.serverchallenge()); string challengeStr(netAuth.serverchallenge());
boost::shared_ptr<SessionData> tmpSession = client->GetContext().GetSessionData(); boost::shared_ptr<SessionData> tmpSession = client->GetContext().GetSessionData();
if (!tmpSession->AuthStep(2, challengeStr.c_str())) if (!tmpSession->AuthStep(2, challengeStr.c_str()))
@@ -1126,9 +1167,11 @@ ClientStateWaitAuthChallenge::InternalHandlePacket(boost::shared_ptr<ClientThrea
string outUserData(tmpSession->AuthGetNextOutMsg()); string outUserData(tmpSession->AuthGetNextOutMsg());
boost::shared_ptr<NetPacket> packet(new NetPacket); boost::shared_ptr<NetPacket> packet(new NetPacket);
packet->GetMsg()->set_messagetype(PokerTHMessage::Type_AuthClientResponseMessage); packet->GetMsg()->set_messagetype(PokerTHMessage::Type_AuthMessage);
AuthClientResponseMessage *outAuth = packet->GetMsg()->mutable_authclientresponsemessage(); AuthMessage *netAuthOut = packet->GetMsg()->mutable_authmessage();
outAuth->set_clientresponse(outUserData); netAuthOut->set_messagetype(AuthMessage::Type_AuthClientResponseMessage);
AuthClientResponseMessage *authResponse = netAuthOut->mutable_authclientresponsemessage();
authResponse->set_clientresponse(outUserData);
client->GetSender().Send(tmpSession, packet); client->GetSender().Send(tmpSession, packet);
client->SetState(ClientStateWaitAuthVerify::Instance()); client->SetState(ClientStateWaitAuthVerify::Instance());
} }
@@ -1162,16 +1205,33 @@ ClientStateWaitAuthVerify::Exit(boost::shared_ptr<ClientThread> /*client*/)
} }
void 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. // Check subtype.
const AuthServerVerificationMessage &netAuth = tmpPacket->GetMsg()->authserververificationmessage(); ClientContext &context = client->GetContext();
const AuthServerVerificationMessage &netAuth = authMsg.authserververificationmessage();
string verificationStr(netAuth.serververification()); 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())) if (!tmpSession->AuthStep(3, verificationStr.c_str()))
throw ClientException(__FILE__, __LINE__, ERR_NET_INVALID_PASSWORD, 0); 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()); client->SetState(ClientStateWaitSession::Instance());
} }
} }
@@ -1204,24 +1264,20 @@ ClientStateWaitSession::Exit(boost::shared_ptr<ClientThread> /*client*/)
} }
void 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. // Everything is fine - we are in the lobby.
const InitAckMessage &netInitAck = tmpPacket->GetMsg()->initackmessage(); const InitAckMessage &netInitAck = lobbyMsg.initackmessage();
client->SetGuiPlayerId(netInitAck.yourplayerid());
client->GetContext().SetSessionGuid(netInitAck.yoursessionid());
client->SetSessionEstablished(true); client->SetSessionEstablished(true);
client->GetCallback().SignalNetClientConnect(MSG_SOCK_SESSION_DONE); client->GetCallback().SignalNetClientConnect(MSG_SOCK_SESSION_DONE);
if (netInitAck.has_rejoingameid()) if (netInitAck.has_rejoingameid())
client->GetCallback().SignalNetClientRejoinPossible(netInitAck.rejoingameid()); client->GetCallback().SignalNetClientRejoinPossible(netInitAck.rejoingameid());
client->SetState(ClientStateWaitJoin::Instance()); 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. // 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; NetPacketList tmpList;
int avatarError = client->GetAvatarManager().AvatarFileToNetPackets( int avatarError = client->GetAvatarManager().AvatarFileToNetPackets(
client->GetQtToolsInterface().stringFromUtf8(client->GetContext().GetAvatarFile()), client->GetQtToolsInterface().stringFromUtf8(client->GetContext().GetAvatarFile()),
@@ -1367,29 +1423,34 @@ ClientStateWaitGame::Exit(boost::shared_ptr<ClientThread> /*client*/)
} }
void 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) { if (gameMsg.messagetype() == GameMessage::Type_GameManagementMessage)
const StartEventMessage &netStartEvent = tmpPacket->GetMsg()->starteventmessage(); {
const GameManagementMessage &managementMsg = gameMsg.gamemanagementmessage();
if (managementMsg.messagetype() == GameManagementMessage::Type_StartEventMessage) {
const StartEventMessage &netStartEvent = managementMsg.starteventmessage();
if (netStartEvent.starteventtype() == StartEventMessage::rejoinEvent) { if (netStartEvent.starteventtype() == StartEventMessage::rejoinEvent) {
client->GetCallback().SignalNetClientGameInfo(MSG_NET_GAME_CLIENT_SYNCREJOIN); client->GetCallback().SignalNetClientGameInfo(MSG_NET_GAME_CLIENT_SYNCREJOIN);
} else { }
else {
client->GetCallback().SignalNetClientGameInfo(MSG_NET_GAME_CLIENT_SYNCSTART); client->GetCallback().SignalNetClientGameInfo(MSG_NET_GAME_CLIENT_SYNCSTART);
} }
client->SetState(ClientStateSynchronizeStart::Instance()); client->SetState(ClientStateSynchronizeStart::Instance());
} else if (tmpPacket->GetMsg()->messagetype() == PokerTHMessage::Type_InviteNotifyMessage) { } else if (managementMsg.messagetype() == GameManagementMessage::Type_InviteNotifyMessage) {
const InviteNotifyMessage &netInvNotify = tmpPacket->GetMsg()->invitenotifymessage(); const InviteNotifyMessage &netInvNotify = managementMsg.invitenotifymessage();
client->GetCallback().SignalPlayerGameInvitation( client->GetCallback().SignalPlayerGameInvitation(
netInvNotify.gameid(), netInvNotify.gameid(),
netInvNotify.playeridwho(), netInvNotify.playeridwho(),
netInvNotify.playeridbywhom()); netInvNotify.playeridbywhom());
} else if (tmpPacket->GetMsg()->messagetype() == PokerTHMessage::Type_RejectInvNotifyMessage) { } else if (managementMsg.messagetype() == GameManagementMessage::Type_RejectInvNotifyMessage) {
const RejectInvNotifyMessage &netRejNotify = tmpPacket->GetMsg()->rejectinvnotifymessage(); const RejectInvNotifyMessage &netRejNotify = tmpPacket->GetMsg()->rejectinvnotifymessage();
client->GetCallback().SignalRejectedGameInvitation( client->GetCallback().SignalRejectedGameInvitation(
netRejNotify.gameid(), netRejNotify.gameid(),
netRejNotify.playerid(), netRejNotify.playerid(),
static_cast<DenyGameInvitationReason>(netRejNotify.playerrejectreason())); static_cast<DenyGameInvitationReason>(netRejNotify.playerrejectreason()));
} }
}
} }
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
src/net/common/netpacket.cpp
+13 -10
View File
@@ -72,17 +72,20 @@ bool
NetPacket::IsClientActivity() const NetPacket::IsClientActivity() const
{ {
bool retVal = false; 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 && if (m_msg &&
(m_msg->messagetype() == PokerTHMessage::Type_InitMessage (isLobbyMsg && m_msg->lobbymessage().messagetype() == LobbyMessage::Type_InitMessage
|| m_msg->messagetype() == PokerTHMessage::Type_JoinNewGameMessage || isLobbyMsg && m_msg->lobbymessage().messagetype() == LobbyMessage::Type_CreateGameMessage
|| m_msg->messagetype() == PokerTHMessage::Type_JoinExistingGameMessage || isLobbyMsg && m_msg->lobbymessage().messagetype() == LobbyMessage::Type_ResetTimeoutMessage
|| m_msg->messagetype() == PokerTHMessage::Type_RejoinExistingGameMessage || isGameManagementMsg && m_msg->gamemessage().gamemanagementmessage().messagetype() == GameManagementMessage::Type_JoinGameMessage
|| m_msg->messagetype() == PokerTHMessage::Type_KickPlayerRequestMessage || isGameManagementMsg && m_msg->gamemessage().gamemanagementmessage().messagetype() == GameManagementMessage::Type_RejoinGameMessage
|| m_msg->messagetype() == PokerTHMessage::Type_LeaveGameRequestMessage || isGameManagementMsg && m_msg->gamemessage().gamemanagementmessage().messagetype() == GameManagementMessage::Type_KickPlayerRequestMessage
|| m_msg->messagetype() == PokerTHMessage::Type_StartEventMessage || isGameManagementMsg && m_msg->gamemessage().gamemanagementmessage().messagetype() == GameManagementMessage::Type_LeaveGameRequestMessage
|| m_msg->messagetype() == PokerTHMessage::Type_MyActionRequestMessage || isGameManagementMsg && m_msg->gamemessage().gamemanagementmessage().messagetype() == GameManagementMessage::Type_StartEventMessage
|| m_msg->messagetype() == PokerTHMessage::Type_ResetTimeoutMessage || isGameManagementMsg && m_msg->gamemessage().gamemanagementmessage().messagetype() == GameManagementMessage::Type_ChatRequestMessage
|| m_msg->messagetype() == PokerTHMessage::Type_ChatRequestMessage)) { || isGameEngineMsg && m_msg->gamemessage().gameenginemessage().messagetype() == GameEngineMessage::Type_MyActionRequestMessage)) {
retVal = true; retVal = true;
} }
return retVal; return retVal;
src/third_party/protobuf/pokerth.pb.cc
Vendored
+6781 -5919
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
+18461 -16673
View File
File diff suppressed because it is too large Load Diff