1

     2

#include "Server.hh"

     3

#include "Protocol.hh"

     4

#include "Config.hh"

     5

#include "../Engine.hh"

     6

#include "../Logger.hh"

     7

     8

#include <cassert>

     9

    10

NetworkServer::NetworkServer (GameState &state, const NetworkAddress &listen_addr) : 

    11

    state(state), netsession(NETWORK_MAGIC_ID), controller(netsession, NETCHAN_CORE) {

    12

    13

    // connect slots

    14

    slots.connect(netsession.sig_node_connected(), this, &NetworkServer::on_node_connected);

    15

    16

    // and then we listen

    17

    netsession.listen(listen_addr);

    18

    19

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

    20

}

    21

    22

void NetworkServer::on_node_connected (NetworkNode *node) {

    23

    // create the player object (it logs it)

    24

    NetworkServerPlayer *player = new NetworkServerPlayer(*this, node);

    25

    26

    // add to players

    27

    players.push_back(player);

    28

}

    29

    30

void NetworkServer::handle_disconnect (NetworkServerPlayer *player) {

    31

    // remove from state

    32

    state.removePlayer(player);

    33

    34

    // remove from list

    35

    players.remove(player);

    36

}

    37

    38

/*

    39

 * NetworkServerObject

    40

 */

    41

NetworkServerObject::NetworkServerObject (NetworkServer &server) :

    42

    NetworkObject_Server(server.controller), server(server)

    43

{

    44

    45

}

    46

    47

/*

    48

 * NetworkServerPlayer

    49

 */

    50

NetworkServerPlayer::NetworkServerPlayer (NetworkServer &server, NetworkNode *node) : 

    51

    Player(server.state, Vector(PLAYER_INITIAL_X, PLAYER_INITIAL_Y), true), NetworkServerObject(server), node(node) 

    52

{

    53

    // log

    54

    Engine::log(INFO, "server_player.connected") << this << ": node=" << node;

    55

    56

    // messages

    57

    slots.connect(node->sig_disconnected(), this, &NetworkServerPlayer::on_disconnected);

    58

    slots.connect(this->sig_message(NETMSG_CLIENT_INPUT), this, &NetworkServerPlayer::on_input);

    59

    60

    // the initial NETMSG_PLAYER_HELLO

    61

    NetworkPacket hello_pkt;

    62

    hello_pkt.write_vector(position);

    63

    64

    this->send_to(node, NETMSG_SERVER_HELLO, hello_pkt, true);

    65

    66

    // send other player objects

    67

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

    68

        NetworkServerPlayer *player = *it;

    69

        NetworkPacket player_pkt;

    70

    71

        // player is not in players list yet

    72

        assert(player != this);

    73

    74

        player_pkt.write_vector(player->position);

    75

    76

        player->send_to(node, NETMSG_PLAYER_INFO, player_pkt, true);

    77

    }

    78

    79

    // broadcast NETMSG_PLAYER_JOIN to all clients except current

    80

    this->send_all_except(NETMSG_PLAYER_JOIN, hello_pkt, node, true);

    81

    82

    // send terrain data...

    83

    send_terrain_data();

    84

}

    85

    86

void NetworkServerPlayer::handleDig (Vector position, float radius) {

    87

    NetworkPacket pkt;

    88

    89

    pkt.write_vector(position);

    90

    pkt.write_float32(radius);

    91

    92

    Engine::log(INFO, "server_player.handle_dig") << "position=" << position << ", radius=" << radius;

    93

    94

    // tell everyone... make this reliable... 

    95

    this->send_all(NETMSG_PLAYER_DIG, pkt, true);

    96

    97

    // and carry out the actual dig on the server as well

    98

    Player::handleDig(position, radius);

    99

}

   100

   101

void NetworkServerPlayer::handleFireWeapon (Weapon *weapon, Vector position, Vector velocity) {

   102

    Engine::log(INFO, "server_player.fire_weapon") << "weapon='" << weapon->getName() << "', position=" << position << ", velocity=" << velocity;

   103

   104

    // create new NetworkServerProjectile object

   105

    new NetworkServerProjectile(server, this, position, velocity, weapon);

   106

   107

    // as handleFireWeapon does

   108

    weaponFired(weapon);

   109

}

   110

   111

void NetworkServerPlayer::handleChangeWeapon (unsigned int weaponIndex) {

   112

    NetworkPacket pkt;

   113

   114

    Engine::log(INFO, "server_player.change_weapon") << "weaponIndex=" << weaponIndex;

   115

   116

    // write packet

   117

    pkt.write_uint8(weaponIndex);

   118

   119

    // XXX: only tell the client itself?

   120

    send_all(NETMSG_PLAYER_WEAPON_CHANGE, pkt, true);

   121

   122

    // pass through

   123

    Player::handleChangeWeapon(weaponIndex);

   124

}

   125

   126

void NetworkServerPlayer::handleRopeState (RopeState state) {

   127

    NetworkPacket pkt; 

   128

   129

    Engine::log(INFO, "server_player.rope_state") << "state=" << rope.getState() << ", position=" << rope.getPosition() << ", velocity=" << rope.getVelocity() << ", length=" << rope.getLength();

   130

   131

    switch (state) {

   132

    case ROPE_FLYING:

   133

        pkt.write_vector(rope.getPosition());

   134

        pkt.write_vector(rope.getVelocity());

   135

        pkt.write_float32(rope.getLength());

   136

   137

        send_all(NETMSG_PLAYER_ROPE_THROW, pkt, true);

   138

   139

        break;

   140

   141

    case ROPE_FIXED:

   142

        pkt.write_vector(rope.getPosition());

   143

        pkt.write_float32(rope.getLength());

   144

   145

        send_all(NETMSG_PLAYER_ROPE_FIXED, pkt, true);

   146

   147

        break;

   148

   149

    case ROPE_FOLDED:

   150

        send_all(NETMSG_PLAYER_ROPE_RELEASED, pkt, true);

   151

   152

        break;

   153

    }

   154

}

   155

   156

void NetworkServerPlayer::handleRopeLength (float length) {

   157

    NetworkPacket pkt;

   158

   159

    pkt.write_float32(length);

   160

   161

    send_all(NETMSG_PLAYER_ROPE_LENGTH, pkt, true);

   162

}

   163

   164

void NetworkServerPlayer::on_disconnected (void) {

   165

    NetworkPacket pkt;

   166

   167

    Engine::log(INFO, "server_player.disconnected") << this << ": node=" << node;

   168

   169

    // remove from server

   170

    server.handle_disconnect(this);

   171

   172

    // tell other clients

   173

    send_all(NETMSG_PLAYER_QUIT, pkt, true);

   174

   175

    // free

   176

//    delete this;

   177

}

   178

   179

void NetworkServerPlayer::on_input (NetworkNode *src, NetworkPacketInput &pkt) {

   180

    // sanity-check, other players shouldn't move

   181

    if (src != node) {

   182

        Engine::log(WARN, "server_player.on_input") << "packet from wrong src=" << src << ", node=" << node;

   183

        return;

   184

    }

   185

   186

    // read packet 

   187

    PlayerInput input = pkt.read_uint16();

   188

   189

//    Engine::log(INFO, "server_player.on_input") << "player=" << obj << ", old_pos=" << position << ", input=" << input;

   190

   191

    // apply input

   192

    handleInput(input, 10);  

   193

   194

    // send position update

   195

    send_position_update();

   196

}

   197

   198

void NetworkServerPlayer::send_terrain_data (void) {

   199

    Terrain &terrain = server.state.world;

   200

   201

    uint32_t map_w = terrain.terrain.size();

   202

    uint32_t map_h = terrain.terrain[0].size();

   203

   204

    // allocate our packet...

   205

    BigNetworkPacket pkt (NETWORK_SESSION_HEADER_SIZE + 2 * sizeof(uint32_t) + map_w * map_h);

   206

   207

    // write netsession header

   208

    node->write_packet_header(pkt, NETCHAN_TERRAIN_ARRAY);

   209

   210

    // write terrain dimensions

   211

    pkt.write_uint32(map_w);

   212

    pkt.write_uint32(map_h);

   213

   214

    // write out terrain data

   215

    for (int x = 0; x < map_w; x++) {

   216

        for (int y = 0; y < map_h; y++) {

   217

            pkt.write_uint8((uint8_t) terrain.terrain[x][y]);

   218

        }

   219

    }

   220

   221

    // send

   222

    node->send_raw(pkt, true);

   223

}

   224

   225

void NetworkServerPlayer::send_position_update (void) {

   226

    NetworkPacket pkt;

   227

   228

    int flags = 

   229

        (inAir ? NETWORK_PHYSICS_INAIR : 0) | 

   230

        (facing == FACING_RIGHT ? NETWORK_PHYSICS_FACE_RIGHT : 0);

   231

   232

    pkt.write_vector(position);

   233

    pkt.write_vector(velocity);

   234

    pkt.write_uint8(flags);

   235

    pkt.write_float32(aim);

   236

   237

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

   238

   239

    send_all(NETMSG_PLAYER_POSITION, pkt, false);

   240

}

   241

   242

/* 

   243

 * NetworkServerProjectile

   244

 */

   245

NetworkServerProjectile::NetworkServerProjectile (NetworkServer &server, NetworkServerPlayer *player, Vector position,

   246

        Vector velocity, Weapon *weapon) :

   247

    Projectile(player, position, velocity, weapon, true), NetworkServerObject(server)

   248

{

   249

    NetworkPacket pkt;

   250

   251

    server.controller.write_object(pkt, player);

   252

    pkt.write_vector(position);

   253

    pkt.write_vector(velocity);

   254

    pkt.write_uint8(weapon->getID());

   255

   256

    send_all(NETMSG_PROJECTILE_PLAYER_FIRED, pkt, true);

   257

}

   258

   259

void NetworkServerProjectile::onDestroy (Vector position, bool removeGround) {

   260

    NetworkPacket pkt;

   261

   262

    Engine::log(INFO, "server_projectile.destroy") << "position=" << position << ", removeGround=" << removeGround;

   263

   264

    pkt.write_vector(position);

   265

    pkt.write_uint8(removeGround ? NETWORK_PROJECTILE_REMOVE_GROUND : 0);

   266

   267

    send_all(NETMSG_PROJECTILE_DESTROY, pkt, true);

   268

   269

    // XXX: leak obj, not yet implemented:  obj.destory();

   270

   271

    // pass on to super

   272

    Projectile::onDestroy(position, removeGround);

   273

}

   274