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>

    10

    11

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

    12

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

    13

    14

    // connect slots

    15

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

    16

    17

    // and then we listen

    18

    netsession.listen(listen_addr);

    19

    20

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

    21

}

    22

    23

void NetworkServer::on_node_connected (NetworkNode *node) {

    24

    // create the player object (it logs it)

    25

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

    26

    27

    // add to players

    28

    players.push_back(player);

    29

}

    30

    31

void NetworkServer::handle_disconnect (NetworkServerPlayer *player) {

    32

    // remove from list

    33

    players.remove(player);

    34

}

    35

    36

/*

    37

 * NetworkServerObject

    38

 */

    39

NetworkServerObject::NetworkServerObject (NetworkServer &server) :

    40

    NetworkObject_Server(server.controller), server(server)

    41

{

    42

    43

}

    44

    45

/*

    46

 * NetworkServerPlayer

    47

 */

    48

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

    49

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

    50

{

    51

    // log

    52

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

    53

    54

    // messages

    55

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

    56

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

    57

    58

    // the initial NETMSG_PLAYER_HELLO

    59

    NetworkPacket hello_pkt;

    60

    hello_pkt.write_vector(position);

    61

    62

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

    63

    64

    // send other player objects

    65

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

    66

        NetworkPacket player_pkt;

    67

        NetworkServerPlayer *player = *it;

    68

    69

        // player is not in players list yet

    70

        assert(player != this);

    71

    72

        // write packet

    73

        player_pkt.write_vector(player->position);

    74

    75

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

    76

    77

        // XXX: send rope info...

    78

    }

    79

    80

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

    81

    82

    // broadcast NETMSG_PLAYER_JOIN to all clients except current

    83

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

    84

    85

    // send terrain data...

    86

    send_terrain_data();

    87

}

    88

    89

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

    90

    NetworkPacket pkt;

    91

    92

    pkt.write_vector(position);

    93

    pkt.write_float32(radius);

    94

    95

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

    96

    97

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

    98

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

    99

   100

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

   101

    Player::handleDig(position, radius);

   102

}

   103

   104

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

   105

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

   106

   107

    // create new NetworkServerProjectile object

   108

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

   109

   110

    // as handleFireWeapon does

   111

    weaponFired(weapon);

   112

}

   113

   114

void NetworkServerPlayer::handleChangeWeapon (unsigned int weaponIndex) {

   115

    NetworkPacket pkt;

   116

   117

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

   118

   119

    // write packet

   120

    pkt.write_uint8(weaponIndex);

   121

   122

    // XXX: only tell the client itself?

   123

    send_all(NETMSG_PLAYER_WEAPON_CHANGE, pkt, true);

   124

   125

    // pass through

   126

    Player::handleChangeWeapon(weaponIndex);

   127

}

   128

   129

void NetworkServerPlayer::handleRopeState (RopeState state) {

   130

    NetworkPacket pkt; 

   131

   132

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

   133

   134

    switch (state) {

   135

    case ROPE_FLYING:

   136

        pkt.write_vector(rope.getPosition());

   137

        pkt.write_vector(rope.getVelocity());

   138

        pkt.write_float32(rope.getLength());

   139

   140

        send_all(NETMSG_PLAYER_ROPE_THROW, pkt, true);

   141

   142

        break;

   143

   144

    case ROPE_FIXED: {

   145

        Player *player_base = rope.getPivotPlayer();

   146

        NetworkServerPlayer *player = NULL;

   147

   148

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

   149

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

   150

   151

        pkt.write_vector(rope.getPosition());

   152

        pkt.write_float32(rope.getLength());

   153

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

   154

   155

        send_all(NETMSG_PLAYER_ROPE_FIXED, pkt, true);

   156

   157

    } break;

   158

   159

    case ROPE_FOLDED:

   160

        send_all(NETMSG_PLAYER_ROPE_RELEASED, pkt, true);

   161

   162

        break;

   163

    }

   164

}

   165

   166

void NetworkServerPlayer::handleRopeLength (float length) {

   167

    NetworkPacket pkt;

   168

   169

    pkt.write_float32(length);

   170

   171

    send_all(NETMSG_PLAYER_ROPE_LENGTH, pkt, true);

   172

}

   173

   174

void NetworkServerPlayer::spawn (Vector position) {

   175

    NetworkPacket pkt;

   176

   177

    // write packet

   178

    pkt.write_vector(position);

   179

   180

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

   181

   182

    // send

   183

    send_all(NETMSG_PLAYER_SPAWN, pkt, true);

   184

   185

    // super

   186

    Player::spawn(position);

   187

}

   188

   189

void NetworkServerPlayer::die (bool start_timer) {

   190

    NetworkPacket pkt;

   191

   192

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

   193

   194

    // send

   195

    send_all(NETMSG_PLAYER_DIE, pkt, true);

   196

   197

    // super

   198

    Player::die(start_timer);

   199

}

   200

   201

void NetworkServerPlayer::on_disconnected (void) {

   202

    NetworkPacket pkt;

   203

   204

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

   205

   206

    // remove from server

   207

    server.handle_disconnect(this);

   208

   209

    // tell other clients

   210

    send_all(NETMSG_PLAYER_QUIT, pkt, true);

   211

   212

    // free

   213

//    delete this;

   214

}

   215

   216

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

   217

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

   218

    if (src != node) {

   219

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

   220

        return;

   221

    }

   222

   223

    // read packet 

   224

    PlayerInput input = pkt.read_uint16();

   225

    TimeMS dt = pkt.read_uint32();

   226

   227

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

   228

   229

    // apply input

   230

    handleInput(input, dt);

   231

   232

    // send position update

   233

    send_position_update();

   234

}

   235

   236

void NetworkServerPlayer::send_terrain_data (void) {

   237

    Terrain &terrain = server.state.world;

   238

   241

   261

    // allocate our packet...

   267

   268

    // write netsession header

   269

    node->write_packet_header(pkt, NETCHAN_TERRAIN_ARRAY);

   270

   271

    // write terrain dimensions

   274

   277

   278

    // send

   279

    node->send_raw(pkt, true);

   280

}

   281

   282

void NetworkServerPlayer::send_position_update (void) {

   283

    NetworkPacket pkt;

   284

   285

    int flags = 

   286

        (inAir ? NETWORK_PHYSICS_INAIR : 0) | 

   287

        (facing == FACING_RIGHT ? NETWORK_PHYSICS_FACE_RIGHT : 0);

   288

   289

    pkt.write_vector(position);

   290

    pkt.write_vector(velocity);

   291

    pkt.write_uint8(flags);

   292

    pkt.write_float32(aim);

   293

   294

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

   295

   296

    send_all(NETMSG_PLAYER_POSITION, pkt, false);

   297

}

   298

   299

/* 

   300

 * NetworkServerProjectile

   301

 */

   302

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

   303

        Vector velocity, Weapon *weapon) :

   304

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

   305

{

   306

    NetworkPacket pkt;

   307

   308

    server.controller.write_object(pkt, player);

   309

    pkt.write_vector(position);

   310

    pkt.write_vector(velocity);

   311

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

   312

   313

    send_all(NETMSG_PROJECTILE_PLAYER_FIRED, pkt, true);

   314

}

   315

   316

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

   317

    NetworkPacket pkt;

   318

   319

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

   320

   321

    pkt.write_vector(position);

   322

    pkt.write_uint8(removeGround ? NETWORK_PROJECTILE_REMOVE_GROUND : 0);

   323

   324

    send_all(NETMSG_PROJECTILE_DESTROY, pkt, true);

   325

   326

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

   327

   328

    // pass on to super

   329

    Projectile::onDestroy(position, removeGround);

   330

}

   331

   332

void NetworkServerProjectile::onHitPlayer (Player *player_ptr) {

   333

    NetworkPacket pkt;

   334

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

   335

   336

    if (player == NULL) 

   337

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

   338

   339

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

   340

   341

    // write packet

   342

    controller.write_object(pkt, player);

   343

   344

    // send

   345

    send_all(NETMSG_PROJECTILE_HIT_PLAYER, pkt, true);

   346

   347

    // super

   348

    Projectile::onHitPlayer(player_ptr);

   349

}

   350