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

    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 list

    32

    players.remove(player);

    33

}

    34

    35

/*

    36

 * NetworkServerObject

    37

 */

    38

NetworkServerObject::NetworkServerObject (NetworkServer &server) :

    39

    NetworkObject_Server(server.controller), server(server)

    40

{

    41

    42

}

    43

    44

/*

    45

 * NetworkServerPlayer

    46

 */

    47

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

    48

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

    49

{

    50

    // log

    51

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

    52

    53

    // messages

    54

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

    55

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

    56

    57

    // the initial NETMSG_PLAYER_HELLO

    58

    NetworkPacket hello_pkt;

    59

    hello_pkt.write_vector(position);

    60

    61

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

    62

    63

    // send other player objects

    64

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

    65

        NetworkPacket player_pkt;

    66

        NetworkServerPlayer *player = *it;

    67

    68

        // player is not in players list yet

    69

        assert(player != this);

    70

    71

        // write packet

    72

        player_pkt.write_vector(player->position);

    73

    74

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

    75

    76

        // XXX: send rope info...

    77

    }

    78

    79

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

    80

    81

    // broadcast NETMSG_PLAYER_JOIN to all clients except current

    82

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

    83

    84

    // send terrain data...

    85

    send_terrain_data();

    86

}

    87

    88

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

    89

    NetworkPacket pkt;

    90

    91

    pkt.write_vector(position);

    92

    pkt.write_float32(radius);

    93

    94

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

    95

    96

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

    97

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

    98

    99

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

   100

    Player::handleDig(position, radius);

   101

}

   102

   103

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

   104

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

   105

   106

    // create new NetworkServerProjectile object

   107

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

   108

   109

    // as handleFireWeapon does

   110

    weaponFired(weapon);

   111

}

   112

   113

void NetworkServerPlayer::handleChangeWeapon (unsigned int weaponIndex) {

   114

    NetworkPacket pkt;

   115

   116

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

   117

   118

    // write packet

   119

    pkt.write_uint8(weaponIndex);

   120

   121

    // XXX: only tell the client itself?

   122

    send_all(NETMSG_PLAYER_WEAPON_CHANGE, pkt, true);

   123

   124

    // pass through

   125

    Player::handleChangeWeapon(weaponIndex);

   126

}

   127

   128

void NetworkServerPlayer::handleRopeState (RopeState state) {

   129

    NetworkPacket pkt; 

   130

   131

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

   132

   133

    switch (state) {

   134

    case ROPE_FLYING:

   135

        pkt.write_vector(rope.getPosition());

   136

        pkt.write_vector(rope.getVelocity());

   137

        pkt.write_float32(rope.getLength());

   138

   139

        send_all(NETMSG_PLAYER_ROPE_THROW, pkt, true);

   140

   141

        break;

   142

   143

    case ROPE_FIXED: {

   144

        Player *player_base = rope.getPivotPlayer();

   145

        NetworkServerPlayer *player = NULL;

   146

   147

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

   148

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

   149

   150

        pkt.write_vector(rope.getPosition());

   151

        pkt.write_float32(rope.getLength());

   152

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

   153

   154

        send_all(NETMSG_PLAYER_ROPE_FIXED, pkt, true);

   155

   156

    } break;

   157

   158

    case ROPE_FOLDED:

   159

        send_all(NETMSG_PLAYER_ROPE_RELEASED, pkt, true);

   160

   161

        break;

   162

    }

   163

}

   164

   165

void NetworkServerPlayer::handleRopeLength (float length) {

   166

    NetworkPacket pkt;

   167

   168

    pkt.write_float32(length);

   169

   170

    send_all(NETMSG_PLAYER_ROPE_LENGTH, pkt, true);

   171

}

   172

   173

void NetworkServerPlayer::spawn (Vector position) {

   174

    NetworkPacket pkt;

   175

   176

    // write packet

   177

    pkt.write_vector(position);

   178

   179

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

   180

   181

    // send

   182

    send_all(NETMSG_PLAYER_SPAWN, pkt, true);

   183

   184

    // super

   185

    Player::spawn(position);

   186

}

   187

   188

void NetworkServerPlayer::die (bool start_timer) {

   189

    NetworkPacket pkt;

   190

   191

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

   192

   193

    // send

   194

    send_all(NETMSG_PLAYER_DIE, pkt, true);

   195

   196

    // super

   197

    Player::die(start_timer);

   198

}

   199

   200

void NetworkServerPlayer::on_disconnected (void) {

   201

    NetworkPacket pkt;

   202

   203

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

   204

   205

    // remove from server

   206

    server.handle_disconnect(this);

   207

   208

    // tell other clients

   209

    send_all(NETMSG_PLAYER_QUIT, pkt, true);

   210

   211

    // free

   212

//    delete this;

   213

}

   214

   215

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

   216

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

   217

    if (src != node) {

   218

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

   219

        return;

   220

    }

   221

   222

    // read packet 

   223

    PlayerInput input = pkt.read_uint16();

   224

    TimeMS dt = pkt.read_uint32();

   225

   226

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

   227

   228

    // apply input

   229

    handleInput(input, dt);

   230

   231

    // send position update

   232

    send_position_update();

   233

}

   234

   235

void NetworkServerPlayer::send_terrain_data (void) {

   236

    Terrain &terrain = server.state.world;

   237

   238

    // XXX: over 2**31?

   239

    PixelDimension map_w = terrain.terrain.size();

   240

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

   241

   242

    // allocate our packet...

   243

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

   244

   245

    // write netsession header

   246

    node->write_packet_header(pkt, NETCHAN_TERRAIN_ARRAY);

   247

   248

    // write terrain dimensions

   249

    pkt.write_uint32(map_w);

   250

    pkt.write_uint32(map_h);

   251

   252

    // write out terrain data

   253

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

   254

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

   255

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

   256

        }

   257

    }

   258

   259

    // send

   260

    node->send_raw(pkt, true);

   261

}

   262

   263

void NetworkServerPlayer::send_position_update (void) {

   264

    NetworkPacket pkt;

   265

   266

    int flags = 

   267

        (inAir ? NETWORK_PHYSICS_INAIR : 0) | 

   268

        (facing == FACING_RIGHT ? NETWORK_PHYSICS_FACE_RIGHT : 0);

   269

   270

    pkt.write_vector(position);

   271

    pkt.write_vector(velocity);

   272

    pkt.write_uint8(flags);

   273

    pkt.write_float32(aim);

   274

   275

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

   276

   277

    send_all(NETMSG_PLAYER_POSITION, pkt, false);

   278

}

   279

   280

/* 

   281

 * NetworkServerProjectile

   282

 */

   283

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

   284

        Vector velocity, Weapon *weapon) :

   285

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

   286

{

   287

    NetworkPacket pkt;

   288

   289

    server.controller.write_object(pkt, player);

   290

    pkt.write_vector(position);

   291

    pkt.write_vector(velocity);

   292

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

   293

   294

    send_all(NETMSG_PROJECTILE_PLAYER_FIRED, pkt, true);

   295

}

   296

   297

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

   298

    NetworkPacket pkt;

   299

   300

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

   301

   302

    pkt.write_vector(position);

   303

    pkt.write_uint8(removeGround ? NETWORK_PROJECTILE_REMOVE_GROUND : 0);

   304

   305

    send_all(NETMSG_PROJECTILE_DESTROY, pkt, true);

   306

   307

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

   308

   309

    // pass on to super

   310

    Projectile::onDestroy(position, removeGround);

   311

}

   312

   313

void NetworkServerProjectile::onHitPlayer (Player *player_ptr) {

   314

    NetworkPacket pkt;

   315

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

   316

   317

    if (player == NULL) 

   318

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

   319

   320

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

   321

   322

    // write packet

   323

    controller.write_object(pkt, player);

   324

   325

    // send

   326

    send_all(NETMSG_PROJECTILE_HIT_PLAYER, pkt, true);

   327

   328

    // super

   329

    Projectile::onHitPlayer(player_ptr);

   330

}

   331