physicallayer/network.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_NETWORK__
#define __CEL_PL_NETWORK__

#include "cstypes.h"
#include "csutil/scf.h"
#include "csutil/strset.h"

struct iCelEntity;
struct iCelDataBuffer;
enum celNetworkGameType;
enum celServerNetworkState;
enum celPlayerNetworkState;
struct celGame;
class celGameInfo;
class celPlayer;
struct iCelPlayerList;
class celServerEventData;
class celClientEventData;
class celNetworkLinkData;
class celGameFactoryManager;
class celGameClientManager;
class celGameServerManager;
struct celNetworkServerStats;
struct celNetworkPlayerStats;
struct celNetworkServerTotalStats;

struct iCelGame : public virtual iBase
{
  SCF_INTERFACE (iCelGame, 0, 0, 1);

  virtual celNetworkGameType GetGameType () const = 0;

  virtual celGameInfo* GetGameInfo () = 0;

  virtual bool IsServerAvailable () const = 0;

  virtual iCelGameServer* GetGameServer () const = 0;

  virtual bool IsClientAvailable () const = 0;

  virtual iCelGameClient* GetGameClient () const = 0;
};

struct iCelGameFactory : public virtual iBase
{
  SCF_INTERFACE (iCelGameFactory, 1, 0, 0);

  virtual void SetGameName (const char* game_name) = 0;

  virtual const char* GetGameName () const = 0;

  virtual void SetProtocolVersion (const char* protocol_version) = 0;

  virtual const char* GetProtocolVersion () const = 0;

  virtual void RegisterGameFactoryManager
    (celGameFactoryManager* manager) = 0;

  virtual void StartSearchForGameList (celNetworkGameType game_type, 
        celGameInfo* filter = 0) = 0;

  virtual void StopSearchForGameList () = 0;

  virtual iCelGame* GetCurrentGame () const = 0;

  virtual bool CreateNewGame (celNetworkGameType game_type, 
        celGameInfo* game_info, celPlayer* player = 0) = 0;

  virtual bool ConnectGame (celGameInfo* game_info, 
        celPlayer* player) = 0;

  virtual bool CloseGame () = 0;

  virtual void StartRecordingGame (const char* filename) = 0;

  virtual void StopRecordingGame () = 0;

  virtual void StartPlayBackGame (const char* filename, 
        csTicks start_time, csTicks stop_time) = 0;
};

class celGameFactoryManager
{
public:
  virtual ~celGameFactoryManager () {}

  virtual void GameInfoReceived (celGameInfo* game_info, 
        csTicks server_latency) {}

  virtual void ServerNetworkStateChanged (celServerNetworkState new_state, 
        celServerNetworkState previous_state, const char* reason = "") = 0;

  virtual bool InitClient (iCelGame* game) { return true; }

  virtual bool InitServer (iCelGame* game) { return true; }

  virtual csPtr<iCelDataBuffer> GetClientEventBaseline (
        celClientEventType event_type) { return 0; }

  virtual csPtr<iCelDataBuffer> GetServerEventBaseline (
        celServerEventType event_type) { return 0; }

  virtual csPtr<iCelDataBuffer> GetNetworkLinkBaseline (
        celNetworkLinkType link_type) { return 0; }

};

struct iCelGameServer : public virtual iBase
{
  SCF_INTERFACE (iCelGameServer, 1, 0, 0);

  virtual void RegisterServerManager (celGameServerManager* manager) = 0;

  virtual void SetAdministrator (celPlayer* new_admin) = 0;

  virtual celPlayer* GetAdministrator () = 0;

  virtual iCelPlayerList* GetPlayerList () = 0;

  virtual celPlayerNetworkState GetPlayerState (celPlayer* player) = 0;

  virtual void KickPlayer (celPlayer* player, const char* reason) = 0;

  virtual iCelPlayerList* CreateChannel (csStringID channel_id) = 0;

  virtual void RemoveChannel (csStringID channel_id) = 0;

  virtual void LaunchServerEvent (celPlayer* player, 
        celServerEventData &event_data) = 0;

  virtual void LaunchServerEvent (csStringID channel_id, 
        celServerEventData &event_data) = 0;

  virtual void SetNetworkLink (celPlayer* player, 
        celNetworkLinkData &link_data, bool player_controlled) = 0;

  virtual void ChangeLinkControl (iCelEntity* entity, celPlayer* player, 
        bool player_controlled) = 0;

  virtual void SetNetworkLink (csStringID channel_id, 
        celNetworkLinkData &link_data) = 0;

  virtual void RemoveNetworkLink (iCelEntity* entity, celPlayer* player) = 0;

  virtual void RemoveNetworkLink (iCelEntity* entity,
        csStringID channel_id) = 0;

  virtual void ChangeLevel (celGameInfo* new_game) = 0;

  virtual void SetNetworkPeriod (csTicks period) = 0;

  virtual void SetMaximumBandwidth (size_t width) = 0;

  virtual void SetClientTimeOut (csTicks timeout) = 0;

  virtual void GetNetworkPlayerStats (celPlayer* player, 
        celNetworkPlayerStats& stats) const = 0;

  virtual void GetNetworkTotalStats (
        celNetworkPlayerTotalStats& stats) const = 0;
};

struct iCelGameClient : public virtual iBase
{
  SCF_INTERFACE (iCelGameClient, 0, 0, 1);

  virtual void RegisterClientManager (celGameClientManager* manager) = 0;

  virtual celPlayer* GetPlayer () = 0;

  virtual void UpdatePlayer (celPlayer* player) = 0;

  virtual csTicks ConvertServerClock (csTicks server_time) const = 0;

  virtual uint GetMappedID (uint entity_id) const = 0;

  virtual iCelEntity* GetMappedEntity (uint entity_id) const = 0;

  virtual void SetReady () = 0;

  virtual void LaunchClientEvent (celClientEventData &event_data) = 0;

  virtual void SetNetworkPeriod (csTicks period) = 0;

  virtual void SetMaximumBandwidth (size_t width) = 0;

  virtual void SetServerTimeOut (csTicks timeout) = 0;

  virtual void GetNetworkStats (celNetworkServerStats& stats) const = 0;
};

class celGameServerManager
{
 public:
  virtual ~celGameServerManager () {};

  virtual bool AuthorizePlayer (celPlayer* player, csString& reason) = 0;

  virtual celPlayer* ValidatePlayerUpdate (celPlayer* previous_player_data) = 0;

  virtual void PlayerNetworkStateChanged (celPlayer* player, 
        celPlayerNetworkState new_state, 
        celPlayerNetworkState previous_state) = 0;

  virtual void HandleClientEvent (celPlayer* player, 
        celClientEventType event_type, csTicks event_time, 
        iCelDataBuffer* event_data) = 0;

  virtual void PersistenceProblem (celPlayer* player, iCelEntity* entity,
        iCelPropertyClass* pc, celPersistenceResult persist_code) = 0;

  virtual void ServerEnd () = 0;
};

class celGameClientManager
{
 public:
  virtual ~celGameClientManager () {};

  virtual void PlayerValidated (celPlayer* player) = 0;

  virtual void HandleServerEvent (celServerEventType event_type, 
        csTicks event_time, iCelDataBuffer* event_data) = 0;

  virtual iCelEntity* CreateNetworkLinkTarget (celNetworkLinkType link_type, 
        csTicks creation_time, iCelPersistentDataList* creation_data, 
        bool player_controlled) = 0;

  virtual void NetworkLinkControlChanged (iCelEntity* entity, 
        bool player_controlled) = 0;

  virtual void NetworkLinkRemoved (csTicks deletion_time,
        iCelEntity* entity) = 0;

  virtual void LevelChanged (celGameInfo* new_game) = 0;

  virtual void ClientEnd () = 0;
};

#endif // __CEL_PL_NETWORK__