1

#ifndef NETWORKCLIENT_HH

     2

#define NETWORKCLIENT_HH

     3

     4

// forward-declare

     5

class NetworkClient;

     6

class NetworkClientLocalPlayer;

     7

class NetworkClientRemotePlayer;

     8

     9

#include "../GameState.hh"

    10

#include "../Engine.hh"

    11

#include "Session.hh"

    12

#include "Object.hh"

    13

    14

/**

    15

 * Our specialized NetworkObject_ClientController that overrides handle_create to create the right kind of

    16

 * object (a subclass of NetowrkClientObject).

    17

 */

    18

class NetworkClientController : public NetworkObject_ClientController {

    19

    protected:

    20

        /**

    21

         * The NetworkClient

    22

         */

    23

        NetworkClient &client;

    24

    25

    public:

    26

        /**

    27

         * Control objects on the given client using the client.netsession's NETCHAN_CORE channel

    28

         */

    29

        NetworkClientController (NetworkClient &client);

    30

    31

    protected:

    32

        /**

    33

         * We override handle_create from NetworkObject_ClientController to call one of the on_* methods, which creates

    34

         * a NetworkClientObject subclass

    35

         *

    36

         * @see NetworkObject_ClientController::handle_create

    37

         */

    38

        virtual void handle_create (NetworkObjectID obj_id, NetworkMessageID msg_id, NetworkPacketInput &pkt, NetworkNode *node);

    39

    40

        /**

    41

         * Handle NETMSG_SERVER_HELLO -> NetworkClientLocalPlayer

    42

         */

    43

        void on_server_hello (NetworkObjectID obj_id, NetworkPacketInput &pkt);

    44

    45

        /**

    46

         * Handle NETMSG_PLAYER_INFO -> NetworkClientRemotePlayer

    47

         */

    48

        void on_player_info (NetworkObjectID obj_id, NetworkPacketInput &pkt);

    49

    50

        /**

    51

         * Handle NETMSG_PLAYER_JOIN -> NetworkClientRemotePlayer

    52

         */

    53

        void on_player_join (NetworkObjectID obj_id, NetworkPacketInput &pkt);

    54

    55

        /**

    56

         * Handle NETMSG_PROJECTILE_PLAYER_FIRED -> NetworkClientProjectile

    57

         */

    58

        void on_projectile_player_fired (NetworkObjectID obj_id, NetworkPacketInput &pkt);

    59

};

    60

    61

/**

    62

 * Our NetworkClient, that connects to a NetworkServer. This has the GameState, NetworkSession, NetworkClientController, etc.

    63

 */

    64

class NetworkClient {

    65

    friend class NetworkClientController;

    66

    friend class NetworkClientObject;

    67

    friend class NetworkClientPlayerBase;

    68

    friend class NetworkClientLocalPlayer;

    69

    friend class NetworkClientRemotePlayer;

    70

    friend class NetworkClientProjectile;

    71

    72

    protected:

    73

        /**

    74

         * The Engine

    75

         */

    76

        Engine &engine;

    77

    78

        /**

    79

         * The GameState

    80

         */

    81

        GameState &state;

    82

    83

        CL_SlotContainer slots;

    84

    85

        /**

    86

         * The connect()-mode NetworkSession

    87

         */

    88

        NetworkSession netsession;

    89

    90

        /**

    91

         * The server NetworkNode from Netsession::connect

    92

         */

    93

        NetworkNode *server;

    94

    95

        /**

    96

         * Our specialized NetworkObject_ClientController

    97

         */

    98

        NetworkClientController controller;

    99

   100

    public:

   101

        /**

   103

         *

   104

         * @param engine the Engine we're running as

   105

         * @param state the GameState to use

   106

         * @param connect_to the address to connect to

   107

         */

   109

   110

    protected:

   111

        /**

   112

         * We have disconnected from the server

   113

         */

   114

        void on_disconnected (void);

   115

   116

        /**

   117

         * Receive the NETCHAN_TERRAIN_ARRAY message from the server and apply it to our GameState::world terrain

   118

         */

   119

        void on_terrain_array (NetworkPacketInput &pkt, NetworkNode *node);

   120

   121

    public:

   122

        /**

   123

         * Called by NetworkClientRemotePlayer when they get disconnected. Doesn't do anything currently

   124

         */

   125

        void player_quit (NetworkClientRemotePlayer *player);

   126

};

   127

   128

/**

   129

 * Our base NetworkObject_Client object, containing the NetworkClient and a CL_SlotContainer for conveniance

   130

 */

   131

class NetworkClientObject : public NetworkObject_Client {

   132

    protected:

   133

        /**

   134

         * The NetworkClient

   135

         */

   136

        NetworkClient &client;

   137

   138

        CL_SlotContainer slots;

   139

   140

        /**

   141

         * Construct this using the given client and obj_id, passing the client.controller and obj_id to the

   142

         * NetworkObject_Client's constructor

   143

         */

   144

        NetworkClientObject (NetworkClient &client, NetworkObjectID obj_id);

   145

};

   146

   147

/**

   148

 * Our base class for NetworkClient Players, this implements most of the server -> client messages

   149

 *

   150

 * This inherits from NetworkClientObject and virtually from Player, as classes should inherit from both this and

   151

 * LocalPlayer/RemotePlayer

   152

 */

   153

class NetworkClientPlayerBase : public NetworkClientObject, public virtual Player {

   154

    protected:

   155

        /**

   156

         * Dummy-initialize Player, initialize NetworkClientObject, and hook up our signals

   157

         */

   158

        NetworkClientPlayerBase (NetworkClient &client, NetworkObjectID obj_id, Vector position);

   159

   160

    protected:

   161

        // @{

   162

        /**

   163

         * These should never be called directly, always via the network

   164

         */

   165

        virtual void spawn (Vector position);

   166

        virtual void respawn (TimeMS dt);

   167

        // @}

   168

   169

        /**

   170

         * Ignore, the servers tells us this

   171

         */

   172

        virtual void die (bool start_timer = true);

   173

   174

    private:

   175

        /**

   176

         * NETMSG_PLAYER_POSITION -> PhysicsObject::updatePhysics

   177

         */

   178

        void on_position (NetworkPacketInput &pkt);

   179

   180

        /**

   181

         * NETMSG_PLAYER_DIG -> Player::handleDig

   182

         */

   183

        void on_dig (NetworkPacketInput &pkt);

   184

   185

        /**

   186

         * NETMSG_PLAYER_WEAPON_CHANGE -> Player::rope.handleChangeWeapon

   187

         */

   188

        void on_weapon_change (NetworkPacketInput &pkt);

   189

   190

        /**

   191

         * NETMSG_PLAYER_ROPE_THROW -> Player::rope.updateState(ROPE_FLYING)

   192

         */

   193

        void on_rope_throw (NetworkPacketInput &pkt);

   194

   195

        /**

   196

         * NETMSG_PLAYER_ROPE_FIXED -> Player::rope.updateState(ROPE_FIXED)

   197

         */

   198

        void on_rope_fixed (NetworkPacketInput &pkt);

   199

   200

        /**

   201

         * NETMSG_PLAYER_ROPE_RELEASED -> Player::rope.updateState(ROPE_FOLDED)

   202

         */

   203

        void on_rope_released (NetworkPacketInput &pkt);

   204

   205

        /**

   206

         * NETMSG_PLAYER_ROPE_LENGTH -> Player::Rope.updateLength

   207

         */

   208

        void on_rope_length (NetworkPacketInput &pkt);

   209

   210

        /**

   211

         * NETMSG_PLAYER_SPAWN -> Player::spawn

   212

         */

   213

        void on_spawn (NetworkPacketInput &pkt);

   214

   215

        /**

   216

         * NETMSG_PLAYER_Die -> Player::die

   217

         */

   218

        void on_die (NetworkPacketInput &pkt);

   219

};

   220

   221

/**

   222

 * Our NetworkClientPlayerBase + LocalPlayer specialization, this lets us handle local input

   223

 */

   224

class NetworkClientLocalPlayer : public NetworkClientPlayerBase, public LocalPlayer {

   225

    public:

   226

        /**

   227

         * Calls NetworkClientPlayerBase/Player constructors, calls GameState::setLocalPlayer

   228

         */

   229

        NetworkClientLocalPlayer (NetworkClient &client, NetworkObjectID obj_id, Vector position);

   230

   231

        /**

   232

         * Overriden from LocalPlayer to send a NETMSG_CLIENT_INPUT message without executing LocalPlayer::handleInput

   233

         * locally

   234

         */

   235

        virtual void handleInput (PlayerInput input, TimeMS dt);

   236

};

   237

   238

/**

   239

 * Our NetworkClientPlayerBase + RemotePlayer specialization, this lets us handle players quitting

   240

 */

   241

class NetworkClientRemotePlayer : public NetworkClientPlayerBase, public RemotePlayer {

   242

    public:

   243

        /**

   244

         * Calls NetworkClientPlayerBase/Player constructors and hooks up signals

   245

         */

   246

        NetworkClientRemotePlayer (NetworkClient &client, NetworkObjectID obj_id, Vector position);

   247

   248

    private:

   249

        /**

   250

         * Calls NetworkClient::player_quit, and then destroys ourselves

   251

         */

   252

        void on_quit (NetworkPacketInput &pkt);

   253

};

   254

   255

/**

   256

 * A Projectile that was created on the server

   257

 */

   258

class NetworkClientProjectile : public NetworkClientObject, public Projectile {

   259

    public:

   260

        /**

   261

         * Call Projectile's constructor, hook up signals and call player->weaponFired

   262

         */

   263

        NetworkClientProjectile (NetworkClient &client, NetworkObjectID obj_id, Player *player, Vector position, 

   264

                Vector velocity, Weapon *weapon);

   265

   266

    protected:

   267

        /**

   268

         * Overrides Projectile::onDestroy to ignore this, as we must wait for the server to tell us where it impacted

   269

         * so that we can remove the ground reliably

   270

         */

   271

        virtual void onDestroy (Vector position, bool removeGround);

   272

   273

        /**

   274

         * Overrides Projectile::onHitPlayer to ignore this, as we must wait for the server to tell us if it really did

   275

         * happen.

   276

         */

   277

        virtual void onHitPlayer (Player *player);

   278

   279

    private:

   280

        /**

   281

         * NETMSG_PROJECTILE_DESTROY -> Projectile::onDestory

   282

         */

   283

        void on_destroy (NetworkPacketInput &pkt);

   284

   285

        /**

   286

         * NETMSG_PROJECTILE_HIT_PLAYER -> Projectile::onHitPlayer

   287

         */

   288

        void on_hit_player (NetworkPacketInput &pkt);

   289

};

   290

   291

#endif