client__lobby_8hpp_source.html

 //

 //  SuperTuxKart - a fun racing game with go-kart

 //  Copyright (C) 2018 SuperTuxKart-Team

 //

 //  This program is free software; you can redistribute it and/or

 //  modify it under the terms of the GNU General Public License

 //  as published by the Free Software Foundation; either version 3

 //  of the License, or (at your option) any later version.

 //

 //  This program is distributed in the hope that it will be useful,

 //  but WITHOUT ANY WARRANTY; without even the implied warranty of

 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 //  GNU General Public License for more details.

 //

 //  You should have received a copy of the GNU General Public License

 //  along with this program; if not, write to the Free Software

 //  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.


 #ifndef CLIENT_LOBBY_HPP

 #define CLIENT_LOBBY_HPP


 #include "input/input.hpp"

 #include "network/protocols/lobby_protocol.hpp"

 #include "utils/cpp2011.hpp"


 #include <enet/enet.h>


 #include <atomic>

 #include <map>

 #include <memory>

 #include <set>


 enum PeerDisconnectInfo : unsigned int;

 enum KartTeam : int8_t;

 enum HandicapLevel : uint8_t;


 class BareNetworkString;

 class Server;


 namespace Online

 {

     class HTTPRequest;

 }


 struct LobbyPlayer

 {

     irr::core::stringw m_user_name;

     int m_local_player_id;

     uint32_t m_host_id;

     KartTeam m_kart_team;

     HandicapLevel m_handicap;

     uint32_t m_online_id;

     /* Icon used in networking lobby, see NetworkingLobby::loadedFromFile. */

     int m_icon_id;

     std::string m_country_code;

     /* Icon id for spectator in NetworkingLobby::loadedFromFile is 5. */

     bool isSpectator() const { return m_icon_id == 5; }

     bool isAI() const { return m_icon_id == 6; }

 };


 class ClientLobby : public LobbyProtocol

 {

 private:

     void disconnectedPlayer(Event* event);

     void connectionAccepted(Event* event);

     void connectionRefused(Event* event);

     void startGame(Event* event);

     void startSelection(Event* event);

     void raceFinished(Event* event);

     void backToLobby(Event *event);

     // race votes

     void receivePlayerVote(Event* event);

     void updatePlayerList(Event* event);

     void handleChat(Event* event);

     void handleServerInfo(Event* event);

     void reportSuccess(Event* event);

     void handleBadTeam();

     void handleBadConnection();

     void becomingServerOwner();


     std::shared_ptr<Server> m_server;


     enum ClientState : unsigned int

     {

         NONE,

         LINKED,

         REQUESTING_CONNECTION,

         CONNECTED,              // means in the lobby room

         SELECTING_ASSETS,       // in the kart selection or tracks screen

         RACING,                 // racing

         RACE_FINISHED,          // race result shown

         DONE,

         EXITING

     };


     bool m_waiting_for_game;


     bool m_server_auto_game_time;


     bool m_received_server_result;


     bool m_auto_started;


     bool m_first_connect;


     bool m_spectator;


     bool m_server_live_joinable;


     bool m_server_send_live_load_world;


     bool m_server_enabled_chat;


     bool m_server_enabled_track_voting;


     bool m_server_enabled_report_player;


     uint64_t m_auto_back_to_lobby_time;


     uint64_t m_start_live_game_time;


     std::atomic<ClientState> m_state;


     std::set<std::string> m_available_karts;

     std::set<std::string> m_available_tracks;


     void addAllPlayers(Event* event);

     void finalizeConnectionRequest(NetworkString* header,

                                    BareNetworkString* rest, bool encrypt);


     std::map<PeerDisconnectInfo, irr::core::stringw> m_disconnected_msg;


     std::vector<LobbyPlayer> m_lobby_players;


     std::vector<float> m_ranking_changes;


     irr::core::stringw m_total_players;


     static std::thread m_background_download;


     static std::shared_ptr<Online::HTTPRequest> m_download_request;


     void liveJoinAcknowledged(Event* event);

     void handleKartInfo(Event* event);

     void finishLiveJoin();

     std::vector<std::shared_ptr<NetworkPlayerProfile> >

          decodePlayers(const BareNetworkString& data,

          std::shared_ptr<STKPeer> peer = nullptr,

          bool* is_spectator = NULL) const;

     void getPlayersAddonKartType(const BareNetworkString& data,

         std::vector<std::shared_ptr<NetworkPlayerProfile> >& players) const;

     void getKartsTracksNetworkString(BareNetworkString* ns);

     void doInstallAddonsPack();

 public:

              ClientLobby(std::shared_ptr<Server> s);

     virtual ~ClientLobby();

     void doneWithResults();

     bool receivedServerResult()            { return m_received_server_result; }

     void startingRaceNow();

     const std::set<std::string>& getAvailableKarts() const

                                                   { return m_available_karts; }

     const std::set<std::string>& getAvailableTracks() const

                                                  { return m_available_tracks; }

     virtual bool notifyEvent(Event* event) OVERRIDE;

     virtual bool notifyEventAsynchronous(Event* event) OVERRIDE;

     virtual void finishedLoadingWorld() OVERRIDE;

     virtual void setup() OVERRIDE;

     virtual void update(int ticks) OVERRIDE;

     virtual void asynchronousUpdate() OVERRIDE {}

     virtual bool allPlayersReady() const OVERRIDE

                                            { return m_state.load() >= RACING; }

     bool waitingForServerRespond() const

                             { return m_state.load() == REQUESTING_CONNECTION; }

     bool isLobbyReady() const                      { return !m_first_connect; }

     bool isWaitingForGame() const                { return m_waiting_for_game; }

     bool isServerAutoGameTime() const       { return m_server_auto_game_time; }

     virtual bool isRacing() const OVERRIDE { return m_state.load() == RACING; }

     void requestKartInfo(uint8_t kart_id);

     void setSpectator(bool val)                          { m_spectator = val; }

     bool isSpectator() const

                      { return m_spectator && m_state.load() != RACE_FINISHED; }

     void startLiveJoinKartSelection();

     void sendChat(irr::core::stringw text, KartTeam team);

     const std::vector<LobbyPlayer>& getLobbyPlayers() const

                                                     { return m_lobby_players; }

     bool isServerLiveJoinable() const        { return m_server_live_joinable; }

     void changeSpectateTarget(PlayerAction action, int value,

                               Input::InputType type) const;

     void addSpectateHelperMessage() const;

     bool serverEnabledChat() const            { return m_server_enabled_chat; }

     bool serverEnabledTrackVoting() const

                                       { return m_server_enabled_track_voting; }

     bool serverEnabledReportPlayer() const

                                      { return m_server_enabled_report_player; }

     const std::vector<float>& getRankingChanges() const

                                                   { return m_ranking_changes; }

     void handleClientCommand(const std::string& cmd);

     ClientState getCurrentState() const { return m_state.load(); }

     std::shared_ptr<Server> getJoinedServer() const { return m_server; }

     static bool startedDownloadAddonsPack()

              { return m_background_download.joinable() || m_download_request; }

     static void downloadAddonsPack(std::shared_ptr<Online::HTTPRequest> r);

     static void destroyBackgroundDownload();

     void updateAssetsToServer();

 };


 #endif // CLIENT_LOBBY_HPP

BareNetworkString
Describes a chain of 8-bit unsigned integers.
Definition: network_string.hpp:53

ClientLobby
Definition: client_lobby.hpp:62

ClientLobby::doInstallAddonsPack
void doInstallAddonsPack()
Called when the asynchronous download of the addon finished.
Definition: client_lobby.cpp:1940

ClientLobby::raceFinished
void raceFinished(Event *event)
Called when all karts have finished the race.
Definition: client_lobby.cpp:1146

ClientLobby::disconnectedPlayer
void disconnectedPlayer(Event *event)
Called when a new player is disconnected.
Definition: client_lobby.cpp:626

ClientLobby::m_state
std::atomic< ClientState > m_state
The state of the finite state machine.
Definition: client_lobby.hpp:123

ClientLobby::startSelection
void startSelection(Event *event)
Called when the kart selection starts.
Definition: client_lobby.cpp:1063

ClientLobby::asynchronousUpdate
virtual void asynchronousUpdate() OVERRIDE
Called by the protocol listener as often as possible.
Definition: client_lobby.hpp:170

ClientLobby::setup
virtual void setup() OVERRIDE
A previous GameSetup is deleted and a new one is created.
Definition: client_lobby.cpp:158

ClientLobby::connectionRefused
void connectionRefused(Event *event)
Callback function on connection refusal.
Definition: client_lobby.cpp:967

ClientLobby::update
virtual void update(int ticks) OVERRIDE
Called by the protocol listener, synchronously with the main loop.
Definition: client_lobby.cpp:405

ClientLobby::notifyEvent
virtual bool notifyEvent(Event *event) OVERRIDE
Notify a protocol matching the Event type of that event.
Definition: client_lobby.cpp:188

ClientLobby::doneWithResults
void doneWithResults()
Called from the gui when a client clicked on 'continue' on the race result screen.
Definition: client_lobby.cpp:178

ClientLobby::backToLobby
void backToLobby(Event *event)
Called when the server informs the clients to exit the race result screen.
Definition: client_lobby.cpp:1216

ClientLobby::notifyEventAsynchronous
virtual bool notifyEventAsynchronous(Event *event) OVERRIDE
Notify a protocol matching the Event type of that event.
Definition: client_lobby.cpp:226

ClientLobby::ClientLobby
ClientLobby(std::shared_ptr< Server > s)
The protocol that manages starting a race with the server.
Definition: client_lobby.cpp:121

ClientLobby::startGame
void startGame(Event *event)
Called when the server broadcasts to start the race to all clients.
Definition: client_lobby.cpp:1019

ClientLobby::connectionAccepted
void connectionAccepted(Event *event)
Callback function on connection acceptation.
Definition: client_lobby.cpp:665

ClientLobby::finishedLoadingWorld
virtual void finishedLoadingWorld() OVERRIDE
Callback when the world is loaded.
Definition: client_lobby.cpp:1289

Event
Class representing an event that need to pass trough the system. This is used to remove ENet dependen...
Definition: event.hpp:73

LobbyProtocol
Base class for both client and server lobby. The lobbies are started when a server opens a game,...
Definition: lobby_protocol.hpp:47

NetworkString
A new implementation of NetworkString, which has a fixed format: Byte 0: The type of the message,...
Definition: network_string.hpp:422

Server
Definition: server.hpp:44

PlayerAction
PlayerAction
types of input events / what actions the players can do
Definition: input.hpp:117

HandicapLevel
HandicapLevel
Handicap per player.
Definition: remote_kart_info.hpp:43

PeerDisconnectInfo
PeerDisconnectInfo
Definition: stk_peer.hpp:48

LobbyPlayer
Definition: client_lobby.hpp:46