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)), netobjs(netsession, NETCHAN_CORE, server) {

    12

    13

    // connect slots

    14

    slots.connect(netobjs.sig_create(NETMSG_SERVER_HELLO), this, &NetworkClient::on_server_hello);

    15

    slots.connect(netobjs.sig_create(NETMSG_PLAYER_INFO), this, &NetworkClient::on_player_info);

    16

    slots.connect(netobjs.sig_create(NETMSG_PLAYER_JOIN), this, &NetworkClient::on_player_join);

    17

    slots.connect(netobjs.sig_create(NETMSG_PROJECTILE_CREATE), this, &NetworkClient::on_projectile_create);

    18

    19

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

    20

    21

    // XXX: sig_disconnected

    22

}

    23

    24

void NetworkClient::on_server_hello (NetworkObject_Client *obj, NetworkPacketInput &pkt) {

    25

    // read the packet

    26

    Vector position = pkt.read_vector();

    27

    28

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

    29

    30

    // create the LocalPlayer object

    31

    NetworkClientLocalPlayer *player = new NetworkClientLocalPlayer(*this, obj, position);

    32

    33

    // inform state

    34

    state.newLocalPlayer(player);

    35

}

    36

    37

void NetworkClient::on_player_info (NetworkObject_Client *obj, NetworkPacketInput &pkt) {

    38

    // read the packet

    39

    Vector position = pkt.read_vector();

    40

    41

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

    42

    43

    // create the LocalPlayer object

    44

    NetworkClientRemotePlayer *player = new NetworkClientRemotePlayer(*this, obj, position);

    45

    46

    // inform state

    47

    state.newPlayer(player);

    48

    49

}

    50

    51

void NetworkClient::on_player_join (NetworkObject_Client *obj, NetworkPacketInput &pkt) {

    52

    // read the packet

    53

    Vector position = pkt.read_vector();

    54

    55

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

    56

    57

    // create the RemotePlayer object

    58

    NetworkClientRemotePlayer *player = new NetworkClientRemotePlayer(*this, obj, position);

    59

    60

    // inform state

    61

    state.newPlayer(player);

    62

}

    63

    64

void NetworkClient::on_projectile_create (NetworkObject_Client *obj, NetworkPacketInput &pkt) {

    65

    // read the packet

    66

    Vector position = pkt.read_vector();

    67

    Vector velocity = pkt.read_vector();

    68

    float explosionRadius = pkt.read_float32();

    69

    float radius = pkt.read_float32();

    70

    71

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

    72

    73

    // create the NetworkClientPorjectile object

    74

    new NetworkClientProjectile(*this, obj, position, velocity, explosionRadius, radius);

    75

}

    76

    77

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

    78

    // ignore if not from server

    79

    if (node != server)

    80

        return;

    81

    82

    Terrain &terrain = state.world;

    83

    84

    // read map width/height

    85

    uint32_t map_w = pkt.read_uint32();

    86

    uint32_t map_h = pkt.read_uint32();

    87

    88

    // read map data

    89

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

    90

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

    91

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

    92

        }

    93

    }

    94

    95

    // update the pixbuf

    96

    terrain.generatePixelBuffer();

    97

}

    98

    99

void NetworkClient::player_quit (NetworkClientRemotePlayer *player) {

   100

    // inform state

   101

    state.removePlayer(player);

   102

   103

    // delete

   104

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

   105

    //  delete player;

   106

}

   107

   108

/*

   109

 * NetworkClientObjectHelper

   110

 */

   111

NetworkClientObjectHelper::NetworkClientObjectHelper (NetworkClient &client, NetworkObject_Client *obj) :

   112

    client(client), obj(obj)

   113

{

   114

   115

}

   116

   117

/*

   118

 * NetworkClientPlayerHelper

   119

 */

   120

NetworkClientPlayerHelper::NetworkClientPlayerHelper (NetworkClient &client, Vector position, NetworkObject_Client *obj) :

   121

    NetworkClientObjectHelper(client, obj), Player(client.state, position, true) 

   122

{

   123

    slots.connect(obj->sig_message(NETMSG_PLAYER_POSITION),         this,   &NetworkClientPlayerHelper::on_position         );

   124

    slots.connect(obj->sig_message(NETMSG_PLAYER_DIG),              this,   &NetworkClientPlayerHelper::on_dig              );

   125

    slots.connect(obj->sig_message(NETMSG_PLAYER_WEAPON_CHANGE),    this,   &NetworkClientPlayerHelper::on_weapon_change    );

   126

    slots.connect(obj->sig_message(NETMSG_PLAYER_ROPE_THROW),       this,   &NetworkClientPlayerHelper::on_rope_throw       );

   127

    slots.connect(obj->sig_message(NETMSG_PLAYER_ROPE_FIXED),       this,   &NetworkClientPlayerHelper::on_rope_fixed       );

   128

    slots.connect(obj->sig_message(NETMSG_PLAYER_ROPE_RELEASED),    this,   &NetworkClientPlayerHelper::on_rope_released    );

   129

    slots.connect(obj->sig_message(NETMSG_PLAYER_ROPE_LENGTH),      this,   &NetworkClientPlayerHelper::on_rope_length      );

   130

   131

}

   132

   133

void NetworkClientPlayerHelper::on_position (NetworkPacketInput &pkt) {

   134

    Vector position = pkt.read_vector();

   135

    Vector velocity = pkt.read_vector();

   136

    int flags = pkt.read_uint8();

   137

    float aim = pkt.read_float32();

   138

   139

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

   140

   141

    // just update... 

   142

    updatePhysics(position, velocity, 

   143

            flags & NETWORK_PHYSICS_INAIR, 

   144

            flags & NETWORK_PHYSICS_FACE_RIGHT ? FACING_RIGHT : FACING_LEFT, 

   145

            aim

   146

    );

   147

}

   148

   149

void NetworkClientPlayerHelper::on_dig (NetworkPacketInput &pkt) {

   150

    Vector position = pkt.read_vector();

   151

    float radius = pkt.read_float32();

   152

   153

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

   154

   155

    // just update... 

   156

    handleDig(position, radius);

   157

}

   158

   159

void NetworkClientPlayerHelper::on_weapon_change (NetworkPacketInput &pkt) {

   160

    uint8_t weapon_index = pkt.read_uint8();

   161

   162

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

   163

   164

    handleChangeWeapon(weapon_index);

   165

}

   166

   167

void NetworkClientPlayerHelper::on_rope_throw (NetworkPacketInput &pkt) {

   168

    Vector position = pkt.read_vector();

   169

    Vector velocity = pkt.read_vector();

   170

    float length = pkt.read_float32();

   171

   172

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

   173

   174

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

   175

}

   176

   177

void NetworkClientPlayerHelper::on_rope_fixed (NetworkPacketInput &pkt) {

   178

    Vector position = pkt.read_vector();

   179

    float length = pkt.read_float32();

   180

   181

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

   182

   183

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

   184

}

   185

   186

void NetworkClientPlayerHelper::on_rope_released (NetworkPacketInput &pkt) {

   187

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

   188

   189

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

   190

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

   191

}

   192

   193

void NetworkClientPlayerHelper::on_rope_length (NetworkPacketInput &pkt) {

   194

    float length = pkt.read_float32();

   195

   196

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

   197

   198

    rope.updateLength(length);

   199

}

   200

   201

NetworkClientLocalPlayer::NetworkClientLocalPlayer (NetworkClient &client, NetworkObject_Client *obj, Vector position) :

   202

    Player(client.state, position, true), NetworkClientPlayerHelper(client, position, obj) {

   203

   204

}

   205

   206

void NetworkClientLocalPlayer::handleInput (PlayerInput input) {

   207

    // always send move, in all cases

   208

    NetworkPacket pkt;

   209

    pkt.write_uint16(input);

   210

   211

    obj->send(NETMSG_CLIENT_INPUT, pkt, false);

   212

   213

    // do not handle locally

   214

}

   215

   216

NetworkClientRemotePlayer::NetworkClientRemotePlayer (NetworkClient &client, NetworkObject_Client *obj, Vector position) :

   217

    Player(client.state, position, true), NetworkClientPlayerHelper(client, position, obj) {

   218

   219

    // receive messages

   220

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

   221

}

   222

   223

void NetworkClientRemotePlayer::on_quit (NetworkPacketInput &pkt) {

   224

    // pkt is empty

   225

    (void) pkt;

   226

   227

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

   228

   229

    client.player_quit(this);

   230

}

   231

   232

NetworkClientProjectile::NetworkClientProjectile (NetworkClient &client, NetworkObject_Client *obj, Vector position,

   233

        Vector velocity, float explosionRadius, float radius) :

   234

    NetworkClientObjectHelper(client, obj), Projectile(client.state, position, velocity, true, explosionRadius, radius)

   235

{

   236

    // hook up signals

   237

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

   238

}

   239

   240

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

   241

    // ignore :>

   242

}

   243

   244

void NetworkClientProjectile::on_destroy (NetworkPacketInput &pkt) {

   245

    Vector position = pkt.read_vector();

   246

    uint8_t flags = pkt.read_uint8();

   247

   248

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

   249

   250

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

   251

   252

    // pass on to super

   253

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

   254

}