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

    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

    // XXX: over 2**31?

    33

    PixelDimension map_w = pkt.read_uint32();

    34

    PixelDimension map_h = pkt.read_uint32();

    35

    36

    // read map data

    37

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

    38

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

    39

            terrain.terrain[x][y] = (TerrainType) pkt.read_uint8();

    40

        }

    41

    }

    42

    43

    // update the pixbuf

    44

    terrain.generatePixelBuffer();

    45

}

    46

    47

void NetworkClient::player_quit (NetworkClientRemotePlayer *player) {

    48

    (void) player;

    49

}

    50

    51

/*

    52

 * NetworkClientController

    53

 */ 

    54

NetworkClientController::NetworkClientController (NetworkClient &client) :

    55

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

    56

{

    57

    58

}

    59

    60

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

    61

    // XXX: should be server

    62

    (void) node;

    63

    64

    switch (msg_id) {

    65

        case NETMSG_SERVER_HELLO:

    66

            on_server_hello(obj_id, pkt);

    67

            break;

    68

    69

        case NETMSG_PLAYER_INFO:

    70

            on_player_info(obj_id, pkt);

    71

            break;

    72

    73

        case NETMSG_PLAYER_JOIN:

    74

            on_player_join(obj_id, pkt);

    75

            break;

    76

    77

        case NETMSG_PROJECTILE_PLAYER_FIRED:

    78

            on_projectile_player_fired(obj_id, pkt);

    79

            break;

    80

    81

        default:

    82

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

    83

    }

    84

}

    85

    86

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

    87

    // read the packet

    88

    Vector position = pkt.read_vector();

    89

    90

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

    91

    92

    // create the LocalPlayer object

    93

    new NetworkClientLocalPlayer(client, obj_id, position);

    94

}

    95

    96

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

    97

    // read the packet

    98

    Vector position = pkt.read_vector();

    99

   100

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

   101

   102

    // create the LocalPlayer object

   103

    new NetworkClientRemotePlayer(client, obj_id, position);

   104

}

   105

   106

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

   107

    // read the packet

   108

    Vector position = pkt.read_vector();

   109

   110

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

   111

   112

    // create the RemotePlayer object

   113

    new NetworkClientRemotePlayer(client, obj_id, position);

   114

}

   115

   116

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

   117

    // read the packet

   118

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

   119

    Vector position = pkt.read_vector();

   120

    Vector velocity = pkt.read_vector();

   121

    WeaponID weapon_id = pkt.read_uint8();

   122

   123

    NetworkClientPlayerBase *player;

   124

   125

    // ignore for invalid players

   126

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

   127

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

   128

        return;

   129

    }

   130

   131

    Weapon *weapon;

   132

   133

    // try and get the weapon

   134

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

   135

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

   136

    }

   137

   138

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

   139

   140

    // create the NetworkClientPorjectile object

   141

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

   142

}

   143

   144

/*

   145

 * NetworkClientObject

   146

 */

   147

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

   148

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

   149

{

   150

   151

}

   152

   153

/*

   154

 * NetworkClientPlayerBase

   155

 */

   156

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

   157

    Player(client.state, position, true),

   158

    NetworkClientObject(client, obj_id)

   159

{

   160

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

   161

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

   162

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

   163

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

   164

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

   165

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

   166

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

   167

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

   168

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

   169

}

   170

   171

void NetworkClientPlayerBase::spawn (Vector position) {

   172

    (void) position;

   173

   174

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

   175

}

   176

   177

void NetworkClientPlayerBase::respawn (TimeMS dt) {

   178

    (void) dt;

   179

   180

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

   181

}

   182

   183

void NetworkClientPlayerBase::die (bool start_timer) {

   184

    (void) start_timer;

   185

   186

    // ignore :>

   187

}

   188

   189

void NetworkClientPlayerBase::on_position (NetworkPacketInput &pkt) {

   190

    Vector position = pkt.read_vector();

   191

    Vector velocity = pkt.read_vector();

   192

    int flags = pkt.read_uint8();

   193

    float aim = pkt.read_float32();

   194

   195

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

   196

   197

    // just update... 

   198

    updatePhysics(position, velocity, 

   199

            flags & NETWORK_PHYSICS_INAIR, 

   200

            flags & NETWORK_PHYSICS_FACE_RIGHT ? FACING_RIGHT : FACING_LEFT, 

   201

            aim

   202

    );

   203

}

   204

   205

void NetworkClientPlayerBase::on_dig (NetworkPacketInput &pkt) {

   206

    Vector position = pkt.read_vector();

   207

    float radius = pkt.read_float32();

   208

   209

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

   210

   211

    // just update... 

   212

    handleDig(position, radius);

   213

}

   214

   215

void NetworkClientPlayerBase::on_weapon_change (NetworkPacketInput &pkt) {

   216

    uint8_t weapon_index = pkt.read_uint8();

   217

   218

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

   219

   220

    handleChangeWeapon(weapon_index);

   221

}

   222

   223

void NetworkClientPlayerBase::on_rope_throw (NetworkPacketInput &pkt) {

   224

    Vector position = pkt.read_vector();

   225

    Vector velocity = pkt.read_vector();

   226

    float length = pkt.read_float32();

   227

   228

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

   229

   230

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

   231

}

   232

   233

void NetworkClientPlayerBase::on_rope_fixed (NetworkPacketInput &pkt) {

   234

    Vector position = pkt.read_vector();

   235

    float length = pkt.read_float32();

   236

    NetworkObject *player_obj = controller.read_object(pkt);

   237

   238

    NetworkClientPlayerBase *player = NULL;

   239

   240

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

   241

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

   242

        return;

   243

    }

   244

   245

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

   246

        << ", player=" << player;

   247

   248

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

   249

}

   250

   251

void NetworkClientPlayerBase::on_rope_released (NetworkPacketInput &pkt) {

   252

    (void) pkt;

   253

   254

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

   255

   256

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

   257

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

   258

}

   259

   260

void NetworkClientPlayerBase::on_rope_length (NetworkPacketInput &pkt) {

   261

    float length = pkt.read_float32();

   262

   263

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

   264

   265

    rope.updateLength(length);

   266

}

   267

   268

void NetworkClientPlayerBase::on_spawn (NetworkPacketInput &pkt) {

   269

    // read packet

   270

    Vector position = pkt.read_vector();

   271

   272

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

   273

   274

    // super

   275

    Player::spawn(position);

   276

}

   277

   278

void NetworkClientPlayerBase::on_die (NetworkPacketInput &pkt) {

   279

    (void) pkt;

   280

   281

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

   282

   283

    // super, but don't start the respawn_timer

   284

    Player::die(false);

   285

}

   286

   287

/*

   288

 * NetworkClientLocalPlayer

   289

 */

   290

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

   291

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

   292

{

   293

    // set ourselves as the local player

   294

    state.setLocalPlayer(this);

   295

}

   296

   297

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

   298

    NetworkPacket pkt;

   299

   300

    // write packet

   301

    pkt.write_uint16(input);

   302

    pkt.write_uint32(dt);

   303

   304

    // send

   305

    send(NETMSG_CLIENT_INPUT, pkt, false);

   306

   307

    // do not handle locally

   308

}

   309

   310

/*

   311

 * NetworkClientRemotePlayer

   312

 */

   313

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

   314

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

   315

   316

    // receive messages

   317

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

   318

}

   319

   320

void NetworkClientRemotePlayer::on_quit (NetworkPacketInput &pkt) {

   321

    // pkt is empty

   322

    (void) pkt;

   323

   324

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

   325

   326

    client.player_quit(this);

   327

   328

    // delete

   329

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

   330

    //  delete this;

   331

}

   332

   333

/*

   334

 * NetworkClientProjectile

   335

 */

   336

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

   337

        Vector position, Vector velocity, Weapon *weapon) :

   338

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

   339

{

   340

    // hook up signals

   341

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

   342

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

   343

   344

    // tell Player

   345

    player->weaponFired(weapon);

   346

}

   347

   348

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

   349

    (void) position;

   350

    (void) removeGround;

   351

   352

    // ignore :>

   353

}

   354

   355

void NetworkClientProjectile::onHitPlayer (Player *player) {

   356

    (void) player;

   357

   358

    // ignore :>

   359

}

   360

   361

void NetworkClientProjectile::on_destroy (NetworkPacketInput &pkt) {

   362

    Vector position = pkt.read_vector();

   363

    uint8_t flags = pkt.read_uint8();

   364

   365

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

   366

   367

    // pass on to super

   368

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

   369

}

   370

   371

void NetworkClientProjectile::on_hit_player (NetworkPacketInput &pkt) {

   372

    // read packet

   373

    NetworkObject *player_obj = controller.read_object(pkt);

   374

   375

    NetworkClientPlayerBase *player;

   376

   377

    // ignore for invalid players

   378

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

   379

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

   380

        return;

   381

    }

   382

   383

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

   384

   385

    // pass on to super

   386

    Projectile::onHitPlayer(player);

   387

}

   388