1

#include "NetworkServer.hh"

     2

#include "Engine.hh"

     3

#include "Logger.hh"

     4

     5

#include <cassert>

     6

     7

NetworkServer::NetworkServer (GameState &state, const std::string &listen_port) : 

     8

    NetworkCore(state), pid_pool(0) {

     9

    10

    // connect slots

    11

    slots.connect(netsession.sig_computer_connected(), this, &NetworkServer::on_connect);

    12

    slots.connect(netsession.sig_computer_disconnected(), this, &NetworkServer::on_disconnect);

    13

    14

    // and then we listen

    15

    netsession.start_listen(listen_port);

    16

    17

    Engine::log(INFO, "server") << "running, listen_port=" << listen_port;

    18

}

    19

    20

void NetworkServer::on_connect (CL_NetComputer &computer) {

    21

    // assign a pid

    22

    uint16_t pid = ++pid_pool;

    23

    24

    // create the player object (it logs it)

    25

    NetworkServerPlayer *player = new NetworkServerPlayer(*this, computer, pid);

    26

    27

    // map computer to it

    28

    players[computer] = player;

    29

    30

    // add to GameState

    31

    state.newRemotePlayer(player);

    32

}

    33

    34

void NetworkServer::on_disconnect (CL_NetComputer &computer) {

    35

    NetworkServerPlayer *player = players[computer];

    36

    37

    // remove from players

    38

    players.erase(computer);

    39

    40

    // remove from state

    41

    state.removePlayer(player);

    42

    43

    // remove from game

    44

    player->disconnected();

    45

    46

    // delete

    47

    delete player;

    48

}

    49

    50

NetworkServerPlayer::NetworkServerPlayer (NetworkServer &server, CL_NetComputer &computer, uint16_t pid) : 

    52

    53

    // log

    54

    Engine::log(INFO, "server_player.connected") << "computer=" << computer << ", obj=" << obj;

    55

    56

    // messages

    57

    slots.connect(obj.sig_received_message(NETMSG_CLIENT_MOVE), this, &NetworkServerPlayer::on_move);   

    58

    59

    // the initial NETMSG_PLAYER_HELLO

    60

    CL_NetPacket hello_pkt;

    61

    hello_pkt.output.write_uint32(position.x);

    62

    hello_pkt.output.write_uint32(position.y);

    63

    64

    obj.send(computer, NETMSG_SERVER_HELLO, hello_pkt, true);

    65

    66

    // send other player objects

    67

    for (std::map<CL_NetComputer, NetworkServerPlayer*>::iterator it = server.players.begin(); it != server.players.end(); it++) {

    68

        NetworkServerPlayer *player = it->second;

    69

        CL_NetPacket player_pkt;

    70

    71

        // player is not in players list yet

    72

        assert(player != this);

    73

    74

        player_pkt.output.write_uint32(player->position.x);

    75

        player_pkt.output.write_uint32(player->position.y);

    76

    77

        player->obj.send(computer, NETMSG_PLAYER_INFO, player_pkt, true);

    78

    }

    79

    80

    81

    // broadcast NETMSG_PLAYER_JOIN to all clients

    82

    obj.send(server.netsession.get_all(), NETMSG_PLAYER_JOIN, hello_pkt, true);

    83

}

    84

    85

void NetworkServerPlayer::disconnected (void) {

    86

    CL_NetPacket pkt;

    87

    88

    Engine::log(INFO, "server_player.disconnected") << "computer=" << computer << ", obj=" << obj;

    89

    90

    obj.send(server.netsession.get_all(), NETMSG_PLAYER_QUIT, pkt, true);

    91

}

    92

    93

void NetworkServerPlayer::on_move (CL_NetComputer &from, CL_NetPacket &pkt) {

    94

    // sanity-check

    95

    if (!(from == computer))

    96

        return;

    97

    98

    // read packet

    99

    int32_t dx = pkt.input.read_int32();

   100

    int32_t dy = pkt.input.read_int32();

   101

   102

    // movement delta

   103

    PositionDelta delta(dx, dy);

   104

   105

    Engine::log(INFO, "server_player.on_move") << "obj=" << obj << ", old_pos=" << position << ", delta=" << delta;

   106

   107

    // apply movement

   108

    position += delta;

   109

   110

    // send position update

   111

    send_position_update();

   112

}

   113

   114

void NetworkServerPlayer::send_position_update (void) {

   115

    CL_NetPacket pkt;

   116

    pkt.output.write_uint32(position.x);

   117

    pkt.output.write_uint32(position.y);

   118

   119

    Engine::log(INFO, "server_player.send_position_update") << "obj=" << obj << " -> " << position;

   120

   121

    obj.send(server.netsession.get_all(), NETMSG_PLAYER_POSITION, pkt, false);

   122

}

   123