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

    70

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

    71

    72

    // create the NetworkClientPorjectile object

    73

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

    74

}

    75

    76

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

    77

    // ignore if not from server

    78

    if (node != server)

    79

        return;

    80

    81

    Terrain &terrain = state.world;

    82

    83

    // read map width/height

    84

    uint32_t map_w = pkt.read_uint32();

    85

    uint32_t map_h = pkt.read_uint32();

    86

    87

    // read map data

    88

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

    89

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

    90

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

    91

        }

    92

    }

    93

    94

    // update the pixbuf

    95

    terrain.generatePixelBuffer();

    96

}

    97

    98

void NetworkClient::player_quit (NetworkClientRemotePlayer *player) {

    99

    // inform state

   100

    state.removePlayer(player);

   101

   102

    // delete

   103

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

   104

    //  delete player;

   105

}

   106

   107

/*

   108

 * NetworkClientObjectHelper

   109

 */

   110

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

   111

    client(client), obj(obj)

   112

{

   113

   114

}

   115

   116

/*

   117

 * NetworkClientPlayerHelper

   118

 */

   119

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

   120

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

   121

{

   130

}

   131

   132

void NetworkClientPlayerHelper::on_position (NetworkPacketInput &pkt) {

   133

    Vector position = pkt.read_vector();

   134

    Vector velocity = pkt.read_vector();

   135

    int flags = pkt.read_uint8();

   136

    float aim = pkt.read_float32();

   137

   138

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

   139

   140

    // just update... 

   141

    updatePhysics(position, velocity, flags & NETWORK_PHYSICS_INAIR, flags & NETWORK_PHYSICS_FACE_RIGHT, aim);

   142

}

   143

   144

void NetworkClientPlayerHelper::on_dig (NetworkPacketInput &pkt) {

   145

    Vector position = pkt.read_vector();

   146

    float radius = pkt.read_float32();

   147

   148

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

   149

   150

    // just update... 

   151

    handleDig(position, radius);

   152

}

   153

   154

void NetworkClientPlayerHelper::on_weapon_change (NetworkPacketInput &pkt) {

   155

    uint8_t weapon_index = pkt.read_uint8();

   156

   157

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

   158

   159

    handleChangeWeapon(weapon_index);

   160

}

   161

   196

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

   197

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

   198

   199

}

   200

   201

void NetworkClientLocalPlayer::handleInput (PlayerInput input) {

   202

    // always send move, in all cases

   203

    NetworkPacket pkt;

   204

    pkt.write_uint16(input);

   205

   206

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

   207

   208

    // do not handle locally

   209

}

   210

   211

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

   212

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

   213

   214

    // receive messages

   215

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

   216

}

   217

   218

void NetworkClientRemotePlayer::on_quit (NetworkPacketInput &pkt) {

   219

    // pkt is empty

   220

    (void) pkt;

   221

   222

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

   223

   224

    client.player_quit(this);

   225

}

   226

   227

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

   228

        Vector velocity, float explosionRadius) :

   229

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

   230

{

   231

    // hook up signals

   232

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

   233

}

   234

   235

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

   236

    // ignore :>

   237

}

   238

   239

void NetworkClientProjectile::on_destroy (NetworkPacketInput &pkt) {

   240

    Vector position = pkt.read_vector();

   241

    uint8_t flags = pkt.read_uint8();

   242

   243

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

   244

   245

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

   246

   247

    // pass on to super

   248

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

   249

}