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

{

   122

    // receive position updates

   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

}

   126

   127

void NetworkClientPlayerHelper::on_position (NetworkPacketInput &pkt) {

   128

    Vector position = pkt.read_vector();

   129

    Vector velocity = pkt.read_vector();

   130

    int flags = pkt.read_uint8();

   131

    float aim = pkt.read_float32();

   132

   133

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

   134

   135

    // just update... 

   136

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

   137

}

   138

   139

void NetworkClientPlayerHelper::on_dig (NetworkPacketInput &pkt) {

   140

    Vector position = pkt.read_vector();

   141

    float radius = pkt.read_float32();

   142

   143

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

   144

   145

    // just update... 

   146

    handleDig(position, radius);

   147

}

   148

   149

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

   150

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

   151

   152

}

   153

   154

void NetworkClientLocalPlayer::handleInput (PlayerInput input) {

   155

    // always send move, in all cases

   156

    NetworkPacket pkt;

   157

    pkt.write_uint16(input);

   158

   159

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

   160

   161

    // do not handle locally

   162

}

   163

   164

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

   165

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

   166

   167

    // receive messages

   168

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

   169

}

   170

   171

void NetworkClientRemotePlayer::on_quit (NetworkPacketInput &pkt) {

   172

    // pkt is empty

   173

    (void) pkt;

   174

   175

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

   176

   177

    client.player_quit(this);

   178

}

   179

   180

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

   181

        Vector velocity, float explosionRadius) :

   182

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

   183

{

   186

}

   187