Server.c

// Copyright DarkNeutrino 2021
#include "Server.h"

#include "../Extern/libmapvxl/libmapvxl.h"
#include "Commands.h"
#include "Gamemodes.h"
#include "Map.h"
#include "Master.h"
#include "Packets.h"
#include "ParseConvert.h"
#include "Ping.h"
#include "Protocol.h"
#include "Structs.h"
#include "Util/Compress.h"
#include "Util/DataStream.h"
#include "Util/Enums.h"
#include "Util/JSONHelpers.h"
#include "Util/Line.h"
#include "Util/Log.h"
#include "Util/Queue.h"
#include "Util/Types.h"
#include "Util/Utlist.h"

#include <stdio.h>
//
#include <enet/enet.h>
#include <errno.h>
#include <json-c/json.h>
#include <json-c/json_object.h>
#include <json-c/json_types.h>
#include <json-c/json_util.h>
#include <math.h>
#include <pthread.h>
#include <readline/history.h>
#include <readline/readline.h>
#include <signal.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.h>

server_t        server;
pthread_mutex_t server_lock;

volatile int ctrlc = 0;

server_t* get_server(void)
{
    return &server; // Needed when we cant pass Server as argument into function
}

static void _string_nodes_free(string_node_t* root)
{
    string_node_t *el, *tmp;
    DL_FOREACH_SAFE(root, el, tmp)
    {
        free(el->string);
        DL_DELETE(root, el);
        free(el);
    }
}

static void _for_players(void)
{
    for (int playerID = 0; playerID < server.protocol.max_players; ++playerID) {
        if (is_past_join_screen(&server, playerID)) {
            uint64_t timeNow = get_nanos();
            if (server.player[playerID].primary_fire == 1 && server.player[playerID].reloading == 0) {
                if (server.player[playerID].weapon_clip > 0) {
                    uint64_t milliseconds = 0;
                    switch (server.player[playerID].weapon) {
                    case WEAPON_RIFLE: {
                        milliseconds = 500;
                        break;
                    }
                    case WEAPON_SMG: {
                        milliseconds = 100;
                        break;
                    }
                    case WEAPON_SHOTGUN: {
                        milliseconds = 1000;
                        break;
                    }
                    }
                    if (diffIsOlderThen(
                            timeNow,
                            &server.player[playerID].timers.since_last_weapon_input,
                            NANO_IN_MILLI * milliseconds)) {
                        server.player[playerID].weapon_clip--;
                    }
                }
            } else if (server.player[playerID].primary_fire == 0 && server.player[playerID].reloading == 1) {
                switch (server.player[playerID].weapon) {
                case WEAPON_RIFLE:
                case WEAPON_SMG: {
                    if (diffIsOlderThen(
                            timeNow,
                            &server.player[playerID].timers.since_reload_start,
                            NANO_IN_MILLI * (uint64_t)2500)) {
                        uint8_t defaultAmmo = RIFLE_DEFAULT_CLIP;
                        if (server.player[playerID].weapon == WEAPON_SMG) {
                            defaultAmmo = SMG_DEFAULT_CLIP;
                        }
                        double newReserve = fmax(0,
                            server.player[playerID].weapon_reserve - (defaultAmmo - server.player[playerID].weapon_clip));
                        server.player[playerID].weapon_clip += server.player[playerID].weapon_reserve - newReserve;
                        server.player[playerID].weapon_reserve = newReserve;
                        server.player[playerID].reloading      = 0;
                        send_weapon_reload(&server, playerID, 0, 0, 0);
                    }
                    break;
                }
                case WEAPON_SHOTGUN: {
                    if (diffIsOlderThen(
                            timeNow,
                            &server.player[playerID].timers.since_reload_start,
                            NANO_IN_MILLI * (uint64_t)500)) {
                        if (server.player[playerID].weapon_reserve == 0 || server.player[playerID].weapon_clip == SHOTGUN_DEFAULT_CLIP) {
                            server.player[playerID].reloading = 0;
                            break;
                        }
                        server.player[playerID].weapon_clip++;
                        server.player[playerID].weapon_reserve--;
                        if (server.player[playerID].weapon_clip == SHOTGUN_DEFAULT_CLIP) {
                            server.player[playerID].reloading = 0;
                        }
                        send_weapon_reload(&server, playerID, 0, 0, 0);
                    }
                    break;
                }
                }
            }
            if (diffIsOlderThen(timeNow,
                    &server.player[playerID].timers.since_periodic_message,
                    (uint64_t)(server.periodic_delays[server.player[playerID].periodic_delay_index] * 60) * NANO_IN_SECOND)) {
                string_node_t* message;
                DL_FOREACH(server.periodic_messages, message)
                {
                    send_server_notice(&server, playerID, 0, message->string);
                }
                server.player[playerID].periodic_delay_index = fmin(server.player[playerID].periodic_delay_index + 1, 4);
            }
        } else if (server.player[playerID].state == STATE_PICK_SCREEN) {
            block_node_t *node, *tmp;
            LL_FOREACH_SAFE(server.player[playerID].blockBuffer, node, tmp)
            {
                if (node->type == 10) {
                    send_set_color_to_player(
                        &server,
                        node->sender_id,
                        playerID,
                        node->color.r,
                        node->color.g,
                        node->color.b);
                    block_line_to_player(&server, node->sender_id, playerID, node->position, node->position_end);
                    send_set_color_to_player(&server,
                        node->sender_id,
                        playerID,
                        server.player[node->sender_id].color.r,
                        server.player[node->sender_id].color.g,
                        server.player[node->sender_id].color.b);
                } else {
                    send_set_color_to_player(
                        &server,
                        node->sender_id,
                        playerID,
                        node->color.r,
                        node->color.g,
                        node->color.b);
                    send_block_action_to_player(&server,
                        node->sender_id,
                        playerID,
                        node->type,
                        node->position.x,
                        node->position.y,
                        node->position.z);
                    send_set_color_to_player(&server,
                        node->sender_id,
                        playerID,
                        server.player[node->sender_id].color.r,
                        server.player[node->sender_id].color.g,
                        server.player[node->sender_id].color.b);
                }
                LL_DELETE(server.player[playerID].blockBuffer, node);
                free(node);
            }
        } else if (is_past_state_data(&server, playerID)) {
        }
    }
}

static void* calculatePhysics(void)
{
    server.global_timers.update_time = get_nanos();
    if (server.global_timers.update_time - server.global_timers.last_update_time >= (1000000000 / 60)) {
        updateMovementAndGrenades(&server);
        server.global_timers.last_update_time = get_nanos();
    }
    return 0;
}

static void ServerInit(server_t* server,
    uint32_t                     connections,
    const char*                  serverName,
    const char*                  team1Name,
    const char*                  team2Name,
    uint8_t*                     team1_color,
    uint8_t*                     team2_color,
    uint8_t                      gamemode,
    uint8_t                      reset)
{
    server->global_timers.update_time = server->global_timers.last_update_time = get_nanos();
    if (reset == 0) {
        server->protocol.num_players = 0;
        server->protocol.max_players = (connections <= 32) ? connections : 32;
    }

    server->s_map.compressed_map  = NULL;
    server->s_map.compressed_size = 0;
    server->protocol.input_flags  = 0;

    char    vxlMap[64];
    uint8_t index;
    if (reset == 0) {
        srand(time(NULL));
    }
    index                     = rand() % server->s_map.map_count;
    server->s_map.current_map = server->s_map.map_list;
    for (int i = 0; i <= index; ++i) {
        if (server->s_map.current_map->next != NULL) {
            server->s_map.current_map = server->s_map.current_map->next;
        } else {
            break; // Safety if we by some magical reason go beyond the list
        }
    }
    snprintf(
        server->map_name,
        fmin(strlen(server->s_map.current_map->string) + 1, 20),
        "%s",
        server->s_map.current_map->string);
    LOG_STATUS("Selecting %s as map", server->map_name);

    snprintf(vxlMap, 64, "%s.vxl", server->s_map.current_map->string);

    LOG_STATUS("Loading spawn ranges from map file");
    char mapConfig[64];
    snprintf(mapConfig, 64, "%s.json", server->s_map.current_map->string);

    struct json_object* parsed_map_json;
    parsed_map_json = json_object_from_file(mapConfig);

    int         team1Start[2];
    int         team2Start[2];
    int         team1End[2];
    int         team2End[2];
    int         map_size[3];
    const char* author;

    READ_INT_ARR_FROM_JSON(parsed_map_json, team1Start, team1_start, "team1 start", ((int[]) { 0, 0 }), 2, 0)
    READ_INT_ARR_FROM_JSON(parsed_map_json, team1End, team1_end, "team1 end", ((int[]) { 10, 10 }), 2, 0)
    READ_INT_ARR_FROM_JSON(parsed_map_json, team2Start, team2_start, "team2 start", ((int[]) { 20, 20 }), 2, 0)
    READ_INT_ARR_FROM_JSON(parsed_map_json, team2End, team2_end, "team2 end", ((int[]) { 30, 30 }), 2, 0)
    READ_INT_ARR_FROM_JSON(parsed_map_json, map_size, map_size, "map_size", ((int[]) { 512, 512, 64 }), 3, 1)
    READ_STR_FROM_JSON(parsed_map_json, author, author, "author", "Unknown", 0)
    (void)author;

    json_object_put(parsed_map_json);

    if (map_load(server, vxlMap, map_size) == 0) {
        return;
    }

    vector3f_t empty   = { 0, 0, 0 };
    vector3f_t forward = { 1, 0, 0 };
    vector3f_t height  = { 0, 0, 1 };
    vector3f_t strafe  = { 0, 1, 0 };
    for (uint32_t i = 0; i < server->protocol.max_players; ++i) {
        init_player(server, i, reset, 0, empty, forward, strafe, height);
    }

    server->global_ab = 1;
    server->global_ak = 1;

    server->protocol.spawns[0].from.x = team1Start[0];
    server->protocol.spawns[0].from.y = team1Start[1];
    server->protocol.spawns[0].to.x   = team1End[0];
    server->protocol.spawns[0].to.y   = team1End[1];

    server->protocol.spawns[1].from.x = team2Start[0];
    server->protocol.spawns[1].from.y = team2Start[1];
    server->protocol.spawns[1].to.x   = team2End[0];
    server->protocol.spawns[1].to.y   = team2End[1];

    server->protocol.color_fog.r = 0x80;
    server->protocol.color_fog.g = 0xE8;
    server->protocol.color_fog.b = 0xFF;

    server->protocol.color_team[0].b = team1_color[B_CHANNEL];
    server->protocol.color_team[0].g = team1_color[G_CHANNEL];
    server->protocol.color_team[0].r = team1_color[R_CHANNEL];

    server->protocol.color_team[1].b = team2_color[B_CHANNEL];
    server->protocol.color_team[1].g = team2_color[G_CHANNEL];
    server->protocol.color_team[1].r = team2_color[R_CHANNEL];

    memcpy(server->protocol.name_team[0], team1Name, strlen(team1Name));
    memcpy(server->protocol.name_team[1], team2Name, strlen(team2Name));
    server->protocol.name_team[0][strlen(team1Name)] = '\0';
    server->protocol.name_team[1][strlen(team2Name)] = '\0';

    memcpy(server->server_name, serverName, strlen(serverName));
    server->server_name[strlen(serverName)] = '\0';
    gamemode_init(server, gamemode);
}

void server_reset(server_t* server)
{
    ServerInit(server,
        server->protocol.max_players,
        server->server_name,
        server->protocol.name_team[0],
        server->protocol.name_team[1],
        server->protocol.color_team[0].arr,
        server->protocol.color_team[1].arr,
        server->protocol.current_gamemode,
        1);
}

static void SendJoiningData(server_t* server, uint8_t playerID)
{
    LOG_INFO("Sending state to %s (#%hhu)", server->player[playerID].name, playerID);
    for (uint8_t i = 0; i < server->protocol.max_players; ++i) {
        if (i != playerID && is_past_join_screen(server, i)) {
            send_existing_player(server, playerID, i);
        }
    }
    send_state_data(server, playerID);
}

static uint8_t OnConnect(server_t* server)
{
    if (server->protocol.num_players == server->protocol.max_players) {
        return 0xFF;
    }
    uint8_t playerID;
    for (playerID = 0; playerID < server->protocol.max_players; ++playerID) {
        if (server->player[playerID].state == STATE_DISCONNECTED) {
            server->player[playerID].state = STATE_STARTING_MAP;
            break;
        }
    }
    server->protocol.num_players++;
    return playerID;
}

static void OnPlayerUpdate(server_t* server, uint8_t playerID)
{
    switch (server->player[playerID].state) {
    case STATE_STARTING_MAP:
        server->player[playerID].blockBuffer = NULL;
        send_map_start(server, playerID);
        break;
    case STATE_LOADING_CHUNKS:
        send_map_chunks(server, playerID);
        break;
    case STATE_JOINING:
        SendJoiningData(server, playerID);
        break;
    case STATE_SPAWNING:
        server->player[playerID].hp             = 100;
        server->player[playerID].grenades       = 3;
        server->player[playerID].blocks         = 50;
        server->player[playerID].item           = 2;
        server->player[playerID].input          = 0;
        server->player[playerID].move_forward   = 0;
        server->player[playerID].move_backwards = 0;
        server->player[playerID].move_left      = 0;
        server->player[playerID].move_right     = 0;
        server->player[playerID].jumping        = 0;
        server->player[playerID].crouching      = 0;
        server->player[playerID].sneaking       = 0;
        server->player[playerID].sprinting      = 0;
        server->player[playerID].primary_fire   = 0;
        server->player[playerID].secondary_fire = 0;
        server->player[playerID].alive          = 1;
        server->player[playerID].reloading      = 0;
        SetPlayerRespawnPoint(server, playerID);
        send_respawn(server, playerID);
        LOG_INFO("Player %s (#%hhu) spawning at: %f %f %f",
            server->player[playerID].name,
            playerID,
            server->player[playerID].movement.position.x,
            server->player[playerID].movement.position.y,
            server->player[playerID].movement.position.z);
        break;
    case STATE_WAITING_FOR_RESPAWN: {
        if (time(NULL) - server->player[playerID].timers.start_of_respawn_wait >= server->player[playerID].respawn_time) {
            server->player[playerID].state = STATE_SPAWNING;
        }
        break;
    }
    case STATE_READY:
        // send data
        if (server->master.enable_master_connection == 1) {
            if (server->player[playerID].told_to_master == 0) {
                master_update(server);
                server->player[playerID].told_to_master = 1;
            }
        }
        break;
    default:
        // disconnected
        break;
    }
}

static void* WorldUpdate(void)
{
    for (uint8_t playerID = 0; playerID < server.protocol.max_players; ++playerID) {
        OnPlayerUpdate(&server, playerID);
        if (is_past_join_screen(&server, playerID)) {
            uint64_t time = get_nanos();
            if (time - server.player[playerID].timers.time_since_last_wu >= (uint64_t)(NANO_IN_SECOND / server.player[playerID].ups)) {
                send_world_update(&server, playerID);
                server.player[playerID].timers.time_since_last_wu = get_nanos();
            }
        }
    }
    return 0;
}

static void ServerUpdate(server_t* server, int timeout)
{

    ENetEvent event;
    while (enet_host_service(server->host, &event, timeout) > 0) {
        uint8_t bannedUser = 0;
        uint8_t playerID;
        switch (event.type) {
        case ENET_EVENT_TYPE_NONE:
            LOG_STATUS("Event of type none received. Ignoring");
            break;
        case ENET_EVENT_TYPE_CONNECT:
            if (event.data != VERSION_0_75) {
                enet_peer_disconnect_now(event.peer, REASON_WRONG_PROTOCOL_VERSION);
                break;
            }

            struct json_object* root = json_object_from_file("Bans.json");
            if (root == NULL) {
                FILE* fp;
                fp = fopen("Bans.json", "w+");
                if (fp == NULL) {
                    perror("Unable to open/create Bans.json with error: ");
                    exit(EXIT_FAILURE);
                }
                fclose(fp);
                root = json_object_new_object();
                json_object_object_add(root, "Bans", json_object_new_array());
                json_object_to_file("Bans.json", root);
            }
            ip_t hostIP;
            hostIP.cidr = 24;
            hostIP.ip32 = event.peer->address.host;
            struct json_object* array;
            json_object_object_get_ex(root, "Bans", &array);
            int count = json_object_array_length(array);
            for (int i = 0; i < count; ++i) {
                struct json_object* objectAtIndex = json_object_array_get_idx(array, i);
                const char*         IP;
                const char*         startOfRangeString;
                const char*         endOfRangeString;
                READ_STR_FROM_JSON(
                    objectAtIndex,
                    startOfRangeString,
                    start_of_range,
                    "start of range",
                    "0.0.0.0",
                    1);
                READ_STR_FROM_JSON(objectAtIndex, endOfRangeString, end_of_range, "end of range", "0.0.0.0", 1);
                READ_STR_FROM_JSON(objectAtIndex, IP, IP, "IP", "0.0.0.0", 1);
                ip_t ipStruct;
                ip_t startOfRange, endOfRange;
                if (format_str_to_ip((char*)IP, &ipStruct) && (format_str_to_ip((char*)startOfRangeString, &startOfRange) && format_str_to_ip((char*)endOfRangeString, &endOfRange))) {
                    if (ip_in_range(hostIP, ipStruct, startOfRange, endOfRange)) {
                        const char* nameOfPlayer;
                        const char* reason;
                        double      time    = 0.0f;
                        uint64_t    timeNow = get_nanos();
                        READ_STR_FROM_JSON(objectAtIndex, nameOfPlayer, Name, "Name", "Deuce", 0);
                        READ_STR_FROM_JSON(objectAtIndex, reason, Reason, "Reason", "None", 0);
                        READ_DOUBLE_FROM_JSON(objectAtIndex, time, Time, "Time", 0.0f, 0);
                        if (((long double)timeNow / NANO_IN_MINUTE) > time && time != 0) {
                            json_object_array_del_idx(array, i, 1);
                            json_object_to_file("Bans.json", root);
                            continue; // Continue searching for bans and delete all the old ones that match host IP
                                      // or its range
                        } else {
                            enet_peer_disconnect(event.peer, REASON_BANNED);

                            LOG_WARNING("Banned user %s tried to join with IP: %hhu.%hhu.%hhu.%hhu Banned for: %s",
                                nameOfPlayer,
                                hostIP.ip[0],
                                hostIP.ip[1],
                                hostIP.ip[2],
                                hostIP.ip[3],
                                reason);
                            bannedUser       = 1;
                            event.peer->data = (void*)((size_t)server->protocol.max_players - 1);
                            break;
                        }
                    }
                }
            }
            json_object_put(root);

            if (bannedUser) {
                break;
            }
            // check peer
            // ...
            // find next free ID
            playerID = OnConnect(server);
            if (playerID == 0xFF) {
                enet_peer_disconnect_now(event.peer, REASON_SERVER_FULL);
                LOG_WARNING("Server full. Kicking player");
                break;
            }
            server->player[playerID].peer    = event.peer;
            event.peer->data                 = (void*)((size_t)playerID);
            server->player[playerID].hp      = 100;
            server->player[playerID].ip.ip32 = event.peer->address.host;

            format_ip_to_str(server->player[playerID].name, server->player[playerID].ip);
            snprintf(server->player[playerID].name, 6, "Limbo");
            char ipString[17];
            format_ip_to_str(ipString, server->player[playerID].ip);
            LOG_INFO("Player %s (%s, #%hhu) connected", server->player[playerID].name, ipString, playerID);

            server->player[playerID].timers.since_periodic_message = get_nanos();
            server->player[playerID].current_periodic_message      = server->periodic_messages;
            server->player[playerID].periodic_delay_index          = 0;
            break;
        case ENET_EVENT_TYPE_DISCONNECT:
            playerID = (uint8_t)((size_t)event.peer->data);
            if (playerID != server->protocol.max_players - 1) {
                send_intel_drop(server, playerID);
                send_player_left(server, playerID);
                vector3f_t empty   = { 0, 0, 0 };
                vector3f_t forward = { 1, 0, 0 };
                vector3f_t height  = { 0, 0, 1 };
                vector3f_t strafe  = { 0, 1, 0 };
                init_player(server, playerID, 0, 1, empty, forward, strafe, height);
                server->protocol.num_players--;
                server->protocol.num_team_users[server->player[playerID].team]--;
                if (server->master.enable_master_connection == 1) {
                    master_update(server);
                }
            }
            break;
        case ENET_EVENT_TYPE_RECEIVE: {
            datastream_t stream = { event.packet->data, event.packet->dataLength, 0 };
            playerID            = (uint8_t)((size_t)event.peer->data);
            on_packet_received(server, playerID, &stream, event);
            enet_packet_destroy(event.packet);
            break;
        }
        }
    }
}

void ReadlineNewLine(int signal)
{
    (void)signal; // To prevent a warning about unused variable

    ctrlc = 1;
    printf("\n");
    LOG_INFO_WITHOUT_TIME("Are you sure you want to exit? (Y/n)");

    if (write(STDIN_FILENO, "\n", sizeof("\n")) != sizeof("\n")) {
        LOG_DEBUG("epic write fail");
    }
    rl_replace_line("", 0);
    rl_on_new_line();
    rl_redisplay();
}

void StopServer(void)
{
    server.running = 0;
}

static void* serverConsole(void* arg)
{
    (void)arg;
    char* buf;

    while ((buf = readline("\x1B[0;34mConsole> \x1B[0;37m")) != NULL) {
        if (ctrlc) { // "Are you sure?" prompt
            if (strcmp("n", buf) != 0) {
                break;
            }
            ctrlc = 0;
        } else if (strlen(buf) > 0) {
            add_history(buf);
            pthread_mutex_lock(&server_lock);
            command_handle(&server, 255, buf, 1);
            pthread_mutex_unlock(&server_lock);
        }
        free(buf);
    }
    rl_clear_history();
    StopServer();

    sleep(5); // wait 5 seconds for the server to stop

    // if this thread is not dead at this point, then we need to stop the server by force >:)
    LOG_ERROR("Server did not respond for 5 seconds. Killing it with fire...");
    exit(-1);

    return 0;
}

void server_start(uint16_t port,
    uint32_t               connections,
    uint32_t               channels,
    uint32_t               inBandwidth,
    uint32_t               outBandwidth,
    uint8_t                master,
    string_node_t*         map_list,
    uint8_t                map_count,
    string_node_t*         welcomeMessageList,
    uint8_t                welcomeMessageListLen,
    string_node_t*         periodicMessageList,
    uint8_t                periodicMessageListLen,
    uint8_t*               periodicDelays,
    const char*            managerPasswd,
    const char*            adminPasswd,
    const char*            modPasswd,
    const char*            guardPasswd,
    const char*            trustedPasswd,
    const char*            serverName,
    const char*            team1Name,
    const char*            team2Name,
    uint8_t*               team1_color,
    uint8_t*               team2_color,
    uint8_t                gamemode)
{
    server.global_timers.time_since_start = get_nanos();
    LOG_STATUS("Welcome to SpadesX server");
    LOG_STATUS("Initializing ENet");

    if (enet_initialize() != 0) {
        LOG_ERROR("Failed to initalize ENet");
        exit(EXIT_FAILURE);
    }
    atexit(enet_deinitialize);

    if (pthread_mutex_init(&server_lock, NULL) != 0) {
        LOG_ERROR("Server mutex failed to initialize");
        exit(EXIT_FAILURE);
    }

    ENetAddress address;
    address.host = ENET_HOST_ANY;
    address.port = port;

    LOG_STATUS("Creating server at port %d", port);

    server.host = enet_host_create(&address, connections, channels, inBandwidth, outBandwidth);
    if (server.host == NULL) {
        LOG_ERROR("Failed to create server");
        exit(EXIT_FAILURE);
    }

    if (enet_host_compress_with_range_coder(server.host) != 0) {
        LOG_WARNING("Compress with range coder failed");
    }

    server.port = port;

    server.host->intercept = &raw_udp_intercept_callback;

    LOG_STATUS("Intializing server");
    server.running                = 1;
    server.s_map.map_list         = map_list;
    server.s_map.map_count        = map_count;
    server.welcome_messages       = welcomeMessageList;
    server.welcome_messages_count = welcomeMessageListLen;
    server.periodic_messages      = periodicMessageList;
    server.periodic_message_count = periodicMessageListLen;
    server.periodic_delays        = periodicDelays;
    ServerInit(&server, connections, serverName, team1Name, team2Name, team1_color, team2_color, gamemode, 0);

    command_populate_all(&server);

    server.master.enable_master_connection = master;
    server.manager_passwd                  = managerPasswd;
    server.admin_passwd                    = adminPasswd;
    server.mod_passwd                      = modPasswd;
    server.guard_passwd                    = guardPasswd;
    server.trusted_passwd                  = trustedPasswd;

    if (server.running) {
        LOG_STATUS("Server started");
    }
    if (server.master.enable_master_connection == 1) {
        master_connect(&server, port);
    }
    server.master.time_since_last_send = time(NULL);

    pthread_t masterThread;
    pthread_create(&masterThread, NULL, master_keep_alive, (void*)&server);
    pthread_detach(masterThread);

    rl_catch_signals = 0;
    pthread_t console;
    pthread_create(&console, NULL, serverConsole, NULL);
    pthread_detach(console);

    signal(SIGINT, ReadlineNewLine);

    while (server.running) {
        pthread_mutex_lock(&server_lock);
        calculatePhysics();
        ServerUpdate(&server, 0);
        WorldUpdate();
        _for_players();
        pthread_mutex_unlock(&server_lock);
        sleep(0);
    }
    while (server.s_map.compressed_map) {
        server.s_map.compressed_map = queue_pop(server.s_map.compressed_map);
    }
    free(server.s_map.compressed_map);

    command_free_all(&server);

    _string_nodes_free(server.welcome_messages);
    _string_nodes_free(server.s_map.map_list);
    _string_nodes_free(server.periodic_messages);
    mapvxl_free(&server.s_map.map);

    pthread_mutex_destroy(&server_lock);

    printf("\n");
    LOG_STATUS("Exiting");
    enet_host_destroy(server.host);
}