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) : 

    51

    RemotePlayer(server.state, Vector(PLAYER_INITIAL_X, PLAYER_INITIAL_Y), true), server(server), computer(computer), obj(&server.netobjs), pid(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

    writeVector(hello_pkt, position);

    62

    63

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

    64

    65

    // send other player objects

    66

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

    67

        NetworkServerPlayer *player = it->second;

    68

        CL_NetPacket player_pkt;

    69

    70

        // player is not in players list yet

    71

        assert(player != this);

    72

    73

        writeVector(player_pkt, player->position);

    74

    75

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

    76

    }

    77

    78

    79

    // broadcast NETMSG_PLAYER_JOIN to all clients

    80

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

    81

}

    82

    83

void NetworkServerPlayer::disconnected (void) {

    84

    CL_NetPacket pkt;

    85

    86

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

    87

    88

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

    89

}

    90

    91

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

    92

    // sanity-check

    93

    if (!(from == computer))

    94

        return;

    95

    96

    Vector impulse_force = readVector(pkt);    

    97

    uint16_t impulse_ms = pkt.input.read_uint16();

    98

    99

    Engine::log(INFO, "server_player.on_move") << "obj=" << obj << ", old_pos=" << position << ", impulse=" << impulse_force << "@" << impulse_ms << "ms";

   100

   101

    // apply force

   102

    applyForce(impulse_force, impulse_ms);

   103

   104

    // send position update

   105

    send_position_update();

   106

}

   107

   108

void NetworkServerPlayer::send_position_update (void) {

   109

    CL_NetPacket pkt;

   110

    writeVector(pkt, position);

   111

    writeVector(pkt, velocity);

   112

   113

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

   114

   115

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

   116

}

   117