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), netobjs(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

    // add to GameState

    30

    state.newPlayer(player);

    31

}

    32

    33

void NetworkServer::handle_disconnect (NetworkServerPlayer *player) {

    34

    // remove from state

    35

    state.removePlayer(player);

    36

    37

    // remove from list

    38

    players.remove(player);

    39

}

    40

    41

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

    42

    Player(server.state, Vector(PLAYER_INITIAL_X, PLAYER_INITIAL_Y), true), server(server), obj(server.netobjs), node(node) {

    43

    44

    // log

    45

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

    46

    47

    // messages

    48

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

    49

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

    50

    51

    // the initial NETMSG_PLAYER_HELLO

    52

    NetworkPacket hello_pkt;

    53

    hello_pkt.write_vector(position);

    54

    55

    obj.send_to(node, NETMSG_SERVER_HELLO, hello_pkt, true);

    56

    57

    // send other player objects

    58

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

    59

        NetworkServerPlayer *player = *it;

    60

        NetworkPacket player_pkt;

    61

    62

        // player is not in players list yet

    63

        assert(player != this);

    64

    65

        player_pkt.write_vector(player->position);

    66

    67

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

    68

    }

    69

    70

    // broadcast NETMSG_PLAYER_JOIN to all clients except current

    71

    obj.send_all_except(NETMSG_PLAYER_JOIN, hello_pkt, node, true);

    72

    73

    // send terrain data...

    74

    send_terrain_data();

    75

}

    76

    77

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

    78

    NetworkPacket pkt;

    79

    80

    pkt.write_vector(position);

    81

    pkt.write_float32(radius);

    82

    83

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

    84

    85

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

    86

    obj.send_all(NETMSG_PLAYER_DIG, pkt, true);

    87

    88

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

    89

    Player::handleDig(position, radius);

    90

}

    91

    92

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

    93

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

    94

    95

    // create new NetworkServerProjectile object

    96

    new NetworkServerProjectile(server, position, velocity, weapon->getExplosionRadius(), weapon->getExpireTicks());

    97

}

    98

    99

void NetworkServerPlayer::handleChangeWeapon (unsigned int weaponIndex) {

   100

    NetworkPacket pkt;

   101

   102

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

   103

   104

    // write packet

   105

    pkt.write_uint8(weaponIndex);

   106

   107

    // XXX: only tell the client itself?

   108

    obj.send_all(NETMSG_PLAYER_WEAPON_CHANGE, pkt, true);

   109

   110

    // pass through

   111

    Player::handleChangeWeapon(weaponIndex);

   112

}

   113

   114

void NetworkServerPlayer::handleRopeState (RopeState state) {

   115

    NetworkPacket pkt; 

   116

   117

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

   118

   119

    switch (state) {

   120

    case ROPE_FLYING:

   121

        pkt.write_vector(rope.getPosition());

   122

        pkt.write_vector(rope.getVelocity());

   123

        pkt.write_float32(rope.getLength());

   124

   125

        obj.send_all(NETMSG_PLAYER_ROPE_THROW, pkt, true);

   126

   127

        break;

   128

   129

    case ROPE_FIXED:

   130

        pkt.write_vector(rope.getPosition());

   131

        pkt.write_float32(rope.getLength());

   132

   133

        obj.send_all(NETMSG_PLAYER_ROPE_FIXED, pkt, true);

   134

   135

        break;

   136

   137

    case ROPE_FOLDED:

   138

        obj.send_all(NETMSG_PLAYER_ROPE_RELEASED, pkt, true);

   139

   140

        break;

   141

    }

   142

}

   143

   144

void NetworkServerPlayer::handleRopeLength (float length) {

   145

    NetworkPacket pkt;

   146

   147

    pkt.write_float32(length);

   148

   149

    obj.send_all(NETMSG_PLAYER_ROPE_LENGTH, pkt, true);

   150

}

   151

   152

void NetworkServerPlayer::on_disconnected (void) {

   153

    NetworkPacket pkt;

   154

   155

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

   156

   157

    // remove from server

   158

    server.handle_disconnect(this);

   159

   160

    // tell other clients

   161

    obj.send_all(NETMSG_PLAYER_QUIT, pkt, true);

   162

   163

    // free

   164

//    delete this;

   165

}

   166

   167

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

   168

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

   169

    if (src != node) {

   170

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

   171

        return;

   172

    }

   173

   174

    // read packet 

   175

    PlayerInput input = pkt.read_uint16();

   176

   178

   179

    // apply input

   180

    handleInput(input);  

   181

   182

    // send position update

   183

    send_position_update();

   184

}

   185

   186

void NetworkServerPlayer::send_terrain_data (void) {

   187

    Terrain &terrain = server.state.world;

   188

   189

    uint32_t map_w = terrain.terrain.size();

   190

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

   191

   192

    // allocate our packet...

   193

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

   194

   195

    // write netsession header

   196

    node->write_packet_header(pkt, NETCHAN_TERRAIN_ARRAY);

   197

   198

    // write terrain dimensions

   199

    pkt.write_uint32(map_w);

   200

    pkt.write_uint32(map_h);

   201

   202

    // write out terrain data

   203

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

   204

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

   205

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

   206

        }

   207

    }

   208

   209

    // send

   210

    node->send_raw(pkt, true);

   211

}

   212

   213

void NetworkServerPlayer::send_position_update (void) {

   214

    NetworkPacket pkt;

   215

   216

    int flags = (inAir ? NETWORK_PHYSICS_INAIR : 0) | (facingRight ? NETWORK_PHYSICS_FACE_RIGHT : 0);

   217

   218

    pkt.write_vector(position);

   219

    pkt.write_vector(velocity);

   220

    pkt.write_uint8(flags);

   221

    pkt.write_float32(aim);

   222

   224

   225

    obj.send_all(NETMSG_PLAYER_POSITION, pkt, false);

   226

}

   227

   228

/* 

   229

 * NetworkServerProjectile

   230

 */

   231

NetworkServerProjectile::NetworkServerProjectile (NetworkServer &server, Vector position, Vector velocity, 

   232

        float explosionRadius, TickCount age) :

   233

    Projectile(server.state, position, velocity, true, explosionRadius, age), server(server), obj(server.netobjs)

   234

{

   235

    NetworkPacket pkt;

   236

   237

    pkt.write_vector(position);

   238

    pkt.write_vector(velocity);

   239

    pkt.write_float32(explosionRadius);

   240

   241

    obj.send_all(NETMSG_PROJECTILE_CREATE, pkt, true);

   242

}

   243

   244

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

   245

    NetworkPacket pkt;

   246

   247

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

   248

   249

    pkt.write_vector(position);

   250

    pkt.write_uint8(removeGround ? NETWORK_PROJECTILE_REMOVE_GROUND : 0);

   251

   252

    obj.send_all(NETMSG_PROJECTILE_DESTROY, pkt, true);

   253

   254

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

   255

   256

    // pass on to super

   257

    Projectile::onDestroy(position, removeGround);

   258

}

   259