1

     2

#include "Server.hh"

     3

#include "Protocol.hh"

     4

#include "../Config.hh"

     5

#include "../Engine.hh"

     6

#include "../Logger.hh"

     7

     8

// XXX: move

     9

#include "Message.hh"

    10

    11

#include <cassert>

    12

    13

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

    14

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

    15

    16

    // connect slots

    17

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

    18

    19

    // and then we listen

    20

    netsession.listen(listen_addr);

    21

    22

    Engine::log(INFO, "net.server") << "Listening on interface: " << listen_addr;

    23

}

    24

    25

void NetworkServer::on_node_connected (NetworkNode *node) {

    26

    Engine::log(INFO, "net.server") << "Client connected, sending terrain data: " << node->getRemoteAddress();

    27

    28

    // send the terrain data

    29

    send_terrain_data(*node);

    30

    31

    // create the player object (it logs it)

    32

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

    33

    34

    // add to players

    35

    players.push_back(player);

    36

}

    37

    38

void NetworkServer::send_terrain_data (NetworkNode &node) {

    39

    Terrain &terrain = state.world.terrain;

    40

    41

    // dimensions?

    42

    PixelCoordinate map = terrain.getDimensions();

    43

    44

    // translate to a byte array

    45

    size_t terrain_size = map.x * map.y;

    46

    47

    // get terrain buffer

    48

    const uint8_t *terrain_buf = terrain.getTerrainBuffer();

    49

    50

    // allocate our packet...

    51

    BigNetworkPacket pkt (

    52

        // NetworkChannel header

    53

        NETWORK_SESSION_HEADER_SIZE     

    54

    55

        // our own header

    56

        + 2 * sizeof(uint32_t)          

    57

    58

        // compressed terrain buffer

    59

        + NetworkPacketOutput::write_compressed_size(terrain_size)

    60

    );

    61

    62

    // write netsession header

    63

    netsession.write_packet_header(pkt, NETCHAN_TERRAIN_ARRAY);

    64

    65

    // write terrain dimensions

    66

    pkt.write_uint32(map.x);

    67

    pkt.write_uint32(map.y);

    68

    69

    // write compressed terrain data

    70

    pkt.write_compressed(terrain_buf, terrain_size);

    71

    72

    // send

    73

    node.send_raw(pkt, true);

    74

}

    75

    76

    77

void NetworkServer::handle_disconnect (NetworkServerPlayer *player) {

    78

    // remove from list

    79

    players.remove(player);

    80

}

    81

    82

/*

    83

 * NetworkServerObject

    84

 */

    85

NetworkServerObject::NetworkServerObject (NetworkServer &server) :

    86

    NetworkObject_Server(server.controller), server(server)

    87

{

    88

    89

}

    90

    91

/*

    92

 * NetworkServerPlayer

    93

 */

    94

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

    95

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

    96

{

    97

    // messages

    98

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

    99

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

   100

   101

    // the initial NETMSG_PLAYER_HELLO

   102

    NetworkMessage hello_msg(*this, NETMSG_SERVER_HELLO);

   103

    hello_msg.write_vector(getPosition());

   105

   106

    // sync other players

   107

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

   108

        NetworkMessage player_msg(*this, NETMSG_PLAYER_INFO);

   109

        NetworkServerPlayer *player = *it;

   110

   111

        // player is not in players list yet

   112

        assert(player != this);

   113

   114

        // write packet

   115

        player_msg.write_vector(player->getPosition());

   116

   117

        // send message to client

   119

   120

        // XXX: send rope info...

   121

    }

   122

   123

    // sync projectiles

   124

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

   125

        NetworkServerProjectile *proj = dynamic_cast<NetworkServerProjectile*>(*it);

   126

   127

        // all projectiles should be under the control of the server

   128

        assert(proj);

   129

   130

        // XXX: send info

   131

    }

   132

   133

    // broadcast NETMSG_PLAYER_JOIN to all clients except current

   134

    NetworkMessage join_msg(*this, NETMSG_PLAYER_JOIN);

   135

    join_msg.write_vector(getPosition());

   137

   138

    Engine::log(INFO, "net.server") << "Player joined: " << this << " from " << node.getRemoteAddress();

   139

}

   140

   141

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

   142

    NetworkMessage msg(*this, NETMSG_PLAYER_DIG);

   143

   144

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

   145

   146

    // write packet

   147

    msg.write_vector(position);

   148

    msg.write_float32(radius);

   149

   150

    // broadcast packet

   152

   153

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

   154

    Player::handleDig(position, radius);

   155

}

   156

   157

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

   158

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

   159

   160

    // create new NetworkServerProjectile object

   161

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

   162

   163

    // as handleFireWeapon does

   164

    weaponFired(weapon);

   165

}

   166

   167

void NetworkServerPlayer::handleChangeWeapon (unsigned int weaponIndex) {

   168

    NetworkMessage msg(*this, NETMSG_PLAYER_WEAPON_CHANGE);

   169

   170

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

   171

   172

    // write packet

   173

    msg.write_uint8(weaponIndex);

   174

   175

    // XXX: only tell the client itself?

   177

   178

    // pass through

   179

    Player::handleChangeWeapon(weaponIndex);

   180

}

   181

   182

void NetworkServerPlayer::handleRopeState (RopeState state) {

   183

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

   184

   185

    switch (state) {

   186

    case ROPE_FLYING: {

   187

        NetworkMessage msg(*this, NETMSG_PLAYER_ROPE_THROW);

   188

   189

        msg.write_vector(rope.getPosition());

   190

        msg.write_vector(rope.getVelocity());

   191

        msg.write_float32(rope.getLength());

   192

   194

   195

        } break;

   196

   197

    case ROPE_FIXED: {

   198

        NetworkMessage msg(*this, NETMSG_PLAYER_ROPE_FIXED);

   199

   200

        Player *player_base = rope.getPivotPlayer();

   201

        NetworkServerPlayer *player = NULL;

   202

   203

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

   204

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

   205

   206

        msg.write_vector(rope.getPosition());

   207

        msg.write_float32(rope.getLength());

   208

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

   209

   211

   212

        } break;

   213

   214

    case ROPE_FOLDED: {

   215

        NetworkMessage msg(*this, NETMSG_PLAYER_ROPE_RELEASED);

   216

   218

   219

        } break;

   220

    }

   221

}

   222

   223

void NetworkServerPlayer::handleRopeLength (float length) {

   224

    NetworkMessage msg(*this, NETMSG_PLAYER_ROPE_LENGTH);

   225

   226

    // write packet

   227

    msg.write_float32(length);

   228

   229

    // send packet

   231

}

   232

   233

void NetworkServerPlayer::spawn (Vector position) {

   234

    NetworkMessage msg(*this, NETMSG_PLAYER_SPAWN);

   235

   236

    // write packet

   237

    msg.write_vector(position);

   238

   239

    Engine::log(DEBUG, "server_player.spawn") << this << ": position=" << position;

   240

   241

    // send packet

   243

   244

    // super

   245

    Player::spawn(position);

   246

}

   247

   248

void NetworkServerPlayer::die (bool start_timer) {

   249

    NetworkMessage msg(*this, NETMSG_PLAYER_DIE);

   250

   251

    Engine::log(DEBUG, "server_player.die") << this;

   252

   253

    // send packet

   255

   256

    // super

   257

    Player::die(start_timer);

   258

}

   259

   260

void NetworkServerPlayer::on_disconnected (void) {

   261

    NetworkMessage msg(*this, NETMSG_PLAYER_QUIT);

   262

   263

    Engine::log(INFO, "net.server") << "Player disconnected: " << this;

   264

   265

    // remove from server

   266

    server.handle_disconnect(this);

   267

   268

    // tell other clients

   270

   271

    // XXX: free

   272

//    delete this;

   273

}

   274

   275

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

   276

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

   277

    if (src != &node) {

   278

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

   279

        return;

   280

    }

   281

   282

    // read packet 

   283

    PlayerInput input = pkt.read_uint16();

   284

    TimeMS dt = pkt.read_uint32();

   285

   286

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

   287

   288

    // apply input

   289

    handleInput(input, dt);

   290

   291

    // send position update

   292

    send_position_update();

   293

}

   294

   295

void NetworkServerPlayer::send_position_update (void) {

   296

    NetworkMessage msg(*this, NETMSG_PLAYER_POSITION);

   297

   298

    int flags = 

   299

        (inAir ? NETWORK_PHYSICS_INAIR : 0) | 

   300

        (facing == FACING_RIGHT ? NETWORK_PHYSICS_FACE_RIGHT : 0);

   301

   302

    msg.write_vector(getPosition());

   303

    msg.write_vector(getVelocity());

   304

    msg.write_uint8(flags);

   305

    msg.write_float32(aim);

   306

   307

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

   308

   310

}

   311

   312

/* 

   313

 * NetworkServerProjectile

   314

 */

   315

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

   316

        Vector velocity, Weapon *weapon) :

   317

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

   318

{

   319

    NetworkMessage msg(*this, NETMSG_PROJECTILE_PLAYER_FIRED);

   320

   321

    // write out packet

   322

    server.controller.write_object(msg, player);

   323

    msg.write_vector(getPosition());

   324

    msg.write_vector(getVelocity());

   325

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

   326

   327

    // send to given target

   329

}

   330

   331

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

   332

    NetworkMessage msg(*this, NETMSG_PROJECTILE_DESTROY);

   333

   334

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

   335

   336

    // write packet

   337

    msg.write_vector(position);

   338

    msg.write_uint8(removeGround ? NETWORK_PROJECTILE_REMOVE_GROUND : 0);

   339

   340

    // broadcast packet

   342

   343

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

   344

   345

    // pass on to super

   346

    Projectile::onDestroy(position, removeGround);

   347

}

   348

   349

void NetworkServerProjectile::onHitPlayer (Player *player_ptr) {

   350

    NetworkMessage msg(*this, NETMSG_PROJECTILE_HIT_PLAYER);

   351

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

   352

   353

    if (player == NULL) 

   354

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

   355

   356

    Engine::log(DEBUG, "server_projectile.hit_player") << this << ": player=" << player;

   357

   358

    // write packet

   359

    controller.write_object(msg, player);

   360

   361

    // send packet

   363

   364

    // super

   365

    Projectile::onHitPlayer(player_ptr);

   366

}

   367