1

     2

#include "NetworkClient.hh"

     3

#include "Engine.hh"

     4

#include "Logger.hh"

     5

     8

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

     9

    NetworkCore(state), server(netsession.connect(connect_to)) {

    10

    11

    // connect slots

    12

    slots.connect(netobjs.sig_create_object(), this, &NetworkClient::on_create_object);

    13

    14

    // XXX: sig_disconnected

    15

}

    16

    17

void NetworkClient::on_create_object (CL_NetObject_Client &obj, int msg_type, CL_NetPacket &pkt) {

    18

    switch (msg_type) {

    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_type=" << msg_type << " for obj=" << obj;

    36

    }

    37

}

    38

    39

void NetworkClient::on_server_hello (CL_NetObject_Client &obj, CL_NetPacket &pkt) {

    40

    // read the packet

    41

    uint32_t x = pkt.input.read_uint32();

    42

    uint32_t y = pkt.input.read_uint32();

    43

    44

    Coordinate initial_position(x, y);

    45

    46

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

    47

    48

    // create the LocalPlayer object

    49

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

    50

    51

    // inform state

    52

    state.newLocalPlayer(player);

    53

}

    54

    55

void NetworkClient::on_player_info (CL_NetObject_Client &obj, CL_NetPacket &pkt) {

    56

    // read the packet

    57

    uint32_t x = pkt.input.read_uint32();

    58

    uint32_t y = pkt.input.read_uint32();

    59

    60

    Coordinate initial_position(x, y);

    61

    62

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

    63

    64

    // create the LocalPlayer object

    65

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

    66

    67

    // inform state

    68

    state.newRemotePlayer(player);

    69

    70

}

    71

    72

void NetworkClient::on_player_join (CL_NetObject_Client &obj, CL_NetPacket &pkt) {

    73

    // read the packet

    74

    uint32_t x = pkt.input.read_uint32();

    75

    uint32_t y = pkt.input.read_uint32();

    76

    77

    Coordinate initial_position(x, y);

    78

    79

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

    80

    81

    // create the RemotePlayer object

    82

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

    83

    84

    // inform state

    85

    state.newRemotePlayer(player);

    86

}

    87

    88

void NetworkClient::player_quit (NetworkClientRemotePlayer *player) {

    89

    // inform state

    90

    state.removePlayer(player);

    91

    92

    // delete

    93

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

    94

    //  delete player;

    95

}

    96

    97

NetworkClientLocalPlayer::NetworkClientLocalPlayer (NetworkClient &client, CL_NetObject_Client &obj, Coordinate initial_position) :

    98

    LocalPlayer(initial_position, true), client(client), obj(obj) {

    99

   100

    // receive messages

   101

    slots.connect(obj.sig_received_message(NETMSG_PLAYER_POSITION), this, &NetworkClientLocalPlayer::on_position);

   102

}

   103

   106

    CL_NetPacket pkt;

   109

   110

    obj.send(NETMSG_CLIENT_MOVE, pkt, false);

   114

}

   115

   116

void NetworkClientLocalPlayer::on_position (CL_NetPacket &pkt) {

   117

    uint32_t x = pkt.input.read_uint32();

   118

    uint32_t y = pkt.input.read_uint32();

   119

   120

    Coordinate pos (x, y);

   121

   122

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

   123

   124

    updatePosition(pos);

   125

}

   126

   127

NetworkClientRemotePlayer::NetworkClientRemotePlayer (NetworkClient &client, CL_NetObject_Client &obj, Coordinate initial_position) :

   128

    RemotePlayer(initial_position, true), client(client), obj(obj) {

   129

   130

    // receive messages

   131

    slots.connect(obj.sig_received_message(NETMSG_PLAYER_POSITION), this, &NetworkClientRemotePlayer::on_position);

   132

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

   133

}

   134

   135

void NetworkClientRemotePlayer::on_position (CL_NetPacket &pkt) {

   136

    uint32_t x = pkt.input.read_uint32();

   137

    uint32_t y = pkt.input.read_uint32();

   138

   139

    Coordinate pos (x, y);

   140

   141

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

   142

   144

}

   145

   146

void NetworkClientRemotePlayer::on_quit (CL_NetPacket &pkt) {

   147

    // pkt is empty

   148

    (void) pkt;

   149

   150

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

   151

   152

    client.player_quit(this);

   153

}