Public API Reference

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;

SCF_VERSION (iCelGame, 0, 0, 1);

struct iCelGame : public iBase
{
  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;
};

SCF_VERSION (iCelGameFactory, 0, 0, 1);

struct iCelGameFactory : public iBase
{
  virtual void SetGameName (csString game_name) = 0;

  virtual csString GetGameName () const = 0;

  virtual void SetProtocolVersion (const csString protocol_version) = 0;

  virtual csString 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 (csString filename) = 0;

  virtual void StopRecordingGame () = 0;

  virtual void StartPlayBackGame (csString filename, 
        csTicks start_time, csTicks stop_time) = 0;
};

class celGameFactoryManager
{
 public:
  virtual void GameInfoReceived (celGameInfo* game_info, 
        csTicks server_latency) {}

  virtual void ServerNetworkStateChanged (celServerNetworkState new_state, 
        celServerNetworkState previous_state, csString 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; }

};

SCF_VERSION (iCelGameServer, 0, 0, 1);

struct iCelGameServer : public iBase
{
  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, csString 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;
};

SCF_VERSION (iCelGameClient, 0, 0, 1);

struct iCelGameClient : public iBase
{
  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 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 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__

---