tcp_game.h

Go to the documentation of this file.

/*
 * This file is part of OpenTTD.
 * OpenTTD 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, version 2.
 * OpenTTD 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 OpenTTD. If not, see <http://www.gnu.org/licenses/>.
 */
 
#ifndef NETWORK_CORE_TCP_GAME_H
#define NETWORK_CORE_TCP_GAME_H
 
#include "os_abstraction.h"
#include "tcp.h"
#include "../network_type.h"
#include "../../core/pool_type.hpp"
 
enum PacketGameType {
  /*
   * These first three pair of packets (thus six in
   * total) must remain in this order for backward
   * and forward compatibility between clients that
   * are trying to join directly.
   */
 
  /* Packets sent by socket accepting code without ever constructing a client socket instance. */
  PACKET_SERVER_FULL,                  
  PACKET_SERVER_BANNED,                
 
  /* Packets used by the client to join and an error message when the revision is wrong. */
  PACKET_CLIENT_JOIN,                  
  PACKET_SERVER_ERROR,                 
 
  /* Packets used for the pre-game lobby. */
  PACKET_CLIENT_COMPANY_INFO,          
  PACKET_SERVER_COMPANY_INFO,          
 
  /*
   * Packets after here assume that the client
   * and server are running the same version. As
   * such ordering is unimportant from here on.
   *
   * The following is the remainder of the packets
   * sent as part of authenticating and getting
   * the map and other important data.
   */
 
  /* After the join step, the first is checking NewGRFs. */
  PACKET_SERVER_CHECK_NEWGRFS,         
  PACKET_CLIENT_NEWGRFS_CHECKED,       
 
  /* Checking the game, and then company passwords. */
  PACKET_SERVER_NEED_GAME_PASSWORD,    
  PACKET_CLIENT_GAME_PASSWORD,         
  PACKET_SERVER_NEED_COMPANY_PASSWORD, 
  PACKET_CLIENT_COMPANY_PASSWORD,      
 
  /* The server welcomes the authenticated client and sends information of other clients. */
  PACKET_SERVER_WELCOME,               
  PACKET_SERVER_CLIENT_INFO,           
 
  /* Getting the savegame/map. */
  PACKET_CLIENT_GETMAP,                
  PACKET_SERVER_WAIT,                  
  PACKET_SERVER_MAP_BEGIN,             
  PACKET_SERVER_MAP_SIZE,              
  PACKET_SERVER_MAP_DATA,              
  PACKET_SERVER_MAP_DONE,              
  PACKET_CLIENT_MAP_OK,                
 
  PACKET_SERVER_JOIN,                  
 
  /*
   * At this moment the client has the map and
   * the client is fully authenticated. Now the
   * normal communication starts.
   */
 
  /* Game progress monitoring. */
  PACKET_SERVER_FRAME,                 
  PACKET_CLIENT_ACK,                   
  PACKET_SERVER_SYNC,                  
 
  /* Sending commands around. */
  PACKET_CLIENT_COMMAND,               
  PACKET_SERVER_COMMAND,               
 
  /* Human communication! */
  PACKET_CLIENT_CHAT,                  
  PACKET_SERVER_CHAT,                  
 
  /* Remote console. */
  PACKET_CLIENT_RCON,                  
  PACKET_SERVER_RCON,                  
 
  /* Moving a client.*/
  PACKET_CLIENT_MOVE,                  
  PACKET_SERVER_MOVE,                  
 
  /* Configuration updates. */
  PACKET_CLIENT_SET_PASSWORD,          
  PACKET_CLIENT_SET_NAME,              
  PACKET_SERVER_COMPANY_UPDATE,        
  PACKET_SERVER_CONFIG_UPDATE,         
 
  /* A server quitting this game. */
  PACKET_SERVER_NEWGAME,               
  PACKET_SERVER_SHUTDOWN,              
 
  /* A client quitting. */
  PACKET_CLIENT_QUIT,                  
  PACKET_SERVER_QUIT,                  
  PACKET_CLIENT_ERROR,                 
  PACKET_SERVER_ERROR_QUIT,            
 
  PACKET_END,                          
};
 
struct CommandPacket;
 
class CommandQueue {
  CommandPacket *first; 
  CommandPacket *last;  
  uint count;           
 
public:
  CommandQueue() : first(nullptr), last(nullptr), count(0) {}
  ~CommandQueue() { this->Free(); }
  void Append(CommandPacket *p);
  CommandPacket *Pop(bool ignore_paused = false);
  CommandPacket *Peek(bool ignore_paused = false);
  void Free();
  uint Count() const { return this->count; }
};
 
class NetworkGameSocketHandler : public NetworkTCPSocketHandler {
/* TODO: rewrite into a proper class */
private:
  NetworkClientInfo *info;  
 
protected:
  NetworkRecvStatus ReceiveInvalidPacket(PacketGameType type);
 
  virtual NetworkRecvStatus Receive_SERVER_FULL(Packet *p);
 
  virtual NetworkRecvStatus Receive_SERVER_BANNED(Packet *p);
 
  virtual NetworkRecvStatus Receive_CLIENT_JOIN(Packet *p);
 
  virtual NetworkRecvStatus Receive_SERVER_ERROR(Packet *p);
 
  virtual NetworkRecvStatus Receive_CLIENT_COMPANY_INFO(Packet *p);
 
  virtual NetworkRecvStatus Receive_SERVER_COMPANY_INFO(Packet *p);
 
  virtual NetworkRecvStatus Receive_SERVER_CLIENT_INFO(Packet *p);
 
  virtual NetworkRecvStatus Receive_SERVER_NEED_GAME_PASSWORD(Packet *p);
 
  virtual NetworkRecvStatus Receive_SERVER_NEED_COMPANY_PASSWORD(Packet *p);
 
  virtual NetworkRecvStatus Receive_CLIENT_GAME_PASSWORD(Packet *p);
 
  virtual NetworkRecvStatus Receive_CLIENT_COMPANY_PASSWORD(Packet *p);
 
  virtual NetworkRecvStatus Receive_SERVER_WELCOME(Packet *p);
 
  virtual NetworkRecvStatus Receive_CLIENT_GETMAP(Packet *p);
 
  virtual NetworkRecvStatus Receive_SERVER_WAIT(Packet *p);
 
  virtual NetworkRecvStatus Receive_SERVER_MAP_BEGIN(Packet *p);
 
  virtual NetworkRecvStatus Receive_SERVER_MAP_SIZE(Packet *p);
 
  virtual NetworkRecvStatus Receive_SERVER_MAP_DATA(Packet *p);
 
  virtual NetworkRecvStatus Receive_SERVER_MAP_DONE(Packet *p);
 
  virtual NetworkRecvStatus Receive_CLIENT_MAP_OK(Packet *p);
 
  virtual NetworkRecvStatus Receive_SERVER_JOIN(Packet *p);
 
  virtual NetworkRecvStatus Receive_SERVER_FRAME(Packet *p);
 
  virtual NetworkRecvStatus Receive_SERVER_SYNC(Packet *p);
 
  virtual NetworkRecvStatus Receive_CLIENT_ACK(Packet *p);
 
  virtual NetworkRecvStatus Receive_CLIENT_COMMAND(Packet *p);
 
  virtual NetworkRecvStatus Receive_SERVER_COMMAND(Packet *p);
 
  virtual NetworkRecvStatus Receive_CLIENT_CHAT(Packet *p);
 
  virtual NetworkRecvStatus Receive_SERVER_CHAT(Packet *p);
 
  virtual NetworkRecvStatus Receive_CLIENT_SET_PASSWORD(Packet *p);
 
  virtual NetworkRecvStatus Receive_CLIENT_SET_NAME(Packet *p);
 
  virtual NetworkRecvStatus Receive_CLIENT_QUIT(Packet *p);
 
  virtual NetworkRecvStatus Receive_CLIENT_ERROR(Packet *p);
 
  virtual NetworkRecvStatus Receive_SERVER_QUIT(Packet *p);
 
  virtual NetworkRecvStatus Receive_SERVER_ERROR_QUIT(Packet *p);
 
  virtual NetworkRecvStatus Receive_SERVER_SHUTDOWN(Packet *p);
 
  virtual NetworkRecvStatus Receive_SERVER_NEWGAME(Packet *p);
 
  virtual NetworkRecvStatus Receive_SERVER_RCON(Packet *p);
 
  virtual NetworkRecvStatus Receive_CLIENT_RCON(Packet *p);
 
  virtual NetworkRecvStatus Receive_SERVER_CHECK_NEWGRFS(Packet *p);
 
  virtual NetworkRecvStatus Receive_CLIENT_NEWGRFS_CHECKED(Packet *p);
 
  virtual NetworkRecvStatus Receive_SERVER_MOVE(Packet *p);
 
  virtual NetworkRecvStatus Receive_CLIENT_MOVE(Packet *p);
 
  virtual NetworkRecvStatus Receive_SERVER_COMPANY_UPDATE(Packet *p);
 
  virtual NetworkRecvStatus Receive_SERVER_CONFIG_UPDATE(Packet *p);
 
  NetworkRecvStatus HandlePacket(Packet *p);
 
  NetworkGameSocketHandler(SOCKET s);
public:
  ClientID client_id;          
  uint32 last_frame;           
  uint32 last_frame_server;    
  CommandQueue incoming_queue; 
  uint last_packet;            
 
  NetworkRecvStatus CloseConnection(bool error = true) override;
 
  virtual NetworkRecvStatus CloseConnection(NetworkRecvStatus status) = 0;
  virtual ~NetworkGameSocketHandler() {}
 
  inline void SetInfo(NetworkClientInfo *info)
  {
    assert(info != nullptr && this->info == nullptr);
    this->info = info;
  }
 
  inline NetworkClientInfo *GetInfo() const
  {
    return this->info;
  }
 
  NetworkRecvStatus ReceivePackets();
 
  const char *ReceiveCommand(Packet *p, CommandPacket *cp);
  void SendCommand(Packet *p, const CommandPacket *cp);
};
 
#endif /* NETWORK_CORE_TCP_GAME_H */