initial commit

1 files changed, 640 insertions, 0 deletions

diff --git a/src/server/server.cc b/src/server/server.cc
new file mode 100644
index 0000000..72faa03
--- /dev/null
+++ b/src/server/server.cc
@@ -0,0 +1,640 @@
+#include "server.hh"
+
+namespace server {
+
+static proto::packet
+make_init_packet(const resources::client_map_value& client) noexcept {
+    proto::packet packet;
+
+    const auto init_packet = packet.mutable_init_packet();
+    init_packet->set_seed(state.seed);
+    init_packet->set_draw_distance(state.draw_distance);
+    shared::net::set_player(*init_packet->mutable_localplayer(),
+                            client->get_player());
+
+    return packet;
+}
+
+static proto::packet make_player_packet(const shared::player& player) noexcept {
+    proto::packet packet;
+
+    const auto player_packet = packet.mutable_player_packet();
+    shared::net::set_player(*player_packet, player);
+
+    return packet;
+}
+
+static proto::packet make_server_message_packet(const std::string& msg,
+                                                const bool fatal) noexcept {
+    proto::packet packet;
+
+    const auto server_message_packet = packet.mutable_server_message_packet();
+    server_message_packet->set_message(msg);
+    server_message_packet->set_fatal(fatal);
+
+    return packet;
+}
+
+static proto::packet
+make_remove_packet(const resources::client_map_value& client) noexcept {
+    proto::packet packet;
+
+    const auto remove_packet = packet.mutable_remove_player_packet();
+    remove_packet->set_index(client->index);
+
+    return packet;
+}
+
+static proto::packet make_hear_packet(const std::string& message,
+                                      const std::uint32_t index) noexcept {
+    proto::packet packet;
+
+    const auto hear_player_packet = packet.mutable_hear_player_packet();
+    hear_player_packet->set_index(index);
+    hear_player_packet->set_text(message);
+
+    return packet;
+}
+
+static proto::packet make_chunk_packet(const world::chunk& chunk) noexcept {
+    return chunk.packet;
+}
+
+static void block_by_tickrate() noexcept {
+    const auto tickrate = server::state.tickrate;
+    static const auto ratetime = std::chrono::milliseconds(
+        static_cast<int>((1.0 / static_cast<double>(tickrate)) * 1000.0));
+    static auto prev = std::chrono::steady_clock::now();
+    const auto now = std::chrono::steady_clock::now();
+    std::this_thread::sleep_for(ratetime - (now - prev));
+    prev = std::chrono::steady_clock::now();
+}
+
+// Creates, binds, listens on new nonblocking socket.
+static int create_listen_socket(const std::string_view address,
+                                const std::string_view port) noexcept {
+    constexpr addrinfo hints = {.ai_flags = AI_PASSIVE,
+                                .ai_family = AF_INET,
+                                .ai_socktype = SOCK_STREAM};
+    const auto info = shared::net::get_addr_info(address, port, &hints);
+    const auto sock = shared::net::make_socket(info.get());
+    shared::net::bind_socket(sock, info.get());
+    shared::net::listen_socket(sock);
+    return sock;
+}
+
+// Gets new connections if possible based on non-blocking listener socket.
+static std::optional<shared::net::connection> make_connection(const int sock) {
+    const auto accept = shared::net::get_accept(sock);
+    if (!accept.has_value()) {
+        return std::nullopt;
+    }
+    return shared::net::connection(accept->socket);
+}
+
+static void handle_move_packet(const proto::move& packet,
+                               resources::client_map_value& client) noexcept {
+    client->get_player().viewangles = {.pitch = packet.viewangles().pitch(),
+                                       .yaw = packet.viewangles().yaw()};
+    client->get_player().commands = packet.commands();
+}
+
+static void handle_say_packet(const proto::say& packet,
+                              resources::client_map_value& client,
+                              server::resources::client_map& clients) noexcept {
+    if (std::size(packet.text()) > shared::MAX_SAY_LENGTH) {
+#ifndef NDEBUG
+        shared::print::warn(
+            "server: client tried to say a message that was too long, size: " +
+            std::to_string(std::size(packet.text())) + '\n');
+
+#endif
+        return;
+    }
+
+    shared::print::message("server: player " + std::to_string(client->index) +
+                           " said \"" + packet.text() + "\"\n");
+    const auto hear_packet = make_hear_packet(packet.text(), client->index);
+    for (auto& [index, client_ptr] : clients) {
+        client_ptr->connection.rsend_packet(hear_packet);
+    }
+}
+
+static void send_chunk(const server::world::chunk& chunk,
+                       resources::client_map_value& client) noexcept {
+    client->connection.rsend_packet(make_chunk_packet(chunk));
+}
+
+static void send_message(const std::string& message,
+                         resources::client_map_value& client,
+                         const bool fatal = false) {
+    client->connection.rsend_packet(make_server_message_packet(message, fatal));
+}
+
+static void send_chunk_associated(resources::chunk_map_value& chunk_data,
+                                  resources::client_map& clients) noexcept {
+    if (!chunk_data->has_initialised()) {
+        return;
+    }
+
+    chunk_data->get_chunk().update();
+    for (auto& client_index : chunk_data->players) {
+        const auto find_it = clients.find(client_index);
+
+        // Should NEVER happen. If this occurs our clients are not cleaning up
+        // correctly.
+        if (find_it == std::end(clients)) {
+#ifndef NDEBUG
+            shared::print::debug(
+                "client index " + std::to_string(client_index) +
+                " was associated with a chunk, but not found\n");
+#endif
+            continue;
+        }
+
+        auto& client = find_it->second;
+        send_chunk(chunk_data->get_chunk(), client);
+    }
+}
+
+// Checks if a chunk should be removed, posting it's async writing and
+// possible removal if it should.
+static void maybe_post_chunk_rm(const shared::math::coords& coords,
+                                resources::chunk_map_value& chunk_data,
+                                resources::pool_t& pool) noexcept {
+    // Chunk is in a state of contructing/destructing, do not touch.
+    if (!chunk_data->has_initialised()) {
+        return;
+    }
+
+    // Players are still associated with the chunk, do not touch.
+    if (std::size(chunk_data->players) > 0) {
+        return;
+    }
+
+    // Nobody is associated with the chunk and it should be removed.
+    boost::asio::post(
+        pool, std::bind(
+                  [](const shared::math::coords coords,
+                     std::shared_ptr<server::world::chunk> chunk) {
+                      chunk->write();
+
+                      auto res_lock = resources::get_resources_lock();
+                      const auto find_it = res_lock->chunks.find(coords);
+                      if (find_it == std::end(res_lock->chunks)) {
+                          return;
+                      }
+                      auto& chunk_data = find_it->second;
+
+                      // Two possible states here!
+                      // The chunk still has people associated, meaning someone
+                      // has requested the chunk while we were writing it.
+                      // Put the chunk back, and send out the old chunk to the
+                      // new clients.
+                      if (std::size(chunk_data->players) > 0) {
+                          chunk_data->chunk.emplace(std::move(chunk));
+                          send_chunk_associated(chunk_data, res_lock->clients);
+                          return;
+                      }
+
+                      res_lock->chunks.erase(find_it);
+                  },
+                  coords, std::move(*chunk_data->chunk)));
+    chunk_data->chunk.reset(); // std::move is not an implicit .reset()
+}
+
+// We don't send off our chunk immediately here because generating chunks are
+// expensive - we defer it later as it gets added to a threadpool.
+static void handle_request_chunk_packet(const proto::request_chunk& packet,
+                                        resources::client_map_value& client,
+                                        resources::chunk_map& chunks,
+                                        resources::pool_t& pool) noexcept {
+    const shared::math::coords coords{packet.chunk_pos().x(),
+                                      packet.chunk_pos().z()};
+
+    if (const auto find_it = chunks.find(coords); find_it != std::end(chunks)) {
+        auto& chunk_data = find_it->second;
+        resources::associate_client_chunk(coords, client, chunk_data);
+        boost::asio::post(
+            pool,
+            std::bind(
+                [](const shared::math::coords coords,
+                   const shared::player::index_t index) {
+                    auto res_lock = resources::get_resources_lock();
+                    auto& chunk_data = res_lock->chunks.find(coords)->second;
+
+                    if (!chunk_data->has_initialised()) {
+                        return; // will be sent on construction
+                    }
+
+                    const auto& client_it = res_lock->clients.find(index);
+                    if (client_it == std::end(res_lock->clients)) {
+                        return;
+                    }
+                    auto& client = client_it->second;
+                    send_chunk(chunk_data->get_chunk(), client);
+                    maybe_post_chunk_rm(coords, chunk_data, res_lock->pool);
+                },
+                coords, client->index));
+
+        return;
+    }
+
+    auto& data = chunks
+                     .emplace(coords, std::make_unique<chunk_data>(
+                                          chunk_data{.chunk = std::nullopt}))
+                     .first->second;
+    resources::associate_client_chunk(coords, client, data);
+
+    boost::asio::post(
+        pool,
+        std::bind(
+            [](const shared::math::coords coords) {
+                server::world::chunk chunk{server::state.seed, coords};
+
+                auto res_lock = resources::get_resources_lock();
+                auto& chunk_data = res_lock->chunks.find(coords)->second;
+                chunk_data->chunk.emplace(
+                    std::make_unique<server::world::chunk>(std::move(chunk)));
+                send_chunk_associated(chunk_data, res_lock->clients);
+                maybe_post_chunk_rm(coords, chunk_data, res_lock->pool);
+            },
+            coords));
+}
+
+// Disassociates a client with a chunk, while performing necessary cleanups.
+static void disassociate_client_coords(const shared::math::coords& coords,
+                                       resources::client_map_value& client,
+                                       resources::chunk_map& chunks,
+                                       resources::pool_t& pool) noexcept {
+    // Disassociate client with chunk.
+    client->chunks.erase(coords);
+
+    // Disassociate chunk with client.
+    const auto find_it = chunks.find(coords);
+    if (find_it == std::end(chunks)) {
+        return;
+    }
+    auto& chunk_data = find_it->second;
+    chunk_data->players.erase(client->index);
+
+    // Potentially remove the chunk from the chunks (if necessary).
+    maybe_post_chunk_rm(coords, chunk_data, pool);
+}
+
+// Our client tells us if they removed a chunk.
+// This system could be abused to blow up our memory, so we set a hard
+// limit for the amount of chunks a player may have associated.
+static void handle_remove_chunk_packet(const proto::remove_chunk& packet,
+                                       resources::client_map_value& client,
+                                       resources::chunk_map& chunks,
+                                       resources::pool_t& pool) noexcept {
+    const shared::math::coords coords{packet.chunk_pos().x(),
+                                      packet.chunk_pos().z()};
+    disassociate_client_coords(coords, client, chunks, pool);
+}
+
+static void post_chunk_update(const shared::math::coords& coords,
+                              resources::pool_t& pool) noexcept {
+    boost::asio::post(
+        pool, std::bind(
+                  [](const shared::math::coords coords) {
+                      auto res_lock = resources::get_resources_lock();
+                      const auto find_it = res_lock->chunks.find(coords);
+                      if (find_it == std::end(res_lock->chunks)) {
+                          return;
+                      }
+                      auto& chunk_data = find_it->second;
+                      send_chunk_associated(chunk_data, res_lock->clients);
+                  },
+                  coords));
+}
+
+static void modify_block(const enum shared::world::block::type block_type,
+                         const glm::ivec3& block_pos,
+                         const shared::math::coords& coords,
+                         resources::chunk_map& chunks) noexcept {
+
+    const auto find_it = chunks.find(coords);
+    if (find_it == std::end(chunks)) {
+        return;
+    }
+
+    if (shared::world::chunk::is_outside_chunk(block_pos)) {
+        return;
+    }
+
+    auto& chunk_data = find_it->second;
+    if (!chunk_data->has_initialised()) {
+        return;
+    }
+
+    chunk_data->get_chunk().get_block(block_pos) = block_type;
+    chunk_data->get_chunk().arm_should_update();
+}
+
+static void
+handle_add_block_packet(const proto::add_block& packet,
+                        [[maybe_unused]] resources::client_map_value& client,
+                        server::resources::chunk_map& chunks,
+                        resources::pool_t& pool) noexcept {
+    const shared::math::coords coords{packet.chunk_pos().x(),
+                                      packet.chunk_pos().z()};
+    const glm::ivec3 block_pos{packet.block_pos().x(), packet.block_pos().y(),
+                               packet.block_pos().z()};
+    const auto block =
+        static_cast<enum shared::world::block::type>(packet.block());
+    modify_block(block, block_pos, coords, chunks);
+    post_chunk_update(coords, pool);
+}
+
+static void
+handle_remove_block_packet(const proto::remove_block& packet,
+                           [[maybe_unused]] resources::client_map_value& client,
+                           resources::chunk_map& chunks,
+                           resources::pool_t& pool) noexcept {
+    const shared::math::coords coords{packet.chunk_pos().x(),
+                                      packet.chunk_pos().z()};
+    const glm::ivec3 block_pos{packet.block_pos().x(), packet.block_pos().y(),
+                               packet.block_pos().z()};
+    modify_block(shared::world::block::type::air, block_pos, coords, chunks);
+    post_chunk_update(coords, pool);
+}
+
+static void handle_auth_packet(const proto::auth& packet,
+                               resources::client_map_value& client,
+                               resources::pool_t& pool) noexcept {
+    boost::asio::post(
+        pool,
+        std::bind(
+            [](const resources::client_map_key client_index,
+               const std::string user, const std::string pass) {
+                const auto db_plr = database::maybe_read_player(user);
+
+                auto res_lock = resources::get_resources_lock();
+                const auto find_it = res_lock->clients.find(client_index);
+                if (find_it == std::end(res_lock->clients)) {
+                    return;
+                }
+                auto& client = find_it->second;
+
+                // find if we're already associated, eventually kick our client
+                // it would be nice if this wasn't a find_if
+                if (std::find_if(std::begin(res_lock->clients),
+                                 std::end(res_lock->clients),
+                                 [&](const auto& it) {
+                                     auto& client = it.second;
+                                     if (!client->has_initialised()) {
+                                         return false;
+                                     }
+                                     return client->index != client_index &&
+                                            client->get_username() == user;
+                                 }) != std::end(res_lock->clients)) {
+
+                    client->disconnect_reason.emplace("user already in server");
+                    return;
+                }
+
+                struct client::player_info player_info {
+                    .username = user, .password = pass
+                };
+                if (db_plr.has_value()) {
+                    auto& [player, db_password] = *db_plr;
+
+                    if (db_password != pass) {
+                        client->disconnect_reason.emplace("bad password");
+                        return;
+                    }
+
+                    player_info.player = shared::net::get_player(player);
+                    player_info.player.index = client_index;
+                } else {
+                    // TODO: Find a random spawn chunk and put the player
+                    // on the highest block. Because we don't want to gen chunks
+                    // while blocking, we can't do this here. For now, we'll
+                    // just put the player at a high spot.
+                    player_info.player =
+                        shared::player{.index = client_index,
+                                       .local_pos = {0.0f, 140.0f, 0.0f}};
+                }
+                client->player_info.emplace(
+                    std::make_shared<struct client::player_info>(
+                        std::move(player_info)));
+
+                client->connection.rsend_packet(make_init_packet(client));
+            },
+            client->index, std::move(packet.username()),
+            std::move(packet.password())));
+}
+
+// Get new packets from clients, this will change client data and worldata.
+static void parse_client_packets(resources::client_map_value& client,
+                                 resources::resources& res) noexcept {
+    while (auto packet = client->connection.recv_packet()) {
+        if (packet->has_auth_packet()) {
+            handle_auth_packet(packet->auth_packet(), client, res.pool);
+        } else if (packet->has_move_packet()) {
+            handle_move_packet(packet->move_packet(), client);
+        } else if (packet->has_say_packet()) {
+            handle_say_packet(packet->say_packet(), client, res.clients);
+        } else if (packet->has_request_chunk_packet()) {
+            handle_request_chunk_packet(packet->request_chunk_packet(), client,
+                                        res.chunks, res.pool);
+        } else if (packet->has_remove_chunk_packet()) {
+            handle_remove_chunk_packet(packet->remove_chunk_packet(), client,
+                                       res.chunks, res.pool);
+        } else if (packet->has_add_block_packet()) {
+            handle_add_block_packet(packet->add_block_packet(), client,
+                                    res.chunks, res.pool);
+        } else if (packet->has_remove_block_packet()) {
+            handle_remove_block_packet(packet->remove_block_packet(), client,
+                                       res.chunks, res.pool);
+        }
+#ifndef NDEBUG
+        else {
+            shared::print::warn("server: unhandled packet type\n");
+        }
+#endif
+    }
+}
+
+[[maybe_unused]] // [[actually_used]]
+static void
+send_remove_packets(server::resources::client_map_value& remove_client,
+                    server::resources::client_map& clients) noexcept {
+    const auto remove_packet = make_remove_packet(remove_client);
+    for (auto& [index, client_ptr] : clients) {
+        client_ptr->connection.rsend_packet(remove_packet);
+    }
+}
+
+static void handle_new_connections(shared::net::connection& connection,
+                                   resources::resources& res) noexcept {
+    shared::print::message("server: got connection from " +
+                           connection.get_address() + '\n');
+
+    // Add the client, waiting for an auth packet.
+    static uint32_t index = 0;
+    res.clients.insert_or_assign(index, server::resources::client_map_value{
+                                            std::make_unique<server::client>(
+                                                std::move(connection), index)});
+    ++index;
+}
+
+static void move_client(resources::client_map_value& client,
+                        resources::chunk_map& chunks) noexcept {
+    // shared::movement::fly(client.player, client.commands);
+    movement::move(*client, chunks);
+}
+
+static void send_client_packets(resources::client_map_value& client,
+                                resources::resources& res) noexcept {
+    // TODO PVS, as simple as checking if a client has our chunk pos in their
+    // associated chunks list
+    for (auto& [index, c] : res.clients) {
+        if (!c->has_initialised()) {
+            continue;
+        }
+        if (!client->chunks.contains(c->get_player().chunk_pos)) {
+            continue;
+        }
+
+        client->connection.usend_packet(make_player_packet(c->get_player()));
+    }
+}
+
+// returns a dc reason that will be printed and sent to the client
+[[maybe_unused]] std::optional<std::string>
+get_sent_disconnect_reason(const resources::client_map_value& client) noexcept {
+    if (!client->connection.good()) {
+        return client->connection.get_bad_reason();
+    }
+
+    if (client->chunks.size() >
+        unsigned(state.draw_distance * state.draw_distance * 4)) {
+        return "too many chunks associated with client";
+    }
+
+    return client->disconnect_reason;
+}
+
+static void remove_bad_clients(resources::resources& res) noexcept {
+    for (auto& [index, client] : res.clients) {
+        const auto reason = get_sent_disconnect_reason(client);
+        if (reason == std::nullopt) {
+            continue;
+        }
+
+        if (client->disconnecting) {
+            continue;
+        }
+        client->disconnecting = true;
+
+        shared::print::message("server: dropped " +
+                               client->connection.get_address() + " for \"" +
+                               *reason + "\"\n");
+        send_message("disconnected for " + *reason, client, true);
+        send_remove_packets(client, res.clients);
+
+        boost::asio::post(
+            res.pool,
+            std::bind(
+                [](const auto rm_coords,
+                   const resources::client_map_key client_index,
+                   const decltype(client::player_info) plr_info) {
+                    // Write the player to the db before we do any locks.
+                    if (plr_info.has_value()) {
+                        database::write_player(
+                            (*plr_info)->username, (*plr_info)->password,
+                            make_player_packet((*plr_info)->player)
+                                .player_packet());
+                    }
+
+                    // cleanup associated chunks
+                    for (const auto& coords : rm_coords) {
+                        auto res_lock = resources::get_resources_lock();
+
+                        const auto find_it = res_lock->chunks.find(coords);
+                        if (find_it == std::end(res_lock->chunks)) {
+                            return;
+                        }
+                        auto& chunk_data = find_it->second;
+                        chunk_data->players.erase(client_index);
+
+                        maybe_post_chunk_rm(coords, chunk_data, res_lock->pool);
+                    }
+
+                    // final cleanup, now we may reconnect
+                    resources::get_resources_lock()->clients.erase(
+                        client_index);
+                },
+                std::move(client->chunks), client->index,
+                std::move(client->player_info)));
+        client->chunks.clear(); // just being explicit
+        client->player_info.reset();
+    }
+}
+
+static void process_resources(resources::resources& res) noexcept {
+    // Get new packets from clients. The contents of these packets will
+    // determine how the world + client data changes.
+    for (auto& [index, client] : res.clients) {
+        parse_client_packets(client, res);
+    }
+
+    // Move clients via their (hopefully updated) command.
+    for (auto& [index, client] : res.clients) {
+        move_client(client, res.chunks);
+    }
+
+    // Send packets which are sent once per tick, as of now the player
+    // struct of other clients.
+    for (auto& [index, client] : res.clients) {
+        send_client_packets(client, res);
+    }
+
+    // Delete bad connections, print if it happens. Also sends a remove
+    // to all clients per client removed.
+    remove_bad_clients(res);
+}
+
+void main(const std::string_view address, const std::string_view port) {
+    const auto rsock = create_listen_socket(address, port); // reliable socket
+
+    server::resources::init();
+    has_initialised = true;
+    shared::print::notify("server: started at " + std::string{address} + ':' +
+                          std::string{port} + '\n');
+
+    // Server has a tickrate, we will use non-blocking polling at this
+    // tickrate.
+    for (; !shared::should_exit; block_by_tickrate()) {
+        // Lock resources with a higher priority than work on the pool
+        auto resources_lock = server::resources::get_resources_lock_immediate();
+
+        // Get new connections and add them to our clients map.
+        while (auto connection = make_connection(rsock)) {
+            handle_new_connections(connection.value(), *resources_lock);
+        }
+
+        // Process data from resources including client packets, chunk
+        // updates, etc.
+        process_resources(*resources_lock);
+    }
+
+    // Cleanup of clients.
+    {
+        auto res_lock = resources::get_resources_lock();
+        std::ranges::for_each(res_lock->clients, [](const auto& it) {
+            const auto& client = it.second;
+            client->disconnect_reason.emplace("server shutting down");
+        });
+        remove_bad_clients(*res_lock);
+    }
+
+    shared::print::notify("server: writing world data\n");
+    server::resources::quit();
+    shared::print::notify("server: gracefully exited\n");
+}
+
+} // namespace server