1

     2

#include "NetworkClient.hh"

     3

#include "Engine.hh"

     4

#include "Logger.hh"

     5

     6

#include <cassert>

     7

     8

NetworkClient::NetworkClient (GameState &state, const NetworkAddress &connect_to) : 

     9

    NetworkCore(state), netsession(NETWORK_MAGIC_ID), server(netsession.connect(connect_to)), netobjs(netsession, NETCHAN_CORE, server) {

    10

    11

    // connect slots

    12

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

    13

    14

    // XXX: sig_disconnected

    15

}

    16

    17

void NetworkClient::on_create (NetworkObject_Client *obj, NetworkMessageID msg_id, NetworkPacket &pkt) {

    18

    switch (msg_id) {

    19

        case NETMSG_SERVER_HELLO:

    20

            on_server_hello(obj, pkt);

    21

    22

            break;

    23

    24

        case NETMSG_PLAYER_INFO:

    25

            on_player_info(obj, pkt);

    26

    27

            break;

    28

    29

        case NETMSG_PLAYER_JOIN:

    30

            on_player_join(obj, pkt);

    31

    32

            break;

    33

    34

        default:

    35

            Engine::log(WARN, "client.on_create_object") << "unknown msg_id=" << msg_id << " for obj=" << obj;

    36

    }

    37

}

    38

    39

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

    40

    // read the packet

    41

    Vector position = pkt.read_vector();

    42

    43

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

    44

    45

    // create the LocalPlayer object

    46

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

    47

    48

    // inform state

    49

    state.newLocalPlayer(player);

    50

}

    51

    52

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

    53

    // read the packet

    54

    Vector position = pkt.read_vector();

    55

    56

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

    57

    58

    // create the LocalPlayer object

    59

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

    60

    61

    // inform state

    62

    state.newRemotePlayer(player);

    63

    64

}

    65

    66

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

    67

    // read the packet

    68

    Vector position = pkt.read_vector();

    69

    70

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

    71

    72

    // create the RemotePlayer object

    73

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

    74

    75

    // inform state

    76

    state.newRemotePlayer(player);

    77

}

    78

    79

void NetworkClient::player_quit (NetworkClientRemotePlayer *player) {

    80

    // inform state

    81

    state.removePlayer(player);

    82

    83

    // delete

    84

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

    85

    //  delete player;

    86

}

    87

    88

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

    89

    LocalPlayer(client.state, position, true), client(client), obj(obj) {

    90

    91

    // receive messages

    92

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

    93

}

    94

    95

void NetworkClientLocalPlayer::handleMove (PlayerInput_Move input) {

    96

    // always send move, in all cases

    97

    NetworkPacket pkt;

    98

    pkt.write_uint16(input);

    99

   100

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

   101

   102

    // do not handle locally

   103

}

   104

   105

void NetworkClientLocalPlayer::on_position (NetworkPacket &pkt) {

   106

    Vector position = pkt.read_vector();

   107

    Vector velocity = pkt.read_vector();

   108

    uint8_t flags = pkt.read_uint8();

   109

   110

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

   111

   112

    // just update... 

   113

    updatePhysics(position, velocity, flags & NETWORK_PHYSICS_INAIR);

   114

}

   115

   116

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

   117

    RemotePlayer(client.state, position, true), client(client), obj(obj) {

   118

   119

    // receive messages

   120

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

   121

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

   122

}

   123

   124

void NetworkClientRemotePlayer::on_position (NetworkPacket &pkt) {

   125

    Vector position = pkt.read_vector();

   126

    Vector velocity = pkt.read_vector();

   127

    uint8_t flags = pkt.read_uint8();

   128

   129

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

   130

   131

    // just update... 

   132

    updatePhysics(position, velocity, flags & NETWORK_PHYSICS_INAIR);

   133

}

   134

   135

void NetworkClientRemotePlayer::on_quit (NetworkPacket &pkt) {

   136

    // pkt is empty

   137

    (void) pkt;

   138

   139

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

   140

   141

    client.player_quit(this);

   142

}

   143