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 <https://www.gnu.org/licenses/old-licenses/gpl-2.0>.
 */

 
#ifndef NETWORK_CORE_TCP_GAME_H
#define NETWORK_CORE_TCP_GAME_H
 
#include "os_abstraction.h"
#include "tcp.h"
#include "../network_type.h"
#include <chrono>

enum class PacketGameType : uint8_t {
  /*
   * These first ten packets must remain in this order for backward and forward compatibility
   * between clients that are trying to join directly. These packets can be received and/or sent
   * by the server before the server has processed the 'join' packet from the client.
   */
 
  /* Packets sent by socket accepting code without ever constructing a client socket instance. */
  ServerFull, 
  ServerBanned, 
 
  /* Packets used by the client to join and an error message when the revision is wrong. */
  ClientJoin, 
  ServerError, 
 
  /* Unused packet types, formerly used for the pre-game lobby. */
  ClientUnused, 
  ServerUnused, 
 
  /* Packets used to get the game info. */
  ServerGameInfo, 
  ClientGameInfo, 
 
  /* A server quitting this game. */
  ServerNewGame, 
  ServerShutdown, 
 
  /*
   * 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 perform game authentication and enabling encryption. */
  ServerAuthenticationRequest, 
  ClientAuthenticationResponse, 
  ServerEnableEncryption, 
 
  /* After the authentication is done, the next step is identification. */
  ClientIdentify, 
 
  /* After the identify step, the next is checking NewGRFs. */
  ServerCheckNewGRFs, 
  ClientNewGRFsChecked, 
 
  /* The server welcomes the authenticated client and sends information of other clients. */
  ServerWelcome, 
  ServerClientInfo, 
 
  /* Getting the savegame/map. */
  ClientGetMap, 
  ServerWaitForMap, 
  ServerMapBegin, 
  ServerMapSize, 
  ServerMapData, 
  ServerMapDone, 
  ClientMapOk, 
 
  ServerClientJoined, 
 
  /*
   * At this moment the client has the map and
   * the client is fully authenticated. Now the
   * normal communication starts.
   */
 
  /* Game progress monitoring. */
  ServerFrame, 
  ClientAck, 
  ServerSync, 
 
  /* Sending commands around. */
  ClientCommand, 
  ServerCommand, 
 
  /* Human communication! */
  ClientChat, 
  ServerChat, 
  ServerExternalChat, 
 
  /* Remote console. */
  ClientRemoteConsoleCommand, 
  ServerRemoteConsoleCommand, 
 
  /* Moving a client.*/
  ClientMove, 
  ServerMove, 
 
  /* Configuration updates. */
  ClientSetName, 
  ServerConfigurationUpdate, 
 
  /* A client quitting. */
  ClientQuit, 
  ServerQuit, 
  ClientError, 
  ServerErrorQuit, 
};

template <> struct IsEnumPacketType<PacketGameType> {
  static constexpr bool value = true; 
};

struct CommandPacket;

using CommandQueue = std::vector<CommandPacket>;

class NetworkGameSocketHandler : public NetworkTCPSocketHandler {
/* TODO: rewrite into a proper class */
private:
  NetworkClientInfo *info = nullptr; 
  bool is_pending_deletion = false; 
 
protected:
  NetworkRecvStatus ReceiveInvalidPacket(PacketGameType type);

  virtual NetworkRecvStatus ReceiveServerFull(Packet &p);

  virtual NetworkRecvStatus ReceiveServerBanned(Packet &p);

  virtual NetworkRecvStatus ReceiveClientJoin(Packet &p);

  virtual NetworkRecvStatus ReceiveServerError(Packet &p);

  virtual NetworkRecvStatus ReceiveClientGameInfo(Packet &p);

  virtual NetworkRecvStatus ReceiveServerGameInfo(Packet &p);

  virtual NetworkRecvStatus ReceiveServerClientInfo(Packet &p);

  virtual NetworkRecvStatus ReceiveClientIdentify(Packet &p);

  virtual NetworkRecvStatus ReceiveServerAuthenticationRequest(Packet &p);

  virtual NetworkRecvStatus ReceiveClientAuthenticationResponse(Packet &p);

  virtual NetworkRecvStatus ReceiveServerEnableEncryption(Packet &p);

  virtual NetworkRecvStatus ReceiveServerWelcome(Packet &p);

  virtual NetworkRecvStatus ReceiveClientGetMap(Packet &p);

  virtual NetworkRecvStatus ReceiveServerWaitForMap(Packet &p);

  virtual NetworkRecvStatus ReceiveServerMapBegin(Packet &p);

  virtual NetworkRecvStatus ReceiveServerMapSize(Packet &p);

  virtual NetworkRecvStatus ReceiveServerMapData(Packet &p);

  virtual NetworkRecvStatus ReceiveServerMapDone(Packet &p);

  virtual NetworkRecvStatus ReceiveClientMapOk(Packet &p);

  virtual NetworkRecvStatus ReceiveServerClientJoined(Packet &p);

  virtual NetworkRecvStatus ReceiveServerFrame(Packet &p);

  virtual NetworkRecvStatus ReceiveServerSync(Packet &p);

  virtual NetworkRecvStatus ReceiveClientAck(Packet &p);

  virtual NetworkRecvStatus ReceiveClientCommand(Packet &p);

  virtual NetworkRecvStatus ReceiveServerCommand(Packet &p);

  virtual NetworkRecvStatus ReceiveClientChat(Packet &p);

  virtual NetworkRecvStatus ReceiveServerChat(Packet &p);

  virtual NetworkRecvStatus ReceiveServerExternalChat(Packet &p);

  virtual NetworkRecvStatus ReceiveClientSetName(Packet &p);

  virtual NetworkRecvStatus ReceiveClientQuit(Packet &p);

  virtual NetworkRecvStatus ReceiveClientError(Packet &p);

  virtual NetworkRecvStatus ReceiveServerQuit(Packet &p);

  virtual NetworkRecvStatus ReceiveServerErrorQuit(Packet &p);

  virtual NetworkRecvStatus ReceiveServerShutdown(Packet &p);

  virtual NetworkRecvStatus ReceiveServerNewGame(Packet &p);

  virtual NetworkRecvStatus ReceiveServerRemoteConsoleCommand(Packet &p);

  virtual NetworkRecvStatus ReceiveClientRemoteConsoleCommand(Packet &p);

  virtual NetworkRecvStatus ReceiveServerCheckNewGRFs(Packet &p);

  virtual NetworkRecvStatus ReceiveClientNewGRFsChecked(Packet &p);

  virtual NetworkRecvStatus ReceiveServerMove(Packet &p);

  virtual NetworkRecvStatus ReceiveClientMove(Packet &p);

  virtual NetworkRecvStatus ReceiveServerConfigurationUpdate(Packet &p);
 
  NetworkRecvStatus HandlePacket(Packet &p);
 
  NetworkGameSocketHandler(SOCKET s);
public:
  ClientID client_id = INVALID_CLIENT_ID; 
  uint32_t last_frame = 0; 
  uint32_t last_frame_server = 0; 
  CommandQueue incoming_queue; 
  std::chrono::steady_clock::time_point last_packet{}; 
 
  NetworkRecvStatus CloseConnection(bool error = true) override;

  virtual NetworkRecvStatus CloseConnection(NetworkRecvStatus status) = 0;
  ~NetworkGameSocketHandler() override = default;

  inline void SetInfo(NetworkClientInfo *info)
  {
    assert(info != nullptr && this->info == nullptr);
    this->info = info;
  }

  inline NetworkClientInfo *GetInfo() const
  {
    return this->info;
  }
 
  NetworkRecvStatus ReceivePackets();
 
  std::optional<std::string_view> ReceiveCommand(Packet &p, CommandPacket &cp);
  void SendCommand(Packet &p, const CommandPacket &cp);

  bool IsPendingDeletion() const { return this->is_pending_deletion; }
 
  void DeferDeletion();
  static void ProcessDeferredDeletions();
};
 
#endif /* NETWORK_CORE_TCP_GAME_H */