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 NetworkEndpoint &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

    20

}

    21

    22

void NetworkServer::on_node_connected (NetworkNode *node) {

    25

    // send the terrain data

    26

    send_terrain_data(node);

    27

    28

    // create the player object (it logs it)

    29

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

    30

    31

    // add to players

    32

    players.push_back(player);

    33

}

    34

    35

void NetworkServer::send_terrain_data (NetworkNode *node) {

    36

    Terrain &terrain = state.world.terrain;

    37

    38

    // dimensions?

    39

    PixelCoordinate map = terrain.getDimensions();

    40

    41

    // translate to a byte array

    42

    size_t terrain_size = map.x * map.y;

    43

    44

    // get terrain buffer

    45

    const uint8_t *terrain_buf = terrain.getTerrainBuffer();

    46

    47

    // allocate our packet...

    48

    BigNetworkPacket pkt (

    49

        // NetworkChannel header

    50

        NETWORK_SESSION_HEADER_SIZE     

    51

    52

        // our own header

    53

        + 2 * sizeof(uint32_t)          

    54

    55

        // compressed terrain buffer

    56

        + NetworkPacketOutput::write_compressed_size(terrain_size)

    57

    );

    58

    59

    // write netsession header

    60

    node->write_packet_header(pkt, NETCHAN_TERRAIN_ARRAY);

    61

    62

    // write terrain dimensions

    63

    pkt.write_uint32(map.x);

    64

    pkt.write_uint32(map.y);

    65

    66

    // write compressed terrain data

    67

    pkt.write_compressed(terrain_buf, terrain_size);

    68

    69

    // send

    70

    node->send_raw(pkt, true);

    71

}

    72

    73

    74

void NetworkServer::handle_disconnect (NetworkServerPlayer *player) {

    75

    // remove from list

    76

    players.remove(player);

    77

}

    78

    79

/*

    80

 * NetworkServerObject

    81

 */

    82

NetworkServerObject::NetworkServerObject (NetworkServer &server) :

    83

    NetworkObject_Server(server.controller), server(server)

    84

{

    85

    86

}

    87

    88

/*

    89

 * NetworkServerPlayer

    90

 */

    91

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

    92

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

    93

{

    94

    // messages

    95

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

    96

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

    97

    98

    // the initial NETMSG_PLAYER_HELLO

    99

    NetworkPacket hello_pkt;

   100

    hello_pkt.write_vector(position);

   101

   102

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

   103

   104

    // send other player objects

   105

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

   106

        NetworkPacket player_pkt;

   107

        NetworkServerPlayer *player = *it;

   108

   109

        // player is not in players list yet

   110

        assert(player != this);

   111

   112

        // write packet

   113

        player_pkt.write_vector(player->position);

   114

   115

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

   116

   117

        // XXX: send rope info...

   118

    }

   119

   120

    // XXX: send projectiles? Or let the client handle the events that the unknown projectiles generate?

   121

   122

    // broadcast NETMSG_PLAYER_JOIN to all clients except current

   123

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

   126

}

   127

   128

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

   129

    NetworkPacket pkt;

   130

   131

    pkt.write_vector(position);

   132

    pkt.write_float32(radius);

   133

   135

   136

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

   137

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

   138

   139

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

   140

    Player::handleDig(position, radius);

   141

}

   142

   143

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

   145

   146

    // create new NetworkServerProjectile object

   147

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

   148

   149

    // as handleFireWeapon does

   150

    weaponFired(weapon);

   151

}

   152

   153

void NetworkServerPlayer::handleChangeWeapon (unsigned int weaponIndex) {

   154

    NetworkPacket pkt;

   155

   157

   158

    // write packet

   159

    pkt.write_uint8(weaponIndex);

   160

   161

    // XXX: only tell the client itself?

   162

    send_all(NETMSG_PLAYER_WEAPON_CHANGE, pkt, true);

   163

   164

    // pass through

   165

    Player::handleChangeWeapon(weaponIndex);

   166

}

   167

   168

void NetworkServerPlayer::handleRopeState (RopeState state) {

   169

    NetworkPacket pkt; 

   170

   172

   173

    switch (state) {

   174

    case ROPE_FLYING:

   175

        pkt.write_vector(rope.getPosition());

   176

        pkt.write_vector(rope.getVelocity());

   177

        pkt.write_float32(rope.getLength());

   178

   179

        send_all(NETMSG_PLAYER_ROPE_THROW, pkt, true);

   180

   181

        break;

   182

   183

    case ROPE_FIXED: {

   184

        Player *player_base = rope.getPivotPlayer();

   185

        NetworkServerPlayer *player = NULL;

   186

   187

        if (player_base != NULL && (player = dynamic_cast<NetworkServerPlayer*>(player_base)) == NULL)

   188

            throw Error("NetworkServerPlayer::handleRopeState: rope's pivotPlayer is not a NetworkServerPlayer");

   189

   190

        pkt.write_vector(rope.getPosition());

   191

        pkt.write_float32(rope.getLength());

   192

        controller.write_object(pkt, player);    // may be NULL

   193

   194

        send_all(NETMSG_PLAYER_ROPE_FIXED, pkt, true);

   195

   196

    } break;

   197

   198

    case ROPE_FOLDED:

   199

        send_all(NETMSG_PLAYER_ROPE_RELEASED, pkt, true);

   200

   201

        break;

   202

    }

   203

}

   204

   205

void NetworkServerPlayer::handleRopeLength (float length) {

   206

    NetworkPacket pkt;

   207

   208

    pkt.write_float32(length);

   209

   210

    send_all(NETMSG_PLAYER_ROPE_LENGTH, pkt, true);

   211

}

   212

   213

void NetworkServerPlayer::spawn (Vector position) {

   214

    NetworkPacket pkt;

   215

   216

    // write packet

   217

    pkt.write_vector(position);

   218

   220

   221

    // send

   222

    send_all(NETMSG_PLAYER_SPAWN, pkt, true);

   223

   224

    // super

   225

    Player::spawn(position);

   226

}

   227

   228

void NetworkServerPlayer::die (bool start_timer) {

   229

    NetworkPacket pkt;

   230

   232

   233

    // send

   234

    send_all(NETMSG_PLAYER_DIE, pkt, true);

   235

   236

    // super

   237

    Player::die(start_timer);

   238

}

   239

   240

void NetworkServerPlayer::on_disconnected (void) {

   241

    NetworkPacket pkt;

   242

   244

   245

    // remove from server

   246

    server.handle_disconnect(this);

   247

   248

    // tell other clients

   249

    send_all(NETMSG_PLAYER_QUIT, pkt, true);

   250

   251

    // free

   252

//    delete this;

   253

}

   254

   255

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

   256

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

   257

    if (src != node) {

   258

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

   259

        return;

   260

    }

   261

   262

    // read packet 

   263

    PlayerInput input = pkt.read_uint16();

   264

    TimeMS dt = pkt.read_uint32();

   265

   266

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

   267

   268

    // apply input

   269

    handleInput(input, dt);

   270

   271

    // send position update

   272

    send_position_update();

   273

}

   274

   275

void NetworkServerPlayer::send_position_update (void) {

   276

    NetworkPacket pkt;

   277

   278

    int flags = 

   279

        (inAir ? NETWORK_PHYSICS_INAIR : 0) | 

   280

        (facing == FACING_RIGHT ? NETWORK_PHYSICS_FACE_RIGHT : 0);

   281

   282

    pkt.write_vector(position);

   283

    pkt.write_vector(velocity);

   284

    pkt.write_uint8(flags);

   285

    pkt.write_float32(aim);

   286

   287

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

   288

   289

    send_all(NETMSG_PLAYER_POSITION, pkt, false);

   290

}

   291

   292

/* 

   293

 * NetworkServerProjectile

   294

 */

   295

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

   296

        Vector velocity, Weapon *weapon) :

   297

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

   298

{

   299

    NetworkPacket pkt;

   300

   301

    server.controller.write_object(pkt, player);

   302

    pkt.write_vector(position);

   303

    pkt.write_vector(velocity);

   304

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

   305

   306

    send_all(NETMSG_PROJECTILE_PLAYER_FIRED, pkt, true);

   307

}

   308

   309

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

   310

    NetworkPacket pkt;

   311

   313

   314

    pkt.write_vector(position);

   315

    pkt.write_uint8(removeGround ? NETWORK_PROJECTILE_REMOVE_GROUND : 0);

   316

   317

    send_all(NETMSG_PROJECTILE_DESTROY, pkt, true);

   318

   319

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

   320

   321

    // pass on to super

   322

    Projectile::onDestroy(position, removeGround);

   323

}

   324

   325

void NetworkServerProjectile::onHitPlayer (Player *player_ptr) {

   326

    NetworkPacket pkt;

   327

    NetworkServerPlayer *player = dynamic_cast<NetworkServerPlayer*>(player_ptr);

   328

   329

    if (player == NULL) 

   330

        throw Error("NetworkServerProjectile::onHitPlayer called with non-NetworkServerPlayer player");

   331

   333

   334

    // write packet

   335

    controller.write_object(pkt, player);

   336

   337

    // send

   338

    send_all(NETMSG_PROJECTILE_HIT_PLAYER, pkt, true);

   339

   340

    // super

   341

    Projectile::onHitPlayer(player_ptr);

   342

}

   343