1

     2

#include "Client.hh"

     3

#include "Protocol.hh"

     4

#include "Config.hh"

     5

#include "../Engine.hh"

     6

#include "../Logger.hh"

     7

     8

#include <cassert>

     9

    10

NetworkClient::NetworkClient (Engine &engine, GameState &state, const NetworkEndpoint &connect_to) : 

    11

    engine(engine), state(state), netsession(NETWORK_MAGIC_ID), server(netsession.connect(connect_to)),

    12

    controller(*this)

    13

{

    14

    // connect slots

    15

    slots.connect(netsession.sig_chan_message(NETCHAN_TERRAIN_ARRAY), this, &NetworkClient::on_terrain_array);

    16

    slots.connect(server->sig_disconnected(), this, &NetworkClient::on_disconnected);

    17

}

    18

    19

void NetworkClient::on_disconnected (void) {

    20

    Engine::log(ERROR, "client.on_disconnect") << "Disconnected from server";

    21

    engine.stop();

    22

}

    23

    24

void NetworkClient::on_terrain_array (NetworkPacketInput &pkt, NetworkNode *node) {

    25

    // ignore if not from server

    26

    if (node != server)

    27

        return;

    28

    29

    Terrain &terrain = state.world;

    30

    31

    // read map width/height

    32

    PixelDimension map_w = pkt.read_uint32();

    33

    PixelDimension map_h = pkt.read_uint32();

    34

    35

    // the terrain byte array

    36

    size_t terrain_size = map_w * map_h;

    38

    39

    // read uncompressed terrain data

    40

    size_t inflate_size = pkt.read_uncompressed(terrain_buf, terrain_size);

    41

    42

    // invalid data?

    43

    if (inflate_size != terrain_size)

    44

        throw Error("Corrupt terrain data");

    45

    49

    52

}

    53

    54

void NetworkClient::player_quit (NetworkClientRemotePlayer *player) {

    55

    (void) player;

    56

}

    57

    58

/*

    59

 * NetworkClientController

    60

 */ 

    61

NetworkClientController::NetworkClientController (NetworkClient &client) :

    62

    NetworkObject_ClientController(client.netsession, NETCHAN_CORE, client.server), client(client)

    63

{

    64

    65

}

    66

    67

void NetworkClientController::handle_create (NetworkObjectID obj_id, NetworkMessageID msg_id, NetworkPacketInput &pkt, NetworkNode *node) {

    68

    // XXX: should be server

    69

    (void) node;

    70

    71

    switch (msg_id) {

    72

        case NETMSG_SERVER_HELLO:

    73

            on_server_hello(obj_id, pkt);

    74

            break;

    75

    76

        case NETMSG_PLAYER_INFO:

    77

            on_player_info(obj_id, pkt);

    78

            break;

    79

    80

        case NETMSG_PLAYER_JOIN:

    81

            on_player_join(obj_id, pkt);

    82

            break;

    83

    84

        case NETMSG_PROJECTILE_PLAYER_FIRED:

    85

            on_projectile_player_fired(obj_id, pkt);

    86

            break;

    87

    88

        default:

    89

            Engine::log(WARN, "client.handle_create") << "Unknown object create message: obj_id=" << obj_id << ", msg_id=" << msg_id;

    90

    }

    91

}

    92

    93

void NetworkClientController::on_server_hello (NetworkObjectID obj_id, NetworkPacketInput &pkt) {

    94

    // read the packet

    95

    Vector position = pkt.read_vector();

    96

    97

    Engine::log(INFO, "client.on_server_hello") << this << ": pos=" << position;

    98

    99

    // create the LocalPlayer object

   100

    new NetworkClientLocalPlayer(client, obj_id, position);

   101

}

   102

   103

void NetworkClientController::on_player_info (NetworkObjectID obj_id, NetworkPacketInput &pkt) {

   104

    // read the packet

   105

    Vector position = pkt.read_vector();

   106

   107

    Engine::log(INFO, "client.on_player_info") << this << ": pos=" << position;

   108

   109

    // create the LocalPlayer object

   110

    new NetworkClientRemotePlayer(client, obj_id, position);

   111

}

   112

   113

void NetworkClientController::on_player_join (NetworkObjectID obj_id, NetworkPacketInput &pkt) {

   114

    // read the packet

   115

    Vector position = pkt.read_vector();

   116

   117

    Engine::log(INFO, "client.on_player_join") << this << ": pos=" << position;

   118

   119

    // create the RemotePlayer object

   120

    new NetworkClientRemotePlayer(client, obj_id, position);

   121

}

   122

   123

void NetworkClientController::on_projectile_player_fired (NetworkObjectID obj_id, NetworkPacketInput &pkt) {

   124

    // read the packet

   125

    NetworkObject *player_obj = client.controller.read_object(pkt);

   126

    Vector position = pkt.read_vector();

   127

    Vector velocity = pkt.read_vector();

   128

    WeaponID weapon_id = pkt.read_uint8();

   129

   130

    NetworkClientPlayerBase *player;

   131

   132

    // ignore for invalid players

   133

    if ((player = dynamic_cast<NetworkClientPlayerBase*>(player_obj)) == NULL) {

   134

        Engine::log(ERROR, "client.on_projectile_player_fired") << this << ": Unknown player object";

   135

        return;

   136

    }

   137

   138

    Weapon *weapon;

   139

   140

    // try and get the weapon

   141

    if ((weapon = player->getWeapon(weapon_id)) == NULL) {

   142

        Engine::log(ERROR, "client.on_projectile_player_fired") << this << ": Unknown weapon id: player=" << player << ", weapon_id=" << weapon_id;

   143

    }

   144

   145

    Engine::log(INFO, "client.on_projectile_create") << this << ": player=" << player << ", pos=" << position << ", velocity=" << velocity << ", weapon=" << weapon;

   146

   147

    // create the NetworkClientPorjectile object

   148

    new NetworkClientProjectile(client, obj_id, player, position, velocity, weapon);

   149

}

   150

   151

/*

   152

 * NetworkClientObject

   153

 */

   154

NetworkClientObject::NetworkClientObject (NetworkClient &client, NetworkObjectID obj_id) :

   155

    NetworkObject_Client(client.controller, obj_id), client(client)

   156

{

   157

   158

}

   159

   160

/*

   161

 * NetworkClientPlayerBase

   162

 */

   163

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

   164

    Player(client.state, position, true),

   165

    NetworkClientObject(client, obj_id)

   166

{

   167

    slots.connect(sig_message(NETMSG_PLAYER_POSITION),          this,   &NetworkClientPlayerBase::on_position           );

   168

    slots.connect(sig_message(NETMSG_PLAYER_DIG),               this,   &NetworkClientPlayerBase::on_dig                );

   169

    slots.connect(sig_message(NETMSG_PLAYER_WEAPON_CHANGE),     this,   &NetworkClientPlayerBase::on_weapon_change      );

   170

    slots.connect(sig_message(NETMSG_PLAYER_ROPE_THROW),        this,   &NetworkClientPlayerBase::on_rope_throw         );

   171

    slots.connect(sig_message(NETMSG_PLAYER_ROPE_FIXED),        this,   &NetworkClientPlayerBase::on_rope_fixed         );

   172

    slots.connect(sig_message(NETMSG_PLAYER_ROPE_RELEASED),     this,   &NetworkClientPlayerBase::on_rope_released      );

   173

    slots.connect(sig_message(NETMSG_PLAYER_ROPE_LENGTH),       this,   &NetworkClientPlayerBase::on_rope_length        );

   174

    slots.connect(sig_message(NETMSG_PLAYER_SPAWN),             this,   &NetworkClientPlayerBase::on_spawn              );

   175

    slots.connect(sig_message(NETMSG_PLAYER_DIE),               this,   &NetworkClientPlayerBase::on_die                );

   176

}

   177

   178

void NetworkClientPlayerBase::spawn (Vector position) {

   179

    (void) position;

   180

   181

    throw Error("NetworkClientPlayerBase::spawn called");

   182

}

   183

   184

void NetworkClientPlayerBase::respawn (TimeMS dt) {

   185

    (void) dt;

   186

   187

    throw Error("NetworkClientPlayerBase::respawn called");

   188

}

   189

   190

void NetworkClientPlayerBase::die (bool start_timer) {

   191

    (void) start_timer;

   192

   193

    // ignore :>

   194

}

   195

   196

void NetworkClientPlayerBase::on_position (NetworkPacketInput &pkt) {

   197

    Vector position = pkt.read_vector();

   198

    Vector velocity = pkt.read_vector();

   199

    int flags = pkt.read_uint8();

   200

    float aim = pkt.read_float32();

   201

   202

//    Engine::log(INFO, "client_player.on_position") << "obj=" << obj << ", position=" << position << ", velocity=" << velocity << ", aim=" << aim << ", [" << flags << "]";

   203

   204

    // just update... 

   205

    updatePhysics(position, velocity, 

   206

            flags & NETWORK_PHYSICS_INAIR, 

   207

            flags & NETWORK_PHYSICS_FACE_RIGHT ? FACING_RIGHT : FACING_LEFT, 

   208

            aim

   209

    );

   210

}

   211

   212

void NetworkClientPlayerBase::on_dig (NetworkPacketInput &pkt) {

   213

    Vector position = pkt.read_vector();

   214

    float radius = pkt.read_float32();

   215

   216

    Engine::log(INFO, "client_player.on_dig") << this << ": position=" << position << ", radius=" << radius;

   217

   218

    // just update... 

   219

    handleDig(position, radius);

   220

}

   221

   222

void NetworkClientPlayerBase::on_weapon_change (NetworkPacketInput &pkt) {

   223

    uint8_t weapon_index = pkt.read_uint8();

   224

   225

    Engine::log(INFO, "client_player.on_weapon_change") << this << ": weapon_index=" << weapon_index;

   226

   227

    handleChangeWeapon(weapon_index);

   228

}

   229

   230

void NetworkClientPlayerBase::on_rope_throw (NetworkPacketInput &pkt) {

   231

    Vector position = pkt.read_vector();

   232

    Vector velocity = pkt.read_vector();

   233

    float length = pkt.read_float32();

   234

   235

    Engine::log(INFO, "client_player.on_rope_throw") << this << ": position=" << position << ", velocity=" << velocity << ", length=" << length;

   236

   237

    rope.updateState(ROPE_FLYING, position, velocity, length, NULL);

   238

}

   239

   240

void NetworkClientPlayerBase::on_rope_fixed (NetworkPacketInput &pkt) {

   241

    Vector position = pkt.read_vector();

   242

    float length = pkt.read_float32();

   243

    NetworkObject *player_obj = controller.read_object(pkt);

   244

   245

    NetworkClientPlayerBase *player = NULL;

   246

   247

    if (player_obj != NULL && (player = dynamic_cast<NetworkClientPlayerBase*>(player_obj)) == NULL) {

   248

        Engine::log(ERROR, "client.on_rope_fixed") << this << ": Unknown player object";

   249

        return;

   250

    }

   251

   252

    Engine::log(INFO, "client_player.on_rope_fixed") << this << ": position=" << position << ", length=" << length 

   253

        << ", player=" << player;

   254

   255

    rope.updateState(ROPE_FIXED, position, Vector(0, 0), length, player);

   256

}

   257

   258

void NetworkClientPlayerBase::on_rope_released (NetworkPacketInput &pkt) {

   259

    (void) pkt;

   260

   261

    Engine::log(INFO, "client_player.on_rope_released") << this;

   262

   263

    // use rope.getPosition() instead of e.g. Vector(0, 0) because it will collide there...

   264

    rope.updateState(ROPE_FOLDED, rope.getPosition(), Vector(0, 0), 0, NULL);

   265

}

   266

   267

void NetworkClientPlayerBase::on_rope_length (NetworkPacketInput &pkt) {

   268

    float length = pkt.read_float32();

   269

   270

    Engine::log(INFO, "client_player.on_rope_length") << this << ": length=" << length;

   271

   272

    rope.updateLength(length);

   273

}

   274

   275

void NetworkClientPlayerBase::on_spawn (NetworkPacketInput &pkt) {

   276

    // read packet

   277

    Vector position = pkt.read_vector();

   278

   279

    Engine::log(INFO, "client_player.on_spawn") << this << ": position=" << position;

   280

   281

    // super

   282

    Player::spawn(position);

   283

}

   284

   285

void NetworkClientPlayerBase::on_die (NetworkPacketInput &pkt) {

   286

    (void) pkt;

   287

   288

    Engine::log(INFO, "client_player.on_die") << this;

   289

   290

    // super, but don't start the respawn_timer

   291

    Player::die(false);

   292

}

   293

   294

/*

   295

 * NetworkClientLocalPlayer

   296

 */

   297

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

   298

    Player(client.state, position, true), NetworkClientPlayerBase(client, obj_id, position) 

   299

{

   300

    // set ourselves as the local player

   301

    state.setLocalPlayer(this);

   302

}

   303

   304

void NetworkClientLocalPlayer::handleInput (PlayerInput input, TimeMS dt) {

   305

    NetworkPacket pkt;

   306

   307

    // write packet

   308

    pkt.write_uint16(input);

   309

    pkt.write_uint32(dt);

   310

   311

    // send

   312

    send(NETMSG_CLIENT_INPUT, pkt, false);

   313

   314

    // do not handle locally

   315

}

   316

   317

/*

   318

 * NetworkClientRemotePlayer

   319

 */

   320

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

   321

    Player(client.state, position, true), NetworkClientPlayerBase(client, obj_id, position) {

   322

   323

    // receive messages

   324

    slots.connect(sig_message(NETMSG_PLAYER_QUIT), this, &NetworkClientRemotePlayer::on_quit);

   325

}

   326

   327

void NetworkClientRemotePlayer::on_quit (NetworkPacketInput &pkt) {

   328

    // pkt is empty

   329

    (void) pkt;

   330

   331

    Engine::log(INFO, "client_player.on_quit") << this;

   332

   333

    client.player_quit(this);

   334

   335

    // delete

   336

    // XXX: leak because deleting the slot while it's being called breaks ClanLib

   337

    //  delete this;

   338

}

   339

   340

/*

   341

 * NetworkClientProjectile

   342

 */

   343

NetworkClientProjectile::NetworkClientProjectile (NetworkClient &client, NetworkObjectID obj_id, Player *player,

   344

        Vector position, Vector velocity, Weapon *weapon) :

   345

    NetworkClientObject(client, obj_id), Projectile(player, position, velocity, weapon)

   346

{

   347

    // hook up signals

   348

    slots.connect(sig_message(NETMSG_PROJECTILE_DESTROY), this, &NetworkClientProjectile::on_destroy);

   349

    slots.connect(sig_message(NETMSG_PROJECTILE_HIT_PLAYER), this, &NetworkClientProjectile::on_hit_player);

   350

   351

    // tell Player

   352

    player->weaponFired(weapon);

   353

}

   354

   355

void NetworkClientProjectile::onDestroy (Vector position, bool removeGround) {

   356

    (void) position;

   357

    (void) removeGround;

   358

   359

    // ignore :>

   360

}

   361

   362

void NetworkClientProjectile::onHitPlayer (Player *player) {

   363

    (void) player;

   364

   365

    // ignore :>

   366

}

   367

   368

void NetworkClientProjectile::on_destroy (NetworkPacketInput &pkt) {

   369

    Vector position = pkt.read_vector();

   370

    uint8_t flags = pkt.read_uint8();

   371

   372

    Engine::log(INFO, "client_projectile.on_destroy") << this << ": position=" << position << ", flags=" << flags;

   373

   374

    // pass on to super

   375

    Projectile::onDestroy(position, flags & NETWORK_PROJECTILE_REMOVE_GROUND);

   376

}

   377

   378

void NetworkClientProjectile::on_hit_player (NetworkPacketInput &pkt) {

   379

    // read packet

   380

    NetworkObject *player_obj = controller.read_object(pkt);

   381

   382

    NetworkClientPlayerBase *player;

   383

   384

    // ignore for invalid players

   385

    if ((player = dynamic_cast<NetworkClientPlayerBase*>(player_obj)) == NULL) {

   386

        Engine::log(ERROR, "client.on_hit_player") << this << ": Unknown player object";

   387

        return;

   388

    }

   389

   390

    Engine::log(INFO, "client_projectile.hit_player") << this << ": player=" << player;

   391

   392

    // pass on to super

   393

    Projectile::onHitPlayer(player);

   394

}

   395