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 (GameState &state, const NetworkAddress &connect_to) : 

    11

    state(state), netsession(NETWORK_MAGIC_ID), server(netsession.connect(connect_to)), controller(*this)

    12

{

    13

    // connect slots

    14

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

    15

    16

    // XXX: sig_disconnected

    17

}

    18

    19

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

    20

    // ignore if not from server

    21

    if (node != server)

    22

        return;

    23

    24

    Terrain &terrain = state.world;

    25

    26

    // read map width/height

    30

    31

    // read map data

    34

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

    35

        }

    36

    }

    37

    38

    // update the pixbuf

    39

    terrain.generatePixelBuffer();

    40

}

    41

    42

void NetworkClient::player_quit (NetworkClientRemotePlayer *player) {

    43

    // inform state

    44

    state.removePlayer(player);

    45

    46

    // delete

    47

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

    48

    //  delete 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) {

    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) :

   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

}

   168

   169

void NetworkClientPlayerBase::on_position (NetworkPacketInput &pkt) {

   170

    Vector position = pkt.read_vector();

   171

    Vector velocity = pkt.read_vector();

   172

    int flags = pkt.read_uint8();

   173

    float aim = pkt.read_float32();

   174

   175

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

   176

   177

    // just update... 

   178

    updatePhysics(position, velocity, 

   179

            flags & NETWORK_PHYSICS_INAIR, 

   180

            flags & NETWORK_PHYSICS_FACE_RIGHT ? FACING_RIGHT : FACING_LEFT, 

   181

            aim

   182

    );

   183

}

   184

   185

void NetworkClientPlayerBase::on_dig (NetworkPacketInput &pkt) {

   186

    Vector position = pkt.read_vector();

   187

    float radius = pkt.read_float32();

   188

   189

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

   190

   191

    // just update... 

   192

    handleDig(position, radius);

   193

}

   194

   195

void NetworkClientPlayerBase::on_weapon_change (NetworkPacketInput &pkt) {

   196

    uint8_t weapon_index = pkt.read_uint8();

   197

   198

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

   199

   200

    handleChangeWeapon(weapon_index);

   201

}

   202

   203

void NetworkClientPlayerBase::on_rope_throw (NetworkPacketInput &pkt) {

   204

    Vector position = pkt.read_vector();

   205

    Vector velocity = pkt.read_vector();

   206

    float length = pkt.read_float32();

   207

   208

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

   209

   210

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

   211

}

   212

   213

void NetworkClientPlayerBase::on_rope_fixed (NetworkPacketInput &pkt) {

   214

    Vector position = pkt.read_vector();

   215

    float length = pkt.read_float32();

   216

   217

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

   218

   219

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

   220

}

   221

   222

void NetworkClientPlayerBase::on_rope_released (NetworkPacketInput &pkt) {

   225

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

   226

   227

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

   228

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

   229

}

   230

   231

void NetworkClientPlayerBase::on_rope_length (NetworkPacketInput &pkt) {

   232

    float length = pkt.read_float32();

   233

   234

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

   235

   236

    rope.updateLength(length);

   237

}

   238

   239

/*

   240

 * NetworkClientLocalPlayer

   241

 */

   242

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

   243

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

   244

{

   245

    // set ourselves as the local player

   246

    state.setLocalPlayer(this);

   247

}

   248

   249

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

   250

    (void) dt;

   251

   252

    // always send move, in all cases

   253

    NetworkPacket pkt;

   254

    pkt.write_uint16(input);

   255

   256

    send(NETMSG_CLIENT_INPUT, pkt, false);

   257

   258

    // do not handle locally

   259

}

   260

   261

/*

   262

 * NetworkClientRemotePlayer

   263

 */

   264

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

   265

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

   266

   267

    // receive messages

   268

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

   269

}

   270

   271

void NetworkClientRemotePlayer::on_quit (NetworkPacketInput &pkt) {

   272

    // pkt is empty

   273

    (void) pkt;

   274

   275

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

   276

   277

    client.player_quit(this);

   278

}

   279

   280

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

   281

        Vector position, Vector velocity, Weapon *weapon) :

   282

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

   283

{

   284

    // hook up signals

   285

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

   286

   287

    // tell Player

   288

    player->weaponFired(weapon);

   289

}

   290

   291

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

   295

    // ignore :>

   296

}

   297

   298

void NetworkClientProjectile::on_destroy (NetworkPacketInput &pkt) {

   299

    Vector position = pkt.read_vector();

   300

    uint8_t flags = pkt.read_uint8();

   301

   302

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

   303

   304

    // XXX: leak obj, not yet implemented:  obj.destory();

   305

   306

    // pass on to super

   307

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

   308

}

   309