Public API Reference

physicallayer/nettypes.h

/*
    Crystal Space Entity Layer
    Copyright (C) 2005 by Christian Van Brussel

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

    This library 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
    Library General Public License for more details.

    You should have received a copy of the GNU Library General Public
    License along with this library; if not, write to the Free
    Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/

#ifndef __CEL_PL_NETTYPES__
#define __CEL_PL_NETTYPES__

#include "cstypes.h"
#include "csutil/scf.h"
#include "csutil/csstring.h"
#include "csutil/bitarray.h"

#include "physicallayer/persist.h"
#include "physicallayer/entity.h"
#include "celtool/persisthelper.h"

struct iCelEntity;
class celGameInfoList;
struct celGameInfoListIterator;
struct iCelGameServer;
struct iCelGameClient;
class csBitArray;
struct celPlayerListIterator;

enum celNetworkGameType
{
  CEL_NET_UNDEF = 0,
  CEL_NET_SINGLEPLAYER,
  CEL_NET_LOCAL,
  CEL_NET_PUBLIC,
  CEL_NET_PLAYBACK
};

// TODO: these types must be changed if there are more than 256 values
typedef uint8 celClientEventType;
typedef uint8 celServerEventType;
typedef uint8 celNetworkLinkType;

enum celPlayerNetworkState
{
  CEL_NET_PLAYER_UNDEF = 0,
  CEL_NET_PLAYER_NOT_CONNECTED,
  CEL_NET_PLAYER_CONNECTING,
  CEL_NET_PLAYER_PLAYING,
  CEL_NET_PLAYER_DISCONNECTED,
  CEL_NET_PLAYER_UNREACHABLE,
  CEL_NET_PLAYER_LOST
};

enum celServerNetworkState
{
  CEL_NET_SERVER_UNDEF = 0,
  CEL_NET_SERVER_NOT_CONNECTED,
  CEL_NET_SERVER_INVALID_HOSTNAME,
  CEL_NET_SERVER_TRYING_CONNECTION,
  CEL_NET_SERVER_CONNECTING,
  CEL_NET_SERVER_REJECTED_BAD_GAME,
  CEL_NET_SERVER_REJECTED_BAD_PROTOCOL,
  CEL_NET_SERVER_REJECTED_BAD_PASSWORD,
  CEL_NET_SERVER_REJECTED_SINGLEPLAYER,
  CEL_NET_SERVER_REJECTED_UNAUTHORIZED,
  CEL_NET_SERVER_REJECTED_MAX_PLAYERS,
  CEL_NET_SERVER_LOADING_DATA,
  CEL_NET_SERVER_PLAYING,
  CEL_NET_SERVER_DISCONNECTED,
  CEL_NET_SERVER_UNREACHABLE,
  CEL_NET_SERVER_LOST,
  CEL_NET_SERVER_KICKED
};

class celGameInfo
{
 public:
  uint32 game_id;

  csString game_name;

  csString hostname;

  uint8 ip_address[32];

  uint16 port_nb;

  size_t max_players;

  size_t current_num_players;

  csString password;

  csRef<iCelDataBuffer> custom_data;

  celGameInfo ()
  {
    game_id = 0;
    memset (ip_address, 0, 32);
    port_nb = 0;
    max_players = 0;
    current_num_players = 0;
    custom_data = 0;
  }

  bool MatchFilter (celGameInfo* filter);

  int Compare (celGameInfo* other, celGameInfoList* filters);
};

class celGameInfoList
{
 public:
  virtual size_t GetCount () const = 0;
  virtual celGameInfo* Get (size_t index) const = 0;
  virtual size_t Add (celGameInfo* player) = 0;
  virtual bool Remove (celGameInfo* player) = 0;
  virtual bool Remove (size_t n) = 0;
  virtual void RemoveAll () = 0;
  virtual size_t Find (celGameInfo* player) const = 0;

  void Filter (celGameInfo* game_info);

  void Sort (celGameInfoList* filters);
};

class celPlayer
{
 public:
  uint32 player_id;

  csString player_name;

  csString hostname;

  uint8 ip_address[32];

  uint16 port_nb;

  celPlayer ()
  {
    player_id = 0;
    memset (ip_address, 0, 32);
    port_nb = 0;
  }

  bool operator == (const celPlayer& other) const
  {
    return hostname.Compare(other.hostname) && port_nb == other.port_nb;
  }

  void PrintDebugInfo ()
  {
    printf("Player data:\n");
    printf("\tID: %d\n", player_id);
    printf("\tname: %s\n", player_name.GetData());
    printf("\thostname: %s\n", hostname.GetData());
    printf("\taddress: ");
    int i = 0;
    for ( ; i < 32; i++)
      printf("%d", ip_address[i]);
    printf("\n");
    printf("\tport: %d\n", port_nb);
  }
};

SCF_VERSION (iCelPlayerList, 0, 0, 1);

struct iCelPlayerList
{
 public:
  virtual size_t GetCount () const = 0;
  virtual celPlayer* Get (size_t index) const = 0;
  virtual size_t Add (celPlayer* player) = 0;
  virtual bool Remove (celPlayer* player) = 0;
  virtual bool Remove (size_t n) = 0;
  virtual void RemoveAll () = 0;
  virtual size_t Find (celPlayer* player) const = 0;
  //virtual bool Contains (celPlayer* player) = 0;
};

class celServerEventData
{
 public:
  celServerEventType event_type;

  csTicks event_time;

  csRef<iCelDataBuffer> event_data;

  bool reliable;
};

class celClientEventData
{
 public:
  celClientEventType event_type;

  csTicks event_time;

  csRef<iCelDataBuffer> event_data;

  bool reliable;

  celClientEventData () :
    event_type (0),
    event_time (0),
    event_data (0),
    reliable (true)
    {}

  celClientEventData (celClientEventData &event) :
    event_type (event.event_type),
    event_time (event.event_time),
    event_data (event.event_data),
    reliable (event.reliable)
    {}
};

class celNetworkLinkData
{
 public:
  celNetworkLinkType link_type;

  csRef<iCelEntity> linked_entity;

  csBitArray persistence_mask;

  csTicks period;

  celNetworkLinkData () {}

  celNetworkLinkData (celNetworkLinkType _link_type, iCelEntity* _linked_entity,
                      csBitArray _persistence_mask, csTicks _period) :
    link_type (_link_type),
    linked_entity (_linked_entity),
    persistence_mask (_persistence_mask),
    period (_period)
    {}

  ~celNetworkLinkData () {}
};

struct celNetworkServerStats
{
  // The latency of the network transmission to the player
  csTicks latency;
  // The state of the connection
  celServerNetworkState network_state;
  // Instant flow of the data sent by the client, in bytes per second
  size_t incoming_bandwidth;
  // Instant flow of the data sent by the server to this client, in bytes
  // per second
  size_t outgoing_bandwidth;
};

struct celNetworkPlayerStats
{
  // The latency of the network transmission to the player
  csTicks latency;
  // Instant flow of the data sent by the client, in bytes per second
  size_t incoming_bandwidth;
  // Instant flow of the data sent by the server to this client, in bytes
  // per second
  size_t outgoing_bandwidth;
};

struct celNetworkPlayerTotalStats
{
  // Instant flow of all the data sent by the clients, in bytes per second
  size_t total_incoming_bandwidth;
  // Instant flow of all the data sent by the server to the clients, in bytes
  // per second
  size_t total_outgoing_bandwidth;
};

#endif // __CEL_PL_NETTYPES__

---