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;

    37

    uint8_t terrain_buf[map_w][map_h];

    41

    42

    // invalid data?

    43

    if (inflate_size != terrain_size)

    44

        throw Error("Corrupt terrain data");

    45

    46

    // translate map data to terrain vector

    47

    for (PixelDimension x = 0; x < map_w; x++) {

    48

        for (PixelDimension y = 0; y < map_h; y++) {

    49

            terrain.terrain[x][y] = (TerrainType) terrain_buf[x][y];

    50

        }

    51

    }

    52

    53

    // update the pixbuf

    54

    terrain.generatePixelBuffer();

    55

}

    56

    57

void NetworkClient::player_quit (NetworkClientRemotePlayer *player) {

    58

    (void) player;

    59

}

    60

    61

/*

    62

 * NetworkClientController

    63

 */ 

    64

NetworkClientController::NetworkClientController (NetworkClient &client) :

    65

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

    66

{

    67

    68

}

    69

    70

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

    71

    // XXX: should be server

    72

    (void) node;

    73

    74

    switch (msg_id) {

    75

        case NETMSG_SERVER_HELLO:

    76

            on_server_hello(obj_id, pkt);

    77

            break;

    78

    79

        case NETMSG_PLAYER_INFO:

    80

            on_player_info(obj_id, pkt);

    81

            break;

    82

    83

        case NETMSG_PLAYER_JOIN:

    84

            on_player_join(obj_id, pkt);

    85

            break;

    86

    87

        case NETMSG_PROJECTILE_PLAYER_FIRED:

    88

            on_projectile_player_fired(obj_id, pkt);

    89

            break;

    90

    91

        default:

    92

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

    93

    }

    94

}

    95

    96

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

    97

    // read the packet

    98

    Vector position = pkt.read_vector();

    99

   100

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

   101

   102

    // create the LocalPlayer object

   103

    new NetworkClientLocalPlayer(client, obj_id, position);

   104

}

   105

   106

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

   107

    // read the packet

   108

    Vector position = pkt.read_vector();

   109

   110

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

   111

   112

    // create the LocalPlayer object

   113

    new NetworkClientRemotePlayer(client, obj_id, position);

   114

}

   115

   116

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

   117

    // read the packet

   118

    Vector position = pkt.read_vector();

   119

   120

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

   121

   122

    // create the RemotePlayer object

   123

    new NetworkClientRemotePlayer(client, obj_id, position);

   124

}

   125

   126

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

   127

    // read the packet

   128

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

   129

    Vector position = pkt.read_vector();

   130

    Vector velocity = pkt.read_vector();

   131

    WeaponID weapon_id = pkt.read_uint8();

   132

   133

    NetworkClientPlayerBase *player;

   134

   135

    // ignore for invalid players

   136

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

   137

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

   138

        return;

   139

    }

   140

   141

    Weapon *weapon;

   142

   143

    // try and get the weapon

   144

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

   145

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

   146

    }

   147

   148

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

   149

   150

    // create the NetworkClientPorjectile object

   151

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

   152

}

   153

   154

/*

   155

 * NetworkClientObject

   156

 */

   157

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

   158

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

   159

{

   160

   161

}

   162

   163

/*

   164

 * NetworkClientPlayerBase

   165

 */

   166

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

   167

    Player(client.state, position, true),

   168

    NetworkClientObject(client, obj_id)

   169

{

   170

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

   171

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

   172

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

   173

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

   174

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

   175

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

   176

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

   177

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

   178

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

   179

}

   180

   181

void NetworkClientPlayerBase::spawn (Vector position) {

   182

    (void) position;

   183

   184

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

   185

}

   186

   187

void NetworkClientPlayerBase::respawn (TimeMS dt) {

   188

    (void) dt;

   189

   190

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

   191

}

   192

   193

void NetworkClientPlayerBase::die (bool start_timer) {

   194

    (void) start_timer;

   195

   196

    // ignore :>

   197

}

   198

   199

void NetworkClientPlayerBase::on_position (NetworkPacketInput &pkt) {

   200

    Vector position = pkt.read_vector();

   201

    Vector velocity = pkt.read_vector();

   202

    int flags = pkt.read_uint8();

   203

    float aim = pkt.read_float32();

   204

   205

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

   206

   207

    // just update... 

   208

    updatePhysics(position, velocity, 

   209

            flags & NETWORK_PHYSICS_INAIR, 

   210

            flags & NETWORK_PHYSICS_FACE_RIGHT ? FACING_RIGHT : FACING_LEFT, 

   211

            aim

   212

    );

   213

}

   214

   215

void NetworkClientPlayerBase::on_dig (NetworkPacketInput &pkt) {

   216

    Vector position = pkt.read_vector();

   217

    float radius = pkt.read_float32();

   218

   219

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

   220

   221

    // just update... 

   222

    handleDig(position, radius);

   223

}

   224

   225

void NetworkClientPlayerBase::on_weapon_change (NetworkPacketInput &pkt) {

   226

    uint8_t weapon_index = pkt.read_uint8();

   227

   228

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

   229

   230

    handleChangeWeapon(weapon_index);

   231

}

   232

   233

void NetworkClientPlayerBase::on_rope_throw (NetworkPacketInput &pkt) {

   234

    Vector position = pkt.read_vector();

   235

    Vector velocity = pkt.read_vector();

   236

    float length = pkt.read_float32();

   237

   238

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

   239

   240

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

   241

}

   242

   243

void NetworkClientPlayerBase::on_rope_fixed (NetworkPacketInput &pkt) {

   244

    Vector position = pkt.read_vector();

   245

    float length = pkt.read_float32();

   246

    NetworkObject *player_obj = controller.read_object(pkt);

   247

   248

    NetworkClientPlayerBase *player = NULL;

   249

   250

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

   251

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

   252

        return;

   253

    }

   254

   255

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

   256

        << ", player=" << player;

   257

   258

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

   259

}

   260

   261

void NetworkClientPlayerBase::on_rope_released (NetworkPacketInput &pkt) {

   262

    (void) pkt;

   263

   264

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

   265

   266

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

   267

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

   268

}

   269

   270

void NetworkClientPlayerBase::on_rope_length (NetworkPacketInput &pkt) {

   271

    float length = pkt.read_float32();

   272

   273

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

   274

   275

    rope.updateLength(length);

   276

}

   277

   278

void NetworkClientPlayerBase::on_spawn (NetworkPacketInput &pkt) {

   279

    // read packet

   280

    Vector position = pkt.read_vector();

   281

   282

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

   283

   284

    // super

   285

    Player::spawn(position);

   286

}

   287

   288

void NetworkClientPlayerBase::on_die (NetworkPacketInput &pkt) {

   289

    (void) pkt;

   290

   291

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

   292

   293

    // super, but don't start the respawn_timer

   294

    Player::die(false);

   295

}

   296

   297

/*

   298

 * NetworkClientLocalPlayer

   299

 */

   300

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

   301

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

   302

{

   303

    // set ourselves as the local player

   304

    state.setLocalPlayer(this);

   305

}

   306

   307

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

   308

    NetworkPacket pkt;

   309

   310

    // write packet

   311

    pkt.write_uint16(input);

   312

    pkt.write_uint32(dt);

   313

   314

    // send

   315

    send(NETMSG_CLIENT_INPUT, pkt, false);

   316

   317

    // do not handle locally

   318

}

   319

   320

/*

   321

 * NetworkClientRemotePlayer

   322

 */

   323

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

   324

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

   325

   326

    // receive messages

   327

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

   328

}

   329

   330

void NetworkClientRemotePlayer::on_quit (NetworkPacketInput &pkt) {

   331

    // pkt is empty

   332

    (void) pkt;

   333

   334

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

   335

   336

    client.player_quit(this);

   337

   338

    // delete

   339

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

   340

    //  delete this;

   341

}

   342

   343

/*

   344

 * NetworkClientProjectile

   345

 */

   346

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

   347

        Vector position, Vector velocity, Weapon *weapon) :

   348

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

   349

{

   350

    // hook up signals

   351

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

   352

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

   353

   354

    // tell Player

   355

    player->weaponFired(weapon);

   356

}

   357

   358

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

   359

    (void) position;

   360

    (void) removeGround;

   361

   362

    // ignore :>

   363

}

   364

   365

void NetworkClientProjectile::onHitPlayer (Player *player) {

   366

    (void) player;

   367

   368

    // ignore :>

   369

}

   370

   371

void NetworkClientProjectile::on_destroy (NetworkPacketInput &pkt) {

   372

    Vector position = pkt.read_vector();

   373

    uint8_t flags = pkt.read_uint8();

   374

   375

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

   376

   377

    // pass on to super

   378

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

   379

}

   380

   381

void NetworkClientProjectile::on_hit_player (NetworkPacketInput &pkt) {

   382

    // read packet

   383

    NetworkObject *player_obj = controller.read_object(pkt);

   384

   385

    NetworkClientPlayerBase *player;

   386

   387

    // ignore for invalid players

   388

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

   389

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

   390

        return;

   391

    }

   392

   393

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

   394

   395

    // pass on to super

   396

    Projectile::onHitPlayer(player);

   397

}

   398