diff --git a/ANTI_TROLL.md b/ANTI_TROLL.md
new file mode 100644
index 00000000000..bc9a67d8aad
--- /dev/null
+++ b/ANTI_TROLL.md
@@ -0,0 +1,40 @@
+## Info on experimental anti-troll system
+If activated, a timer is kept for all players. System can be activated in xml config or in the lobby with command:
+\admin troll [0,1]
+
+Timer is increased by the amount of time when
+* a player drives in the wrong way
+* a player moves below a given speed (troll-max-stop-speed)
+
+Timer is not increased when the player is hit or rescued (during animation).
+
+It is decreased (not below 0 obviously) when a player drives in correct direction with at least given speed (troll-min-normal-speed).
+
+If a player's timer exceeds the warning level (troll-warning-time), they get a warning (troll-warn-message). After that the timer is reset.
+If a player got a warning and their timer exceeds the kick level (troll-kick-time), they get kicked.
+Warnings and Kicks are logged.
+
+Config can be controlled in xml file like this:
+
+    <!-- Set values for anti-troll system -->
+    <!-- If true, use anti troll system
+         This can also be controlled with server command:
+         \admin troll [0,1] -->
+    <use-anti-troll-system value="true" />
+    <!-- Warn string to show to player -->
+    <troll-warn-message value="WARNING: You troll, you get kicked !!" />
+    <!-- Warn player that drives backwards or stopps for given time -->
+    <troll-warning-time value="7.0" />
+    <!-- Kick player that drives backwards or stopps for given time -->
+    <troll-kick-time value="10.0" />
+    <!-- Minimum speed in correct direction to decrease wrong-way timer -->
+    <troll-min-normal-speed value="12.0" />
+    <!-- A player going slower than this is considered stopping -->
+    <troll-max-stop-speed value="5.0" />
+
+### Things to note
+* The system can be fooled of course, but it should be a lot harder to troll. Testing would be necessary. However, when I set up a test server, most players coming by just wanted to play normally...
+* The system should not warn or kick weak players who get lost or stuck on obstacles (too quickly). The current configuration values are most probably not yet perfect.
+* Players should probably be informed about the system, because waiting for others (like some pros do when giving weaker players some advice or driving lessons) would be punished, so the system should not be activated in those cases.
+* If a player presses UP-key early, the timer is increased during time punishment at the beginning of the race (1 sec). I don't know how to find out if a player is in that state.
+* **There may still be bugs** (of course)... ;)
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 21a1ae43b51..37113dc4b55 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -34,11 +34,11 @@ CMAKE_DEPENDENT_OPTION(USE_IPV6 "Allow create or connect to game server with IPv
 option(USE_SYSTEM_WIIUSE "Use system WiiUse instead of the built-in version, when available." OFF)
 option(USE_SQLITE3 "Use sqlite to manage server stats and ban list." ON)
 
+option(WEB_SUPPORT "Website integration tools" OFF)
 if(APPLE)
     CMAKE_DEPENDENT_OPTION(DLOPEN_MOLTENVK "Use dlopen to load MoltenVK for Apple." ON
         "NOT IOS;NOT SERVER_ONLY" OFF)
 endif()
-
 CMAKE_DEPENDENT_OPTION(USE_CRYPTO_OPENSSL "Use OpenSSL instead of MbedTLS for cryptography in STK." ON
     "NOT USE_SWITCH;NOT WIN32" OFF)
 CMAKE_DEPENDENT_OPTION(BUILD_RECORDER "Build opengl recorder" ON
@@ -475,6 +475,11 @@ if(USE_SQLITE3)
     endif()
 endif()
 
+# Web support
+if(WEB_SUPPORT)
+    add_definitions(-DENABLE_WEB_SUPPORT)
+endif()
+
 # Set some compiler options
 if(UNIX OR MINGW)
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=gnu++0x")
diff --git a/FORK_CHANGES.md b/FORK_CHANGES.md
new file mode 100644
index 00000000000..cc73679df3b
--- /dev/null
+++ b/FORK_CHANGES.md
@@ -0,0 +1,94 @@
+This page lists the major changes of this repository compared to standard STK code, as of April 2024. Most changes (sadly, not all of them) here are implemented as options, that is, you can disable them and return to standard behaviour.
+
+You can find more information such as explanations and minor details in [wiki](https://github.com/kimden/stk-code/wiki/). It will be probably filled with even more data in the future.
+
+## Improved Grand Prix mode
+
+* Server doesn't become private
+* Players can pick karts, join or leave
+* Custom scoring systems
+* Custom teams (up to 9)
+* Standings ingame (short) and in the lobby (longer)
+* Anti-troll and team hit punishment systems, by Heuchi1
+* Allows to shuffle the starting grid every race
+
+## Records, replays and stats
+
+* Game results for racing and battle modes can be saved to the database, together with game settings and kart statistics
+* Public or private record tables can be created using that information
+* Ghost replays can be recorded on servers if players agree
+* Players who beat server records can be notified (includes separation of times set with different config files)
+* Maximum replay size is increased
+
+## Chat
+
+* Private chat with an arbitrary set of players
+* Teamchat during CTF and soccer which works both ingame and in the lobby
+* Messages are never logged, even by the bots (though they pass through the server code)
+
+## Game configuration, available maps and karts, playing restrictions
+
+* Game length can be set to a fixed value, or to a certain multiple of default lap number, or to be chosen ingame
+* Game direction can be set to forward or reverse, or to be chosen ingame
+* For karts and maps, the next game can be customized so that the set of karts/maps available for choice is fixed, or defined by a certain algorithm (including "you have to play this track", "select from $N$ random maps from this set", "you can choose either Adiumy, or whatever is given to you by random of Suzanne and Konqi")
+* The same is true for any number of next games, and the server can be set to repeat the customization every number of games
+
+All of the above settings can be changed arbitrarily when the server already runs, or in the config before the server starts.
+
+* Servers can be started with other powerup.xml or kart_characteristics.xml files being specified
+* It's possible for a server to force certain maps for players to join the server or to join the game, or vice versa, disable certain maps (or all but a certain set of maps). There are various commands to find out which addons you (or other players) have or don't have, to make it easy to deal with the above
+* The default setting of number of playable slots (playable places on the server) can be changed with a command
+* If the player is unable to play due to imposed restrictions (lacking maps, being out of playable slots), that player doesn't affect the set of available maps, and is given the hourglass icon.
+
+## Command manager
+
+Command manager is an entity made to manipulate all existing server commands easier. It supports:
+
+* commands with voting
+* text commands / commands reading external files
+* auth commands
+* setting permissions for commands without recompiling the code and/or depending on server
+* subcommands and different permissions for them
+* fixing errors in arguments (usernames, map names)
+* showing available commands depending on permissions
+* documentation for all commands via `/help`
+* huge number of new commands
+
+All the commands and their descriptions are available in `data/commands.xml`. This file is also used to generate output for `/commands` and `/help`.
+
+## Moderation and permissions
+
+* It's possible to disable kicks attempted by the crowned player
+* If a player kicks another player, the fact of the kick can be stored in the database table with reports
+* Inactive players can be kicked automatically from the lobby too, not only from the game
+* A hammer mode is added: players having a password can get a hammer, then they can change server settings and kick players
+* There are commands to ban (or unban) a player temporary from a single server by username, as opposed to standard bans which are applied to all servers using the same database, and are usually banning by online id or IP address
+* Players are allowed to report something to server owner without reporting other people
+* Starting the game can be allowed or forbidden using a command
+
+## Game modes and their improvements
+
+These are not implemented as separate modes, but are rather additions to functionality of existing modes:
+
+* **Soccer tournament** mode: for hosting matches of several soccer games. The rules, the number of games and their duration, allowed arenas, tournament teams can be loaded from a config file. Referees have multiple commands to control the game flow
+* **Gnu Elimination** mode: every race, the last (or quitting) non-eliminated player gets eliminated, and eliminated players use the same kart chosen in advance. The last standing player wins
+
+Separate changes for modes:
+
+* Soccer games produce a log of all goals / actions that happened (originally made for tournament mode, but can be used without it too), if the score is edited using tournament commands, the game shows it as a message after each goal and at the end
+* FFA and CTF scores are preserved per username during the game, so that leaving the game is not punished
+
+## Other features
+
+* You can allow only the crowned player to play (speedrun server), or no one at all (chat server)
+* Minor `/spectate` changes (you can invoke it ingame, game doesn't start with everyone spectating)
+* For a configurable server, you can specify which exact difficulties and modes are allowed
+* Players can send a message to the server owner (without reporting anyone else), and the server owner can send one-time messages to specific players
+* For private servers, players can be whitelisted so that they can enter any password to join
+* Different strategies to determine who scored a goal (allowing or forbidding own goals)
+* `max-moveable-objects` is changed to 30 to allow tracks like `addon_bowling` to work
+* Server can be customized to reset or preserve many settings like game mode, game length, ..., when everyone leaves it
+* Server git version and whether it's modified is shown in `/version`
+* Server console allows sending arbitrary messages to players
+* Supported player categories aka sets of players (for now only displaying their names, and some minor usage)
+* Minor additions in StringUtils used in typo fixing and string parsing
\ No newline at end of file
diff --git a/NETWORKING.md b/NETWORKING.md
index 97ad3dc34ee..42b7c4ff991 100644
--- a/NETWORKING.md
+++ b/NETWORKING.md
@@ -25,7 +25,7 @@ Than you can just run:
 It will create that xml configuration file if not found in current directory, you can type `quit` in terminal, than you can edit that file for further configuration as required.
 ` --network-console` should not be used if you run supertuxkart server later with systemd service, see issue [#4299](https://github.com/supertuxkart/stk-code/issues/4299).
 
-The current server configuration xml looks like this:
+The current server configuration xml looks like this (this is only an example, just copying and running server with this config file makes some tracks obligatory and some unplayable, please read carefully):
 ```xml
 <?xml version="1.0"?>
 <server-config version="6" >
@@ -60,9 +60,12 @@ The current server configuration xml looks like this:
     <!-- Password for private server, leave empty for a public server. -->
     <private-server-password value="" />
 
-    <!-- Message of today shown in lobby, you can enter encoded XML words here or a file.txt and let STK load it. -->
+    <!-- Message of today shown in lobby, you can enter here encoded XML words or a .txt file and let STK load it. -->
     <motd value="" />
 
+    <!-- Help message shown after sending /help. You can enter here the message or a .txt file and let STK load it. -->
+    <help value="" />
+
     <!-- If this value is set to false, the server will ignore chat messages from all players. -->
     <chat value="true" />
 
@@ -92,6 +95,12 @@ The current server configuration xml looks like this:
 
     <!-- Time to wait before entering kart selection screen if satisfied min-start-game-players below for owner less or ranked server. -->
     <start-game-counter value="60" />
+    
+    <!-- If this value is set to true, a message is send to everybody if a player makes a teammate explode. -->
+    <show-teammate-hits value="false" />
+
+    <!-- Punish teammate hits? If set to true players get an anvil when they hit teammates. -->
+    <teammate-hit-mode value="false" />
 
     <!-- Clients below this value will be rejected from joining this server. It's determined by number of official karts in client / number of official karts in server -->
     <official-karts-threshold value="1" />
@@ -99,6 +108,30 @@ The current server configuration xml looks like this:
     <!-- Clients below this value will be rejected from joining this server. It's determined by number of official tracks in client / number of official tracks in server, setting this value too high will prevent android players from joining this server, because STK android apk has some official tracks removed. -->
     <official-tracks-threshold value="0.7" />
 
+    <!-- Clients below this value will be rejected from joining this server. It's determined by number of addon karts in client -->
+    <addon_karts_threshold value="0" />
+
+    <!-- Clients below this value will be rejected from joining this server. It's determined by number of addon tracks in client -->
+    <addon_tracks_threshold value="0" />
+
+    <!-- Clients below this value will be rejected from joining this server. It's determined by number of addon arenas in client -->
+    <addon_arenas_threshold value="0" />
+
+    <!-- Clients below this value will be rejected from joining this server. It's determined by number of addon soccer fields in client -->
+    <addon_soccers_threshold value="0" />
+
+    <!-- Tracks needed to enter the server, leave empty for no restriction. -->
+    <must-have-tracks value="hacienda xr591 addon_animtrack_1 minigolf" />
+
+    <!-- List of tracks that can be played on a server, leave empty for no restriction or put 'not' before the list to name tracks that cannot be played. -->
+    <only-played-tracks value="not abyss snowtuxpeak addon_minigolf" />
+
+    <!-- Use fixed lap count, negative or zero to disable. -->
+    <fixed-lap-count value="-1" />
+    
+    <!-- If this value is set to true, players and the server must have at least one common official track. -->
+    <official-tracks-needed value="true" />
+
     <!-- Only auto start kart selection when number of connected player is larger than or equals this value, for owner less or ranked server, after start-game-counter reaches 0. -->
     <min-start-game-players value="2" />
 
@@ -117,6 +150,9 @@ The current server configuration xml looks like this:
     <!-- If true, the server owner can config the difficulty and game mode in the GUI of lobby. This option cannot be used with owner-less or grand prix server, and will be automatically turned on if the server was created using the in-game GUI. The changed difficulty and game mode will not be saved in this config file. -->
     <server-configurable value="false" />
 
+    <!-- Description of modes and difficulties that can be set on a configurable server. Doesn't affect initial mode and doesn't affect unconfigurable servers. Use the format "d0123 m012345678". -->
+    <available-modes value="d0123 m012345678" />
+
     <!-- If true, players can live join or spectate the in-progress game. Currently live joining is only available if the current game mode used in server is FFA, CTF or soccer, also official-karts-threshold will be made 1.0. If false addon karts will use their original hitbox other than tux, all players having it restriction applies. -->
     <live-spectate value="true" />
 
@@ -192,9 +228,57 @@ The current server configuration xml looks like this:
     <!-- If true this server will auto add / remove AI connected with network-ai=x, which will kick N - 1 bot(s) where N is the number of human players. Only use this for non-GP racing server. -->
     <ai-handling value="false" />
 
+    <!-- If true no one can start a race and everyone should use the server for sleeping/chatting only. -->
+    <sleeping-server value="false" />
+
+    <!-- IP that should be used to connect to a server, set 0 for a default IP. You need this only if the server's IP shouldn't be used for some reason (e.g. blocking) and there is another IP ('good') that points to the same server. In this case, you should write a good IP here as a number. Only IPv4 is supported. -->
+    <false-ip value="0" />
+
+    <!-- When true, stores race results in a separate table for each server. -->
+    <store-results value="false" />
+
+    <!-- When non-empty, server is telling whether a player has beaten a server record, records are taken from the table specified in this field. So it can be the results table for this server or for all servers hosted on the machine.-->
+    <records-table-name value="" />
+
+    <!-- When true, stores the info about each forced kick in a database (if it exists). -->
+    <track-kicks value="false" />
+
+    <!-- When true, the server allows changing teams freely. -->
+    <free-teams value="false" />
+
+    <!-- When true, the server has the functionality to host soccer tournaments. Rules may change so better ask STK players about the actual rules. -->
+    <soccer-tournament value="false" />
+
+    <!-- List of players and judges. Use the format "R red red red B blue blue blue J judge judge" where the category is preceded by its letter. Categories can be empty or absent and can go in any order. -->
+    <soccer-tournament-players value="" />
+
+    <!-- A string given to a peer if it has incompatible data, so that it can know why it cannot enter, empty to disable. -->
+    <incompatible-advice value="Well, you have incompatible data!" />
+
+    <!-- If true and no track is selected, then an addon track can be picked. -->
+    <random-selects-addons value="false" />
+
+    <!-- If non-empty, these tracks are played in the order until the list ends. Can be useful for grands prix. -->
+    <tracks-queue value="" />
+
+    <!-- A custom Grand Prix scoring system to be used, empty for default. -->
+    <grand-prix-scoring value="" />
+
+    <!-- For a private server, a list of players who can enter with any password. Works only for online accounts. -->
+    <white-list value="kimden" />
+
+    <!-- If true, all mobile peers get a corresponding icon into the name. -->
+    <expose-mobile value="true" />
+
+    <!-- Specifies how to count own goals: standard - last touching player is counted, no-own-goals - last touching player of scoring team is counted if existing, advanced - as standard for now. -->
+    <soccer-goals-policy value="standard" />
+
     <!-- If true this server will allow AI instance to be connected from anywhere. (other than LAN network only) -->
     <ai-anywhere value="false" />
 
+    <!-- If true, the server owner can kick players, either via the UI button or using /kick command. -->
+    <kicks-allowed value="true" />
+
 </server-config>
 
 ```
@@ -265,7 +349,12 @@ CREATE TABLE IF NOT EXISTS (table name above)
     os TEXT NOT NULL, -- Operating system of the host
     connected_time TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP, -- Time when connected
     disconnected_time TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP, -- Time when disconnected (saved when disconnected)
-    ping INTEGER UNSIGNED NOT NULL DEFAULT 0 -- Ping of the host
+    ping INTEGER UNSIGNED NOT NULL DEFAULT 0, -- Ping of the host
+    packet_loss INTEGER NOT NULL DEFAULT 0, -- Mean packet loss count from ENet (saved when disconnected)
+    addon_karts_count INTEGER UNSIGNED NOT NULL DEFAULT 0, -- Number of addon karts of the host
+    addon_tracks_count INTEGER UNSIGNED NOT NULL DEFAULT 0, -- Number of addon tracks of the host
+    addon_arenas_count INTEGER UNSIGNED NOT NULL DEFAULT 0, -- Number of addon arenas of the host
+    addon_soccers_count INTEGER UNSIGNED NOT NULL DEFAULT 0 -- Number of addon soccers of the host
 ) WITHOUT ROWID;
 ```
 
@@ -293,7 +382,7 @@ CREATE TABLE IF NOT EXISTS (table name above)
 
 If you want to see flags and readable names of countries in the above views, you need to initialize `v(server database version)_countries` table, check [this script](tools/generate-countries-table.py).
 
-For IPv4 and online ID ban list, player reports or IP mapping, you need to create one yourself:
+For IPv4 and online ID ban list, player reports or IP mapping (in case your server doesn't communicate with STK addons server, which can do IP mapping instead of your server), you need to create one yourself:
 ```sql
 CREATE TABLE ip_ban
 (
diff --git a/README.md b/README.md
index a29e33b138e..d8d4e84b4c0 100644
--- a/README.md
+++ b/README.md
@@ -1,40 +1,38 @@
-# SuperTuxKart
-[![Linux build status](https://github.com/supertuxkart/stk-code/actions/workflows/linux.yml/badge.svg)](https://github.com/supertuxkart/stk-code/actions/workflows/linux.yml)
-[![Apple build status](https://github.com/supertuxkart/stk-code/actions/workflows/apple.yml/badge.svg)](https://github.com/supertuxkart/stk-code/actions/workflows/apple.yml)
-[![Windows build status](https://github.com/supertuxkart/stk-code/actions/workflows/windows.yml/badge.svg)](https://github.com/supertuxkart/stk-code/actions/workflows/windows.yml)
-[![Switch build status](https://github.com/supertuxkart/stk-code/actions/workflows/switch.yml/badge.svg)](https://github.com/supertuxkart/stk-code/actions/workflows/switch.yml)
-[![#supertuxkart on the libera IRC network](https://img.shields.io/badge/libera-%23supertuxkart-brightgreen.svg)](https://web.libera.chat/?channels=#supertuxkart)
+[![Linux build status](https://github.com/kimden/stk-code/actions/workflows/linux.yml/badge.svg)](https://github.com/kimden/stk-code/actions/workflows/linux.yml)
+[![Apple build status](https://github.com/kimden/stk-code/actions/workflows/apple.yml/badge.svg)](https://github.com/kimden/stk-code/actions/workflows/apple.yml)
+[![Windows build status](https://github.com/kimden/stk-code/actions/workflows/windows.yml/badge.svg)](https://github.com/kimden/stk-code/actions/workflows/windows.yml)
+[![Switch build status](https://github.com/kimden/stk-code/actions/workflows/switch.yml/badge.svg)](https://github.com/kimden/stk-code/actions/workflows/switch.yml)
 
-SuperTuxKart is a free kart racing game. It focuses on fun and not on realistic kart physics. Instructions can be found on the in-game help page.
+This repository contains a **modified** version of SuperTuxKart (STK), mainly intended for server-side usage. Most important changes are listed [here](/FORK_CHANGES.md). Standard version of STK can be found [here](https://github.com/supertuxkart/stk-code/), and the changes between it and latest commits of this repo can be found [here](https://github.com/supertuxkart/stk-code/compare/master...kimden:stk-code:command-manager-prototype).
 
-The SuperTuxKart homepage can be found at <https://supertuxkart.net/>. There is also our [FAQ](https://supertuxkart.net/FAQ) and information on how get in touch with the [community](https://supertuxkart.net/Community).
+## Important branches
 
-Latest release binaries can be found [here](https://github.com/supertuxkart/stk-code/releases/latest), and preview release [here](https://github.com/supertuxkart/stk-code/releases/preview).
+* [master](https://github.com/kimden/stk-code/): contains an old but stable version, which cannot be suddenly broken by recent commits (as almost all of them are currently in `command-manager-prototype` branch).
 
-## Hardware Requirements
-To run SuperTuxKart, make sure that your computer's specifications are equal or higher than the following specifications:
+* [command-manager-prototype](https://github.com/kimden/stk-code/tree/command-manager-prototype): contains all the latest commits, starting from introduction of command manager. As there are too many commits already, it will be merged into `master` branch soon, but not before the long-term database structure and similar important things are defined.
 
-* A graphics card capable of 3D rendering - NVIDIA GeForce 470 GTX, AMD Radeon 6870 HD series card or Intel HD Graphics 4000 and newer. OpenGL >= 3.3
-* You should have a dual-core CPU that's running at 1 GHz or faster.
-* You'll need at least 512 MB of free VRAM (video memory).
-* System memory: 1 GB
-* Minimum disk space: 700 MB
-* Ideally, you'll want a joystick with at least 6 buttons.
+* [command-manager-2x](https://github.com/kimden/stk-code/tree/command-manager-2x): the branch combining `command-manager-prototype` and [BalanceSTK2](https://github.com/Alayan-stk-2/stk-code/tree/BalanceSTK2), which is currently the source code of 2.X development version. This branch might not have the latest commits, its purpose is to store game results while testing 2.X version.
 
-## License
-The software is released under the GNU General Public License (GPL) which can be found in the file [`COPYING`](/COPYING) in the same directory as this file.
+* [local-client](https://github.com/kimden/stk-code/tree/local-client): the version of client with some optimizations and edits, used by kimden. For now, this is the only branch of this repo that is really intended for client-side usage.
+
+There are also several less important branches.
 
 ---
 
-## 3D coordinates
-A reminder for those who are looking at the code and 3D models:
+The software is released under the GNU General Public License (GPL) which can be found in the file [`COPYING`](/COPYING) in the same directory as this file.
 
-SuperTuxKart: X right, Y up, Z forwards
+Building instructions can be found in [`INSTALL.md`](/INSTALL.md).
 
-Blender: X right, Y forwards, Z up
+Info on experimental anti-troll system can be found in [`ANTI_TROLL.md`](/ANTI_TROLL.md).
 
-The export utilities  perform the needed transformation, so in Blender you just work with the XY plane as ground, and things will appear fine in STK (using XZ as ground in the code, obviously).
+---
 
-## Building from source
+## About SuperTuxKart
 
-Building instructions can be found in [`INSTALL.md`](/INSTALL.md)
+[![#supertuxkart on the libera IRC network](https://img.shields.io/badge/libera-%23supertuxkart-brightgreen.svg)](https://web.libera.chat/?channels=#supertuxkart)
+
+SuperTuxKart is a free kart racing game. It focuses on fun and not on realistic kart physics. Instructions can be found on the in-game help page.
+
+The SuperTuxKart homepage can be found at <https://supertuxkart.net/>. There is also our [FAQ](https://supertuxkart.net/FAQ) and information on how get in touch with the [community](https://supertuxkart.net/Community).
+
+Latest release binaries can be found [here](https://github.com/supertuxkart/stk-code/releases/latest), and preview release [here](https://github.com/supertuxkart/stk-code/releases/preview).
diff --git a/data/stk_config.xml b/data/stk_config.xml
index 8f879af8092..7740f0d1661 100644
--- a/data/stk_config.xml
+++ b/data/stk_config.xml
@@ -186,7 +186,7 @@
                 new transform event is generated before maximum time.
         delta-steering If the steering angle difference exceeds this delta,
                 new transform event is generated before maximum time. -->
-  <replay max-frames="12000" delta-t="0.100"  delta-speed="0.6"
+  <replay max-frames="540000" delta-t="0.100"  delta-speed="0.6"
           delta-steering="0.26" />
 
   <!-- Special urls -->
@@ -259,7 +259,7 @@
            larger than this value.
   -->
   <networking steering-reduction="1.0"
-              max-moveable-objects="15"/>
+              max-moveable-objects="30"/>
 
   <!-- Camera
        The field of views for 1-4 player split screen. fov-3 is
diff --git a/src/items/bowling.cpp b/src/items/bowling.cpp
index 39c28ce31a7..639764d0033 100644
--- a/src/items/bowling.cpp
+++ b/src/items/bowling.cpp
@@ -26,6 +26,8 @@
 #include "karts/abstract_kart.hpp"
 #include "modes/linear_world.hpp"
 
+#include "network/protocols/server_lobby.hpp"
+
 #include "utils/log.hpp" //TODO: remove after debugging is done
 
 float Bowling::m_st_max_distance;   // maximum distance for a bowling ball to be attracted
@@ -154,12 +156,21 @@ bool Bowling::updateAndDelete(int ticks)
  */
 bool Bowling::hit(AbstractKart* kart, PhysicalObject* obj)
 {
+    auto sl = LobbyProtocol::get<ServerLobby>();
+    if (sl)
+        sl->setTeamMateHitOwner(getOwnerId(),m_ticks_since_thrown);
+
     bool was_real_hit = Flyable::hit(kart, obj);
-    if(was_real_hit)
+    if (was_real_hit)
     {
-        if(kart && kart->isShielded())
+        if (kart && kart->isShielded())
         {
             kart->decreaseShieldTime();
+            if (sl)
+            {
+                sl->registerTeamMateHit(kart->getWorldKartId());
+                sl->handleTeamMateHits();
+            }
             return true;
         }
         else
@@ -168,6 +179,8 @@ bool Bowling::hit(AbstractKart* kart, PhysicalObject* obj)
             explode(kart, obj, /*hit_secondary*/false);
         }
     }
+    if (sl)
+        sl->handleTeamMateHits();
     return was_real_hit;
 }   // hit
 
diff --git a/src/items/cake.cpp b/src/items/cake.cpp
index 8e09cff63fc..ba10bfb14d5 100644
--- a/src/items/cake.cpp
+++ b/src/items/cake.cpp
@@ -26,6 +26,8 @@
 #include "utils/constants.hpp"
 #include "utils/random_generator.hpp"
 
+#include "network/protocols/server_lobby.hpp"
+
 #include "utils/log.hpp" //TODO: remove after debugging is done
 
 float Cake::m_st_max_distance_squared;
@@ -61,17 +63,28 @@ void Cake::init(const XMLNode &node, scene::IMesh *cake_model)
  */
 bool Cake::hit(AbstractKart* kart, PhysicalObject* obj)
 {
+    auto sl = LobbyProtocol::get<ServerLobby>();
+    if (sl)
+        sl->setTeamMateHitOwner(getOwnerId());
+
     bool was_real_hit = Flyable::hit(kart, obj);
-    if(was_real_hit)
+    if (was_real_hit)
     {
-        if(kart && kart->isShielded())
+        if (kart && kart->isShielded())
         {
             kart->decreaseShieldTime();
+            if (sl)
+            {
+                sl->registerTeamMateHit(kart->getWorldKartId());
+                sl->handleTeamMateHits();
+            }
             return false; //Not sure if a shield hit is a real hit.
         }
         explode(kart, obj);
     }
 
+    if (sl)
+        sl->handleTeamMateHits();
     return was_real_hit;
 }   // hit
 
diff --git a/src/items/powerup.cpp b/src/items/powerup.cpp
index ef92cbd50e0..4ca2ef88793 100644
--- a/src/items/powerup.cpp
+++ b/src/items/powerup.cpp
@@ -38,6 +38,8 @@
 #include "utils/string_utils.hpp"
 #include "utils/log.hpp" //TODO: remove after debugging is done
 
+#include "network/protocols/server_lobby.hpp"
+
 //-----------------------------------------------------------------------------
 /** Constructor, stores the kart to which this powerup belongs.
  *  \param kart The kart to which this powerup belongs.
@@ -400,6 +402,11 @@ void Powerup::use()
             if(kart == m_kart) continue;
             if(kart->getPosition() == 1)
             {
+                // check if we are in team gp and hit a teammate and should punish the attacker
+                auto sl = LobbyProtocol::get<ServerLobby>();
+                if(sl && !kart->hasFinishedRace())
+                    sl->handleAnvilHit(m_kart->getWorldKartId(), kart->getWorldKartId());
+
                 kart->getAttachment()->set(Attachment::ATTACH_ANVIL,
                                            stk_config->
                                            time2Ticks(kp->getAnvilDuration()) );
diff --git a/src/items/powerup_manager.cpp b/src/items/powerup_manager.cpp
index 595f6b40a91..edab5f82b16 100644
--- a/src/items/powerup_manager.cpp
+++ b/src/items/powerup_manager.cpp
@@ -53,6 +53,7 @@ PowerupManager::PowerupManager()
         m_all_meshes[i] = NULL;
         m_all_icons[i]  = (Material*)NULL;
     }
+    m_config_file = "powerup.xml";
 }   // PowerupManager
 
 //-----------------------------------------------------------------------------
@@ -125,7 +126,7 @@ PowerupManager::PowerupType
  */
 void PowerupManager::loadPowerupsModels()
 {
-    const std::string file_name = file_manager->getAsset("powerup.xml");
+    const std::string file_name = file_manager->getAsset(m_config_file);
     XMLNode *root               = file_manager->createXMLTree(file_name);
     for(unsigned int i=0; i<root->getNumNodes(); i++)
     {
diff --git a/src/items/powerup_manager.hpp b/src/items/powerup_manager.hpp
index b7f61d8a251..b6070abff7b 100644
--- a/src/items/powerup_manager.hpp
+++ b/src/items/powerup_manager.hpp
@@ -158,11 +158,15 @@ class PowerupManager : public NoCopy
      *  for network games it will use the start time from server. */
     std::atomic<uint64_t> m_random_seed;
 
+    std::string m_config_file;
+
 public:
     static void unitTesting();
 
                   PowerupManager  ();
                  ~PowerupManager  ();
+    void          setFileName(std::string s)              { m_config_file = s; }
+    std::string   getFileName()                        { return m_config_file; }
     void          loadPowerupsModels ();
     void          loadWeights(const XMLNode *node, const std::string &category);
     void          unloadPowerups  ();
diff --git a/src/items/swatter.cpp b/src/items/swatter.cpp
index dabf8ec9d60..e7ced836672 100644
--- a/src/items/swatter.cpp
+++ b/src/items/swatter.cpp
@@ -43,6 +43,8 @@
 #include "network/network_string.hpp"
 #include "network/rewind_manager.hpp"
 
+#include "network/protocols/server_lobby.hpp"
+
 #define SWAT_POS_OFFSET        core::vector3df(0.0, 0.2f, -0.4f)
 #define SWAT_ANGLE_MIN  45
 #define SWAT_ANGLE_MAX  135
@@ -65,6 +67,8 @@ Swatter::Swatter(AbstractKart *kart, int16_t bomb_ticks, int ticks,
     m_animation_phase  = SWATTER_AIMING;
     m_discard_now      = false;
     m_closest_kart     = NULL;
+    m_has_hit_kart     = false;
+    m_created_ticks    = World::getWorld()->getTicksSinceStart();
     m_discard_ticks    = World::getWorld()->getTicksSinceStart() + ticks;
     m_bomb_remaining   = bomb_ticks;
     m_scene_node       = NULL;
@@ -396,10 +400,22 @@ void Swatter::squashThingsAround()
     float slowdown =  kp->getSwatterSquashSlowdown();
     // The squash attempt may fail because of invulnerability, shield, etc.
     // Making a bomb explode counts as a success
+    bool wasHit = !m_closest_kart->isInvulnerable() && !m_closest_kart->getKartAnimation();
     bool success = m_closest_kart->setSquash(duration, slowdown);
     const bool has_created_explosion_animation =
         success && m_closest_kart->getKartAnimation() != NULL;
 
+    // we can't use success here, because unshielding a kart is not considered a succes
+    // punishment system however, does consider it a hit
+    if (wasHit)
+    {
+        // check if we are in team gp and hit a teammate and should punish attacker
+        auto sl = LobbyProtocol::get<ServerLobby>();
+        if (sl && !m_closest_kart->hasFinishedRace())
+            sl->handleSwatterHit(m_kart->getWorldKartId(),
+                m_closest_kart->getWorldKartId(), success, m_has_hit_kart,
+                World::getWorld()->getTicksSinceStart() - m_created_ticks);
+    }
     if (success)
     {
         World::getWorld()->kartHit(m_closest_kart->getWorldKartId(),
@@ -424,6 +440,7 @@ void Swatter::squashThingsAround()
                 PlayerManager::increaseAchievement(AchievementsStatus::ALL_HITS_1RACE, 1);
             }
         }
+        m_has_hit_kart = true;
     }
 
     if (!GUIEngine::isNoGraphics() && has_created_explosion_animation &&
diff --git a/src/items/swatter.hpp b/src/items/swatter.hpp
index f3c11cfcea7..e25c2755ad0 100644
--- a/src/items/swatter.hpp
+++ b/src/items/swatter.hpp
@@ -72,6 +72,8 @@ class Swatter : public NoCopy, public AttachmentPlugin
     scene::IAnimatedMeshSceneNode *m_bomb_scene_node;
 
     int                m_discard_ticks;
+    int                m_created_ticks;
+    bool               m_has_hit_kart;
 
     int                m_swatter_duration;
 
diff --git a/src/karts/explosion_animation.cpp b/src/karts/explosion_animation.cpp
index d3e09aa5756..8b8040297fd 100644
--- a/src/karts/explosion_animation.cpp
+++ b/src/karts/explosion_animation.cpp
@@ -28,6 +28,7 @@
 #include "modes/follow_the_leader.hpp"
 #include "network/network_string.hpp"
 #include "network/protocols/client_lobby.hpp"
+#include "network/protocols/server_lobby.hpp"
 #include "race/race_manager.hpp"
 #include "tracks/track.hpp"
 #include "utils/mini_glm.hpp"
@@ -55,9 +56,13 @@ ExplosionAnimation *ExplosionAnimation::create(AbstractKart *kart,
     // Ignore explosion that are too far away.
     if(!direct_hit && pos.distance2(kart->getXYZ())>r*r) return NULL;
 
+    auto sl = LobbyProtocol::get<ServerLobby>();
+
     if(kart->isShielded())
     {
         kart->decreaseShieldTime();
+        if (sl)
+            sl->registerTeamMateHit(kart->getWorldKartId());
         return NULL;
     }
 
@@ -69,6 +74,8 @@ ExplosionAnimation *ExplosionAnimation::create(AbstractKart *kart,
             ftl_world->leaderHit();
     }
 
+    if (sl)
+        sl->registerTeamMateExplode(kart->getWorldKartId());
     return new ExplosionAnimation(kart, direct_hit);
 }   // create
 
diff --git a/src/main.cpp b/src/main.cpp
index caf9f5b5917..badd21b1f7b 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -2316,7 +2316,11 @@ int main(int argc, char *argv[])
             material_manager->addSharedMaterial(materials_file);
         }
         Referee::init();
+
+        if (CommandLine::has("--powerup-file", &s))
+            powerup_manager->setFileName(s);
         powerup_manager->loadPowerupsModels();
+
         ItemManager::loadDefaultItemMeshes();
 
         GUIEngine::addLoadingIcon( irr_driver->getTexture(FileManager::GUI_ICON,
diff --git a/src/main_loop.cpp b/src/main_loop.cpp
index 3a413f3fe26..2137c7b041b 100644
--- a/src/main_loop.cpp
+++ b/src/main_loop.cpp
@@ -603,6 +603,22 @@ void MainLoop::run()
                     PROFILER_POP_CPU_MARKER();
                 }
             }
+            else
+            {
+                if (World::getWorld())
+                {
+                    // test if player is driving backward
+                    float frame_duration = num_steps * dt;
+                    LinearWorld *lin_world = dynamic_cast<LinearWorld*>(World::getWorld());
+                    if (lin_world && lin_world->getTicksSinceStart() > 0)
+                    {
+                        for (unsigned int i = 0; i < lin_world->getNumKarts(); i++)
+                        {
+                            lin_world->serverCheckForWrongDirection(i,frame_duration);
+                        }
+                    }
+                }
+            }
             // Some protocols in network will use RequestManager
             if (!m_download_assets)
             {
diff --git a/src/modes/linear_world.cpp b/src/modes/linear_world.cpp
index 64d7da984a9..d29a36d9aa5 100644
--- a/src/modes/linear_world.cpp
+++ b/src/modes/linear_world.cpp
@@ -1103,6 +1103,75 @@ void LinearWorld::checkForWrongDirection(unsigned int i, float dt)
     
 }   // checkForWrongDirection
 
+//-----------------------------------------------------------------------------
+/** Checks if a kart is going in the wrong direction.
+ *  This is the online server only version to kick players
+ *  who misbehave.
+ *  \param i Kart id.
+ *  \param dt Time step size.
+ */
+void LinearWorld::serverCheckForWrongDirection(unsigned int i, float dt)
+{
+    KartInfo &ki = m_kart_info[i];
+
+    const AbstractKart *kart=m_karts[i].get();
+    // If the kart can go in more than one directions from the current track
+    // don't do any reverse message handling, since it is likely that there
+    // will be one direction in which it isn't going backwards anyway.
+    int sector = getTrackSector(i)->getCurrentGraphNode();
+
+    if (DriveGraph::get()->getNumberOfSuccessors(sector) > 1)
+        return;
+
+    // check if the player is going in the wrong direction
+    const DriveNode* node = DriveGraph::get()->getNode(sector);
+    Vec3 center_line = node->getUpperCenter() - node->getLowerCenter();
+    float angle_diff = kart->getVelocity().angle(center_line);
+
+    if (angle_diff > M_PI)
+        angle_diff -= 2*M_PI;
+    else if (angle_diff < -M_PI)
+        angle_diff += 2*M_PI;
+
+    // if the kart is going back way, i.e. if angle
+    // is too big(unless the kart has already finished the race).
+    // record how long this happens
+    if ((angle_diff > DEGREE_TO_RAD * 120.0f ||
+        angle_diff < -DEGREE_TO_RAD * 120.0f) &&
+        kart->getVelocityLC().getY() > 0.0f &&
+        !kart->hasFinishedRace())
+    {
+        ki.m_wrong_way_timer += dt;
+    }
+    else
+    {
+        if (!kart->hasFinishedRace() && !kart->getKartAnimation())
+        {
+            if (kart->getSpeed() < ServerConfig::m_troll_max_stop_speed)
+                // stopping is also trolling
+                ki.m_wrong_way_timer += dt;
+            else if(kart->getSpeed() > ServerConfig::m_troll_min_normal_speed)
+            {
+                // racing normally reduces timer
+                ki.m_wrong_way_timer -= dt;
+                if (ki.m_wrong_way_timer < 0)
+                    ki.m_wrong_way_timer = 0;
+            }
+        }
+    }
+
+    // If a kart is going wrong way for too long, take action
+    if (ki.m_warn_level == 0 && ki.m_wrong_way_timer > ServerConfig::m_troll_warning_time)
+    {   // warning
+        ki.m_warn_level = 1;
+        ki.m_wrong_way_timer = 0;
+    }
+    if (ki.m_warn_level == 1 && ki.m_wrong_way_timer > ServerConfig::m_troll_kick_time)
+    {   // kick
+        ki.m_warn_level = 2;
+    }
+}   // serverCheckForWrongDirection
+
 //-----------------------------------------------------------------------------
 void LinearWorld::setLastTriggeredCheckline(unsigned int kart_index, int index)
 {
diff --git a/src/modes/linear_world.hpp b/src/modes/linear_world.hpp
index ae0430c5fa1..b4c9b1b66f6 100644
--- a/src/modes/linear_world.hpp
+++ b/src/modes/linear_world.hpp
@@ -104,6 +104,9 @@ class LinearWorld : public WorldWithRank
          *  direction so that a message can be displayed. */
         float       m_wrong_way_timer;
 
+        int         m_warn_level;
+        int         m_warn_issued;
+
         /** Initialises all fields. */
         KartInfo()  { reset(); }
         // --------------------------------------------------------------------
@@ -116,6 +119,8 @@ class LinearWorld : public WorldWithRank
             m_estimated_finish  = -1.0f;
             m_overall_distance  = 0.0f;
             m_wrong_way_timer   = 0.0f;
+            m_warn_level        = 0;
+            m_warn_issued       = 0;
         }   // reset
         // --------------------------------------------------------------------
         void saveCompleteState(BareNetworkString* bns);
@@ -192,6 +197,17 @@ class LinearWorld : public WorldWithRank
     {
         return m_kart_info[kart_index].m_overall_distance;
     }   // getOverallDistance
+    /** Returns the warn level
+     *  \param kart_index World kart id of the kart. */
+    int getWarnLevel(unsigned int kart_index)
+    {
+        if (m_kart_info[kart_index].m_warn_level > m_kart_info[kart_index].m_warn_issued)
+        {
+            m_kart_info[kart_index].m_warn_issued = m_kart_info[kart_index].m_warn_level;
+            return m_kart_info[kart_index].m_warn_level;
+        }
+        return 0;
+    }   // getWarnLevel
     // ------------------------------------------------------------------------
     /** Returns time for the fastest laps */
     float getFastestLap() const
@@ -237,6 +253,8 @@ class LinearWorld : public WorldWithRank
     // ------------------------------------------------------------------------
     void handleServerCheckStructureCount(unsigned count);
     // ------------------------------------------------------------------------
+    void serverCheckForWrongDirection(unsigned int i, float dt);
+    // ------------------------------------------------------------------------
     virtual bool showLapsTarget() OVERRIDE { return true; }
 };   // LinearWorld
 
diff --git a/src/modes/soccer_world.cpp b/src/modes/soccer_world.cpp
index 1144ef113ea..d692ae35702 100644
--- a/src/modes/soccer_world.cpp
+++ b/src/modes/soccer_world.cpp
@@ -247,6 +247,12 @@ SoccerWorld::SoccerWorld() : WorldWithRank()
         WorldStatus::setClockMode(CLOCK_CHRONO);
     }
 
+    stopped = false;
+    m_explicit_stop = false;
+    m_bad_red_goals = 0;
+    m_bad_blue_goals = 0;
+    m_init_red_goals = 0;
+    m_init_blue_goals = 0;
     m_frame_count = 0;
     m_use_highscores = false;
     m_red_ai = 0;
@@ -282,6 +288,13 @@ void SoccerWorld::init()
     m_goal_target  = RaceManager::get()->getMaxGoal();
     m_goal_sound   = SFXManager::get()->createSoundSource("goal_scored");
 
+
+    m_red_ball_hitter = -1;
+    m_blue_ball_hitter = -1;
+    m_red_hit_ticks = -1;
+    m_blue_hit_ticks = -1;
+    m_scoring_policy = GoalScoringPolicy::STANDARD;
+
     Track *track = Track::getCurrentTrack();
     if (track->hasNavMesh())
     {
@@ -380,6 +393,9 @@ void SoccerWorld::reset(bool restart)
 //-----------------------------------------------------------------------------
 void SoccerWorld::onGo()
 {
+    Log::info("SoccerWorld", "SoccerMatchLog: The game starts now.");
+    Log::info("SoccerWorld", "SoccerMatchLog: The arena is %s",
+        RaceManager::get()->getTrackName().c_str());
     m_ball->setEnabled(true);
     m_ball->reset();
     WorldWithRank::onGo();
@@ -423,6 +439,20 @@ void SoccerWorld::update(int ticks)
     WorldWithRank::update(ticks);
     WorldWithRank::updateTrack(ticks);
 
+    // if (stopped)
+    // {
+    //     for (unsigned int i = 0; i < m_karts.size(); i++)
+    //     {
+    //         auto& kart = m_karts[i];
+    //         if (kart->isEliminated())
+    //             continue;
+    //         kart->getBody()->setLinearVelocity(Vec3(0.0f));
+    //         kart->getBody()->setAngularVelocity(Vec3(0.0f));
+    //         kart->getBody()->proceedToTransform(m_goal_transforms[i]);
+    //         kart->setTrans(m_goal_transforms[i]);
+    //     }
+    // }
+
     if (isGoalPhase())
     {
         for (unsigned int i = 0; i < m_karts.size(); i++)
@@ -495,26 +525,67 @@ void SoccerWorld::onCheckGoalTriggered(bool first_goal)
         }
 
         ScorerData sd = {};
-        sd.m_id = m_ball_hitter;
-        sd.m_correct_goal = isCorrectGoal(m_ball_hitter, first_goal);
-        sd.m_kart = getKart(m_ball_hitter)->getIdent();
-        sd.m_player = getKart(m_ball_hitter)->getController()
-            ->getName(false/*include_handicap_string*/);
-        sd.m_handicap_level = getKart(m_ball_hitter)->getHandicap();
-        if (RaceManager::get()->getKartGlobalPlayerId(m_ball_hitter) > -1)
+
+        if (m_scoring_policy == GoalScoringPolicy::STANDARD)
         {
-            sd.m_country_code =
-                RaceManager::get()->getKartInfo(m_ball_hitter).getCountryCode();
+            sd.m_id = m_ball_hitter;
         }
-        if (sd.m_correct_goal)
+        else if (m_scoring_policy == GoalScoringPolicy::NO_OWN_GOALS)
+        {
+            int hitter = (first_goal ? m_red_ball_hitter : m_blue_ball_hitter);
+            if (hitter < 0)
+                hitter = m_ball_hitter;
+            sd.m_id = hitter;
+        }
+        else if (m_scoring_policy == GoalScoringPolicy::ADVANCED)
+        {
+            // will be changed when we come up with something better
+            sd.m_id = m_ball_hitter;
+        }
+        m_red_hit_ticks = -1;
+        m_blue_hit_ticks = -1;
+        m_red_ball_hitter = -1;
+        m_blue_ball_hitter = -1;
+        sd.m_correct_goal = isCorrectGoal(sd.m_id, first_goal);
+        sd.m_kart = getKart(sd.m_id)->getIdent();
+        sd.m_player = getKart(sd.m_id)->getController()
+            ->getName(false/*include_handicap_string*/);
+        sd.m_handicap_level = getKart(sd.m_id)->getHandicap();
+        if (RaceManager::get()->getKartGlobalPlayerId(sd.m_id) > -1)
         {
-            m_karts[m_ball_hitter]->getKartModel()
-                ->setAnimation(KartModel::AF_WIN_START, true/* play_non_loop*/);
+            sd.m_country_code =
+                RaceManager::get()->getKartInfo(sd.m_id).getCountryCode();
         }
-        else if (!sd.m_correct_goal)
+        std::string team_name = (first_goal ? "red team" : "blue team");
+        std::string player_name = StringUtils::wideToUtf8(sd.m_player);
+        // if (!stopped)
+        // {
+            if (sd.m_correct_goal)
+            {
+                if (!stopped)
+                    Log::info("SoccerWorld", "SoccerMatchLog: [Goal] %s scored a goal for %s",
+                        player_name.c_str(), team_name.c_str());
+                m_karts[sd.m_id]->getKartModel()
+                    ->setAnimation(KartModel::AF_WIN_START, true/* play_non_loop*/);
+            }
+            else if (!sd.m_correct_goal)
+            {
+                if (!stopped)
+                    Log::info("SoccerWorld", "SoccerMatchLog: [Goal] %s scored an own goal for %s",
+                        player_name.c_str(), team_name.c_str());
+                m_karts[sd.m_id]->getKartModel()
+                    ->setAnimation(KartModel::AF_LOSE_START, true/* play_non_loop*/);
+            }
+        // }
+
+        if (stopped)
         {
-            m_karts[m_ball_hitter]->getKartModel()
-                ->setAnimation(KartModel::AF_LOSE_START, true/* play_non_loop*/);
+            if (first_goal)
+                ++m_bad_red_goals;
+            else
+                ++m_bad_blue_goals;
+            player_name += " (not counted)";
+            sd.m_player = StringUtils::utf8ToWide(player_name);
         }
 
 #ifndef SERVER_ONLY
@@ -542,7 +613,8 @@ void SoccerWorld::onCheckGoalTriggered(bool first_goal)
                 sd.m_time = getTime();
             // Notice: true first_goal means it's blue goal being shoot,
             // so red team can score
-            m_red_scorers.push_back(sd);
+            // if (!stopped)
+                m_red_scorers.push_back(sd);
         }
         else
         {
@@ -552,7 +624,8 @@ void SoccerWorld::onCheckGoalTriggered(bool first_goal)
             }
             else
                 sd.m_time = getTime();
-            m_blue_scorers.push_back(sd);
+            // if (!stopped)
+                m_blue_scorers.push_back(sd);
         }
         if (NetworkConfig::get()->isNetworking() &&
             NetworkConfig::get()->isServer())
@@ -568,6 +641,7 @@ void SoccerWorld::onCheckGoalTriggered(bool first_goal)
             NetworkString p_1_1 = p;
             p_1_1.encodeString(sd.m_country_code)
                 .addUInt8(sd.m_handicap_level);
+
             auto peers = STKHost::get()->getPeers();
             for (auto& peer : peers)
             {
@@ -584,6 +658,9 @@ void SoccerWorld::onCheckGoalTriggered(bool first_goal)
                     }
                 }
             }
+
+            // if you tell me how to make ServerLobby send that, i'd be glad
+            tellCountIfDiffers();
         }
     }
     for (unsigned i = 0; i < m_karts.size(); i++)
@@ -593,6 +670,13 @@ void SoccerWorld::onCheckGoalTriggered(bool first_goal)
         kart->getBody()->setAngularVelocity(Vec3(0.0f));
         m_goal_transforms[i] = kart->getBody()->getWorldTransform();
     }
+    // if (stopped)
+    // {
+    //     m_red_scorers = m_backup_red_scorers;
+    //     m_blue_scorers = m_backup_blue_scorers;
+    //     m_reset_ball_ticks = m_backup_reset_ball_ticks;
+    //     m_ticks_back_to_own_goal = m_backup_ticks_back_to_own_goal;
+    // }
 }   // onCheckGoalTriggered
 
 //-----------------------------------------------------------------------------
@@ -727,6 +811,17 @@ void SoccerWorld::resetKartsToSelfGoals()
 void SoccerWorld::setBallHitter(unsigned int kart_id)
 {
     m_ball_hitter = kart_id;
+    KartTeam team = getKartTeam(kart_id);
+    if (team == KART_TEAM_RED)
+    {
+        m_red_ball_hitter = kart_id;
+        m_red_hit_ticks = m_time_ticks;
+    }
+    else if (team == KART_TEAM_BLUE)
+    {
+        m_blue_ball_hitter = kart_id;
+        m_blue_hit_ticks = m_time_ticks;
+    }
 }   // setBallHitter
 
 //-----------------------------------------------------------------------------
@@ -734,7 +829,7 @@ void SoccerWorld::setBallHitter(unsigned int kart_id)
  */
 bool SoccerWorld::isRaceOver()
 {
-    if (m_unfair_team)
+    if (m_unfair_team || m_explicit_stop)
         return true;
 
     if (RaceManager::get()->hasTimeTarget())
@@ -744,8 +839,10 @@ bool SoccerWorld::isRaceOver()
     // One team scored the target goals ...
     else
     {
-        return (getScore(KART_TEAM_BLUE) >= m_goal_target ||
-            getScore(KART_TEAM_RED) >= m_goal_target);
+        return (getScore(KART_TEAM_BLUE) + m_init_blue_goals
+            - m_bad_blue_goals >= m_goal_target ||
+            getScore(KART_TEAM_RED) + m_init_red_goals
+            - m_bad_red_goals >= m_goal_target);
     }
 
 }   // isRaceOver
@@ -1163,3 +1260,70 @@ void SoccerWorld::getKartsDisplayInfo(
         }
     }
 }   // getKartsDisplayInfo
+// ----------------------------------------------------------------------------
+
+void SoccerWorld::stop()
+{
+    stopped = true;
+    Log::info("SoccerWorld", "The game is stopped.");
+
+    m_backup_red_scorers = m_red_scorers;
+    m_backup_blue_scorers = m_blue_scorers;
+    m_backup_reset_ball_ticks = m_reset_ball_ticks;
+    m_backup_ticks_back_to_own_goal = m_ticks_back_to_own_goal;
+
+    // resetKartsToSelfGoals();
+    // if (UserConfigParams::m_arena_ai_stats)
+    //     getKart(8)->flyUp();
+}   // stop
+// ----------------------------------------------------------------------------
+
+void SoccerWorld::resume()
+{
+    stopped = false;
+    Log::info("SoccerWorld", "The game is resumed.");
+
+    // m_red_scorers = m_backup_red_scorers;
+    // m_blue_scorers = m_backup_blue_scorers;
+    // m_reset_ball_ticks = m_backup_reset_ball_ticks;
+    // m_ticks_back_to_own_goal = m_backup_ticks_back_to_own_goal;
+}   // resume
+// ----------------------------------------------------------------------------
+
+void SoccerWorld::setInitialCount(int red, int blue)
+{
+    m_init_red_goals = red;
+    m_init_blue_goals = blue;
+}   // setInitialCount
+// ----------------------------------------------------------------------------
+
+void SoccerWorld::tellCount() const
+{
+    auto peers = STKHost::get()->getPeers();
+    NetworkString* chat = new NetworkString(PROTOCOL_LOBBY_ROOM);
+    chat->addUInt8(17); // LE_CHAT
+    chat->setSynchronous(true);
+    int real_red = (int)m_red_scorers.size() - m_bad_red_goals
+        + m_init_red_goals;
+    int real_blue = (int)m_blue_scorers.size() - m_bad_blue_goals
+        + m_init_blue_goals;
+    std::string real_count =
+        std::to_string(real_red) + " : " + std::to_string(real_blue);
+    chat->encodeString16(StringUtils::utf8ToWide(real_count));
+    for (auto& peer : peers)
+        if (peer->isValidated() && !peer->isWaitingForGame())
+            peer->sendPacket(chat, true/*reliable*/);
+
+    delete chat;
+}   // tellCount
+// ----------------------------------------------------------------------------
+
+void SoccerWorld::tellCountIfDiffers() const
+{
+    if (m_init_red_goals - m_bad_red_goals != 0 ||
+        m_init_blue_goals - m_bad_blue_goals != 0)
+    {
+        tellCount();
+    }
+}   // tellCountIfDiffers
+// ----------------------------------------------------------------------------
diff --git a/src/modes/soccer_world.hpp b/src/modes/soccer_world.hpp
index ab5855ef17c..5135a6ddcd4 100644
--- a/src/modes/soccer_world.hpp
+++ b/src/modes/soccer_world.hpp
@@ -44,7 +44,7 @@ class SoccerWorld : public WorldWithRank
     {
         /** World ID of kart which scores. */
         unsigned int  m_id;
-        /** Whether this goal is socred correctly (identify for own goal). */
+        /** Whether this goal is scored correctly (identify for own goal). */
         bool          m_correct_goal;
         /** Time goal. */
         float         m_time;
@@ -97,6 +97,20 @@ class SoccerWorld : public WorldWithRank
     int m_ball_invalid_timer;
     int m_ball_hitter;
 
+    int m_red_hit_ticks;
+    int m_blue_hit_ticks;
+
+    int m_red_ball_hitter;
+    int m_blue_ball_hitter;
+
+    enum GoalScoringPolicy {
+        STANDARD = 0,
+        NO_OWN_GOALS = 1,
+        ADVANCED = 2
+    };
+
+    GoalScoringPolicy m_scoring_policy;
+
     /** Goals data of each team scored */
     std::vector<ScorerData> m_red_scorers;
     std::vector<ScorerData> m_blue_scorers;
@@ -108,6 +122,8 @@ class SoccerWorld : public WorldWithRank
 
     std::vector<int> m_team_icon_draw_id;
 
+    bool stopped;
+
     std::vector<btTransform> m_goal_transforms;
     /** Function to update the location the ball on the polygon map */
     void updateBallPosition(int ticks);
@@ -125,6 +141,18 @@ class SoccerWorld : public WorldWithRank
 
     void resetKartsToSelfGoals();
 
+
+    std::vector<ScorerData> m_backup_red_scorers;
+    std::vector<ScorerData> m_backup_blue_scorers;
+    int m_backup_reset_ball_ticks;
+    int m_backup_ticks_back_to_own_goal;
+
+    bool m_explicit_stop;
+    int m_bad_red_goals;
+    int m_bad_blue_goals;
+    int m_init_red_goals;
+    int m_init_blue_goals;
+
 public:
 
     SoccerWorld();
@@ -250,6 +278,23 @@ class SoccerWorld : public WorldWithRank
     AbstractKart* getKartAtDrawingPosition(unsigned int p) const OVERRIDE
                                 { return getKart(m_team_icon_draw_id[p - 1]); }
     // ------------------------------------------------------------------------
+    void setGoalScoringPolicy(int value)
+                                { m_scoring_policy = (GoalScoringPolicy)value;}
+    // ------------------------------------------------------------------------
+    void stop();
+    // ------------------------------------------------------------------------
+    void resume();
+    // ------------------------------------------------------------------------
+    void allToLobby() { m_explicit_stop = true; }
+    // ------------------------------------------------------------------------
+    void setInitialCount(int red, int blue);
+    // ------------------------------------------------------------------------
+    void tellCount() const;
+    // ------------------------------------------------------------------------
+    void tellCountIfDiffers() const;
+    // ------------------------------------------------------------------------
+    bool getStopped() { return stopped; }
+    // ------------------------------------------------------------------------
     TrackObject* getBall() const { return m_ball; }
 };   // SoccerWorld
 
diff --git a/src/modes/world_with_rank.cpp b/src/modes/world_with_rank.cpp
index 30bfee10f93..66bb02c0720 100644
--- a/src/modes/world_with_rank.cpp
+++ b/src/modes/world_with_rank.cpp
@@ -50,7 +50,10 @@ void WorldWithRank::init()
     m_position_used.resize(m_karts.size());
     m_position_setting_initialised = false;
 #endif
-    stk_config->getAllScores(&m_score_for_position, getNumKarts());
+    if (!m_custom_scoring)
+        stk_config->getAllScores(&m_score_for_position, getNumKarts());
+    else
+        refreshCustomScores(getNumKarts());
 
     Track *track = Track::getCurrentTrack();
     // Don't init track sector if navmesh is not found in arena
@@ -59,7 +62,6 @@ void WorldWithRank::init()
 
     for (unsigned int i = 0; i < m_karts.size(); i++)
         m_kart_track_sector.push_back(new TrackSector());
-
 }   // init
 
 //-----------------------------------------------------------------------------
@@ -213,9 +215,14 @@ unsigned int WorldWithRank::getRescuePositionIndex(AbstractKart *kart)
  */
 int WorldWithRank::getScoreForPosition(int p)
 {
-    assert(p-1 >= 0);
-    assert(p - 1 <(int) m_score_for_position.size());
-    return m_score_for_position[p - 1];
+    assert(p - 1 >= 0);
+    assert(p - 1 < (int)m_score_for_position.size());
+    if (!m_custom_scoring)
+        return m_score_for_position[p - 1];
+    else
+    {
+        return m_score_for_position[p - 1]; // oh really?
+    }
 }   // getScoreForPosition
 
 //-----------------------------------------------------------------------------
@@ -260,3 +267,53 @@ void WorldWithRank::updateSectorForKarts()
             getTrackSector(i)->update(m_karts[i]->getXYZ());
     }
 }   // updateSectorForKarts
+//-----------------------------------------------------------------------------
+
+void WorldWithRank::setCustomScoringSystem(std::string& type, std::vector<int>& params)
+{
+    m_custom_scoring = true;
+    m_custom_scoring_type = type;
+    m_custom_scoring_params = params;
+    refreshCustomScores(getNumKarts());
+}   // setCustomScoringSystem
+//-----------------------------------------------------------------------------
+
+void WorldWithRank::refreshCustomScores(int num_karts)
+{
+    if (m_custom_scoring_type == "inc")
+    {
+        m_score_for_position.clear();
+        for (unsigned i = 2; i < m_custom_scoring_params.size(); i++)
+            m_score_for_position.push_back(m_custom_scoring_params[i]);
+        sort(m_score_for_position.begin(), m_score_for_position.end());
+        for (unsigned i = 1; i < m_score_for_position.size(); i++)
+            m_score_for_position[i] += m_score_for_position[i - 1];
+        reverse(m_score_for_position.begin(), m_score_for_position.end());
+        m_score_for_position.resize(num_karts, 0);
+    }
+    else if (m_custom_scoring_type == "fixed")
+    {
+
+        m_score_for_position.clear();
+        for (unsigned i = 2; i < m_custom_scoring_params.size(); i++)
+            m_score_for_position.push_back(m_custom_scoring_params[i]);
+        m_score_for_position.resize(num_karts, 0);
+    }
+}   // refreshCustomScores
+//-----------------------------------------------------------------------------
+
+int WorldWithRank::getFastestLapPoints() const
+{
+    if (!m_custom_scoring)
+        return 0;
+    return m_custom_scoring_params[1];
+}   // getFastestLapPoints
+//-----------------------------------------------------------------------------
+
+int WorldWithRank::getPolePoints() const
+{
+    if (!m_custom_scoring)
+        return 0;
+    return m_custom_scoring_params[0];
+}   // getPolePoints
+//-----------------------------------------------------------------------------
\ No newline at end of file
diff --git a/src/modes/world_with_rank.hpp b/src/modes/world_with_rank.hpp
index 3b6f7e87def..919f4cc20f6 100644
--- a/src/modes/world_with_rank.hpp
+++ b/src/modes/world_with_rank.hpp
@@ -48,6 +48,12 @@ class WorldWithRank : public World
      *  0 based, so using race-position - 1. */
     std::vector<int> m_score_for_position;
 
+    bool m_custom_scoring;
+
+    std::vector<int> m_custom_scoring_params;
+
+    std::string m_custom_scoring_type;
+
 #ifdef DEBUG
     /** Used for debugging to help detect if the same kart position
      *  is used more than once. */
@@ -68,7 +74,9 @@ class WorldWithRank : public World
     void updateSectorForKarts();
 
 public:
-                  WorldWithRank() : World() {}
+                  WorldWithRank() : World() {
+                       m_custom_scoring = false;
+                  }
     virtual      ~WorldWithRank();
     /** call just after instanciating. can't be moved to the contructor as child
         classes must be instanciated, otherwise polymorphism will fail and the
@@ -101,7 +109,15 @@ class WorldWithRank : public World
     bool isOnRoad(unsigned int kart_index) const;
     // ------------------------------------------------------------------------
     int getSectorForKart(const AbstractKart *kart) const;
-
+    // ------------------------------------------------------------------------
+    void setCustomScoringSystem(std::string& type, std::vector<int>& params);
+    // ------------------------------------------------------------------------
+    void refreshCustomScores(int num_karts);
+    // ------------------------------------------------------------------------
+    int getFastestLapPoints() const;
+    // ------------------------------------------------------------------------
+    int getPolePoints() const;
+    // ------------------------------------------------------------------------
 };   // WorldWithRank
 
 #endif
diff --git a/src/network/game_setup.cpp b/src/network/game_setup.cpp
index 2b80a9f577f..6342c0d1744 100644
--- a/src/network/game_setup.cpp
+++ b/src/network/game_setup.cpp
@@ -41,30 +41,13 @@
 //-----------------------------------------------------------------------------
 GameSetup::GameSetup()
 {
-    const std::string& motd = ServerConfig::m_motd;
-    if (motd.find(".txt") != std::string::npos)
-    {
-        const std::string& path = ServerConfig::getConfigDirectory() + "/" +
-            motd;
-        std::ifstream message(FileUtils::getPortableReadingPath(path));
-        if (message.is_open())
-        {
-            for (std::string line; std::getline(message, line); )
-            {
-                m_message_of_today += StringUtils::utf8ToWide(line).trim() +
-                    L"\n";
-            }
-            // Remove last newline
-            m_message_of_today.erase(m_message_of_today.size() - 1);
-        }
-    }
-    else if (!motd.empty())
-        m_message_of_today = StringUtils::xmlDecode(motd);
-
+    m_message_of_today = readOrLoadFromFile
+        ((std::string) ServerConfig::m_motd);
     const std::string& server_name = ServerConfig::m_server_name;
     m_server_name_utf8 = StringUtils::wideToUtf8
         (StringUtils::xmlDecode(server_name));
     m_extra_server_info = -1;
+    m_extra_seconds = 0.0f;
     m_is_grand_prix.store(false);
     reset();
 }   // GameSetup
@@ -96,12 +79,12 @@ void GameSetup::loadWorld()
             if (isSoccerGoalTarget())
                 RaceManager::get()->setMaxGoal(m_laps);
             else
-                RaceManager::get()->setTimeTarget((float)m_laps * 60.0f);
+                RaceManager::get()->setTimeTarget((float)m_laps * 60.0f - m_extra_seconds);
         }
         else
         {
             RaceManager::get()->setHitCaptureTime(m_hit_capture_limit,
-                m_battle_time_limit);
+                m_battle_time_limit - m_extra_seconds);
         }
         RaceManager::get()->startSingleRace(m_tracks.back(), -1,
             false/*from_overworld*/);
@@ -165,12 +148,13 @@ void GameSetup::addServerInfo(NetworkString* ns)
 
 //-----------------------------------------------------------------------------
 void GameSetup::sortPlayersForGrandPrix(
-    std::vector<std::shared_ptr<NetworkPlayerProfile> >& players) const
+    std::vector<std::shared_ptr<NetworkPlayerProfile> >& players,
+    bool shuffle_instead) const
 {
     if (!isGrandPrix())
         return;
 
-    if (m_tracks.size() == 1)
+    if (m_tracks.size() == 1 || shuffle_instead)
     {
         std::random_device rd;
         std::mt19937 g(rd());
@@ -212,9 +196,35 @@ void GameSetup::sortPlayersForGame(
 }   // sortPlayersForGame
 
 // ----------------------------------------------------------------------------
-void GameSetup::setRace(const PeerVote &vote)
+void GameSetup::setRace(const PeerVote &vote, float extra_seconds)
 {
     m_tracks.push_back(vote.m_track_name);
     m_laps = vote.m_num_laps;
     m_reverse = vote.m_reverse;
+    m_extra_seconds = extra_seconds;
 }   // setRace
+// ----------------------------------------------------------------------------
+irr::core::stringw GameSetup::readOrLoadFromFile(std::string value)
+{
+    const std::string& temp = value;
+    irr::core::stringw answer;
+    if (temp.find(".txt") != std::string::npos)
+    {
+        const std::string& path = ServerConfig::getConfigDirectory() + "/" +
+            temp;
+        std::ifstream message(FileUtils::getPortableReadingPath(path));
+        if (message.is_open())
+        {
+            for (std::string line; std::getline(message, line); )
+            {
+                answer += StringUtils::utf8ToWide(line).trim() +
+                    L"\n";
+            }
+            // Remove last newline
+            answer.erase(answer.size() - 1);
+        }
+    }
+    else if (!temp.empty())
+        answer = StringUtils::xmlDecode(temp);
+    return answer;
+}
diff --git a/src/network/game_setup.hpp b/src/network/game_setup.hpp
index 39e86b887cd..a539acb50d3 100644
--- a/src/network/game_setup.hpp
+++ b/src/network/game_setup.hpp
@@ -61,13 +61,15 @@ class GameSetup
     /** Utf8 server name (with xml decoded) */
     std::string m_server_name_utf8;
 
+    float m_extra_seconds;
+
 public:
     // ------------------------------------------------------------------------
     GameSetup();
     // ------------------------------------------------------------------------
     ~GameSetup() {}
     // ------------------------------------------------------------------------
-    void setRace(const PeerVote &vote);
+    void setRace(const PeerVote &vote, float extra_seconds = 0.0f);
     // ------------------------------------------------------------------------
     void reset()
     {
@@ -125,6 +127,8 @@ class GameSetup
             m_tracks.size() != getTotalGrandPrixTracks();
     }
     // ------------------------------------------------------------------------
+    void cancelOneRace()                                  { m_tracks.pop_back(); }
+    // ------------------------------------------------------------------------
     void stopGrandPrix()                                  { m_tracks.clear(); }
     // ------------------------------------------------------------------------
     const std::vector<std::string>& getAllTracks() const   { return m_tracks; }
@@ -132,7 +136,8 @@ class GameSetup
     const std::string& getCurrentTrack() const      { return m_tracks.back(); }
     // ------------------------------------------------------------------------
     void sortPlayersForGrandPrix(
-        std::vector<std::shared_ptr<NetworkPlayerProfile> >& players) const;
+        std::vector<std::shared_ptr<NetworkPlayerProfile> >& players,
+        bool shuffle_instead) const;
     // ------------------------------------------------------------------------
     void sortPlayersForGame(
         std::vector<std::shared_ptr<NetworkPlayerProfile> >& players) const;
@@ -144,6 +149,8 @@ class GameSetup
     }
     // ------------------------------------------------------------------------
     const std::string& getServerNameUtf8() const { return m_server_name_utf8; }
+    // ------------------------------------------------------------------------
+    irr::core::stringw readOrLoadFromFile(std::string value);
 };
 
 #endif // GAME_SETUP_HPP
diff --git a/src/network/network_console.cpp b/src/network/network_console.cpp
index 502ed5fcdff..41ac4df1e2f 100644
--- a/src/network/network_console.cpp
+++ b/src/network/network_console.cpp
@@ -53,6 +53,8 @@ void showHelp()
     std::cout << "listpeers, List all peers with host ID and IP." << std::endl;
     std::cout << "listban, List IP ban list of server." << std::endl;
     std::cout << "speedstats, Show upload and download speed." << std::endl;
+    std::cout << "msg # string, Sent a message to all peers "
+        "(# is ignored)." << std::endl;
 }   // showHelp
 
 // ----------------------------------------------------------------------------
@@ -178,6 +180,21 @@ void mainLoop(STKHost* host)
                 "   Download speed (KBps): " <<
                 (float)host->getDownloadSpeed() / 1024.0f  << std::endl;
         }
+        else if (str == "msg" && number != -1 &&
+            NetworkConfig::get()->isServer())
+        {
+            std::string message;
+            std::getline(ss, message);
+            std::reverse(message.begin(), message.end());
+            while (!message.empty() && message.back() == ' ')
+                message.pop_back();
+            std::reverse(message.begin(), message.end());
+            while (!message.empty() && message.back() == ' ')
+                message.pop_back();
+            auto sl = LobbyProtocol::get<ServerLobby>();
+            if (sl && !message.empty())
+                sl->sendStringToAllPeers(message);
+        }
         else
         {
             std::cout << "Unknown command: " << str << std::endl;
diff --git a/src/network/network_player_profile.cpp b/src/network/network_player_profile.cpp
index b00045d075e..b50bcec7a91 100644
--- a/src/network/network_player_profile.cpp
+++ b/src/network/network_player_profile.cpp
@@ -20,6 +20,8 @@
 #include "network/network_config.hpp"
 #include "network/stk_host.hpp"
 
+float NetworkPlayerProfile::m_team_color[20] = {1.00, 0.08, 0.15, 0.30, 0.60, 0.80, 0.50, 0.70, 0.90, 0.00};
+
 // ----------------------------------------------------------------------------
 /** Returns true if this player is local, i.e. running on this computer. This
  *  is done by comparing the host id of this player with the host id of this
diff --git a/src/network/network_player_profile.hpp b/src/network/network_player_profile.hpp
index d0141f36c3d..99d0f320810 100644
--- a/src/network/network_player_profile.hpp
+++ b/src/network/network_player_profile.hpp
@@ -72,6 +72,10 @@ class NetworkPlayerProfile
     /** 2-letter country code of player. */
     std::string m_country_code;
 
+    int m_temporary_team;
+
+    static float m_team_color[20];
+
 public:
     // ------------------------------------------------------------------------
     static std::shared_ptr<NetworkPlayerProfile>
@@ -91,6 +95,7 @@ class NetworkPlayerProfile
         m_handicap.store((HandicapLevel)0);
         m_local_player_id       = 0;
         m_team.store(team);
+        m_temporary_team        = -1;
         resetGrandPrixData();
     }
     // ------------------------------------------------------------------------
@@ -110,6 +115,7 @@ class NetworkPlayerProfile
         m_local_player_id       = local_player_id;
         m_team.store(team);
         m_country_code          = country_code;
+        m_temporary_team        = -1;
         resetGrandPrixData();
     }
     // ------------------------------------------------------------------------
@@ -137,7 +143,12 @@ class NetworkPlayerProfile
     /** Returns the name of this player. */
     const irr::core::stringw& getName() const         { return m_player_name; }
     // ------------------------------------------------------------------------
-    float getDefaultKartColor() const          { return m_default_kart_color; }
+    float getDefaultKartColor() const
+    {
+        if (m_temporary_team == -1)
+            return m_default_kart_color;
+        return m_team_color[m_temporary_team];
+    }
     // ------------------------------------------------------------------------
     uint32_t getOnlineId() const                        { return m_online_id; }
     // ------------------------------------------------------------------------
@@ -163,6 +174,10 @@ class NetworkPlayerProfile
     // ------------------------------------------------------------------------
     KartTeam getTeam() const                          { return m_team.load(); }
     // ------------------------------------------------------------------------
+    void setTemporaryTeam(int team)                { m_temporary_team = team; }
+    // ------------------------------------------------------------------------
+    int getTemporaryTeam() const                   { return m_temporary_team; }
+    // ------------------------------------------------------------------------
     const std::string& getCountryCode() const        { return m_country_code; }
 };   // class NetworkPlayerProfile
 
diff --git a/src/network/protocols/server_lobby.cpp b/src/network/protocols/server_lobby.cpp
index 47019ace883..abd99fcaacc 100644
--- a/src/network/protocols/server_lobby.cpp
+++ b/src/network/protocols/server_lobby.cpp
@@ -22,12 +22,13 @@
 #include "config/user_config.hpp"
 #include "items/network_item_manager.hpp"
 #include "items/powerup_manager.hpp"
-#include "karts/abstract_kart.hpp"
+#include "items/attachment.hpp"
 #include "karts/controller/player_controller.hpp"
 #include "karts/kart_properties.hpp"
 #include "karts/kart_properties_manager.hpp"
 #include "karts/official_karts.hpp"
 #include "modes/capture_the_flag.hpp"
+#include "modes/soccer_world.hpp"
 #include "modes/linear_world.hpp"
 #include "network/crypto.hpp"
 #include "network/event.hpp"
@@ -62,6 +63,8 @@
 #include <algorithm>
 #include <fstream>
 #include <iostream>
+#include <iomanip>
+#include <sstream>
 #include <iterator>
 
 
@@ -208,6 +211,55 @@ ServerLobby::ServerLobby() : LobbyProtocol()
 {
     m_client_server_host_id.store(0);
     m_lobby_players.store(0);
+    m_help_message = getGameSetup()->readOrLoadFromFile
+        ((std::string) ServerConfig::m_help);
+
+    m_available_commands = "admin ban commands config game gnu go help init "
+        "installaddon kick kickban listlocaladdon listserveraddon "
+        "liststkaddon lobby nognu play playeraddonscore playerhasaddon "
+        "power public record register replay resume role serverhasaddon "
+        "spectate standings start stop teamchat tell to token unban "
+        "uninstalladdon version";
+
+    m_team_name_to_index = {
+           {"red", 1}, {"r", 1}, {StringUtils::utf32ToUtf8({0x1f7e5}), -1},
+        {"orange", 2}, {"o", 2}, {StringUtils::utf32ToUtf8({0x1f7e7}), -2},
+        {"yellow", 3}, {"y", 3}, {StringUtils::utf32ToUtf8({0x1f7e8}), -3},
+         {"green", 4}, {"g", 4}, {StringUtils::utf32ToUtf8({0x1f7e9}), -4},
+          {"blue", 5}, {"b", 5}, {StringUtils::utf32ToUtf8({0x1f7e6}), -5},
+        {"purple", 6}, {"p", 6}, {StringUtils::utf32ToUtf8({0x1f7ea}), -6},
+        {"violet", 6}, {"v", 6}
+    };
+
+    m_team_name = {"No Team",
+        StringUtils::utf32ToUtf8({0x1f7e5}) + "Red",
+        StringUtils::utf32ToUtf8({0x1f7e7}) + "Orange",
+        StringUtils::utf32ToUtf8({0x1f7e8}) + "Yellow",
+        StringUtils::utf32ToUtf8({0x1f7e9}) + "Green",
+        StringUtils::utf32ToUtf8({0x1f7e6}) + "Blue",
+        StringUtils::utf32ToUtf8({0x1f7ea}) + "Purple"
+    };
+
+    m_shuffle_gp = ServerConfig::m_shuffle_gp;
+
+    m_consent_on_replays = false;
+
+    m_fixed_lap = ServerConfig::m_fixed_lap_count;
+    m_extra_seconds = 0.0f;
+    m_default_lap_multiplier = ServerConfig::m_auto_game_time_ratio;
+
+    m_troll_active = ServerConfig::m_troll_active;
+
+    m_show_teammate_hits = ServerConfig::m_show_teammate_hits;
+    m_teammate_hit_mode = ServerConfig::m_teammate_hit_mode;
+    m_last_teammate_hit_msg = 0;
+    m_teammate_swatter_punish.clear();
+    m_collecting_teammate_hit_info = false;
+
+    initAvailableModes();
+
+    std::vector<int> all_k =
+        kart_properties_manager->getKartsInGroup("standard");
     std::vector<int> all_t =
         track_manager->getTracksInGroup("standard");
     std::vector<int> all_arenas =
@@ -226,6 +278,8 @@ ServerLobby::ServerLobby() : LobbyProtocol()
     }
     updateAddons();
 
+    initAvailableTracks();
+
     m_rs_state.store(RS_NONE);
     m_last_success_poll_time.store(StkTime::getMonoTimeMs() + 30000);
     m_last_unsuccess_poll_time = StkTime::getMonoTimeMs();
@@ -249,6 +303,21 @@ ServerLobby::ServerLobby() : LobbyProtocol()
     m_default_vote = new PeerVote();
     m_player_reports_table_exists = false;
     initDatabase();
+
+    initCategories();
+    if (ServerConfig::m_soccer_tournament)
+    {
+        initTournamentPlayers();
+        m_tournament_game = 0;
+    }
+    m_allowed_to_start = true;
+    loadTracksQueueFromConfig();
+    loadCustomScoring();
+    loadWhiteList();
+#ifdef ENABLE_WEB_SUPPORT
+    m_token_generation_tries.store(0);
+    loadAllTokens();
+#endif
 }   // ServerLobby
 
 //-----------------------------------------------------------------------------
@@ -350,7 +419,11 @@ void ServerLobby::initServerStatsTable()
         "    connected_time TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP, -- Time when connected\n"
         "    disconnected_time TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP, -- Time when disconnected (saved when disconnected)\n"
         "    ping INTEGER UNSIGNED NOT NULL DEFAULT 0, -- Ping of the host\n"
-        "    packet_loss INTEGER NOT NULL DEFAULT 0 -- Mean packet loss count from ENet (saved when disconnected)\n"
+        "    packet_loss INTEGER NOT NULL DEFAULT 0, -- Mean packet loss count from ENet (saved when disconnected)\n"
+        "    addon_karts_count INTEGER UNSIGNED NOT NULL DEFAULT 0, -- Number of addon karts of the host\n"
+        "    addon_tracks_count INTEGER UNSIGNED NOT NULL DEFAULT 0, -- Number of addon tracks of the host\n"
+        "    addon_arenas_count INTEGER UNSIGNED NOT NULL DEFAULT 0, -- Number of addon arenas of the host\n"
+        "    addon_soccers_count INTEGER UNSIGNED NOT NULL DEFAULT 0 -- Number of addon soccers of the host\n"
         ") WITHOUT ROWID;";
     std::string query = oss.str();
     sqlite3_stmt* stmt = NULL;
@@ -388,6 +461,23 @@ void ServerLobby::initServerStatsTable()
         ") WITHOUT ROWID;", country_table_name.c_str());
     easySQLQuery(query);
 
+    // Extra default table _results:
+    // Server owner need to initialise this table himself, check NETWORKING.md
+    m_results_table_name = std::string("v") + StringUtils::toString(
+        ServerConfig::m_server_db_version) + "_" +
+        ServerConfig::m_server_uid + "_results";
+    query = StringUtils::insertValues(
+        "CREATE TABLE IF NOT EXISTS %s (\n"
+        "    time TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP, -- Timestamp of the result\n"
+        "    username TEXT NOT NULL, -- User who set the result\n"
+        "    venue TEXT NOT NULL, -- Track for a race\n"
+        "    reverse TEXT NOT NULL, -- Direction\n"
+        "    mode TEXT NOT NULL, -- Racing mode\n"
+        "    laps INTEGER NOT NULL, -- Number of laps\n"
+        "    result REAL NOT NULL -- Elapsed time for a race, possibly with autofinish\n"
+        ");", m_results_table_name.c_str());
+    easySQLQuery(query);
+
     // Default views:
     // _full_stats
     // Full stats with ip in human readable format and time played of each
@@ -404,7 +494,9 @@ void ServerLobby::initServerStatsTable()
     oss << "    port, online_id, username, player_num,\n"
         << "    " << m_server_stats_table << ".country_code AS country_code, country_flag, country_name, version, os,\n"
         << "    ROUND((STRFTIME(\"%s\", disconnected_time) - STRFTIME(\"%s\", connected_time)) / 60.0, 2) AS time_played,\n"
-        << "    connected_time, disconnected_time, ping, packet_loss FROM " << m_server_stats_table << "\n"
+        << "    connected_time, disconnected_time, ping, packet_loss, \n"
+        << "    addon_karts_count, addon_tracks_count, addon_arenas_count,\n"
+        << "    addon_soccers_count FROM " << m_server_stats_table << "\n"
         << "    LEFT JOIN " << country_table_name << " ON "
         <<      country_table_name << ".country_code = " << m_server_stats_table << ".country_code\n"
         << "    ORDER BY connected_time DESC;";
@@ -427,7 +519,9 @@ void ServerLobby::initServerStatsTable()
     oss << "    port, online_id, username, player_num,\n"
         << "    " << m_server_stats_table << ".country_code AS country_code, country_flag, country_name, version, os,\n"
         << "    ROUND((STRFTIME(\"%s\", 'now') - STRFTIME(\"%s\", connected_time)) / 60.0, 2) AS time_played,\n"
-        << "    connected_time, ping FROM " << m_server_stats_table << "\n"
+        << "    connected_time, ping, "
+        << "    addon_karts_count, addon_tracks_count, addon_arenas_count,\n"
+        << "    addon_soccers_count FROM " << m_server_stats_table << "\n"
         << "    LEFT JOIN " << country_table_name << " ON "
         <<      country_table_name << ".country_code = " << m_server_stats_table << ".country_code\n"
         << "    WHERE connected_time = disconnected_time;";
@@ -598,9 +692,9 @@ void ServerLobby::updateAddons()
             continue;
         if (t->isArena())
             m_addon_arenas.insert(t->getIdent());
-        else if (t->isSoccer())
+        if (t->isSoccer())
             m_addon_soccers.insert(t->getIdent());
-        else
+        if (!t->isArena() && !t->isSoccer())
             m_addon_kts.second.insert(t->getIdent());
     }
 
@@ -620,6 +714,7 @@ void ServerLobby::updateAddons()
         m_available_kts.first = m_official_kts.first;
     else
         m_available_kts.first = { all_k.begin(), all_k.end() };
+    m_entering_kts = m_available_kts;
 }   // updateAddons
 
 //-----------------------------------------------------------------------------
@@ -700,7 +795,7 @@ void ServerLobby::updateTracksForMode()
             assert(false);
             break;
     }
-
+    m_entering_kts = m_available_kts;
 }   // updateTracksForMode
 
 //-----------------------------------------------------------------------------
@@ -713,6 +808,7 @@ void ServerLobby::setup()
     m_winner_peer_id = 0;
     m_client_starting_time = 0;
     m_ai_count = 0;
+    m_collecting_teammate_hit_info = false;
     auto players = STKHost::get()->getPlayersForNewGame();
     if (m_game_setup->isGrandPrix() && !m_game_setup->isGrandPrixStarted())
     {
@@ -830,30 +926,91 @@ void ServerLobby::handleChat(Event* event)
 
         NetworkString* chat = getNetworkString();
         chat->setSynchronous(true);
-        chat->addUInt8(LE_CHAT).encodeString16(message);
         const bool game_started = m_state.load() != WAITING_FOR_START_GAME;
+        STKPeer* sender = event->getPeer();
+        auto can_receive = m_message_receivers[sender];
+        if (!can_receive.empty())
+            message = StringUtils::utf32ToWide({0x1f512, 0x20}) + message;
+        bool team_speak = m_team_speakers.find(sender) != m_team_speakers.end();
+        team_speak &= (
+            RaceManager::get()->getMinorMode() == RaceManager::MINOR_MODE_SOCCER ||
+            RaceManager::get()->getMinorMode() == RaceManager::MINOR_MODE_CAPTURE_THE_FLAG
+        );
+        std::set<KartTeam> teams;
+        for (auto& profile: sender->getPlayerProfiles())
+            teams.insert(profile->getTeam());
+        bool tournament_limit = false;
+        std::set<std::string> important_players;
+        if (ServerConfig::m_soccer_tournament && m_tournament_limited_chat)
+        {
+            tournament_limit = true;
+            for (auto& profile: sender->getPlayerProfiles())
+            {
+                std::string name = StringUtils::wideToUtf8(
+                    profile->getName());
+                if (m_tournament_referees.count(name) > 0 ||
+                    m_tournament_red_players.count(name) > 0 ||
+                    m_tournament_blue_players.count(name) > 0)
+                    tournament_limit = false;
+            }
+        }
+        // Note that mutealls are still spectators
+        if (tournament_limit)
+        {
+            for (const std::string& s: m_tournament_referees)
+                important_players.insert(s);
+            for (const std::string& s: m_tournament_red_players)
+                important_players.insert(s);
+            for (const std::string& s: m_tournament_blue_players)
+                important_players.insert(s);
+            for (const std::string& s: m_tournament_mutealls)
+                important_players.insert(s);
+        }
+        chat->addUInt8(LE_CHAT).encodeString16(message);
         core::stringw sender_name =
             event->getPeer()->getPlayerProfiles()[0]->getName();
+
         STKHost::get()->sendPacketToAllPeersWith(
-            [game_started, sender_in_game, target_team, sender_name, this]
-            (STKPeer* p)
+            [game_started, sender_in_game, target_team, can_receive,
+                sender, team_speak, teams, tournament_limit,
+                important_players, sender_name, this](STKPeer* p)
             {
+                if (sender == p)
+                    return true;
                 if (game_started)
                 {
                     if (p->isWaitingForGame() && !sender_in_game)
                         return false;
                     if (!p->isWaitingForGame() && sender_in_game)
                         return false;
+                    if (tournament_limit)
+                    {
+                        bool all_are_important = true;
+                        for (auto& player : p->getPlayerProfiles())
+                        {
+                            std::string name = StringUtils::wideToUtf8(
+                                player->getName());
+                            if (important_players.count(name) == 0)
+                            {
+                                all_are_important = false;
+                                break;
+                            }
+                        }
+                        if (all_are_important)
+                            return false;
+                    }
                     if (target_team != KART_TEAM_NONE)
                     {
                         if (p->isSpectator())
                             return false;
+                        bool someone_good = false;
                         for (auto& player : p->getPlayerProfiles())
                         {
                             if (player->getTeam() == target_team)
-                                return true;
+                                someone_good = true;
                         }
-                        return false;
+                        if (!someone_good)
+                            return false;
                     }
                 }
                 for (auto& peer : m_peers_muted_players)
@@ -865,9 +1022,28 @@ void ServerLobby::handleChat(Event* event)
                             return false;
                     }
                 }
-                return true;
+                if (team_speak)
+                {
+                    bool someone_good = false;
+                    for (auto& profile: p->getPlayerProfiles())
+                        if (teams.count(profile->getTeam()) > 0)
+                            someone_good = true;
+                    if (!someone_good)
+                        return false;
+                }
+                if (can_receive.empty())
+                    return true;
+                for (auto& profile : p->getPlayerProfiles())
+                {
+                    if (can_receive.find(profile->getName()) !=
+                        can_receive.end())
+                    {
+                        return true;
+                    }
+                }
+                return false;
             }, chat);
-            event->getPeer()->updateLastMessage();
+        event->getPeer()->updateLastMessage();
         delete chat;
     }
 }   // handleChat
@@ -883,16 +1059,19 @@ void ServerLobby::changeTeam(Event* event)
     uint8_t local_id = data.getUInt8();
     auto& player = event->getPeer()->getPlayerProfiles().at(local_id);
     auto red_blue = STKHost::get()->getAllPlayersTeamInfo();
+    if (ServerConfig::m_soccer_tournament)
+        return; // message here?
+
     // At most 7 players on each team (for live join)
     if (player->getTeam() == KART_TEAM_BLUE)
     {
-        if (red_blue.first >= 7)
+        if (red_blue.first >= 7 && !ServerConfig::m_free_teams)
             return;
         player->setTeam(KART_TEAM_RED);
     }
     else
     {
-        if (red_blue.second >= 7)
+        if (red_blue.second >= 7 && !ServerConfig::m_free_teams)
             return;
         player->setTeam(KART_TEAM_BLUE);
     }
@@ -904,13 +1083,45 @@ void ServerLobby::kickHost(Event* event)
 {
     if (m_server_owner.lock() != event->getPeerSP())
         return;
+    if (!ServerConfig::m_kicks_allowed)
+    {
+        std::string msg = "Kicking players is not allowed on this server";
+        auto crown = event->getPeerSP();
+        sendStringToPeer(msg, crown);
+        return;
+    }
     if (!checkDataSize(event, 4)) return;
     NetworkString& data = event->data();
     uint32_t host_id = data.getUInt32();
     std::shared_ptr<STKPeer> peer = STKHost::get()->findPeerByHostId(host_id);
     // Ignore kicking ai peer if ai handling is on
     if (peer && (!ServerConfig::m_ai_handling || !peer->isAIPeer()))
+    {
+        if (peer->isAngryHost())
+        {
+            std::string msg = "This player is the owner of this server, "
+                "and is protected from your actions now";
+            auto crown = event->getPeerSP();
+            sendStringToPeer(msg, crown);
+            return;
+        }
+        if (!peer->hasPlayerProfiles())
+        {
+            Log::info("ServerLobby", "Crown player kicks a player");
+        }
+        else
+        {
+            auto npp = peer->getPlayerProfiles()[0];
+            std::string player_name = StringUtils::wideToUtf8(npp->getName());
+            Log::info("ServerLobby", "Crown player kicks %s", player_name.c_str());
+        }
         peer->kick();
+        if (ServerConfig::m_track_kicks)
+        {
+            std::string auto_report = "[ Auto report caused by kick ]";
+            writeOwnReport(peer.get(), event->getPeerSP().get(), auto_report);
+        }
+    }
 }   // kickHost
 
 //-----------------------------------------------------------------------------
@@ -1150,13 +1361,16 @@ bool ServerLobby::easySQLQuery(const std::string& query,
     {
         if (bind_function)
             bind_function(stmt);
+        char* actual_query_cstr = sqlite3_expanded_sql(stmt);
+        std::string actual_query(actual_query_cstr);
+        sqlite3_free(actual_query_cstr);
         ret = sqlite3_step(stmt);
         ret = sqlite3_finalize(stmt);
         if (ret != SQLITE_OK)
         {
             Log::error("ServerLobby",
                 "Error finalize database for easy query %s: %s",
-                query.c_str(), sqlite3_errmsg(m_db));
+                actual_query.c_str(), sqlite3_errmsg(m_db));
             return false;
         }
     }
@@ -1170,6 +1384,52 @@ bool ServerLobby::easySQLQuery(const std::string& query,
     return true;
 }   // easySQLQuery
 
+//-----------------------------------------------------------------------------
+std::pair<bool, std::vector<std::vector<std::string>>>
+ServerLobby::vectorSQLQuery(const std::string& query,
+    int columns, std::function<void(sqlite3_stmt* stmt)> bind_function) const
+{
+    std::vector<std::vector<std::string>> ans(columns);
+    if (!m_db)
+        return {false, {}};
+    sqlite3_stmt* stmt = NULL;
+    int ret = sqlite3_prepare_v2(m_db, query.c_str(), -1, &stmt, 0);
+    if (ret == SQLITE_OK)
+    {
+        if (bind_function)
+            bind_function(stmt);
+        char* actual_query_cstr = sqlite3_expanded_sql(stmt);
+        std::string actual_query(actual_query_cstr);
+        sqlite3_free(actual_query_cstr);
+        ret = sqlite3_step(stmt);
+        while (sqlite3_column_text(stmt, 0))
+        {
+            for (int i = 0; i < columns; i++)
+            {
+                ans[i].push_back(std::string(
+                    (char*)sqlite3_column_text(stmt, i)));
+            }
+            ret = sqlite3_step(stmt);
+        }
+        ret = sqlite3_finalize(stmt);
+        if (ret != SQLITE_OK)
+        {
+            Log::error("ServerLobby",
+                "Error finalize database for vector query %s: %s",
+                actual_query.c_str(), sqlite3_errmsg(m_db));
+            return {false, {}};
+        }
+    }
+    else
+    {
+        Log::error("ServerLobby",
+            "Error preparing database for vector query %s: %s",
+            query.c_str(), sqlite3_errmsg(m_db));
+        return {false, {}};
+    }
+    return {true, ans};
+}   // vectorSQLQuery
+
 //-----------------------------------------------------------------------------
 /* Write true to result if table name exists in database. */
 void ServerLobby::checkTableExists(const std::string& table, bool& result)
@@ -1421,8 +1681,8 @@ void ServerLobby::asynchronousUpdate()
     if (ServerConfig::m_ranked && m_state.load() == WAITING_FOR_START_GAME)
         clearDisconnectedRankedPlayer();
 
-    if (allowJoinedPlayersWaiting() || (m_game_setup->isGrandPrix() &&
-        m_state.load() == WAITING_FOR_START_GAME))
+    if (allowJoinedPlayersWaiting() /*|| (m_game_setup->isGrandPrix() &&
+        m_state.load() == WAITING_FOR_START_GAME)*/)
     {
         // Only poll the STK server if server has been registered.
         if (m_server_id_online.load() != 0 &&
@@ -1529,7 +1789,8 @@ void ServerLobby::asynchronousUpdate()
                     updatePlayerList();
                 m_timeout.store(std::numeric_limits<int64_t>::max());
             }
-            if (m_timeout.load() < (int64_t)StkTime::getMonoTimeMs() ||
+            if ((!ServerConfig::m_soccer_tournament &&
+                m_timeout.load() < (int64_t)StkTime::getMonoTimeMs()) ||
                 (checkPeersReady(true/*ignore_ai_peer*/) &&
                 (int)players >= ServerConfig::m_min_start_game_players))
             {
@@ -1552,6 +1813,10 @@ void ServerLobby::asynchronousUpdate()
         // For WAIT_FOR_WORLD_LOADED and SELECTING make sure there are enough
         // players to start next game, otherwise exiting and let main thread
         // reset
+
+        // maybe this is not the best place for this?
+        m_last_teammate_hit_msg = 0;
+
         if (m_end_voting_period.load() == 0)
             return;
 
@@ -1594,17 +1859,38 @@ void ServerLobby::asynchronousUpdate()
         bool go_on_race = false;
         if (ServerConfig::m_track_voting)
             go_on_race = handleAllVotes(&winner_vote, &m_winner_peer_id);
-        else if (m_game_setup->isGrandPrixStarted() || isVotingOver())
+        else if (/*m_game_setup->isGrandPrixStarted() || */isVotingOver())
         {
             winner_vote = *m_default_vote;
             go_on_race = true;
         }
         if (go_on_race)
         {
+            if (m_fixed_lap >= 0)
+            {
+                winner_vote.m_num_laps = m_fixed_lap;
+                Log::info("ServerLobby", "Enforcing %d lap race", (int)m_fixed_lap);
+            }
             *m_default_vote = winner_vote;
             m_item_seed = (uint32_t)StkTime::getTimeSinceEpoch();
             ItemManager::updateRandomSeed(m_item_seed);
-            m_game_setup->setRace(winner_vote);
+            m_game_setup->setRace(winner_vote, m_extra_seconds);
+            std::string track_name = winner_vote.m_track_name;
+            if (ServerConfig::m_soccer_tournament)
+                m_tournament_arenas[m_tournament_game] = track_name;
+            auto peers = STKHost::get()->getPeers();
+            std::set<STKPeer*> bad_spectators;
+            for (auto peer : peers)
+            {
+                if (peer->alwaysSpectate() &&
+                    peer->getClientAssets().second.count(track_name) == 0)
+                {
+                    peer->setAlwaysSpectate(ASM_NONE);
+                    peer->setWaitingForGame(true);
+                    m_peers_ready.erase(peer);
+                    bad_spectators.insert(peer.get());
+                }
+            }
             bool has_always_on_spectators = false;
             auto players = STKHost::get()
                 ->getPlayersForNewGame(&has_always_on_spectators);
@@ -1627,7 +1913,7 @@ void ServerLobby::asynchronousUpdate()
                         m_ai_profiles.end());
                 }
             }
-            m_game_setup->sortPlayersForGrandPrix(players);
+            m_game_setup->sortPlayersForGrandPrix(players, m_shuffle_gp);
             m_game_setup->sortPlayersForGame(players);
             for (unsigned i = 0; i < players.size(); i++)
             {
@@ -1652,12 +1938,20 @@ void ServerLobby::asynchronousUpdate()
             {
                 if (players[i]->getKartName().empty())
                 {
-                    RandomGenerator rg;
-                    std::set<std::string>::iterator it =
-                        m_available_kts.first.begin();
-                    std::advance(it,
-                        rg.get((int)m_available_kts.first.size()));
-                    players[i]->setKartName(*it);
+                    if (m_kart_elimination.isEliminated(
+                        StringUtils::wideToUtf8(players[i]->getName())))
+                    {
+                        players[i]->setKartName(m_kart_elimination.getKart());
+                    }
+                    else
+                    {
+                        RandomGenerator rg;
+                        std::set<std::string>::iterator it =
+                            m_available_kts.first.begin();
+                        std::advance(it,
+                            rg.get((int)m_available_kts.first.size()));
+                        players[i]->setKartName(*it);
+                    }
                 }
             }
 
@@ -1668,6 +1962,10 @@ void ServerLobby::asynchronousUpdate()
             uint16_t flag_return_time = (uint16_t)stk_config->time2Ticks(
                 ServerConfig::m_flag_return_timeout);
             RaceManager::get()->setFlagReturnTicks(flag_return_time);
+            if (ServerConfig::m_record_replays && m_consent_on_replays &&
+                (RaceManager::get()->getMinorMode() == RaceManager::MINOR_MODE_TIME_TRIAL ||
+                RaceManager::get()->getMinorMode() == RaceManager::MINOR_MODE_NORMAL_RACE))
+                RaceManager::get()->setRecordRace(true);
             uint16_t flag_deactivated_time = (uint16_t)stk_config->time2Ticks(
                 ServerConfig::m_flag_deactivated_time);
             RaceManager::get()->setFlagDeactivatedTicks(flag_deactivated_time);
@@ -1675,13 +1973,31 @@ void ServerLobby::asynchronousUpdate()
 
             // Reset for next state usage
             resetPeersReady();
+
             m_state = LOAD_WORLD;
             sendMessageToPeers(load_world_message);
             // updatePlayerList so the in lobby players (if any) can see always
             // spectators join the game
-            if (has_always_on_spectators)
+            if (has_always_on_spectators || !bad_spectators.empty())
                 updatePlayerList();
             delete load_world_message;
+
+            if (RaceManager::get()->getMinorMode() ==
+                RaceManager::MINOR_MODE_SOCCER)
+            {
+                for (unsigned i = 0; i < RaceManager::get()->getNumPlayers(); i++)
+                {
+                    if (auto player =
+                        RaceManager::get()->getKartInfo(i).getNetworkPlayerProfile().lock())
+                    {
+                        std::string username = StringUtils::wideToUtf8(player->getName());
+                        if (username.empty())
+                            continue;
+                        Log::info("ServerLobby", "SoccerMatchLog: There is a player %s.",
+                            username.c_str());
+                    }
+                }
+            }
         }
         break;
     }
@@ -1764,11 +2080,13 @@ bool ServerLobby::canLiveJoinNow() const
         }
         if (!fastest_kart)
             return false;
-        float progress = w->getOverallDistance(
-            fastest_kart->getWorldKartId()) /
-            (Track::getCurrentTrack()->getTrackLength() *
-            (float)RaceManager::get()->getNumLaps());
-        if (progress > 0.9f)
+        float leader_distance = w->getOverallDistance(
+            fastest_kart->getWorldKartId());
+        float total_distance =
+            Track::getCurrentTrack()->getTrackLength() *
+            (float)RaceManager::get()->getNumLaps();
+        float progress = leader_distance / total_distance;
+        if (total_distance - leader_distance < 250.0)
             return false;
     }
     return live_join;
@@ -1830,7 +2148,7 @@ void ServerLobby::liveJoinRequest(Event* event)
     peer->clearAvailableKartIDs();
     if (!spectator)
     {
-        auto spectators_by_limit = getSpectatorsByLimit();
+        auto& spectators_by_limit = getSpectatorsByLimit();
         setPlayerKarts(data, peer);
 
         std::vector<int> used_id;
@@ -1842,7 +2160,7 @@ void ServerLobby::liveJoinRequest(Event* event)
             used_id.push_back(id);
         }
         if ((used_id.size() != peer->getPlayerProfiles().size()) ||
-            (spectators_by_limit.find(event->getPeerSP()) != spectators_by_limit.end()))
+            (spectators_by_limit.find(event->getPeerSP().get()) != spectators_by_limit.end()))
         {
             for (unsigned i = 0; i < peer->getPlayerProfiles().size(); i++)
                 peer->getPlayerProfiles()[i]->setKartName("");
@@ -2133,6 +2451,46 @@ void ServerLobby::update(int ticks)
                     StringUtils::wideToUtf8(rki.getPlayerName()).c_str(), sec);
                 peer->kick();
             }
+            if (m_troll_active && !peer->isAIPeer())
+            {
+                // for all human players
+                // if they troll, kick them
+                LinearWorld *lin_world = dynamic_cast<LinearWorld*>(w);
+                if (lin_world) {
+                    // check warn level for each player
+                    switch(lin_world->getWarnLevel(i))
+                    {
+                        case 0: // fine
+                            break;
+                        case 1: // print WARNING
+                        {
+                            std::string msg = ServerConfig::m_troll_warn_msg;
+                            sendStringToPeer(msg, peer);
+                            std::string player_name = StringUtils::wideToUtf8(peer->getPlayerProfiles()[0]->getName());
+                            Log::info("ServerLobby-AntiTroll", "Sent WARNING to %s", player_name.c_str());
+                            break;
+                        }
+                        default: // kick !!
+                        {
+                            std::string player_name = StringUtils::wideToUtf8(peer->getPlayerProfiles()[0]->getName());
+                            Log::info("ServerLobby-AntiTroll", "KICKING %s", player_name.c_str());
+                            peer->kick();
+                            break;
+                        }
+                    }
+                }
+            }
+            if (m_teammate_swatter_punish.size() > 0)
+            {
+                // punish players who swattered teammates
+                for (auto& kart : m_teammate_swatter_punish)
+                {
+                    kart->getAttachment()->set(Attachment::ATTACH_ANVIL,
+                        stk_config->time2Ticks(kart->getKartProperties()->getAnvilDuration()));
+                    kart->adjustSpeed(kart->getKartProperties()->getAnvilSpeedFactor());
+                }
+                m_teammate_swatter_punish.clear();
+            }
         }
     }
     if (w)
@@ -2161,8 +2519,8 @@ void ServerLobby::update(int ticks)
 
     STKHost::get()->updatePlayers();
     if (m_rs_state.load() == RS_NONE &&
-        (m_state.load() > WAITING_FOR_START_GAME ||
-        m_game_setup->isGrandPrixStarted()) &&
+        (m_state.load() > WAITING_FOR_START_GAME/* ||
+        m_game_setup->isGrandPrixStarted()*/) &&
         (STKHost::get()->getPlayersInGame() == 0 ||
         all_players_in_world_disconnected))
     {
@@ -2190,9 +2548,11 @@ void ServerLobby::update(int ticks)
             ai->sendPacket(back_to_lobby, /*reliable*/true);
             delete back_to_lobby;
         }
-
+        if (all_players_in_world_disconnected)
+            m_game_setup->cancelOneRace();
         resetVotingTime();
-        m_game_setup->stopGrandPrix();
+        // m_game_setup->cancelOneRace();
+        //m_game_setup->stopGrandPrix();
         m_rs_state.store(RS_WAITING);
         return;
     }
@@ -2212,7 +2572,8 @@ void ServerLobby::update(int ticks)
         sendMessageToPeers(back_lobby, /*reliable*/true);
         delete back_lobby;
         resetVotingTime();
-        m_game_setup->stopGrandPrix();
+        // m_game_setup->cancelOneRace();
+        //m_game_setup->stopGrandPrix();
         m_rs_state.store(RS_ASYNC_RESET);
     }
 
@@ -2237,6 +2598,7 @@ void ServerLobby::update(int ticks)
         Log::info("ServerLobbyRoom", "Starting the race loading.");
         // This will create the world instance, i.e. load track and karts
         loadWorld();
+        updateWorldSettings();
         m_state = WAIT_FOR_WORLD_LOADED;
         break;
     case RACING:
@@ -2448,6 +2810,7 @@ void ServerLobby::unregisterServer(bool now, std::weak_ptr<ServerLobby> sl)
  */
 void ServerLobby::startSelection(const Event *event)
 {
+    bool need_to_update = false;
     if (event != NULL)
     {
         if (m_state != WAITING_FOR_START_GAME)
@@ -2457,25 +2820,58 @@ void ServerLobby::startSelection(const Event *event)
                 m_state.load());
             return;
         }
+        if (ServerConfig::m_sleeping_server)
+        {
+            Log::warn("ServerLobby",
+                "An attempt to start a race on a sleeping server. Lol.");
+            return;
+        }
+        auto peer = event->getPeerSP();
         if (ServerConfig::m_owner_less)
         {
-            m_peers_ready.at(event->getPeerSP()) =
-                !m_peers_ready.at(event->getPeerSP());
-            updatePlayerList();
+            if (!m_allowed_to_start)
+            {
+                std::string msg = "Starting the game is forbidden by server owner";
+                sendStringToPeer(msg, peer);
+                return;
+            }
+            if (!canRace(peer))
+            {
+                std::string msg = "You cannot play so pressing ready has no action";
+                sendStringToPeer(msg, peer);
+                return;
+            }
+            else
+            {
+                m_peers_ready.at(event->getPeerSP()) =
+                    !m_peers_ready.at(event->getPeerSP());
+                updatePlayerList();
+                return;
+            }
+        }
+        if (!m_allowed_to_start)
+        {
+            std::string msg = "Starting the game is forbidden by server owner";
+            sendStringToPeer(msg, peer);
             return;
         }
-        if (event->getPeerSP() != m_server_owner.lock())
+        if (peer != m_server_owner.lock())
         {
             Log::warn("ServerLobby",
                 "Client %d is not authorised to start selection.",
                 event->getPeer()->getHostId());
             return;
         }
+    } else {
+        if (!m_allowed_to_start)
+        {
+            // Produce no log spam
+            return;
+        }
     }
 
-
     if (!ServerConfig::m_owner_less && ServerConfig::m_team_choosing &&
-        RaceManager::get()->teamEnabled())
+        !ServerConfig::m_free_teams && RaceManager::get()->teamEnabled())
     {
         auto red_blue = STKHost::get()->getAllPlayersTeamInfo();
         if ((red_blue.first == 0 || red_blue.second == 0) &&
@@ -2494,29 +2890,67 @@ void ServerLobby::startSelection(const Event *event)
         }
     }
 
-    // Remove karts / tracks from server that are not supported on all clients
-    std::set<std::string> karts_erase, tracks_erase;
+    unsigned max_player = 0;
+    STKHost::get()->updatePlayers(&max_player);
     auto peers = STKHost::get()->getPeers();
     std::set<STKPeer*> always_spectate_peers;
+
+    // Set late coming player to spectate if too many players
+    auto& spectators_by_limit = getSpectatorsByLimit();
+    if (spectators_by_limit.size() == peers.size())
+    {
+        Log::error("ServerLobby", "Too many players and cannot set "
+            "spectate for late coming players!");
+        return;
+    }
+    for (auto &peer : spectators_by_limit)
+    {
+        peer->setAlwaysSpectate(ASM_FULL);
+        peer->setWaitingForGame(true);
+        always_spectate_peers.insert(peer);
+    }
+
+    // Remove karts / tracks from server that are not supported on all clients
+    std::set<std::string> karts_erase, tracks_erase;
     bool has_peer_plays_game = false;
     for (auto peer : peers)
     {
         if (!peer->isValidated() || peer->isWaitingForGame())
             continue;
+        bool can_race = canRace(peer);
+        if (!can_race && !peer->alwaysSpectate())
+        {
+            if (ServerConfig::m_soccer_tournament/* || ServerConfig::m_only_host_riding*/)
+                peer->setAlwaysSpectate(ASM_COMMAND);
+            peer->setWaitingForGame(true);
+            m_peers_ready.erase(peer);
+            need_to_update = true;
+            continue;
+        }
+        else if (peer->alwaysSpectate())
+        {
+            always_spectate_peers.insert(peer.get());
+            continue;
+        }
         peer->eraseServerKarts(m_available_kts.first, karts_erase);
         peer->eraseServerTracks(m_available_kts.second, tracks_erase);
-        if (peer->alwaysSpectate())
-            always_spectate_peers.insert(peer.get());
-        else if (!peer->isAIPeer())
+        if (!peer->isAIPeer())
             has_peer_plays_game = true;
     }
+    // m_default_always_spectate_peers = always_spectate_peers;
 
-    // Disable always spectate peers if no players join the game
+    // kimden thinks if someone wants to race he should disable spectating
+    // // Disable always spectate peers if no players join the game
     if (!has_peer_plays_game)
     {
-        for (STKPeer* peer : always_spectate_peers)
-            peer->setAlwaysSpectate(ASM_NONE);
-        always_spectate_peers.clear();
+        // The always spectating code will probably behave kinda weird with
+        // spectating commands, I'll try to fix it later but beware
+        Log::warn("ServerLobby",
+            "An attempt to start a game while no one is able to play.");
+        return;
+        // for (STKPeer* peer : always_spectate_peers)
+        //     peer->setAlwaysSpectate(ASM_NONE);
+        // always_spectate_peers.clear();
     }
     else
     {
@@ -2528,24 +2962,6 @@ void ServerLobby::startSelection(const Event *event)
             peer->setWaitingForGame(true);
     }
 
-    unsigned max_player = 0;
-    STKHost::get()->updatePlayers(&max_player);
-
-    // Set late coming player to spectate if too many players
-    auto spectators_by_limit = getSpectatorsByLimit();
-    if (spectators_by_limit.size() == peers.size())
-    {
-        Log::error("ServerLobby", "Too many players and cannot set "
-            "spectate for late coming players!");
-        return;
-    }
-    for(auto &peer : spectators_by_limit)
-    {
-        peer->setAlwaysSpectate(ASM_FULL);
-        peer->setWaitingForGame(true);
-        always_spectate_peers.insert(peer.get());
-    }
-
     for (const std::string& kart_erase : karts_erase)
     {
         m_available_kts.first.erase(kart_erase);
@@ -2554,6 +2970,12 @@ void ServerLobby::startSelection(const Event *event)
     {
         m_available_kts.second.erase(track_erase);
     }
+    if (!m_tracks_queue.empty())
+    {
+        m_available_kts.second.clear();
+        m_available_kts.second.insert(m_tracks_queue.front());
+    }
+
 
     max_player = 0;
     STKHost::get()->updatePlayers(&max_player);
@@ -2585,7 +3007,7 @@ void ServerLobby::startSelection(const Event *event)
         auto it = m_available_kts.second.begin();
         while (it != m_available_kts.second.end())
         {
-            Track* t =  track_manager->getTrack(*it);
+            Track* t = track_manager->getTrack(*it);
             if (t->getMaxArenaPlayers() < max_player)
             {
                 it = m_available_kts.second.erase(it);
@@ -2594,6 +3016,23 @@ void ServerLobby::startSelection(const Event *event)
                 it++;
         }
     }
+    
+    m_global_filter.apply(max_player, m_available_kts.second);
+    if (ServerConfig::m_soccer_tournament)
+    {
+        m_tournament_track_filters[m_tournament_game].apply(
+            max_player, m_available_kts.second, m_tournament_arenas);
+    }
+   /* auto iter = m_available_kts.second.begin();
+    while (iter != m_available_kts.second.end())
+    {
+        // Initial version which will be brought into a separate fuction
+        std::string track = *iter;
+        if (getTrackMaxPlayers(track) < max_player)
+            iter = m_available_kts.second.erase(iter);
+        else
+            iter++;
+    }*/
 
     if (m_available_kts.second.empty())
     {
@@ -2631,21 +3070,29 @@ void ServerLobby::startSelection(const Event *event)
         }
         case RaceManager::MINOR_MODE_SOCCER:
         {
-            if (m_game_setup->isSoccerGoalTarget())
+            if (ServerConfig::m_soccer_tournament)
             {
-                m_default_vote->m_num_laps =
-                    (uint8_t)(UserConfigParams::m_num_goals);
-                if (m_default_vote->m_num_laps > 10)
-                    m_default_vote->m_num_laps = (uint8_t)5;
+                m_default_vote->m_num_laps = 10;
+                m_default_vote->m_reverse = false;
             }
             else
             {
-                m_default_vote->m_num_laps =
-                    (uint8_t)(UserConfigParams::m_soccer_time_limit);
-                if (m_default_vote->m_num_laps > 15)
-                    m_default_vote->m_num_laps = (uint8_t)7;
+                if (m_game_setup->isSoccerGoalTarget())
+                {
+                    m_default_vote->m_num_laps =
+                        (uint8_t)(UserConfigParams::m_num_goals);
+                    if (m_default_vote->m_num_laps > 10)
+                        m_default_vote->m_num_laps = (uint8_t)5;
+                }
+                else
+                {
+                    m_default_vote->m_num_laps =
+                        (uint8_t)(UserConfigParams::m_soccer_time_limit);
+                    if (m_default_vote->m_num_laps > 15)
+                        m_default_vote->m_num_laps = (uint8_t)7;
+                }
+                m_default_vote->m_reverse = rg.get(2) == 0;
             }
-            m_default_vote->m_reverse = rg.get(2) == 0;
             break;
         }
         default:
@@ -2670,8 +3117,9 @@ void ServerLobby::startSelection(const Event *event)
     ns->setSynchronous(true);
     ns->addUInt8(LE_START_SELECTION)
        .addFloat(ServerConfig::m_voting_timeout)
-       .addUInt8(m_game_setup->isGrandPrixStarted() ? 1 : 0)
-       .addUInt8(ServerConfig::m_auto_game_time_ratio > 0.0f ? 1 : 0)
+       .addUInt8(/*m_game_setup->isGrandPrixStarted() ? 1 : */0)
+       .addUInt8((m_fixed_lap >= 0
+            || m_default_lap_multiplier > 0.0f) ? 1 : 0)
        .addUInt8(ServerConfig::m_track_voting ? 1 : 0);
 
     const auto& all_k = m_available_kts.first;
@@ -2686,19 +3134,88 @@ void ServerLobby::startSelection(const Event *event)
         ns->encodeString(track);
     }
 
-    sendMessageToPeers(ns, /*reliable*/true);
-    delete ns;
+    auto remaining = m_kart_elimination.getRemainingParticipants();
+    if (!remaining.empty())
+    {
+        // Seems like I assumed the kart elimination cannot have
+        // preselected tracks. Not sure I really wanted this.
+        STKHost::get()->sendPacketToAllPeersWith(
+            [remaining](STKPeer* p)
+            {
+                for (auto& profile : p->getPlayerProfiles())
+                {
+                    if (remaining.count(
+                        StringUtils::wideToUtf8(profile->getName())) != 0)
+                    {
+                        return true;
+                    }
+                }
+                return false;
+            }, ns, /*reliable*/true);
+        delete ns;
+        bool has_gnu = false;
+        for (auto it = all_k.begin(); it != all_k.end(); it++)
+        {
+            has_gnu |= (*it == m_kart_elimination.getKart());
+        }
+
+        // The same NetworkString but without any non-elimination karts
+        NetworkString *ns = getNetworkString(1);
+        ns->setSynchronous(true);
+        ns->addUInt8(LE_START_SELECTION)
+           .addFloat(ServerConfig::m_voting_timeout)
+           .addUInt8(/*m_game_setup->isGrandPrixStarted() ? 1 : */0)
+           .addUInt8((m_fixed_lap >= 0
+            || m_default_lap_multiplier > 0.0f) ? 1 : 0)
+           .addUInt8(ServerConfig::m_track_voting ? 1 : 0);
+
+        ns->addUInt16((uint16_t)(has_gnu ? 1 : 0)).addUInt16(
+            (uint16_t)all_t.size());
+        if (has_gnu)
+        {
+            ns->encodeString(std::string(m_kart_elimination.getKart()));
+        }
+        for (const std::string& track : all_t)
+        {
+            ns->encodeString(track);
+        }
+
+        STKHost::get()->sendPacketToAllPeersWith(
+            [remaining](STKPeer* p)
+            {
+                for (auto& profile : p->getPlayerProfiles())
+                {
+                    if (remaining.count(
+                        StringUtils::wideToUtf8(profile->getName())) != 0)
+                    {
+                        return false;
+                    }
+                }
+                return true;
+            }, ns, /*reliable*/true);
+    }
+    else
+    {
+        STKHost::get()->sendPacketToAllPeersWith(
+            [this](STKPeer* p) -> bool
+            {
+                return canRace(p);
+            }, ns, /*reliable*/true);
+        delete ns;
+    }
 
     m_state = SELECTING;
-    if (!always_spectate_peers.empty())
+    if (need_to_update || !always_spectate_peers.empty())
     {
         NetworkString* back_lobby = getNetworkString(2);
         back_lobby->setSynchronous(true);
         back_lobby->addUInt8(LE_BACK_LOBBY).addUInt8(BLR_SPECTATING_NEXT_GAME);
         STKHost::get()->sendPacketToAllPeersWith(
-            [always_spectate_peers](STKPeer* peer) {
-            return always_spectate_peers.find(peer) !=
-            always_spectate_peers.end(); }, back_lobby, /*reliable*/true);
+            [always_spectate_peers](STKPeer* peer)
+            {
+                return always_spectate_peers.find(peer) !=
+                always_spectate_peers.end();
+            }, back_lobby, /*reliable*/true);
         delete back_lobby;
         updatePlayerList();
     }
@@ -2719,6 +3236,11 @@ void ServerLobby::startSelection(const Event *event)
 
     // Will be changed after the first vote received
     m_timeout.store(std::numeric_limits<int64_t>::max());
+    if (!m_game_setup->isGrandPrixStarted())
+    {
+        m_gp_scores.clear();
+        m_gp_team_scores.clear();
+    }
 }   // startSelection
 
 //-----------------------------------------------------------------------------
@@ -2861,7 +3383,20 @@ void ServerLobby::checkRaceFinished()
     assert(World::getWorld());
     if (!RaceEventManager::get()->isRaceOver()) return;
 
-    Log::info("ServerLobby", "The game is considered finished.");
+    if (ServerConfig::m_soccer_tournament)
+    {
+        World* w = World::getWorld();
+        if (w)
+        {
+            SoccerWorld *sw = dynamic_cast<SoccerWorld*>(w);
+            sw->tellCountIfDiffers();
+        }
+    }
+    if (RaceManager::get()->getMinorMode() ==
+        RaceManager::MINOR_MODE_SOCCER)
+        Log::info("ServerLobby", "SoccerMatchLog: The game is considered finished.");
+    else
+        Log::info("ServerLobby", "The game is considered finished.");
     // notify the network world that it is stopped
     RaceEventManager::get()->stop();
 
@@ -2872,14 +3407,32 @@ void ServerLobby::checkRaceFinished()
     // Save race result before delete the world
     m_result_ns->clear();
     m_result_ns->addUInt8(LE_RACE_FINISHED);
+    std::vector<float> gp_changes;
     if (m_game_setup->isGrandPrix())
     {
         // fastest lap
         int fastest_lap =
             static_cast<LinearWorld*>(World::getWorld())->getFastestLapTicks();
         m_result_ns->addUInt32(fastest_lap);
-        m_result_ns->encodeString(static_cast<LinearWorld*>(World::getWorld())
-            ->getFastestLapKartName());
+        irr::core::stringw fastest_kart_wide =
+            static_cast<LinearWorld*>(World::getWorld())
+            ->getFastestLapKartName();
+        m_result_ns->encodeString(fastest_kart_wide);
+        std::string fastest_kart = StringUtils::wideToUtf8(fastest_kart_wide);
+
+        int points_fl = 0;
+        int points_pole = 0;
+        WorldWithRank *wwr = dynamic_cast<WorldWithRank*>(World::getWorld());
+        if (wwr)
+        {
+            points_fl = wwr->getFastestLapPoints();
+            points_pole = wwr->getPolePoints();
+        }
+        else
+        {
+            Log::error("ServerLobby",
+                       "World with scores that is not a WorldWithRank??");
+        }
 
         // all gp tracks
         m_result_ns->addUInt8((uint8_t)m_game_setup->getTotalGrandPrixTracks())
@@ -2891,18 +3444,35 @@ void ServerLobby::checkRaceFinished()
         m_result_ns->addUInt8((uint8_t)RaceManager::get()->getNumPlayers());
         for (unsigned i = 0; i < RaceManager::get()->getNumPlayers(); i++)
         {
-            int last_score = RaceManager::get()->getKartScore(i);
+            int last_score = (World::getWorld()->getKart(i)->isEliminated() ?
+                    0 : RaceManager::get()->getKartScore(i));
+            gp_changes.push_back((float)last_score);
             int cur_score = last_score;
             float overall_time = RaceManager::get()->getOverallTime(i);
-            if (auto player =
-                RaceManager::get()->getKartInfo(i).getNetworkPlayerProfile().lock())
+            std::string username = StringUtils::wideToUtf8(
+                RaceManager::get()->getKartInfo(i).getPlayerName());
+            if (username == fastest_kart)
             {
-                last_score = player->getScore();
-                cur_score += last_score;
-                overall_time = overall_time + player->getOverallTime();
-                player->setScore(cur_score);
+                gp_changes.back() += points_fl;
+                cur_score += points_fl;
+            }
+            int team = m_team_for_player[username];
+            if (team > 0)
+            {
+                m_gp_team_scores[team].score += cur_score;
+                m_gp_team_scores[team].time += overall_time;
+            }
+            last_score = m_gp_scores[username].score;
+            cur_score += last_score;
+            overall_time = overall_time + m_gp_scores[username].time;
+            if (auto player =
+                RaceManager::get()->getKartInfo(i).getNetworkPlayerProfile().lock())
+            {
+                player->setScore(cur_score);
                 player->setOverallTime(overall_time);
             }
+            m_gp_scores[username].score = cur_score;
+            m_gp_scores[username].time = overall_time;
             m_result_ns->addUInt32(last_score).addUInt32(cur_score)
                 .addFloat(overall_time);            
         }
@@ -2919,17 +3489,55 @@ void ServerLobby::checkRaceFinished()
     uint8_t ranking_changes_indication = 0;
     if (ServerConfig::m_ranked && RaceManager::get()->modeHasLaps())
         ranking_changes_indication = 1;
+    if (m_game_setup->isGrandPrix())
+        ranking_changes_indication = 1;
     m_result_ns->addUInt8(ranking_changes_indication);
 
+    if (m_kart_elimination.isEnabled())
+    {
+        // ServerLobby's function because we need to take
+        // the list of players from somewhere
+        updateGnuElimination();
+    }
+
+    if (ServerConfig::m_store_results)
+    {
+        bool racing_mode = false;
+        racing_mode |= RaceManager::get()->getMinorMode() ==
+            RaceManager::MINOR_MODE_NORMAL_RACE;
+        racing_mode |= RaceManager::get()->getMinorMode() ==
+            RaceManager::MINOR_MODE_TIME_TRIAL;
+        if (racing_mode)
+            storeResults();
+    }
+
     if (ServerConfig::m_ranked)
     {
         computeNewRankings();
         submitRankingsToAddons();
     }
+    else if (m_game_setup->isGrandPrix())
+    {
+        unsigned player_count = RaceManager::get()->getNumPlayers();
+        m_result_ns->addUInt8((uint8_t)player_count);
+        for (unsigned i = 0; i < player_count; i++)
+        {
+            m_result_ns->addFloat(gp_changes[i]);
+        }
+    }
     m_state.store(WAIT_FOR_RACE_STOPPED);
+
+    if (!m_tracks_queue.empty())
+    {
+        m_tracks_queue.pop_front();
+        // Reload GP tracks if GP ends
+        if (m_tracks_queue.empty() && m_game_setup->isGrandPrix())
+            loadTracksQueueFromConfig();
+    }
 }   // checkRaceFinished
 
 //-----------------------------------------------------------------------------
+
 /** Compute the new player's rankings used in ranked servers
  */
 void ServerLobby::computeNewRankings()
@@ -3106,7 +3714,8 @@ void ServerLobby::computeNewRankings()
             // on how expected the result was (upsets can increase RD)
 
             // If there was a disconnect in this race, RD was handled once already
-            if (!w->getKart(i)->isEliminated()) {
+            if (!w->getKart(i)->isEliminated())
+            {
                 // First the RD reduction based on accuracy and current RD
                 double rd_change_factor = accuracy * 0.0016;
                 double rd_change = (-1) * prev_rating_deviations[i] * rd_change_factor;
@@ -3331,6 +3940,11 @@ void ServerLobby::clientDisconnected(Event* event)
         Log::info("ServerLobby", "%s disconnected", name.c_str());
     }
 
+    unsigned players_number;
+    STKHost::get()->updatePlayers(NULL, NULL, &players_number);
+    if (players_number == 0)
+        resetToDefaultSettings();
+
     // Don't show waiting peer disconnect message to in game player
     STKHost::get()->sendPacketToAllPeersWith([waiting_peer_disconnected]
         (STKPeer* p)
@@ -3421,11 +4035,18 @@ bool ServerLobby::handleAssets(const NetworkString& ns, STKPeer* peer)
     // as server
     float okt = 0.0f;
     float ott = 0.0f;
+    int addon_karts = 0;
+    int addon_tracks = 0;
+    int addon_arenas = 0;
+    int addon_soccers = 0;
     for (auto& client_kart : client_karts)
     {
         if (m_official_kts.first.find(client_kart) !=
             m_official_kts.first.end())
             okt += 1.0f;
+        if (m_addon_kts.first.find(client_kart) !=
+            m_addon_kts.first.end())
+            ++addon_karts;
     }
     okt = okt / (float)m_official_kts.first.size();
     for (auto& client_track : client_tracks)
@@ -3433,18 +4054,27 @@ bool ServerLobby::handleAssets(const NetworkString& ns, STKPeer* peer)
         if (m_official_kts.second.find(client_track) !=
             m_official_kts.second.end())
             ott += 1.0f;
+        if (m_addon_kts.second.find(client_track) !=
+            m_addon_kts.second.end())
+            ++addon_tracks;
+        if (m_addon_arenas.find(client_track) !=
+            m_addon_arenas.end())
+            ++addon_arenas;
+        if (m_addon_soccers.find(client_track) !=
+            m_addon_soccers.end())
+            ++addon_soccers;
     }
     ott = ott / (float)m_official_kts.second.size();
 
     std::set<std::string> karts_erase, tracks_erase;
-    for (const std::string& server_kart : m_available_kts.first)
+    for (const std::string& server_kart : m_entering_kts.first)
     {
         if (client_karts.find(server_kart) == client_karts.end())
         {
             karts_erase.insert(server_kart);
         }
     }
-    for (const std::string& server_track : m_available_kts.second)
+    for (const std::string& server_track : m_entering_kts.second)
     {
         if (client_tracks.find(server_track) == client_tracks.end())
         {
@@ -3452,15 +4082,77 @@ bool ServerLobby::handleAssets(const NetworkString& ns, STKPeer* peer)
         }
     }
 
-    if (karts_erase.size() == m_available_kts.first.size() ||
-        tracks_erase.size() == m_available_kts.second.size() ||
+    bool has_required_tracks = true;
+    for (const std::string& required_track : m_must_have_tracks)
+    {
+        if (client_tracks.find(required_track) == client_tracks.end())
+        {
+            has_required_tracks = false;
+            Log::info("ServerLobby", "Player does not have a required track '%s'.", required_track.c_str());
+            break;
+        }
+    }
+
+    Log::info("ServerLobby", "Player has the following addons: %d/%d karts,"
+        " %d/%d tracks, %d/%d arenas, %d/%d soccer fields.", addon_karts,
+        (int)ServerConfig::m_addon_karts_threshold, addon_tracks,
+        (int)ServerConfig::m_addon_tracks_threshold, addon_arenas,
+        (int)ServerConfig::m_addon_arenas_threshold, addon_soccers,
+        (int)ServerConfig::m_addon_soccers_threshold);
+
+    peer->addon_karts_count = addon_karts;
+    peer->addon_tracks_count = addon_tracks;
+    peer->addon_arenas_count = addon_arenas;
+    peer->addon_soccers_count = addon_soccers;
+
+    if (karts_erase.size() == m_entering_kts.first.size())
+        Log::verbose("ServerLobby", "Bad player: no common karts with server");
+    if (tracks_erase.size() == m_entering_kts.second.size())
+        Log::verbose("ServerLobby", "Bad player: no common tracks with server");
+    if (okt < ServerConfig::m_official_karts_threshold)
+        Log::verbose("ServerLobby", "Bad player: bad official kart threshold");
+    if (ott < ServerConfig::m_official_tracks_threshold)
+        Log::verbose("ServerLobby", "Bad player: bad official track threshold");
+    if (addon_karts < (int)ServerConfig::m_addon_karts_threshold)
+        Log::verbose("ServerLobby", "Bad player: too little addon karts");
+    if (addon_tracks < (int)ServerConfig::m_addon_tracks_threshold)
+        Log::verbose("ServerLobby", "Bad player: too little addon tracks");
+    if (addon_arenas < (int)ServerConfig::m_addon_arenas_threshold)
+        Log::verbose("ServerLobby", "Bad player: too little addon arenas");
+    if (addon_soccers < (int)ServerConfig::m_addon_soccers_threshold)
+        Log::verbose("ServerLobby", "Bad player: too little addon soccers");
+    if (!has_required_tracks)
+        Log::verbose("ServerLobby", "Bad player: no required tracks");
+
+    if (karts_erase.size() == m_entering_kts.first.size() ||
+        tracks_erase.size() == m_entering_kts.second.size() ||
         okt < ServerConfig::m_official_karts_threshold ||
-        ott < ServerConfig::m_official_tracks_threshold)
+        ott < ServerConfig::m_official_tracks_threshold ||
+        addon_karts < (int)ServerConfig::m_addon_karts_threshold ||
+        addon_tracks < (int)ServerConfig::m_addon_tracks_threshold ||
+        addon_arenas < (int)ServerConfig::m_addon_arenas_threshold ||
+        addon_soccers < (int)ServerConfig::m_addon_soccers_threshold ||
+        !has_required_tracks)
     {
         NetworkString *message = getNetworkString(2);
         message->setSynchronous(true);
         message->addUInt8(LE_CONNECTION_REFUSED)
             .addUInt8(RR_INCOMPATIBLE_DATA);
+
+        std::string advice = ServerConfig::m_incompatible_advice;
+        if (!advice.empty())
+        {
+            NetworkString* incompatible_reason = getNetworkString();
+            incompatible_reason->addUInt8(LE_CHAT);
+            incompatible_reason->setSynchronous(true);
+            incompatible_reason->encodeString16(
+                StringUtils::utf8ToWide(advice));
+            peer->sendPacket(incompatible_reason,
+                true/*reliable*/, false/*encrypted*/);
+            Log::info("ServerLobby", "Sent advice");
+            delete incompatible_reason;
+        }
+
         peer->cleanPlayerProfiles();
         peer->sendPacket(message, true/*reliable*/, false/*encrypted*/);
         peer->reset();
@@ -3498,23 +4190,19 @@ bool ServerLobby::handleAssets(const NetworkString& ns, STKPeer* peer)
 
     if (!m_addon_kts.first.empty())
     {
-        addons_scores[AS_KART] = int
-            ((float)addon_kart / (float)m_addon_kts.first.size() * 100.0);
+        addons_scores[AS_KART] = addon_kart;
     }
     if (!m_addon_kts.second.empty())
     {
-        addons_scores[AS_TRACK] = int
-            ((float)addon_track / (float)m_addon_kts.second.size() * 100.0);
+        addons_scores[AS_TRACK] = addon_track;
     }
     if (!m_addon_arenas.empty())
     {
-        addons_scores[AS_ARENA] = int
-            ((float)addon_arena / (float)m_addon_arenas.size() * 100.0);
+        addons_scores[AS_ARENA] = addon_arena;
     }
     if (!m_addon_soccers.empty())
     {
-        addons_scores[AS_SOCCER] = int
-            ((float)addon_soccer / (float)m_addon_soccers.size() * 100.0);
+        addons_scores[AS_SOCCER] = addon_soccer;
     }
 
     // Save available karts and tracks from clients in STKPeer so if this peer
@@ -3529,6 +4217,9 @@ bool ServerLobby::handleAssets(const NetworkString& ns, STKPeer* peer)
         updateAddons();
         updateTracksForMode();
     }
+
+    if (ServerConfig::m_soccer_tournament)
+        updateTournamentRole(peer);
     return true;
 }   // handleAssets
 
@@ -3543,8 +4234,8 @@ void ServerLobby::connectionRequested(Event* event)
 
     // can we add the player ?
     if (!allowJoinedPlayersWaiting() &&
-        (m_state.load() != WAITING_FOR_START_GAME ||
-        m_game_setup->isGrandPrixStarted()))
+        (m_state.load() != WAITING_FOR_START_GAME /*||
+        m_game_setup->isGrandPrixStarted()*/))
     {
         NetworkString *message = getNetworkString(2);
         message->setSynchronous(true);
@@ -3611,8 +4302,18 @@ void ServerLobby::connectionRequested(Event* event)
 
     unsigned total_players = 0;
     STKHost::get()->updatePlayers(NULL, NULL, &total_players);
+    unsigned max_players_mode = (unsigned)ServerConfig::m_server_max_players;
+    if (RaceManager::get()->getMinorMode() ==
+        RaceManager::MINOR_MODE_FREE_FOR_ALL)
+        max_players_mode = std::min<unsigned>(10, max_players_mode);
+    if (RaceManager::get()->getMinorMode() ==
+        RaceManager::MINOR_MODE_CAPTURE_THE_FLAG)
+        max_players_mode = std::min<unsigned>(14, max_players_mode);
+    if (RaceManager::get()->getMinorMode() ==
+        RaceManager::MINOR_MODE_SOCCER && !ServerConfig::m_soccer_tournament)
+        max_players_mode = std::min<unsigned>(14, max_players_mode);
     if (total_players + player_count + m_ai_profiles.size() >
-        (unsigned)ServerConfig::m_server_max_players)
+        max_players_mode)
     {
         NetworkString *message = getNetworkString(2);
         message->setSynchronous(true);
@@ -3685,6 +4386,26 @@ void ServerLobby::handleUnencryptedConnection(std::shared_ptr<STKPeer> peer,
     std::string password;
     data.decodeString(&password);
     const std::string& server_pw = ServerConfig::m_private_server_password;
+    if (online_id > 0)
+    {
+        std::string username = StringUtils::wideToUtf8(online_name);
+        if (m_temp_banned.count(username))
+        {
+            NetworkString* message = getNetworkString(2);
+            message->setSynchronous(true);
+            message->addUInt8(LE_CONNECTION_REFUSED)
+                .addUInt8(RR_BANNED);
+            std::string tempban = "Please behave well next time.";
+            message->encodeString(tempban);
+            peer->sendPacket(message, true/*reliable*/, false/*encrypted*/);
+            peer->reset();
+            delete message;
+            Log::verbose("ServerLobby", "Player refused: invalid player");
+            return;
+        }
+        if (m_usernames_white_list.count(username) > 0)
+            password = server_pw;
+    }
     if (password != server_pw)
     {
         NetworkString *message = getNetworkString(2);
@@ -3746,6 +4467,7 @@ void ServerLobby::handleUnencryptedConnection(std::shared_ptr<STKPeer> peer,
 #endif
 
     auto red_blue = STKHost::get()->getAllPlayersTeamInfo();
+    std::string utf8_online_name = StringUtils::wideToUtf8(online_name);
     for (unsigned i = 0; i < player_count; i++)
     {
         core::stringw name;
@@ -3755,6 +4477,8 @@ void ServerLobby::handleUnencryptedConnection(std::shared_ptr<STKPeer> peer,
             name = L"unnamed";
         else if (name.size() > 30)
             name = name.subString(0, 30);
+
+        std::string utf8_name = StringUtils::wideToUtf8(name);
         float default_kart_color = data.getFloat();
         HandicapLevel handicap = (HandicapLevel)data.getUInt8();
         auto player = std::make_shared<NetworkPlayerProfile>
@@ -3763,7 +4487,7 @@ void ServerLobby::handleUnencryptedConnection(std::shared_ptr<STKPeer> peer,
             peer->getHostId(), default_kart_color, i == 0 ? online_id : 0,
             handicap, (uint8_t)i, KART_TEAM_NONE,
             country_code);
-        if (ServerConfig::m_team_choosing)
+        if (ServerConfig::m_team_choosing && !ServerConfig::m_soccer_tournament)
         {
             KartTeam cur_team = KART_TEAM_NONE;
             if (red_blue.first > red_blue.second)
@@ -3778,6 +4502,35 @@ void ServerLobby::handleUnencryptedConnection(std::shared_ptr<STKPeer> peer,
             }
             player->setTeam(cur_team);
         }
+        if (ServerConfig::m_soccer_tournament)
+        {
+            if (m_tournament_red_players.count(utf8_online_name))
+                player->setTeam(KART_TEAM_RED);
+            else if (m_tournament_blue_players.count(utf8_online_name))
+                player->setTeam(KART_TEAM_BLUE);
+            if (tournamentColorsSwapped(m_tournament_game))
+            {
+                if (player->getTeam() == KART_TEAM_BLUE)
+                    player->setTeam(KART_TEAM_RED);
+                else if (player->getTeam() == KART_TEAM_RED)
+                    player->setTeam(KART_TEAM_BLUE);
+            }
+        }
+        std::string username = StringUtils::wideToUtf8(player->getName());
+        if (m_game_setup->isGrandPrix())
+        {
+            auto it = m_gp_scores.find(username);
+            if (it != m_gp_scores.end())
+            {
+                player->setScore(it->second.score);
+                player->setOverallTime(it->second.time);
+            }
+        }
+        auto it2 = m_team_for_player.find(username);
+        if (it2 != m_team_for_player.end())
+        {
+            player->setTemporaryTeam(it2->second - 1);
+        }
         peer->addPlayer(player);
     }
 
@@ -3883,22 +4636,28 @@ void ServerLobby::handleUnencryptedConnection(std::shared_ptr<STKPeer> peer,
         query = StringUtils::insertValues(
             "INSERT INTO %s "
             "(host_id, ip, ipv6 ,port, online_id, username, player_num, "
-            "country_code, version, os, ping) "
-            "VALUES (%u, 0, \"%s\" ,%u, %u, ?, %u, ?, ?, ?, %u);",
+            "country_code, version, os, ping, addon_karts_count, addon_tracks_count, "
+            "addon_arenas_count, addon_soccers_count) "
+            "VALUES (%u, 0, \"%s\" ,%u, %u, ?, %u, ?, ?, ?, %u, %d, %d, %d, %d);",
             m_server_stats_table.c_str(), peer->getHostId(),
             peer->getAddress().toString(false), peer->getAddress().getPort(),
-            online_id, player_count, peer->getAveragePing());
+            online_id, player_count, peer->getAveragePing(), peer->addon_karts_count,
+            peer->addon_tracks_count, peer->addon_arenas_count,
+            peer->addon_soccers_count);
     }
     else
     {
         query = StringUtils::insertValues(
             "INSERT INTO %s "
             "(host_id, ip, port, online_id, username, player_num, "
-            "country_code, version, os, ping) "
-            "VALUES (%u, %u, %u, %u, ?, %u, ?, ?, ?, %u);",
+            "country_code, version, os, ping, addon_karts_count, addon_tracks_count, "
+            "addon_arenas_count, addon_soccers_count) "
+            "VALUES (%u, %u, %u, %u, ?, %u, ?, ?, ?, %u, %d, %d, %d, %d);",
             m_server_stats_table.c_str(), peer->getHostId(),
             peer->getAddress().getIP(), peer->getAddress().getPort(),
-            online_id, player_count, peer->getAveragePing());
+            online_id, player_count, peer->getAveragePing(), peer->addon_karts_count,
+            peer->addon_tracks_count, peer->addon_arenas_count,
+            peer->addon_soccers_count);
     }
     easySQLQuery(query, [peer, country_code](sqlite3_stmt* stmt)
         {
@@ -3944,6 +4703,34 @@ void ServerLobby::handleUnencryptedConnection(std::shared_ptr<STKPeer> peer,
         }
     );
 #endif
+    if (m_kart_elimination.isEnabled())
+    {
+        NetworkString* chat = getNetworkString();
+        chat->addUInt8(LE_CHAT);
+        chat->setSynchronous(true);
+        std::string warning = m_kart_elimination.getWarningMessage();
+        chat->encodeString16(StringUtils::utf8ToWide(warning));
+        peer->sendPacket(chat, true/*reliable*/);
+        delete chat;
+    }
+    if (ServerConfig::m_record_replays)
+    {
+        std::string msg;
+        if (m_consent_on_replays)
+            msg = "Recording ghost replays is enabled. "
+                "The crowned player can change that "
+                "using /replay 0 (to disable) or /replay 1 (to enable). "
+                "Do not race under this feature if you don't want to be recorded.";
+        else
+            msg = "Recording ghost replays is disabled. "
+                "The crowned player can change that "
+                "using /replay 0 (to disable) or /replay 1 (to enable). ";
+        sendStringToPeer(msg, peer);
+    }
+    getMessagesFromHost(peer.get(), online_id);
+
+    if (ServerConfig::m_soccer_tournament)
+        updateTournamentRole(peer.get());
 }   // handleUnencryptedConnection
 
 //-----------------------------------------------------------------------------
@@ -3958,6 +4745,23 @@ void ServerLobby::updatePlayerList(bool update_when_reset_server)
     const bool game_started = m_state.load() != WAITING_FOR_START_GAME &&
         !update_when_reset_server;
 
+    if (update_when_reset_server)
+    {
+        if (!ServerConfig::m_soccer_tournament)
+        {
+            for (auto& peer : m_default_always_spectate_peers)
+                peer->setAlwaysSpectate(ASM_COMMAND);
+        }
+        else
+        {
+            auto peers = STKHost::get()->getPeers();
+            for (auto& peer: peers)
+            {
+                peer->setAlwaysSpectate(ASM_NONE);
+            }
+        }
+    }
+
     auto all_profiles = STKHost::get()->getAllPlayerProfiles();
     size_t all_profiles_size = all_profiles.size();
     for (auto& profile : all_profiles)
@@ -3966,7 +4770,7 @@ void ServerLobby::updatePlayerList(bool update_when_reset_server)
             all_profiles_size--;
     }
 
-    auto spectators_by_limit = getSpectatorsByLimit();
+    auto& spectators_by_limit = getSpectatorsByLimit(true);
 
     // N - 1 AI
     auto ai_instance = m_ai_peer.lock();
@@ -4018,16 +4822,36 @@ void ServerLobby::updatePlayerList(bool update_when_reset_server)
 
         // get OS information
         auto version_os = StringUtils::extractVersionOS(profile->getPeer()->getUserVersion());
+        bool angry_host = profile->getPeer()->isAngryHost();
         std::string os_type_str = version_os.second;
-        // if mobile OS
-        if (os_type_str == "iOS" || os_type_str == "Android")
-            // Add a Mobile emoji for mobile OS
-            profile_name = StringUtils::utf32ToWide({ 0x1F4F1 }) + profile_name;
+        std::string utf8_profile_name = StringUtils::wideToUtf8(profile_name);
+        // Add a Mobile emoji for mobile OS
+        if (ServerConfig::m_expose_mobile && 
+            (os_type_str == "iOS" || os_type_str == "Android"))
+            profile_name = StringUtils::utf32ToWide({0x1F4F1}) + profile_name;
 
         // Add an hourglass emoji for players waiting because of the player limit
-        if (spectators_by_limit.find(profile->getPeer()) != spectators_by_limit.end()) 
+        if (spectators_by_limit.find(profile->getPeer().get()) != spectators_by_limit.end())
             profile_name = StringUtils::utf32ToWide({ 0x231B }) + profile_name;
 
+        // Add a hammer emoji for angry host
+        if (angry_host)
+            profile_name = StringUtils::utf32ToWide({0x1F528}) + profile_name;
+
+        std::string prefix = "";
+        for (const std::string& category: m_categories_for_player[utf8_profile_name])
+        {
+            if (!m_hidden_categories.count(category))
+                prefix += category + ", ";
+        }
+        if (!prefix.empty())
+        {
+            prefix.resize((int)prefix.size() - 2);
+            prefix = "[" + prefix + "] ";
+        }
+
+        profile_name = StringUtils::utf8ToWide(prefix) + profile_name;
+
         pl->addUInt32(profile->getHostId()).addUInt32(profile->getOnlineId())
             .addUInt8(profile->getLocalPlayerId())
             .encodeString(profile_name);
@@ -4121,7 +4945,7 @@ void ServerLobby::updateServerOwner()
  */
 void ServerLobby::kartSelectionRequested(Event* event)
 {
-    if (m_state != SELECTING || m_game_setup->isGrandPrixStarted())
+    if (m_state != SELECTING /*|| m_game_setup->isGrandPrixStarted()*/)
     {
         Log::warn("ServerLobby", "Received kart selection while in state %d.",
                   m_state.load());
@@ -4174,13 +4998,17 @@ void ServerLobby::handlePlayerVote(Event* event)
     }
 
     // Remove / adjust any invalid settings
-    if (RaceManager::get()->modeHasLaps())
+    if (ServerConfig::m_soccer_tournament)
+    {
+        vote.m_reverse = false;
+    }
+    else if (RaceManager::get()->modeHasLaps())
     {
-        if (ServerConfig::m_auto_game_time_ratio > 0.0f)
+        if (m_default_lap_multiplier > 0.0f)
         {
             vote.m_num_laps =
                 (uint8_t)(fmaxf(1.0f, (float)t->getDefaultNumberOfLaps() *
-                ServerConfig::m_auto_game_time_ratio));
+                m_default_lap_multiplier));
         }
         else if (vote.m_num_laps == 0 || vote.m_num_laps > 20)
             vote.m_num_laps = (uint8_t)3;
@@ -4191,9 +5019,9 @@ void ServerLobby::handlePlayerVote(Event* event)
     {
         if (m_game_setup->isSoccerGoalTarget())
         {
-            if (ServerConfig::m_auto_game_time_ratio > 0.0f)
+            if (m_default_lap_multiplier > 0.0f)
             {
-                vote.m_num_laps = (uint8_t)(ServerConfig::m_auto_game_time_ratio *
+                vote.m_num_laps = (uint8_t)(m_default_lap_multiplier *
                                             UserConfigParams::m_num_goals);
             }
             else if (vote.m_num_laps > 10)
@@ -4201,9 +5029,9 @@ void ServerLobby::handlePlayerVote(Event* event)
         }
         else
         {
-            if (ServerConfig::m_auto_game_time_ratio > 0.0f)
+            if (m_default_lap_multiplier > 0.0f)
             {
-                vote.m_num_laps = (uint8_t)(ServerConfig::m_auto_game_time_ratio *
+                vote.m_num_laps = (uint8_t)(m_default_lap_multiplier *
                                             UserConfigParams::m_soccer_time_limit);
             }
             else if (vote.m_num_laps > 15)
@@ -4221,6 +5049,10 @@ void ServerLobby::handlePlayerVote(Event* event)
         vote.m_num_laps = 0;
         vote.m_reverse = false;
     }
+    if (m_fixed_lap >= 0)
+    {
+        vote.m_num_laps = m_fixed_lap;
+    }
 
     // Store vote:
     vote.m_player_name = event->getPeer()->getPlayerProfiles()[0]->getName();
@@ -4485,8 +5317,8 @@ void ServerLobby::playerFinishedResult(Event *event)
 //-----------------------------------------------------------------------------
 bool ServerLobby::waitingForPlayers() const
 {
-    if (m_game_setup->isGrandPrix() && m_game_setup->isGrandPrixStarted())
-        return false;
+    // if (m_game_setup->isGrandPrix() && m_game_setup->isGrandPrixStarted())
+    //     return false;
     return m_state.load() >= WAITING_FOR_START_GAME;
 }   // waitingForPlayers
 
@@ -4720,7 +5552,7 @@ void ServerLobby::configPeersStartTime()
 //-----------------------------------------------------------------------------
 bool ServerLobby::allowJoinedPlayersWaiting() const
 {
-    return !m_game_setup->isGrandPrix();
+    return true; //!m_game_setup->isGrandPrix();
 }   // allowJoinedPlayersWaiting
 
 //-----------------------------------------------------------------------------
@@ -4848,6 +5680,62 @@ void ServerLobby::testBannedForIP(STKPeer* peer) const
 #endif
 }   // testBannedForIP
 
+//-----------------------------------------------------------------------------
+void ServerLobby::getMessagesFromHost(STKPeer* peer, int online_id) const
+{
+#ifdef ENABLE_SQLITE3
+    if (!m_db || !m_player_reports_table_exists || online_id == 0)
+        return;
+
+    int row_id;
+    // At most one message for now, sorry
+    std::string query = StringUtils::insertValues(
+        "SELECT rowid, reported_time, info FROM \"%s\" "
+        "WHERE reporter_online_id = %u "
+        "AND reporting_online_id = -1 "
+        "AND (server_uid = \"\" OR server_uid = \"%s\") LIMIT 1;",
+        ServerConfig::m_player_reports_table.c_str(),
+        online_id, ServerConfig::m_server_uid.c_str());
+
+    sqlite3_stmt* stmt = NULL;
+    int ret = sqlite3_prepare_v2(m_db, query.c_str(), -1, &stmt, 0);
+    if (ret == SQLITE_OK)
+    {
+        ret = sqlite3_step(stmt);
+        if (ret == SQLITE_ROW)
+        {
+            row_id = sqlite3_column_int(stmt, 0);
+            const char* timestamp = (char*)sqlite3_column_text(stmt, 1);
+            const char* info = (char*)sqlite3_column_text(stmt, 2);
+            Log::info("ServerLobby", "A message from server was delivered");
+            std::string msg = "A message from the server (" +
+                std::string(timestamp) + "):\n" + std::string(info);
+            sendStringToPeer(msg, peer);
+        }
+        ret = sqlite3_finalize(stmt);
+        if (ret != SQLITE_OK)
+        {
+            Log::error("ServerLobby",
+                "Error finalize database for query %s: %s",
+                query.c_str(), sqlite3_errmsg(m_db));
+        }
+    }
+    else
+    {
+        Log::error("ServerLobby", "Error preparing database for query %s: %s",
+            query.c_str(), sqlite3_errmsg(m_db));
+        return;
+    }
+    if (row_id != -1)
+    {
+        query = StringUtils::insertValues(
+            "DELETE FROM \"%s\" WHERE rowid = %u;",
+            ServerConfig::m_player_reports_table.c_str(), row_id);
+        easySQLQuery(query);
+    }
+#endif
+}   // getMessagesFromHost
+
 //-----------------------------------------------------------------------------
 void ServerLobby::testBannedForIPv6(STKPeer* peer) const
 {
@@ -5046,18 +5934,9 @@ float ServerLobby::getStartupBoostOrPenaltyForKart(uint32_t ping,
 }   // getStartupBoostOrPenaltyForKart
 
 //-----------------------------------------------------------------------------
-/*! \brief Called when the server owner request to change game mode or
- *         difficulty.
- *  \param event : Event providing the information.
- *
- *  Format of the data :
- *  Byte 0            1            2
- *       -----------------------------------------------
- *  Size |     1      |     1     |         1          |
- *  Data | difficulty | game mode | soccer goal target |
- *       -----------------------------------------------
- */
-void ServerLobby::handleServerConfiguration(Event* event)
+
+void ServerLobby::handleServerConfiguration(std::shared_ptr<STKPeer> peer,
+    int difficulty, int mode, bool soccer_goal_target)
 {
     if (m_state != WAITING_FOR_START_GAME)
     {
@@ -5071,18 +5950,28 @@ void ServerLobby::handleServerConfiguration(Event* event)
         Log::warn("ServerLobby", "server-configurable is not enabled.");
         return;
     }
-    if (event->getPeerSP() != m_server_owner.lock())
+    unsigned total_players = 0;
+    STKHost::get()->updatePlayers(NULL, NULL, &total_players);
+    if ((mode == 6 && total_players > 14) ||
+        (mode == 7 && total_players > 10) ||
+        (mode == 8 && total_players > 14))
+    {
+        Log::error("ServerLobby", "Too many players (%d) to change mode to %d.",
+            total_players, mode);
+        std::string msg = "Too many players present to activate this mode. "
+            "Soccer and CTF require at most 14, and FFA requires at most 10.";
+        sendStringToPeer(msg, peer);
+        return;
+    }
+    if ((m_available_difficulties.count(difficulty) == 0 || 
+        m_available_modes.count(mode) == 0))
     {
-        Log::warn("ServerLobby",
-            "Client %d is not authorised to config server.",
-            event->getPeer()->getHostId());
+        Log::error("ServerLobby", "Mode %d and/or difficulty %d are not permitted.");
+        std::string msg = "Mode or difficulty are not permitted on this server";
+        sendStringToPeer(msg, peer);
         return;
     }
-    NetworkString& data = event->data();
-    int new_difficulty = data.getUInt8();
-    int new_game_mode = data.getUInt8();
-    bool new_soccer_goal_target = data.getUInt8() == 1;
-    auto modes = ServerConfig::getLocalGameMode(new_game_mode);
+    auto modes = ServerConfig::getLocalGameMode(mode);
     if (modes.second == RaceManager::MAJOR_MODE_GRAND_PRIX)
     {
         Log::warn("ServerLobby", "Grand prix is used for new mode.");
@@ -5091,30 +5980,30 @@ void ServerLobby::handleServerConfiguration(Event* event)
 
     RaceManager::get()->setMinorMode(modes.first);
     RaceManager::get()->setMajorMode(modes.second);
-    RaceManager::get()->setDifficulty(RaceManager::Difficulty(new_difficulty));
+    RaceManager::get()->setDifficulty(RaceManager::Difficulty(difficulty));
     m_game_setup->resetExtraServerInfo();
     if (RaceManager::get()->getMinorMode() == RaceManager::MINOR_MODE_SOCCER)
-        m_game_setup->setSoccerGoalTarget(new_soccer_goal_target);
+        m_game_setup->setSoccerGoalTarget(soccer_goal_target);
 
     if (NetworkConfig::get()->isWAN() &&
-        (m_difficulty.load() != new_difficulty ||
-        m_game_mode.load() != new_game_mode))
+        (m_difficulty.load() != difficulty ||
+        m_game_mode.load() != mode))
     {
         Log::info("ServerLobby", "Updating server info with new "
-            "difficulty: %d, game mode: %d to stk-addons.", new_difficulty,
-            new_game_mode);
+            "difficulty: %d, game mode: %d to stk-addons.", difficulty,
+            mode);
         int priority = Online::RequestManager::HTTP_MAX_PRIORITY;
         auto request = std::make_shared<Online::XMLRequest>(priority);
         NetworkConfig::get()->setServerDetails(request, "update-config");
         const SocketAddress& addr = STKHost::get()->getPublicAddress();
         request->addParameter("address", addr.getIP());
         request->addParameter("port", addr.getPort());
-        request->addParameter("new-difficulty", new_difficulty);
-        request->addParameter("new-game-mode", new_game_mode);
+        request->addParameter("new-difficulty", difficulty);
+        request->addParameter("new-game-mode", mode);
         request->queue();
     }
-    m_difficulty.store(new_difficulty);
-    m_game_mode.store(new_game_mode);
+    m_difficulty.store(difficulty);
+    m_game_mode.store(mode);
     updateTracksForMode();
 
     auto peers = STKHost::get()->getPeers();
@@ -5152,6 +6041,55 @@ void ServerLobby::handleServerConfiguration(Event* event)
     sendMessageToPeers(server_info);
     delete server_info;
     updatePlayerList();
+
+    if (m_kart_elimination.isEnabled() &&
+        RaceManager::get()->getMinorMode() != RaceManager::MINOR_MODE_NORMAL_RACE &&
+        RaceManager::get()->getMinorMode() != RaceManager::MINOR_MODE_TIME_TRIAL)
+    {
+        m_kart_elimination.disable();
+        NetworkString* chat = getNetworkString();
+        chat->addUInt8(LE_CHAT);
+        chat->setSynchronous(true);
+        chat->encodeString16(
+                L"Gnu Elimination is disabled because of non-racing mode");
+        sendMessageToPeers(chat);
+        delete chat;
+    }
+}   // handleServerConfiguration
+//-----------------------------------------------------------------------------
+/*! \brief Called when the server owner request to change game mode or
+ *         difficulty.
+ *  \param event : Event providing the information.
+ *
+ *  Format of the data :
+ *  Byte 0            1            2
+ *       -----------------------------------------------
+ *  Size |     1      |     1     |         1          |
+ *  Data | difficulty | game mode | soccer goal target |
+ *       -----------------------------------------------
+ */
+void ServerLobby::handleServerConfiguration(Event* event)
+{
+    if (event != NULL && event->getPeerSP() != m_server_owner.lock())
+    {
+        Log::warn("ServerLobby",
+            "Client %d is not authorised to config server.",
+            event->getPeer()->getHostId());
+        return;
+    }
+    int new_difficulty = ServerConfig::m_server_difficulty;
+    int new_game_mode = ServerConfig::m_server_mode;
+    bool new_soccer_goal_target = ServerConfig::m_soccer_goal_target;
+    if (event != NULL)
+    {
+        NetworkString& data = event->data();
+        new_difficulty = data.getUInt8();
+        new_game_mode = data.getUInt8();
+        new_soccer_goal_target = data.getUInt8() == 1;
+    }
+    handleServerConfiguration(
+        (event ? event->getPeerSP() : std::shared_ptr<STKPeer>()),
+        new_difficulty, new_game_mode, new_soccer_goal_target);
 }   // handleServerConfiguration
 
 //-----------------------------------------------------------------------------
@@ -5318,10 +6256,18 @@ void ServerLobby::addLiveJoinPlaceholder(
 void ServerLobby::setPlayerKarts(const NetworkString& ns, STKPeer* peer) const
 {
     unsigned player_count = ns.getUInt8();
+    player_count = std::min(player_count, (unsigned)peer->getPlayerProfiles().size());
     for (unsigned i = 0; i < player_count; i++)
     {
         std::string kart;
         ns.decodeString(&kart);
+        std::string username = StringUtils::wideToUtf8(
+            peer->getPlayerProfiles()[i]->getName());
+        if (m_kart_elimination.isEliminated(username))
+        {
+            peer->getPlayerProfiles()[i]->setKartName(m_kart_elimination.getKart());
+            continue;
+        }
         if (kart.find("randomkart") != std::string::npos ||
             (kart.find("addon_") == std::string::npos &&
             m_available_kts.first.find(kart) == m_available_kts.first.end()))
@@ -5454,7 +6400,7 @@ void ServerLobby::clientInGameWantsToBackLobby(Event* event)
     server_info->setSynchronous(true);
     server_info->addUInt8(LE_SERVER_INFO);
     m_game_setup->addServerInfo(server_info);
-    peer->sendPacket(server_info, /*reliable*/true);
+    peer->sendPacket(server_info, /*relsiable*/true);
     delete server_info;
 }   // clientInGameWantsToBackLobby
 
@@ -5506,22 +6452,34 @@ void ServerLobby::clientSelectingAssetsWantsToBackLobby(Event* event)
     delete server_info;
 }   // clientSelectingAssetsWantsToBackLobby
 
-std::set<std::shared_ptr<STKPeer>> ServerLobby::getSpectatorsByLimit()
+//-----------------------------------------------------------------------------
+std::set<STKPeer*>& ServerLobby::getSpectatorsByLimit(bool update)
 {
-    std::set<std::shared_ptr<STKPeer>> spectators_by_limit;
+    if (!update)
+        return m_spectators_by_limit;
+
+    m_spectators_by_limit.clear();
 
     auto peers = STKHost::get()->getPeers();
-    std::set<std::shared_ptr<STKPeer>> always_spectate_peers;
 
     unsigned player_limit = ServerConfig::m_max_players_in_game;
-    // only 10 players allowed for battle or soccer
-    if (RaceManager::get()->isBattleMode() || RaceManager::get()->isSoccerMode())
+    // only 10 players allowed for FFA and 14 for CTF and soccer
+    if (RaceManager::get()->getMinorMode() ==
+            RaceManager::MINOR_MODE_FREE_FOR_ALL)
         player_limit = std::min(player_limit, 10u);
 
+    if (RaceManager::get()->getMinorMode() ==
+            RaceManager::MINOR_MODE_CAPTURE_THE_FLAG)
+        player_limit = std::min(player_limit, 14u);
+
+    if (RaceManager::get()->getMinorMode() ==
+            RaceManager::MINOR_MODE_SOCCER)
+        player_limit = std::min(player_limit, 14u);
+
     unsigned ingame_players = 0, waiting_players = 0, total_players = 0;
     STKHost::get()->updatePlayers(&ingame_players, &waiting_players, &total_players);
     if (total_players <= player_limit)
-        return spectators_by_limit;
+        return m_spectators_by_limit;
 
     std::sort(peers.begin(), peers.end(),
         [](const std::shared_ptr<STKPeer>& a,
@@ -5547,7 +6505,7 @@ std::set<std::shared_ptr<STKPeer>> ServerLobby::getSpectatorsByLimit()
                 continue;
             player_count += (unsigned)peer->getPlayerProfiles().size();
             if (player_count > player_limit)
-                spectators_by_limit.insert(peer);
+                m_spectators_by_limit.insert(peer.get());
         }
         else
         {
@@ -5555,11 +6513,11 @@ std::set<std::shared_ptr<STKPeer>> ServerLobby::getSpectatorsByLimit()
                 continue;
             player_count += (unsigned)peer->getPlayerProfiles().size();
             if (peer->isWaitingForGame() && (player_count > player_limit || ingame_players >= player_limit))
-                spectators_by_limit.insert(peer);
+                m_spectators_by_limit.insert(peer.get());
         }
     }
-    return spectators_by_limit;
-}
+    return m_spectators_by_limit;
+}   // getSpectatorsByLimit
 
 //-----------------------------------------------------------------------------
 void ServerLobby::saveInitialItems(std::shared_ptr<NetworkItemManager> nim)
@@ -5579,18 +6537,22 @@ bool ServerLobby::supportsAI()
 bool ServerLobby::checkPeersReady(bool ignore_ai_peer) const
 {
     bool all_ready = true;
+    bool someone_races = false;
     for (auto p : m_peers_ready)
     {
         auto peer = p.first.lock();
         if (!peer)
             continue;
+        if (!canRace(peer))
+            continue;
         if (ignore_ai_peer && peer->isAIPeer())
             continue;
+        someone_races = true;
         all_ready = all_ready && p.second;
         if (!all_ready)
             return false;
     }
-    return true;
+    return someone_races;
 }   // checkPeersReady
 
 //-----------------------------------------------------------------------------
@@ -5605,30 +6567,142 @@ void ServerLobby::handleServerCommand(Event* event,
     auto argv = StringUtils::split(cmd, ' ');
     if (argv.size() == 0)
         return;
-    if (argv[0] == "spectate")
+    if (argv[0] == "replay")
     {
-        if (m_game_setup->isGrandPrix() || !ServerConfig::m_live_players)
+        if (!ServerConfig::m_owner_less && !hasHostRights(peer))
+        {
+            std::string msg = "You are not server owner";
+            sendStringToPeer(msg, peer);
+            return;
+        }
+        if (ServerConfig::m_record_replays)
+        {
+            if (argv.size() >= 2 && argv[1] == "0")
+                m_consent_on_replays = false;
+            else if (argv.size() >= 2 && argv[1] == "1")
+                m_consent_on_replays = true;
+            else
+                m_consent_on_replays ^= 1;
+
+            std::string msg = "Recording ghost replays is now ";
+            msg += (m_consent_on_replays ? "on" : "off");
+            sendStringToAllPeers(msg);
+        }
+        else
+        {
+            std::string msg = "This server doesn't allow recording replays";
+            sendStringToPeer(msg, peer);
+        }
+    }
+    else if (argv[0] == "start")
+    {
+        if (!ServerConfig::m_owner_less && !hasHostRights(peer))
+        {
+            std::string msg = "You are not server owner";
+            sendStringToPeer(msg, peer);
+            return;
+        }
+        startSelection(event);
+    }
+    else if (argv[0] == "config")
+    {
+        if (!hasHostRights(peer))
+        {
+            std::string msg = "You are not server owner";
+            sendStringToPeer(msg, peer);
+            return;
+        }
+        int difficulty = getDifficulty();
+        int mode = getGameMode();
+        bool goal_target = m_game_setup->isSoccerGoalTarget();
+        bool gp = false;
+        for (unsigned i = 1; i < argv.size(); i++)
+        {
+            if (argv[i] == "tt" || argv[i] == "time-trial"||
+                argv[i] == "trial" || argv[i] == "m4")
+                mode = 4;
+            if (argv[i] == "normal" || argv[i] == "normal-race" ||
+                argv[i] == "race" || argv[i] == "m3")
+                mode = 3;
+            if (argv[i] == "soccer" || argv[i] == "football" ||
+                argv[i] == "m6")
+                mode = 6;
+            if (argv[i] == "ffa" || argv[i] == "free-for-all" ||
+                argv[i] == "free" || argv[i] == "for" ||
+                argv[i] == "all" || argv[i] == "m7")
+                mode = 7;
+            if (argv[i] == "ctf" || argv[i] == "capture-the-flag"
+                || argv[i] == "capture" || argv[i] == "the" ||
+                argv[i] == "flag" || argv[i] == "m8")
+                mode = 8;
+            // if (argv[i] == "gp" || argv[i] == "grand-prix")
+            //     gp = true;
+            if (argv[i] == "d0" || argv[i] == "novice" || argv[i] == "easy")
+                difficulty = 0;
+            if (argv[i] == "d1" || argv[i] == "intermediate" || argv[i] == "medium")
+                difficulty = 1;
+            if (argv[i] == "d2" || argv[i] == "expert" || argv[i] == "hard")
+                difficulty = 2;
+            if (argv[i] == "d3" || argv[i] == "supertux" || argv[i] == "super" || argv[i] == "best")
+                difficulty = 3;
+            if (argv[i] == "goal-limit" || argv[i] == "gl" || argv[i] == "goal" || argv[i] == "goals")
+                goal_target = true;
+            if (argv[i] == "time-limit" || argv[i] == "tl" || argv[i] == "time" || argv[i] == "minutes")
+                goal_target = false;
+        }
+        // if (gp && (mode == 3 || mode == 4))
+        //     mode -= 3;
+        handleServerConfiguration(peer, difficulty, mode, goal_target);
+    }
+    else if (argv[0] == "spectate")
+    {
+        if (ServerConfig::m_soccer_tournament /*|| ServerConfig::m_only_host_riding*/)
+        {
+            std::string msg = "All spectators already have auto spectate ability";
+            sendStringToPeer(msg, peer);
+            return;
+        }
+        if (/*m_game_setup->isGrandPrix() || */!ServerConfig::m_live_players)
         {
-            NetworkString* chat = getNetworkString();
-            chat->addUInt8(LE_CHAT);
-            chat->setSynchronous(true);
             std::string msg = "Server doesn't support spectate";
-            chat->encodeString16(StringUtils::utf8ToWide(msg));
-            peer->sendPacket(chat, true/*reliable*/);
-            delete chat;
+            sendStringToPeer(msg, peer);
             return;
         }
+        if (argv.size() == 1)
+        {
+            if (m_state.load() != WAITING_FOR_START_GAME)
+            {
+                std::string username = StringUtils::wideToUtf8(
+                    peer->getPlayerProfiles()[0]->getName());
+                if (m_default_always_spectate_peers.count(peer.get()))
+                    argv.push_back("0");
+                else
+                    argv.push_back("1");
+            }
+            else
+            {
+                if (peer->alwaysSpectate())
+                    argv.push_back("0");
+                else
+                    argv.push_back("1");
+            }
+        }
 
-        if (argv.size() != 2 || (argv[1] != "0" && argv[1] != "1") ||
-            m_state.load() != WAITING_FOR_START_GAME)
+        if (argv.size() != 2 || (argv[1] != "0" && argv[1] != "1"))
         {
-            NetworkString* chat = getNetworkString();
-            chat->addUInt8(LE_CHAT);
-            chat->setSynchronous(true);
-            std::string msg = "Usage: spectate [0 or 1], before game started";
-            chat->encodeString16(StringUtils::utf8ToWide(msg));
-            peer->sendPacket(chat, true/*reliable*/);
-            delete chat;
+            std::string msg = "Usage: /spectate [empty or 0 or 1], sets or resets (or changes) the spectating mode.";
+            sendStringToPeer(msg, peer);
+            return;
+        }
+
+        if (m_state.load() != WAITING_FOR_START_GAME)
+        {
+            std::string username = StringUtils::wideToUtf8(
+                peer->getPlayerProfiles()[0]->getName());
+            if (argv[1] == "1")
+                m_default_always_spectate_peers.insert(peer.get());
+            else
+                m_default_always_spectate_peers.erase(peer.get());
             return;
         }
 
@@ -5637,13 +6711,8 @@ void ServerLobby::handleServerCommand(Event* event,
             if (m_process_type == PT_CHILD &&
                 peer->getHostId() == m_client_server_host_id.load())
             {
-                NetworkString* chat = getNetworkString();
-                chat->addUInt8(LE_CHAT);
-                chat->setSynchronous(true);
                 std::string msg = "Graphical client server cannot spectate";
-                chat->encodeString16(StringUtils::utf8ToWide(msg));
-                peer->sendPacket(chat, true/*reliable*/);
-                delete chat;
+                sendStringToPeer(msg, peer);
                 return;
             }
             peer->setAlwaysSpectate(ASM_COMMAND);
@@ -5652,13 +6721,125 @@ void ServerLobby::handleServerCommand(Event* event,
             peer->setAlwaysSpectate(ASM_NONE);
         updatePlayerList();
     }
-    else if (argv[0] == "listserveraddon")
+    else if (argv[0] == "addons" || argv[0] == "moreaddons")
     {
-        NetworkString* chat = getNetworkString();
-        chat->addUInt8(LE_CHAT);
-        chat->setSynchronous(true);
-        bool has_options = argv.size() > 1 &&
-            (argv[1].compare("-track") == 0 ||
+        bool more = (argv[0] == "moreaddons");
+        if (argv.size() == 1)
+        {
+            argv.push_back("");
+            switch (m_game_mode.load())
+            {
+                case 0:
+                case 1:
+                case 3:
+                case 4:
+                    argv[1] = "track";
+                    break;
+                case 6:
+                    argv[1] = "soccer";
+                    break;
+                case 7:
+                case 8:
+                    argv[1] = "arena";
+                    break;
+            }
+        }
+        const std::set<std::string>& from =
+            (argv[1] == "kart" ? m_addon_kts.first :
+            (argv[1] == "track" ? m_addon_kts.second :
+            (argv[1] == "arena" ? m_addon_arenas :
+            /*argv[1] == "soccer" ?*/ m_addon_soccers
+        )));
+        std::vector<std::pair<std::string, std::vector<std::string>>> result;
+        for (const std::string& s: from)
+            result.push_back({s, {}});
+
+        auto peers = STKHost::get()->getPeers();
+        int num_players = 0;
+        for (auto peer : peers)
+        {
+            if (!peer || !peer->isValidated() || peer->isWaitingForGame() || !canRace(peer))
+                continue;
+            ++num_players;
+            std::string username = StringUtils::wideToUtf8(
+                    peer->getPlayerProfiles()[0]->getName());
+            const auto& kt = peer->getClientAssets();
+            const auto& container = (argv[1] == "kart" ? kt.first : kt.second);
+            for (auto& p: result)
+                if (container.find(p.first) == container.end())
+                    p.second.push_back(username);
+        }
+        std::random_device rd;
+        std::mt19937 g(rd());
+        std::shuffle(result.begin(), result.end(), g);
+        std::stable_sort(result.begin(), result.end(),
+            [](const std::pair<std::string, std::vector<std::string>>& a,
+                const std::pair<std::string, std::vector<std::string>>& b) -> bool {
+                if (a.second.size() != b.second.size())
+                    return a.second.size() > b.second.size();
+                return false;
+            });
+        std::string response;
+        const int NEXT_ADDONS = 5;
+        std::vector<std::string> all_have;
+        while (!result.empty() && (int)result.back().second.size() == 0)
+        {
+            all_have.push_back(result.back().first);
+            result.pop_back();
+        }
+        if (num_players > 0) {
+            response = "Found " + std::to_string(all_have.size()) + " asset(s)";
+            std::reverse(result.begin(), result.end());
+            if (result.size() > NEXT_ADDONS)
+                result.resize(NEXT_ADDONS);
+            if (!more)
+            {
+                bool nothing = true;
+                for (const std::string& s: all_have)
+                {
+                    if (s.length() < 6 || s.substr(0, 6) != "addon_")
+                        continue;
+                    response.push_back(nothing ? ':' : ',');
+                    nothing = false;
+                    response.push_back(' ');
+                    response += s.substr(6);
+                }
+                if (response.length() > 100)
+                    response += "\nTotal: " + std::to_string(all_have.size());
+            }
+            else
+            {
+                if (result.empty())
+                    response += "\nNothing more to install!";
+                else
+                {
+                    response += ". More addons to install:";
+                    for (unsigned i = 0; i < result.size(); ++i)
+                    {
+                        response += "\n" + result[i].first + ", missing for "
+                            + std::to_string(result[i].second.size())
+                            + " player(s):";
+                        std::sort(result[i].second.begin(), result[i].second.end());
+                        for (unsigned j = 0; j < result[i].second.size(); ++j)
+                        {
+                            response += " " + result[i].second[j];
+                        }
+                    }
+                }
+            }
+        } else {
+            response = "No one in the lobby can play. Found "
+                + std::to_string(all_have.size()) + " assets on the server.";
+        }
+        sendStringToPeer(response, peer);
+    }
+    else if (argv[0] == "listserveraddon")
+    {
+        NetworkString* chat = getNetworkString();
+        chat->addUInt8(LE_CHAT);
+        chat->setSynchronous(true);
+        bool has_options = argv.size() > 1 &&
+            (argv[1].compare("-track") == 0 ||
             argv[1].compare("-arena") == 0 ||
             argv[1].compare("-kart") == 0 ||
             argv[1].compare("-soccer") == 0);
@@ -5687,22 +6868,22 @@ void ServerLobby::handleServerCommand(Event* event,
             }
 
             std::set<std::string> total_addons;
-            if(type.empty() || // not specify addon type
+            if (type.empty() || // not specify addon type
                (!type.empty() && type.compare("kart") == 0)) // list kart addon
             {
                 total_addons.insert(m_addon_kts.first.begin(), m_addon_kts.first.end());
             }
-            if(type.empty() || // not specify addon type
+            if (type.empty() || // not specify addon type
                (!type.empty() && type.compare("track") == 0))
             {
                 total_addons.insert(m_addon_kts.second.begin(), m_addon_kts.second.end());
             }
-            if(type.empty() || // not specify addon type
+            if (type.empty() || // not specify addon type
                (!type.empty() && type.compare("arena") == 0))
             {
                 total_addons.insert(m_addon_arenas.begin(), m_addon_arenas.end());
             }
-            if(type.empty() || // not specify addon type
+            if (type.empty() || // not specify addon type
                (!type.empty() && type.compare("soccer") == 0))
             {
                 total_addons.insert(m_addon_soccers.begin(), m_addon_soccers.end());
@@ -5788,7 +6969,7 @@ void ServerLobby::handleServerCommand(Event* event,
     }
     else if (StringUtils::startsWith(cmd, "kick"))
     {
-        if (m_server_owner.lock() != peer)
+        if (!hasHostRights(peer))
         {
             NetworkString* chat = getNetworkString();
             chat->addUInt8(LE_CHAT);
@@ -5799,8 +6980,15 @@ void ServerLobby::handleServerCommand(Event* event,
             return;
         }
         std::string player_name;
-        if (cmd.length() > 5)
+        if (StringUtils::startsWith(cmd, "kickban"))
+        {
+            if (cmd.length() > 8)
+                player_name = cmd.substr(8);
+        }
+        else if (cmd.length() > 5)
+        {
             player_name = cmd.substr(5);
+        }
         std::shared_ptr<STKPeer> player_peer = STKHost::get()->findPeerByName(
             StringUtils::utf8ToWide(player_name));
         if (player_name.empty() || !player_peer || player_peer->isAIPeer())
@@ -5813,9 +7001,116 @@ void ServerLobby::handleServerCommand(Event* event,
             peer->sendPacket(chat, true/*reliable*/);
             delete chat;
         }
+        else if (player_peer->isAngryHost())
+        {
+            std::string msg = "This player is the owner of this server, "
+                "and is protected from your actions now";
+            sendStringToPeer(msg, peer);
+            return;
+        }
         else
         {
+            if (!peer->isAngryHost() && !ServerConfig::m_kicks_allowed)
+            {
+                std::string msg = "Kicking players is not allowed on this server";
+                sendStringToPeer(msg, peer);
+                return;
+            }
+            Log::info("ServerLobby", "Crown player kicks %s", player_name.c_str());
             player_peer->kick();
+            if (ServerConfig::m_track_kicks)
+            {
+                std::string auto_report = "[ Auto report caused by kick ]";
+                writeOwnReport(player_peer.get(), peer.get(), auto_report);
+            }
+            if (StringUtils::startsWith(cmd, "kickban"))
+            {
+                if (peer->isAngryHost() || ServerConfig::m_soccer_tournament)
+                {
+                    Log::info("ServerLobby", "%s is now banned", player_name.c_str());
+                    m_temp_banned.insert(player_name);
+                    std::string msg = StringUtils::insertValues(
+                        "%s is now banned", player_name.c_str());
+                    sendStringToPeer(msg, peer);
+                }
+                else
+                {
+                    std::string msg = "You cannot ban players";
+                    sendStringToPeer(msg, peer);
+                }
+            }
+        }
+    }
+    else if (StringUtils::startsWith(cmd, "unban"))
+    {
+        if (!hasHostRights(peer) || !(peer->isAngryHost() || ServerConfig::m_soccer_tournament))
+        {
+            NetworkString* chat = getNetworkString();
+            chat->addUInt8(LE_CHAT);
+            chat->setSynchronous(true);
+            chat->encodeString16(L"You cannot unban players");
+            peer->sendPacket(chat, true/*reliable*/);
+            delete chat;
+            return;
+        }
+        std::string player_name;
+        if (cmd.length() > 6)
+        {
+            player_name = cmd.substr(6);
+        }
+        if (player_name.empty())
+        {
+            NetworkString* chat = getNetworkString();
+            chat->addUInt8(LE_CHAT);
+            chat->setSynchronous(true);
+            chat->encodeString16(
+                L"Usage: /unban [player name]");
+            peer->sendPacket(chat, true/*reliable*/);
+            delete chat;
+        }
+        else
+        {
+            std::string msg = StringUtils::insertValues(
+                "%s is now unbanned", player_name.c_str());
+            Log::info("ServerLobby", "%s is now unbanned", player_name.c_str());
+            m_temp_banned.erase(player_name);
+            sendStringToPeer(msg, peer);
+        }
+    }
+    else if (StringUtils::startsWith(cmd, "ban"))
+    {
+        if (!hasHostRights(peer) || !(peer->isAngryHost() || ServerConfig::m_soccer_tournament))
+        {
+            NetworkString* chat = getNetworkString();
+            chat->addUInt8(LE_CHAT);
+            chat->setSynchronous(true);
+            chat->encodeString16(L"You cannot ban players");
+            peer->sendPacket(chat, true/*reliable*/);
+            delete chat;
+            return;
+        }
+        std::string player_name;
+        if (cmd.length() > 4)
+        {
+            player_name = cmd.substr(4);
+        }
+        if (player_name.empty())
+        {
+            NetworkString* chat = getNetworkString();
+            chat->addUInt8(LE_CHAT);
+            chat->setSynchronous(true);
+            chat->encodeString16(
+                L"Usage: /ban [player name]");
+            peer->sendPacket(chat, true/*reliable*/);
+            delete chat;
+        }
+        else
+        {
+            Log::info("ServerLobby", "%s is now banned", player_name.c_str());
+            m_temp_banned.insert(player_name);
+            std::string msg = StringUtils::insertValues(
+                "%s is now banned", player_name.c_str());
+            sendStringToPeer(msg, peer);
         }
     }
     else if (StringUtils::startsWith(cmd, "playeraddonscore"))
@@ -5831,7 +7126,8 @@ void ServerLobby::handleServerCommand(Event* event,
         if (player_name.empty() || !player_peer)
         {
             chat->encodeString16(
-                L"Usage: /playeraddonscore [player name] (return 0-100)");
+                L"Usage: /playeraddonscore [player name] "
+                "(returns the number of addons, not a percentage)");
         }
         else
         {
@@ -5840,21 +7136,21 @@ void ServerLobby::handleServerCommand(Event* event,
                 scores[AS_ARENA] == -1 && scores[AS_SOCCER] == -1)
             {
                 chat->encodeString16(StringUtils::utf8ToWide
-                    (player_name + " has no addon"));
+                    (player_name + " has no addons"));
             }
             else
             {
                 std::string msg = player_name;
-                msg += " addon:";
+                msg += " addons:";
                 if (scores[AS_KART] != -1)
-                    msg += " kart: " + StringUtils::toString(scores[AS_KART]) + ",";
+                    msg += " karts: " + StringUtils::toString(scores[AS_KART]) + ",";
                 if (scores[AS_TRACK] != -1)
-                    msg += " track: " + StringUtils::toString(scores[AS_TRACK]) + ",";
+                    msg += " tracks: " + StringUtils::toString(scores[AS_TRACK]) + ",";
                 if (scores[AS_ARENA] != -1)
-                    msg += " arena: " + StringUtils::toString(scores[AS_ARENA]) + ",";
+                    msg += " arenas: " + StringUtils::toString(scores[AS_ARENA]) + ",";
                 if (scores[AS_SOCCER] != -1)
-                    msg += " soccer: " + StringUtils::toString(scores[AS_SOCCER]) + ",";
-                msg = msg.substr(0, msg.size() - 1);
+                    msg += " fields: " + StringUtils::toString(scores[AS_SOCCER]) + ",";
+                msg.pop_back();
                 chat->encodeString16(StringUtils::utf8ToWide(msg));
             }
         }
@@ -5997,15 +7293,2161 @@ void ServerLobby::handleServerCommand(Event* event,
         peer->sendPacket(chat, true/*reliable*/);
         delete chat;
     }
-    else
+    else if (argv[0] == "help")
     {
         NetworkString* chat = getNetworkString();
         chat->addUInt8(LE_CHAT);
         chat->setSynchronous(true);
-        std::string msg = "Unknown command: ";
-        msg += cmd;
-        chat->encodeString16(StringUtils::utf8ToWide(msg));
+        chat->encodeString16(m_help_message);
         peer->sendPacket(chat, true/*reliable*/);
         delete chat;
     }
-}   // handleServerCommand
+    else if (argv[0] == "commands")
+    {
+        NetworkString* chat = getNetworkString();
+        chat->addUInt8(LE_CHAT);
+        chat->setSynchronous(true);chat->encodeString16
+            (StringUtils::utf8ToWide(m_available_commands));
+        peer->sendPacket(chat, true/*reliable*/);
+        delete chat;
+    }
+    else if (argv[0] == "gnu")
+    {
+        if (m_server_owner.lock() != peer)
+        {
+            std::string msg = "You are not server owner";
+            sendStringToPeer(msg, peer);
+            return;
+        }
+        else if (m_kart_elimination.isEnabled())
+        {
+            std::string msg = "Gnu Elimination mode was already enabled!";
+            sendStringToPeer(msg, peer);
+        }
+        else if (
+            RaceManager::get()->getMinorMode() != RaceManager::MINOR_MODE_NORMAL_RACE &&
+            RaceManager::get()->getMinorMode() != RaceManager::MINOR_MODE_TIME_TRIAL)
+        {
+            std::string msg = "Gnu Elimination is available only with racing modes";
+            sendStringToPeer(msg, peer);
+        }
+        else
+        {
+            if (argv.size() > 1 && m_available_kts.first.count(argv[1]) > 0)
+            {
+                m_kart_elimination.enable(argv[1]);
+            } else {
+                m_kart_elimination.enable("gnu");
+            }
+            std::string msg = m_kart_elimination.getStartingMessage();
+            sendStringToAllPeers(msg);
+        }
+    }
+    else if (argv[0] == "nognu")
+    {        
+        if (m_server_owner.lock() != peer)
+        {
+            std::string msg = "You are not server owner";
+            sendStringToPeer(msg, peer);
+            return;
+        }
+        else if (!m_kart_elimination.isEnabled())
+        {
+            std::string msg = "Gnu Elimination mode was already off!";
+            sendStringToPeer(msg, peer);
+            return;
+        }
+        else
+        {
+            m_kart_elimination.disable();
+            std::string msg = "Gnu Elimination is now off";
+            sendStringToAllPeers(msg);
+        }
+    }
+    else if (argv[0] == "tell")
+    {        
+        if (argv.size() == 1)
+        {
+            NetworkString* chat = getNetworkString();
+            chat->addUInt8(LE_CHAT);
+            chat->setSynchronous(true);
+            chat->encodeString16(L"Tell something non-empty");
+            peer->sendPacket(chat, true/*reliable*/);
+            delete chat;
+            return;
+        }
+        else
+        {
+            std::string ans;
+            for (unsigned i = 1; i < argv.size(); ++i)
+            {
+                if (i > 1)
+                    ans.push_back(' ');
+                ans += argv[i];
+            }
+            writeOwnReport(peer.get(), peer.get(), ans);
+        }
+    }
+    else if (argv[0] == "standings")
+    {
+        std::string msg;
+        if (argv.size() > 1)
+        {
+            if (argv[1] == "gp")
+                msg = getGrandPrixStandings();
+            else if (argv[1] == "gnu")
+                msg = m_kart_elimination.getStandings();
+            else
+                msg = "Usage: /standings [gp | gnu]";
+            sendStringToPeer(msg, peer);
+            return;
+        }
+        if (m_game_setup->isGrandPrix())
+            msg = getGrandPrixStandings();
+        else
+            msg = m_kart_elimination.getStandings();
+        sendStringToPeer(msg, peer);
+    }
+    else if (argv[0] == "teamchat")
+    {
+        NetworkString* chat = getNetworkString();
+        chat->addUInt8(LE_CHAT);
+        chat->setSynchronous(true);
+        m_team_speakers.insert(peer.get());
+        chat->encodeString16(L"Your messages are now addressed to team only");        
+        peer->sendPacket(chat, true/*reliable*/);
+        delete chat;
+    }
+    else if (argv[0] == "to")
+    {
+        if (argv.size() == 1)
+        {
+            NetworkString* chat = getNetworkString();
+            chat->addUInt8(LE_CHAT);
+            chat->setSynchronous(true);
+            chat->encodeString16(L"Usage: /to (username1) ... (usernameN)");
+            peer->sendPacket(chat, true/*reliable*/);
+            delete chat;
+        } else {
+            NetworkString* chat = getNetworkString();
+            chat->addUInt8(LE_CHAT);
+            chat->setSynchronous(true);
+            m_message_receivers[peer.get()].clear();
+            for (unsigned i = 1; i < argv.size(); ++i)
+            {
+                m_message_receivers[peer.get()].insert(
+                    StringUtils::utf8ToWide(argv[i]));
+            }
+            chat->encodeString16(L"Successfully changed chat settings");
+            peer->sendPacket(chat, true/*reliable*/);
+            delete chat;
+        }
+    }
+    else if (argv[0] == "public")
+    {
+        m_message_receivers[peer.get()].clear();
+        m_team_speakers.erase(peer.get());
+        std::string s = "Your messages are now public";
+        sendStringToPeer(s, peer);
+    }
+    else if (argv[0] == "record")
+    {
+        NetworkString* chat = getNetworkString();
+        chat->addUInt8(LE_CHAT);
+        chat->setSynchronous(true);
+#ifdef ENABLE_SQLITE3
+        if (argv.size() < 5)
+        {
+            chat->encodeString16(L"Usage: /record (track id) "
+                "(normal/time-trial) (normal/reverse) (laps)\n"
+                "Receives the server record for the race settings if any");
+        } else {
+            bool error = false;
+            std::string track_name = argv[1];
+            std::string mode_name = (argv[2] == "t" || argv[2] == "tt"
+                || argv[2] == "time-trial" || argv[2] == "timetrial" ?
+                "time-trial" : "normal");
+            std::string reverse_name = (argv[3] == "r" ||
+                argv[3] == "rev" || argv[3] == "reverse" ? "reverse" : 
+                "normal");
+            int laps_count = -1;
+            if (!StringUtils::parseString<int>(argv[4], &laps_count))
+                error = true;
+            if (!error && laps_count < 0)
+                error = true;
+            if (error)
+            {
+                chat->encodeString16(L"Invalid lap count");
+            }
+            else
+            {
+                std::string result = getRecord(track_name, mode_name, reverse_name, laps_count);
+                chat->encodeString16(StringUtils::utf8ToWide(result));
+            }
+        }
+#else
+        chat->encodeString16(L"This command is not supported.");
+#endif
+        peer->sendPacket(chat, true/*reliable*/);
+        delete chat;
+    }
+    else if (argv[0] == "power")
+    {
+        if (peer->isAngryHost())
+        {
+            peer->setAngryHost(false);
+            std::string msg = "You are now a normal player";
+            sendStringToPeer(msg, peer);
+            updatePlayerList();
+            return;
+        }
+        std::string password = ServerConfig::m_power_password;
+        if (password.empty() || argv.size() <= 1 || argv[1] != password)
+        {
+            std::string msg = "You need to provide the password to have the power";
+            sendStringToPeer(msg, peer);
+            return;
+        }
+        peer->setAngryHost(true);
+        std::string msg = "Now you finally have the power!";
+        sendStringToPeer(msg, peer);
+        updatePlayerList();
+        return;
+    }
+    else if (argv[0] == "admin")
+    {
+        std::string msg;
+        bool can = (peer->isAngryHost() || (ServerConfig::m_soccer_tournament && hasHostRights(peer)));
+        bool weak_abilities = (ServerConfig::m_only_host_riding && hasHostRights(peer));
+        if (!can && !weak_abilities) {
+            msg = "You cannot control this server";
+            sendStringToPeer(msg, peer);
+            return;
+        }
+        if (argv.size() == 1)
+        {
+            msg = "Usage: /admin command arg1 arg2 ...";
+            sendStringToPeer(msg, peer);
+            return;
+        }
+        if (argv[1] == "length")
+        {
+            if (argv.size() < 3)
+            {
+                msg = "Usage: /admin length (x (float) | = (int) | check | clear)";
+                sendStringToPeer(msg, peer);
+                return;
+            }
+            if (argv[2] == "check")
+            {
+                if (m_default_lap_multiplier < 0 && m_fixed_lap < 0)
+                    msg = "Game length is currently chosen by players";
+                else if (m_default_lap_multiplier > 0)
+                    msg = StringUtils::insertValues(
+                        "Game length is %f x default",
+                        m_default_lap_multiplier);
+                else if (m_fixed_lap > 0)
+                    msg = StringUtils::insertValues(
+                        "Game length is %d", m_fixed_lap);
+                else
+                    msg = StringUtils::insertValues(
+                        "An error: game length is both %f x default and %d",
+                        m_default_lap_multiplier, m_fixed_lap);
+                sendStringToPeer(msg, peer);
+                return;
+            }
+            if (argv[2] == "clear")
+            {
+                m_default_lap_multiplier = -1.0;
+                m_fixed_lap = -1;
+                msg = "Game length will be chosen by players";
+                sendStringToAllPeers(msg);
+                return;
+            }
+            double temp_double = -1.0;
+            int temp_int = -1;
+            if (argv[2] == "x" && argv.size() >= 4 &&
+                StringUtils::parseString<double>(argv[3], &temp_double))
+            {
+                m_default_lap_multiplier = std::max<double>(0.0, temp_double);
+                m_fixed_lap = -1;
+                msg = StringUtils::insertValues(
+                    "Game length is now %f x default",
+                    m_default_lap_multiplier);
+                sendStringToAllPeers(msg);
+                return;
+            }
+            if (argv[2] == "=" && argv.size() >= 4 &&
+                StringUtils::parseString<int>(argv[3], &temp_int))
+            {
+                m_fixed_lap = std::max<int>(0, temp_int);
+                m_default_lap_multiplier = -1.0;
+                msg = StringUtils::insertValues(
+                        "Game length is now %d", m_fixed_lap);
+                sendStringToAllPeers(msg);
+                return;
+            }
+            msg = "Usage: /admin length (x (float) | = (int) | check | clear)";
+            sendStringToPeer(msg, peer);
+            return;
+        }
+        if (argv[1] == "queue")
+        {
+            std::string format_string = "Format: /admin queue (show | push[_front] (track) | pop[_back])";
+            if (argv.size() < 3)
+            {
+                sendStringToPeer(format_string, peer);
+                return;
+            }
+            if (argv[2] == "show")
+            {
+                std::string msg = "Queue:";
+                for (const std::string& s: m_tracks_queue) {
+                    msg += " " + s;
+                }
+                sendStringToPeer(msg, peer);
+            }
+            else if (argv[2] == "push" || argv[2] == "push_back")
+            {
+                if (argv.size() < 4)
+                {
+                    sendStringToPeer(format_string, peer);
+                    return;
+                }
+                m_tracks_queue.push_back(argv[3]);
+                std::string msg = "Pushed " + argv[3]
+                    + " to the back of queue, current queue size: "
+                    + std::to_string(m_tracks_queue.size());
+                sendStringToPeer(msg, peer);
+            }
+            else if (argv[2] == "push_front")
+            {
+                if (argv.size() < 4)
+                {
+                    sendStringToPeer(format_string, peer);
+                    return;
+                }
+                m_tracks_queue.push_front(argv[3]);
+                std::string msg = "Pushed " + argv[3]
+                    + " to the front of queue, current queue size: "
+                    + std::to_string(m_tracks_queue.size());
+                sendStringToPeer(msg, peer);
+            }
+            else if (argv[2] == "pop" || argv[2] == "pop_back")
+            {
+                std::string msg = "";
+                if (m_tracks_queue.empty()) {
+                    msg = "Queue was empty before.";
+                }
+                else
+                {
+                    std::string msg = "Popped " + m_tracks_queue.front()
+                        + "from the queue,";
+                    m_tracks_queue.pop_front();
+                    msg += " current queue size: "
+                        + std::to_string(m_tracks_queue.size());
+                }
+                sendStringToPeer(msg, peer);
+            }
+            else if (argv[2] == "pop_back")
+            {
+                std::string msg = "";
+                if (m_tracks_queue.empty()) {
+                    msg = "Queue was empty before.";
+                }
+                else
+                {
+                    std::string msg = "Popped " + m_tracks_queue.back()
+                        + "from the queue,";
+                    m_tracks_queue.pop_back();
+                    msg += " current queue size: "
+                        + std::to_string(m_tracks_queue.size());
+                }
+                sendStringToPeer(msg, peer);
+            }
+            return;
+        }
+        if (!can) {
+            msg = "You cannot control this server. As you are the crowned player, "
+                "you can invoke /admin length and /admin queue commands.";
+            sendStringToPeer(msg, peer);
+            return;
+        }
+        if (argv[1] == "seconds")
+        {
+            float seconds = 0.0f;
+            std::string msg = "Usage: /admin seconds [how many seconds to subtract from time]";
+            if (argv.size() >= 3 && StringUtils::parseString<float>(argv[2], &seconds))
+            {
+                m_extra_seconds = seconds;
+                std::string msg = StringUtils::toString(seconds) +
+                    " second(s) will be subtracted from the time";
+            }
+            sendStringToPeer(msg, peer);
+            return;
+        }
+        if (argv[1] == "start")
+        {
+            if (argv.size() == 2 || !(argv[2] == "0" || argv[2] == "1"))
+            {
+                msg = "Usage: /admin start [0/1] - allow or forbid starting a race";
+                sendStringToPeer(msg, peer);
+                return;
+            }
+            if (argv[2] == "0")
+            {
+                m_allowed_to_start = false;
+                msg = "Now starting a race is forbidden";
+            }
+            else
+            {
+                m_allowed_to_start = true;
+                msg = "Now starting a race is allowed";
+            }
+            sendStringToPeer(msg, peer);
+            return;
+        }
+        if (argv[1] == "shuffle")
+        {
+            if (argv.size() == 2 || !(argv[2] == "0" || argv[2] == "1"))
+            {
+                msg = "Usage: /admin shuffle [0/1] - make the GP grid shuffled all the time, or make it result-based";
+                sendStringToPeer(msg, peer);
+                return;
+            }
+            if (argv[2] == "0")
+            {
+                m_shuffle_gp = false;
+                msg = "Now the GP grid is sorted by score";
+            } else {
+                m_shuffle_gp = true;
+                msg = "Now the GP grid is shuffled";
+            }
+            sendStringToPeer(msg, peer);
+            return;
+        }
+        if (argv[1] == "timeout")
+        {
+            int seconds;
+            if (argv.size() < 3 || !StringUtils::parseString(argv[2], &seconds) || seconds <= 0)
+            {
+                msg = "Usage: /admin timeout [positive int x] - set timeout to x seconds";
+                sendStringToPeer(msg, peer);
+                return;
+            }
+            m_timeout.store((int64_t)StkTime::getMonoTimeMs() +
+                    (int64_t)(seconds * 1000.0f));
+            updatePlayerList();
+            return;
+        }
+        if (argv[1] == "team")
+        {
+            if (argv.size() != 4) {
+                msg = "Usage: /admin team (color/0..6) (player) - move a player "
+                    "to a team, or remove from teams (none/0)";
+                sendStringToPeer(msg, peer);
+                return;
+            }
+            auto it = m_team_name_to_index.find(argv[2]);
+            int index = (it == m_team_name_to_index.end() ? 0 : it->second);
+            std::string player;
+            auto wide_player_name = StringUtils::utf8ToWide(argv[3]);
+            std::shared_ptr<STKPeer> player_peer = STKHost::get()->findPeerByWildcard(
+                wide_player_name, player);
+            // if player not found
+            if (!player_peer)
+            {
+                // don't use if wildcard
+                if (wide_player_name.find("*") != -1 || wide_player_name.find("?") != -1)
+                {
+                    msg = "Player not found or not unique";
+                    sendStringToPeer(msg, peer);
+                    return;
+                }
+                else
+                {
+                    // if no wildcard, reset player name to use for absent players
+                    player = argv[3];
+                }
+            }
+            for (const auto& pair: m_team_name_to_index)
+            {
+                if (pair.second < 0)
+                {
+                    if (pair.second == -index)
+                    {
+                        m_player_categories[pair.first].insert(player);
+                        m_categories_for_player[player].insert(pair.first);
+                    }
+                    else
+                    {
+                        m_player_categories[pair.first].erase(player);
+                        m_categories_for_player[player].erase(pair.first);
+                    }
+                }
+            }
+            index = abs(index);
+            m_team_for_player[player] = index;
+            wide_player_name = StringUtils::utf8ToWide(player);
+            if (player_peer)
+            {
+                for (auto& profile : player_peer.get()->getPlayerProfiles())
+                {
+                    if (profile->getName() == wide_player_name)
+                    {
+                        profile->setTemporaryTeam(index - 1);
+                        break;
+                    }
+                }
+            }
+            updatePlayerList();
+            return;
+        }
+        if (argv[1] == "cat+")
+        {
+            if (argv.size() != 4) {
+                msg = "Usage: /admin cat+ (category) (player) - add a player to a category";
+                sendStringToPeer(msg, peer);
+                return;
+            }
+            std::string category = argv[2];
+            std::string player = argv[3];
+            m_player_categories[category].insert(player);
+            m_categories_for_player[player].insert(category);
+            updatePlayerList();
+            return;
+        }
+        if (argv[1] == "cat-")
+        {
+            if (argv.size() != 4) {
+                msg = "Usage: /admin cat- (category) (player) - remove a player from a category";
+                sendStringToPeer(msg, peer);
+                return;
+            }
+            std::string category = argv[2];
+            std::string player = argv[3];
+            m_player_categories[category].erase(player);
+            m_categories_for_player[player].erase(category);
+            updatePlayerList();
+            return;
+        }
+        if (argv[1] == "cat*")
+        {
+            int displayed;
+            if (argv.size() != 4 || !StringUtils::parseString(argv[3], &displayed)
+                    || displayed < 0 || displayed > 1) {
+                msg = "Usage: /admin cat* (category) (0|1) - make category displayed or not";
+                sendStringToPeer(msg, peer);
+                return;
+            }
+            std::string category = argv[2];
+            if (displayed) {
+                m_hidden_categories.erase(category);
+            } else {
+                m_hidden_categories.insert(category);
+            }
+            updatePlayerList();
+            return;
+        }
+        if (argv[1] == "troll")
+        {
+            if (argv.size() == 2 || !(argv[2] == "0" || argv[2] == "1"))
+            {
+                msg = "Usage: /admin troll [0/1] - disable or enable anti troll system";
+                sendStringToPeer(msg, peer);
+                return;
+            }
+            if (argv[2] == "0")
+            {
+                m_troll_active = false;
+                msg = "Trolls can stay";
+            } else {
+                m_troll_active = true;
+                msg = "Trolls will be kicked";
+            }
+            sendStringToPeer(msg, peer);
+            return;
+        }
+        if (argv[1] == "hitmsg")
+        {
+            if (argv.size() == 2 || !(argv[2] == "0" || argv[2] == "1"))
+            {
+                msg = "Usage: /admin hitmsg [0/1] - disable or enable messages if a player makes a teammate explode";
+                sendStringToPeer(msg, peer);
+                return;
+            }
+            if (argv[2] == "0")
+            {
+                m_show_teammate_hits = false;
+                msg = "Teammate hits will not be sent";
+            } else {
+                m_show_teammate_hits = true;
+                msg = "Teammate hits will be sent to all players";
+            }
+            sendStringToAllPeers(msg);
+            return;
+        }
+        if (argv[1] == "teamhit")
+        {
+            if (argv.size() == 2 || !(argv[2] == "0" || argv[2] == "1"))
+            {
+                msg = "Usage: /admin teamhit [0/1] - disable or enable punish mode when hitting team mates";
+                sendStringToPeer(msg, peer);
+                return;
+            }
+            if (argv[2] == "0")
+            {
+                m_teammate_hit_mode = false;
+                msg = "Teammate hits are not punished now";
+            }
+            else
+            {
+                m_teammate_hit_mode = true;
+                msg = "Teammate hits are punished now";
+            }
+            sendStringToAllPeers(msg);
+            return;
+        }
+    }
+    else if (argv[0] == "version")
+    {
+        std::string msg = "1.3-rc1 k 210903 beta";
+        sendStringToPeer(msg, peer);
+    }
+    else if (argv[0] == "clear")
+    {
+        std::string msg(30, '\n');
+        sendStringToPeer(msg, peer);
+    }
+    else if (argv[0] == "register")
+    {
+        int online_id = peer->getPlayerProfiles()[0]->getOnlineId();
+        if (online_id <= 0)
+        {
+            std::string msg = "Please join with a valid online STK account.";
+            sendStringToPeer(msg, peer);
+            return;
+        }
+        std::string ans = "";
+        for (unsigned i = 1; i < argv.size(); ++i)
+        {
+            if (i > 1)
+                ans.push_back(' ');
+            ans += argv[i];
+        }
+        std::string message_ok = "Your registration request is being processed";
+        std::string message_wrong = "Sorry, an error occurred. Please try again.";
+        if (writeOnePlayerReport(peer.get(), ServerConfig::m_register_table_name,
+            ans))
+            sendStringToPeer(message_ok, peer);
+        else
+            sendStringToPeer(message_wrong, peer);
+    }
+#ifdef ENABLE_WEB_SUPPORT
+    else if (argv[0] == "token")
+    {
+        int online_id = peer->getPlayerProfiles()[0]->getOnlineId();
+        if (online_id <= 0)
+        {
+            std::string msg = "Please join with a valid online STK account.";
+            sendStringToPeer(msg, peer);
+            return;
+        }
+        std::string username = StringUtils::wideToUtf8(
+            peer->getPlayerProfiles()[0]->getName());
+        std::string token = getToken();
+        while (m_web_tokens.count(token))
+            token = getToken();
+        m_web_tokens.insert(token);
+        std::string msg = "Your token is " + token;
+#ifdef ENABLE_SQLITE3
+        std::string tokens_table_name = ServerConfig::m_tokens_table;
+        std::string query = StringUtils::insertValues(
+            "INSERT INTO %s (username, token) "
+            "VALUES (\"%s\", \"%s\");",
+            tokens_table_name.c_str(), username.c_str(), token.c_str()
+        );
+        if (easySQLQuery(query))
+            msg += "\nRetype it on the website to connect your STK account. ";
+        else
+            msg = "An error occurred, please try again.";
+#else
+        msg += "\nThough it is useless...";
+#endif
+        sendStringToPeer(msg, peer);
+    }
+#endif
+    else if (ServerConfig::m_soccer_tournament)
+    {
+        std::string peer_username = StringUtils::wideToUtf8(
+            peer->getPlayerProfiles()[0]->getName());
+
+        if (m_tournament_limited_chat && argv[0] == "muteall")
+        {
+            if (argv.size() >= 2 && argv[1] == "0")
+            {
+                m_tournament_mutealls.erase(peer_username);
+            }
+            else if (argv.size() >= 2 && argv[1] == "1")
+            {
+                m_tournament_mutealls.insert(peer_username);
+            }
+            else
+            {
+                if (m_tournament_mutealls.count(peer_username))
+                    m_tournament_mutealls.erase(peer_username);
+                else
+                    m_tournament_mutealls.insert(peer_username);
+            }
+            std::string msg;
+            if (m_tournament_mutealls.count(peer_username))
+                msg = "You are now receiving messages only from players and referees";
+            else
+                msg = "You are now receiving messages from spectators too";
+            sendStringToPeer(msg, peer);
+        }
+
+        // Referee-only commands
+
+        if (m_tournament_referees.count(peer_username) == 0)
+        {
+            std::string msg = "You are not a referee";
+            sendStringToPeer(msg, peer);
+            return;
+        }
+        if (argv[0] == "game")
+        {
+            int old_game = m_tournament_game;
+            int addition = 0;
+            if (argv.size() < 2)
+            {
+                ++m_tournament_game;
+                if (m_tournament_game == m_tournament_max_games)
+                    m_tournament_game = 0;
+                m_fixed_lap = ServerConfig::m_fixed_lap_count;
+            } else {
+                if (!StringUtils::parseString(argv[1], &m_tournament_game)
+                    || m_tournament_game < 0
+                    || m_tournament_game >= m_tournament_max_games)
+                { 
+                    std::string msg = "Please specify a correct number. "
+                        "Format: /game [number 0.."
+                        + std::to_string(m_tournament_max_games - 1) + "] [length]";
+                    sendStringToPeer(msg, peer);
+                    return;
+                }
+                int length = 10;
+                if (argv.size() >= 3)
+                {
+                    bool ok = StringUtils::parseString(argv[2], &length);
+                    if (!ok || length < 0)
+                    {
+                        std::string msg = "Please specify a correct number. "
+                            "Format: /game [number] [length]";
+                        sendStringToPeer(msg, peer);
+                        return;
+                    }
+                }
+                m_fixed_lap = length;
+                if (argv.size() >= 4)
+                {
+                    bool ok = StringUtils::parseString(argv[3], &addition);
+                    if (!ok || addition < 0 || addition > 59)
+                    {
+                        std::string msg = "Please specify a correct number. "
+                            "Format: /game [number] [length] [0..59 additional seconds]";
+                        sendStringToPeer(msg, peer);
+                        return;
+                    }
+                    m_extra_seconds = 0.0f;
+                    if (addition > 0) {
+                        m_extra_seconds = 60.0f - addition;
+                    }
+                } else {
+                    m_extra_seconds = 0.0f;
+                }
+            }
+            if (tournamentColorsSwapped(m_tournament_game) ^ tournamentColorsSwapped(old_game))
+                changeColors();
+            if (tournamentGoalsLimit(m_tournament_game) ^ tournamentGoalsLimit(old_game))
+                changeLimitForTournament(tournamentGoalsLimit(m_tournament_game));
+            std::string msg = StringUtils::insertValues(
+                "Ready to start game %d for %d ", m_tournament_game, m_fixed_lap)
+                + (tournamentGoalsLimit(m_tournament_game) ? "goals" : "minutes");
+            if (!tournamentGoalsLimit(m_tournament_game) && addition > 0)
+            {
+                msg += " " + std::to_string(addition) + " seconds";
+                ++m_fixed_lap;
+            }
+            sendStringToAllPeers(msg);
+            Log::info("ServerLobby", "SoccerMatchLog: Game number changed from %d to %d",
+                old_game, m_tournament_game);
+        }
+        else if (argv[0] == "role")
+        {
+            if (argv.size() < 3)
+            {
+                std::string msg = "Format: /role (R|B|J|S) username";
+                sendStringToPeer(msg, peer);
+                return;
+            }
+            std::string role = argv[1];
+            std::string username = argv[2];
+            bool permanent = (argv.size() >= 4 &&
+                (argv[3] == "p" || argv[3] == "permanent"));
+            if (role.length() != 1)
+                std::swap(role, username);
+            if (role.length() != 1)
+            {
+                std::string msg = "Please specify one-letter role (R/B/J/S) and player";
+                sendStringToPeer(msg, peer);
+                return;
+            }
+            if (role[0] >= 'A' && role[0] <= 'Z')
+                role[0] += 'a' - 'A';
+            std::vector<std::string> changed_usernames;
+            if (!username.empty())
+            {
+                if (username[0] == '#')
+                {
+                    std::string category = username.substr(1);
+                    auto it = m_player_categories.find(category);
+                    if (it != m_player_categories.end())
+                    {
+                        for (const std::string& s: it->second)
+                        {
+                            changed_usernames.push_back(s);
+                        }
+                    }
+                }
+                else
+                {
+                    changed_usernames.push_back(username);
+                }
+            }
+            for (const std::string& username: changed_usernames)
+            {
+                Log::info("ServerLobby", "SoccerMatchLog: Role of %s changed to %s",
+                     username.c_str(), role.c_str());
+                m_tournament_red_players.erase(username);
+                m_tournament_blue_players.erase(username);
+                m_tournament_referees.erase(username);
+                if (permanent)
+                {
+                    m_tournament_init_red.erase(username);
+                    m_tournament_init_blue.erase(username);
+                    m_tournament_init_ref.erase(username);
+                }
+                std::string role_changed = "The referee has updated your role - you are now %s";
+                std::shared_ptr<STKPeer> player_peer = STKHost::get()->findPeerByName(
+                    StringUtils::utf8ToWide(username));
+                std::vector<std::string> missing_assets;
+                if (player_peer)
+                    missing_assets = getMissingTournamentAssets(player_peer);
+                bool fail = false;
+                switch (role[0])
+                {
+                    case 'R':
+                    case 'r':
+                    {
+                        if (!missing_assets.empty())
+                        {
+                            fail = true;
+                            break;
+                        }
+                        if (tournamentColorsSwapped(m_tournament_game))
+                        {
+                            m_tournament_blue_players.insert(username);
+                            if (permanent)
+                                m_tournament_init_blue.insert(username);
+                        }
+                        else
+                        {
+                            m_tournament_red_players.insert(username);
+                            if (permanent)
+                                m_tournament_init_red.insert(username);
+                        }
+                        if (player_peer)
+                        {
+                            role_changed = StringUtils::insertValues(role_changed, "red player");
+                            player_peer->getPlayerProfiles()[0]->setTeam(KART_TEAM_RED);
+                            sendStringToPeer(role_changed, player_peer);
+                        }
+                        break;
+                    }
+                    case 'B':
+                    case 'b':
+                    {
+                        if (!missing_assets.empty())
+                        {
+                            fail = true;
+                            break;
+                        }
+                        if (tournamentColorsSwapped(m_tournament_game))
+                        {
+                            m_tournament_red_players.insert(username);
+                            if (permanent)
+                                m_tournament_init_red.insert(username);
+                        }
+                        else
+                        {
+                            m_tournament_blue_players.insert(username);
+                            if (permanent)
+                                m_tournament_init_blue.insert(username);
+                        }
+                        if (player_peer)
+                        {
+                            role_changed = StringUtils::insertValues(role_changed, "blue player");
+                            player_peer->getPlayerProfiles()[0]->setTeam(KART_TEAM_BLUE);
+                            sendStringToPeer(role_changed, player_peer);
+                        }
+                        break;
+                    }
+                    case 'J':
+                    case 'j':
+                    {
+                        if (!missing_assets.empty())
+                        {
+                            fail = true;
+                            break;
+                        }
+                        m_tournament_referees.insert(username);
+                        if (permanent)
+                            m_tournament_init_ref.insert(username);
+                        if (player_peer)
+                        {
+                            role_changed = StringUtils::insertValues(role_changed, "referee");
+                            player_peer->getPlayerProfiles()[0]->setTeam(KART_TEAM_NONE);
+                            sendStringToPeer(role_changed, player_peer);
+                        }
+                        break;
+                    }
+                    case 'S':
+                    case 's':
+                    {
+                        if (player_peer)
+                        {
+                            role_changed = StringUtils::insertValues(role_changed, "spectator");
+                            player_peer->getPlayerProfiles()[0]->setTeam(KART_TEAM_NONE);
+                            sendStringToPeer(role_changed, player_peer);
+                        }
+                        break;
+                    }
+                }
+                std::string msg;
+                if (!fail)
+                    msg = StringUtils::insertValues(
+                        "Successfully changed role to %s for %s", role, username);
+                else
+                {
+                    msg = StringUtils::insertValues(
+                        "Failed to change role to %s for %s - missing assets:", role, username);
+                    for (unsigned i = 0; i < missing_assets.size(); i++)
+                    {
+                        if (i)
+                            msg.push_back(',');
+                        msg += " " + missing_assets[i];
+                    }
+                }
+                sendStringToPeer(msg, peer);
+            }
+            updatePlayerList();
+        }
+        else if (argv[0] == "stop")
+        {
+            World* w = World::getWorld();
+            if (!w)
+                return;
+            SoccerWorld *sw = dynamic_cast<SoccerWorld*>(w);
+            sw->stop();
+            std::string msg = "The game is stopped.";
+            sendStringToAllPeers(msg);
+            Log::info("ServerLobby", "SoccerMatchLog: The game is stopped");
+        }
+        else if (argv[0] == "go" || argv[0] == "play" || argv[0] == "resume")
+        {
+            World* w = World::getWorld();
+            if (!w)
+                return;
+            SoccerWorld *sw = dynamic_cast<SoccerWorld*>(w);
+            sw->resume();
+            std::string msg = "The game is resumed.";
+            sendStringToAllPeers(msg);
+            Log::info("ServerLobby", "SoccerMatchLog: The game is resumed");
+        }
+        else if (argv[0] == "lobby")
+        {
+            World* w = World::getWorld();
+            if (!w)
+                return;
+            SoccerWorld *sw = dynamic_cast<SoccerWorld*>(w);
+            sw->allToLobby();
+            std::string msg = "The game will be restarted.";
+            sendStringToAllPeers(msg);
+        }
+        else if (argv[0] == "init")
+        {
+            int red, blue;
+            if (argv.size() < 3 ||
+                !StringUtils::parseString<int>(argv[1], &red) ||
+                !StringUtils::parseString<int>(argv[2], &blue))
+            {
+                std::string msg = "Usage: /init [red_count] [blue_count]";
+                sendStringToPeer(msg, peer);
+                return;
+            }
+            World* w = World::getWorld();
+            if (!w)
+            {
+                std::string msg = "Please set the count when the karts "
+                    "are ready. Setting the initial count in lobby is "
+                    "not implemented yet, sorry.";
+                sendStringToPeer(msg, peer);
+                return;
+            }
+            SoccerWorld *sw = dynamic_cast<SoccerWorld*>(w);
+            sw->setInitialCount(red, blue);
+            sw->tellCount();
+        }
+    }
+    else
+    {
+        NetworkString* chat = getNetworkString();
+        chat->addUInt8(LE_CHAT);
+        chat->setSynchronous(true);
+        std::string msg = "Unknown command: ";
+        msg += cmd;
+        chat->encodeString16(StringUtils::utf8ToWide(msg));
+        peer->sendPacket(chat, true/*reliable*/);
+        delete chat;
+    }
+}   // handleServerCommand
+//-----------------------------------------------------------------------------
+void ServerLobby::updateGnuElimination()
+{
+    World* w = World::getWorld();
+    assert(w);
+    int player_count = RaceManager::get()->getNumPlayers();
+    std::map<std::string, double> order;
+    for (int i = 0; i < player_count; i++)
+    {
+        std::string username = StringUtils::wideToUtf8(RaceManager::get()->getKartInfo(i).getPlayerName());
+        if (w->getKart(i)->isEliminated())
+            order[username] = KartElimination::INF_TIME;
+        else
+            order[username] = RaceManager::get()->getKartRaceTime(i);
+    }
+    std::string msg = m_kart_elimination.update(order);
+    if (!msg.empty())
+        sendStringToAllPeers(msg);
+}  // updateGnuElimination
+//-----------------------------------------------------------------------------
+void ServerLobby::storeResults()
+{
+#ifdef ENABLE_SQLITE3
+    World* w = World::getWorld();
+    assert(w);
+    std::string records_table_name = ServerConfig::m_records_table_name;
+    std::string mode_name = RaceManager::get()->getMinorModeName();
+    int player_count = RaceManager::get()->getNumPlayers();
+    int laps_number = RaceManager::get()->getNumLaps();
+    std::string track_name = RaceManager::get()->getTrackName();
+    std::string reverse_string = 
+        (RaceManager::get()->getReverseTrack() ? "reverse" : "normal");
+
+    bool record_fetched = false;
+    bool record_exists = false;
+    double best_result = 0.0;
+    std::string best_user = "";
+
+    if (!records_table_name.empty())
+    {
+        std::string get_query = StringUtils::insertValues("SELECT username, "
+            "result FROM '%s' WHERE venue = '%s' and reverse = '%s' "
+            "and mode = '%s' and laps = %d order by result asc, time asc limit 1;",
+            records_table_name.c_str(), track_name.c_str(), reverse_string.c_str(), mode_name.c_str(),
+            laps_number);
+        auto ret = vectorSQLQuery(get_query, 2);
+        record_fetched = ret.first;
+        if (record_fetched && ret.second[0].size() > 0)
+        {
+            record_exists = true;
+            best_user = ret.second[0][0];
+            if (!StringUtils::parseString<double>(ret.second[1][0], &best_result))
+                record_fetched = false;
+        }
+    }
+
+    int best_cur_player_idx = -1;
+    std::string best_cur_player_name = "";
+    double best_cur_time = 1e18;
+    for (int i = 0; i < player_count; i++)
+    {
+        if (w->getKart(i)->isEliminated())
+            continue;
+        std::string username = StringUtils::wideToUtf8(
+            RaceManager::get()->getKartInfo(i).getPlayerName());
+        auto profile = RaceManager::get()->getKartInfo(i).getNetworkPlayerProfile().lock();
+        // TODO fix this properly.
+        if (profile && profile->getOnlineId() == 0)
+            username = "* " + username;
+        double elapsed_time = RaceManager::get()->getKartRaceTime(i);
+        std::stringstream elapsed_string;
+        elapsed_string << std::setprecision(4) << std::fixed << elapsed_time;
+        if (best_cur_player_idx == -1 || elapsed_time < best_cur_time)
+        {
+            best_cur_player_idx = i;
+            best_cur_time = elapsed_time;
+            best_cur_player_name = username;
+        }
+        std::string query = StringUtils::insertValues(
+            "INSERT INTO %s "
+            "(username, venue, reverse, mode, laps, result) "
+            "VALUES (?, '%s', '%s', '%s', %d, '%s');",
+            m_results_table_name.c_str(), track_name.c_str(),
+            reverse_string.c_str(), mode_name.c_str(), laps_number, elapsed_string.str()
+        );
+        bool written = easySQLQuery(query, [username](sqlite3_stmt* stmt)
+        {
+            if (sqlite3_bind_text(stmt, 1, username.c_str(),
+                -1, SQLITE_TRANSIENT) != SQLITE_OK)
+            {
+                Log::error("easySQLQuery", "Failed to bind %s.",
+                    username.c_str());
+            }
+        });
+    }
+    if (record_fetched && best_cur_player_idx != -1)
+    {
+        NetworkString* chat = getNetworkString();
+        chat->addUInt8(LE_CHAT);
+        chat->setSynchronous(true);
+        std::string message;
+        if (!record_exists)
+        {
+            message = StringUtils::insertValues(
+                "%s has just set a server record: %s\nThis is the first time set.",
+                best_cur_player_name, StringUtils::timeToString(best_cur_time));
+        }
+        else if (best_result > best_cur_time)
+        {
+            message = StringUtils::insertValues(
+                "%s has just beaten a server record: %s\nPrevious record: %s by %s",
+                best_cur_player_name, StringUtils::timeToString(best_cur_time),
+                StringUtils::timeToString(best_result), best_user);
+        } else {
+            delete chat;
+            return;
+        }
+        chat->encodeString16(StringUtils::utf8ToWide(message));
+        sendMessageToPeers(chat);
+        delete chat;
+    }
+#endif
+}  // storeResults
+//-----------------------------------------------------------------------------
+void ServerLobby::initAvailableModes()
+{
+    std::vector<std::string> statements =
+        StringUtils::split(ServerConfig::m_available_modes, ' ', false);
+
+    for (const std::string& s: statements)
+    {
+        if (s.length() <= 1)
+            continue;
+        bool difficulty = s[0] == 'd';
+        if (difficulty)
+        {
+            for (unsigned i = 1; i < s.length(); i++)
+            {
+                m_available_difficulties.insert(s[i] - '0');
+            }
+        }
+        else
+        {
+            for (unsigned i = 1; i < s.length(); i++)
+            {
+                m_available_modes.insert(s[i] - '0');
+            }
+        }
+    }
+}  // initAvailableModes
+//-----------------------------------------------------------------------------
+void ServerLobby::resetToDefaultSettings()
+{
+    if (ServerConfig::m_server_configurable)
+        handleServerConfiguration(NULL);
+    m_kart_elimination.disable();
+}  // resetToDefaultSettings
+//-----------------------------------------------------------------------------
+void ServerLobby::writeOwnReport(STKPeer* reporter, STKPeer* reporting, const std::string& info)
+{
+#ifdef ENABLE_SQLITE3
+    if (!m_db || !m_player_reports_table_exists)
+        return;
+    if (!reporter->hasPlayerProfiles())
+        return;
+    auto reporter_npp = reporter->getPlayerProfiles()[0];
+
+    if (info.empty())
+        return;
+
+    if (!reporting->hasPlayerProfiles())
+        return;
+    auto reporting_npp = reporting->getPlayerProfiles()[0];
+
+    std::string query;
+    if (ServerConfig::m_ipv6_connection)
+    {
+        query = StringUtils::insertValues(
+            "INSERT INTO %s "
+            "(server_uid, reporter_ip, reporter_ipv6, reporter_online_id, reporter_username, "
+            "info, reporting_ip, reporting_ipv6, reporting_online_id, reporting_username) "
+            "VALUES (?, %u, \"%s\", %u, ?, ?, %u, \"%s\", %u, ?);",
+            ServerConfig::m_player_reports_table.c_str(),
+            !reporter->getAddress().isIPv6() ? reporter->getAddress().getIP() : 0,
+            reporter->getAddress().isIPv6() ? reporter->getAddress().toString(false) : "",
+            reporter_npp->getOnlineId(),
+            !reporting->getAddress().isIPv6() ? reporting->getAddress().getIP() : 0,
+            reporting->getAddress().isIPv6() ? reporting->getAddress().toString(false) : "",
+            reporting_npp->getOnlineId());
+    }
+    else
+    {
+        query = StringUtils::insertValues(
+            "INSERT INTO %s "
+            "(server_uid, reporter_ip, reporter_online_id, reporter_username, "
+            "info, reporting_ip, reporting_online_id, reporting_username) "
+            "VALUES (?, %u, %u, ?, ?, %u, %u, ?);",
+            ServerConfig::m_player_reports_table.c_str(),
+            reporter->getAddress().getIP(), reporter_npp->getOnlineId(),
+            reporting->getAddress().getIP(), reporting_npp->getOnlineId());
+    }
+    bool written = easySQLQuery(query,
+        [reporter_npp, reporting_npp, info](sqlite3_stmt* stmt)
+        {
+            // SQLITE_TRANSIENT to copy string
+            if (sqlite3_bind_text(stmt, 1, ServerConfig::m_server_uid.c_str(),
+                -1, SQLITE_TRANSIENT) != SQLITE_OK)
+            {
+                Log::error("easySQLQuery", "Failed to bind %s.",
+                    ServerConfig::m_server_uid.c_str());
+            }
+            if (sqlite3_bind_text(stmt, 2,
+                StringUtils::wideToUtf8(reporter_npp->getName()).c_str(),
+                -1, SQLITE_TRANSIENT) != SQLITE_OK)
+            {
+                Log::error("easySQLQuery", "Failed to bind %s.",
+                    StringUtils::wideToUtf8(reporter_npp->getName()).c_str());
+            }
+            if (sqlite3_bind_text(stmt, 3,
+                info.c_str(),
+                -1, SQLITE_TRANSIENT) != SQLITE_OK)
+            {
+                Log::error("easySQLQuery", "Failed to bind %s.",
+                    info.c_str());
+            }
+            if (sqlite3_bind_text(stmt, 4,
+                StringUtils::wideToUtf8(reporting_npp->getName()).c_str(),
+                -1, SQLITE_TRANSIENT) != SQLITE_OK)
+            {
+                Log::error("easySQLQuery", "Failed to bind %s.",
+                    StringUtils::wideToUtf8(reporting_npp->getName()).c_str());
+            }
+        });
+    if (written)
+    {
+        NetworkString* success = getNetworkString();
+        success->setSynchronous(true);
+        if (reporter == reporting)
+            success->addUInt8(LE_REPORT_PLAYER).addUInt8(1)
+                .encodeString(m_game_setup->getServerNameUtf8());
+        else
+            success->addUInt8(LE_REPORT_PLAYER).addUInt8(1)
+                .encodeString(reporting_npp->getName());
+        reporter->sendPacket(success, true/*reliable*/);
+        delete success;
+    }
+#endif
+}   // writeOwnReport
+//-----------------------------------------------------------------------------
+void ServerLobby::initCategories()
+{
+    std::vector<std::string> tokens = StringUtils::split(
+        ServerConfig::m_categories, ' ');
+    std::string category = "";
+    bool isTeam = false;
+    for (std::string& s: tokens)
+    {
+        if (s.empty())
+            continue;
+        else if (s[0] == '#')
+        {
+            isTeam = false;
+            if (s.length() > 1 && s[1] == '#')
+            {
+                category = s.substr(2);
+                m_hidden_categories.insert(category);
+            }
+            else
+                category = s.substr(1);
+        }
+        else if (s[0] == '$')
+        {
+            isTeam = true;
+            category = s.substr(1);
+        }
+        else
+        {
+            if (!isTeam) {
+                m_player_categories[category].insert(s);
+                m_categories_for_player[s].insert(category);
+            }
+            else
+            {
+                m_team_for_player[s] = category[0] - '0' + 1;
+            }
+        }
+    }
+    /*
+    Temporary team indexing:
+    network_player_profile.hpp: -1 for none, [0..5] for teams
+    server config: (-1 for none,) [0..5] for teams
+    server lobby command: 0 for none, [1..6] for teams
+    m_team_for_player: 0 for none, [1..6] for teams
+    Sorry for the confusion.
+    */
+    // change categories according to the teams
+    for (const auto& who: m_team_for_player)
+    {
+        int idx = who.second;
+        std::string player = who.first;
+        for (const auto& pair: m_team_name_to_index)
+        {
+            if (pair.second < 0)
+            {
+                if (pair.second == -idx)
+                {
+                    m_player_categories[pair.first].insert(player);
+                    m_categories_for_player[player].insert(pair.first);
+                }
+                else
+                {
+                    m_player_categories[pair.first].erase(player);
+                    m_categories_for_player[player].erase(pair.first);
+                }
+            }
+        }
+    }
+}   // initCategories
+//-----------------------------------------------------------------------------
+void ServerLobby::initTournamentPlayers()
+{
+    // Init playing teams
+    std::vector<std::string> tokens = StringUtils::split(
+        ServerConfig::m_soccer_tournament_match, ' ');
+    std::string type = "";
+    for (std::string& s: tokens)
+    {
+        if (s.length() == 1)
+            type = s;
+        else if (s.empty())
+            continue;
+        else if (s[0] == '#')
+        {
+            std::string cat_name = s.substr(1);
+            std::set<std::string>& dest = (
+                type == "R" ? m_tournament_red_players :
+                type == "B" ? m_tournament_blue_players :
+                m_tournament_referees);
+            for (const std::string& member:
+                m_player_categories[cat_name])
+                dest.insert(member);
+        }
+        else if (type == "R") 
+            m_tournament_red_players.insert(s);
+        else if (type == "B")
+            m_tournament_blue_players.insert(s);
+        else if (type == "J")
+            m_tournament_referees.insert(s);
+    }
+    for (const std::string& s: m_tournament_red_players)
+    {
+        Log::info("ServerLobby", "SoccerMatchLog: Role of %s is initially set to r",
+            s.c_str());
+    }
+    for (const std::string& s: m_tournament_blue_players)
+    {
+        Log::info("ServerLobby", "SoccerMatchLog: Role of %s is initially set to b",
+            s.c_str());
+    }
+    for (const std::string& s: m_tournament_referees)
+    {
+        Log::info("ServerLobby", "SoccerMatchLog: Role of %s is initially set to j",
+            s.c_str());
+    }
+    m_tournament_init_red = m_tournament_red_players;
+    m_tournament_init_blue = m_tournament_blue_players;
+    m_tournament_init_ref = m_tournament_referees;
+
+    // Init tournament format
+    tokens = StringUtils::split(
+        ServerConfig::m_soccer_tournament_rules, ';');
+    bool fallback = tokens.size() < 2;
+    std::vector<std::string> general;
+    if (!fallback)
+    {
+        general = StringUtils::split(tokens[0], ' ');
+        if (general.size() < 4)
+            fallback = true;
+    }
+    if (fallback)
+    {
+        Log::warn("ServerLobby", "Tournament rules not complete, fallback to default");
+        general.clear();
+        general.push_back("nochat");
+        general.push_back("10");
+        general.push_back("GGGGT");
+        general.push_back("RRBBR");
+        tokens.clear();
+        tokens.push_back("nochat 10 GGGT RRBBR");
+        tokens.push_back("");
+        tokens.push_back("");
+        tokens.push_back("not %0");
+        tokens.push_back("not %0" " %1");
+        tokens.push_back("");
+        ServerConfig::m_soccer_tournament_rules = "nochat 10 TTTTG RRBBR;"
+            ";;not %1;"
+            "not %1 "
+            "%2;;;";
+    }
+    Log::info("ServerLobby", "SoccerMatchLog: Tournament rules are set to \"%s\"",
+        ServerConfig::m_soccer_tournament_rules.c_str());
+    m_tournament_limited_chat = false;
+    m_tournament_length = 10;
+    if (general[0] == "nochat")
+        m_tournament_limited_chat = true;
+    if (StringUtils::parseString<int>(general[1], &m_tournament_length))
+    {
+        if (m_tournament_length <= 0)
+            m_tournament_length = 10;
+    }
+    else
+        m_tournament_length = 10;
+    ServerConfig::m_fixed_lap_count = m_tournament_length;
+
+    m_tournament_game_limits = general[2];
+    m_tournament_colors = general[3];
+    m_tournament_max_games = std::min(general[2].length(), general[3].length());
+    m_tournament_max_games = std::min(m_tournament_max_games, (int)tokens.size() - 1);
+    m_tournament_arenas.resize(m_tournament_max_games, "");
+    for (int i = 0; i < m_tournament_max_games; i++)
+        m_tournament_track_filters.emplace_back(tokens[i + 1]);
+}   // initTournamentPlayers
+//-----------------------------------------------------------------------------
+void ServerLobby::changeColors()
+{
+    auto peers = STKHost::get()->getPeers();
+    for (auto peer : peers)
+    {
+        if (peer->hasPlayerProfiles())
+        {
+            auto pp = peer->getPlayerProfiles()[0];
+            if (pp->getTeam() == KART_TEAM_RED)
+                pp->setTeam(KART_TEAM_BLUE);
+            else if (pp->getTeam() == KART_TEAM_BLUE)
+                pp->setTeam(KART_TEAM_RED);
+        }
+    }
+    updatePlayerList();
+}   // changeColors
+//-----------------------------------------------------------------------------
+void ServerLobby::sendStringToPeer(std::string& s, std::shared_ptr<STKPeer>& peer) const
+{
+    if (!peer)
+        return;
+    NetworkString* chat = getNetworkString();
+    chat->addUInt8(LE_CHAT);
+    chat->setSynchronous(true);
+    chat->encodeString16(StringUtils::utf8ToWide(s));
+    peer->sendPacket(chat, true/*reliable*/);
+    delete chat;
+}   // sendStringToPeer
+//-----------------------------------------------------------------------------
+void ServerLobby::sendStringToPeer(std::string& s, STKPeer* peer) const
+{
+    if (!peer)
+        return;
+    NetworkString* chat = getNetworkString();
+    chat->addUInt8(LE_CHAT);
+    chat->setSynchronous(true);
+    chat->encodeString16(StringUtils::utf8ToWide(s));
+    peer->sendPacket(chat, true/*reliable*/);
+    delete chat;
+}   // sendStringToPeer
+//-----------------------------------------------------------------------------
+void ServerLobby::sendStringToAllPeers(std::string& s)
+{
+    NetworkString* chat = getNetworkString();
+    chat->addUInt8(LE_CHAT);
+    chat->setSynchronous(true);
+    chat->encodeString16(StringUtils::utf8ToWide(s));
+    sendMessageToPeers(chat, true/*reliable*/);
+    delete chat;
+}   // sendStringToAllPeers
+//-----------------------------------------------------------------------------
+bool ServerLobby::canRace(std::shared_ptr<STKPeer>& peer) const
+{
+    return canRace(peer.get());
+}   // canRace
+//-----------------------------------------------------------------------------
+bool ServerLobby::canRace(STKPeer* peer) const
+{
+    std::string username = StringUtils::wideToUtf8(
+        peer->getPlayerProfiles()[0]->getName());
+    if (ServerConfig::m_soccer_tournament)
+        return m_tournament_red_players.count(username) > 0 || 
+            m_tournament_blue_players.count(username) > 0;
+    else if (m_spectators_by_limit.find(peer) != m_spectators_by_limit.end())
+        return false;
+    // else if (ServerConfig::m_only_host_riding)
+    //     return peer == m_server_owner.lock().get();
+    else if (!m_tracks_queue.empty())
+        return peer->getClientAssets().second.count(m_tracks_queue.front());
+    else
+        return true;
+}   // canRace
+
+//-----------------------------------------------------------------------------
+bool ServerLobby::hasHostRights(std::shared_ptr<STKPeer>& peer) const
+{
+    return hasHostRights(peer.get());
+}   // hasHostRights
+//-----------------------------------------------------------------------------
+bool ServerLobby::hasHostRights(STKPeer* peer) const
+{
+    if (peer == m_server_owner.lock().get())
+        return true;
+    if (peer->isAngryHost())
+        return true;
+    std::string username = StringUtils::wideToUtf8(
+        peer->getPlayerProfiles()[0]->getName());
+    if (ServerConfig::m_soccer_tournament)
+    {
+        return m_tournament_referees.count(username) > 0;
+    }
+    return false;
+}   // hasHostRights
+//-----------------------------------------------------------------------------
+void ServerLobby::loadTracksQueueFromConfig()
+{
+    std::vector<std::string> tokens = StringUtils::split(
+        ServerConfig::m_tracks_order, ' ');
+    m_tracks_queue.clear();
+    for (std::string& s: tokens)
+        m_tracks_queue.push_back(s);
+}   // loadTracksQueueFromConfig
+//-----------------------------------------------------------------------------
+std::string ServerLobby::getGrandPrixStandings() const
+{
+    std::vector<std::pair<GPScore, std::string>> results;
+    for (auto& p: m_gp_scores)
+        results.emplace_back(p.second, p.first);
+    std::stable_sort(results.rbegin(), results.rend());
+    std::stringstream response;
+    response << "Grand Prix standings\n";
+    for (unsigned i = 0; i < results.size(); i++)
+    {
+        response << (i + 1) << ". ";
+        response << "  " << results[i].second;
+        response << "  " << results[i].first.score;
+        response << "  " << "(" << StringUtils::timeToString(results[i].first.time) << ")";
+        response << "\n";
+    }
+    results.clear();
+
+    if (!m_gp_team_scores.empty())
+    {
+        std::vector<std::pair<GPScore, int>> results2;
+        response << "\n";
+        for (auto& p: m_gp_team_scores)
+            results2.emplace_back(p.second, p.first);
+        std::stable_sort(results2.rbegin(), results2.rend());
+        for (unsigned i = 0; i < results2.size(); i++)
+        {
+            response << (i + 1) << ". ";
+            response << "  " << m_team_name[results2[i].second];
+            response << "  " << results2[i].first.score;
+            response << "  " << "(" << StringUtils::timeToString(results2[i].first.time) << ")";
+            response << "\n";
+        }
+    }
+    return response.str();
+}   // getGrandPrixStandings
+//-----------------------------------------------------------------------------
+void ServerLobby::loadCustomScoring()
+{
+    m_scoring_int_params.clear();
+    m_scoring_type = "";
+    std::string scoring = ServerConfig::m_gp_scoring;
+    if (!scoring.empty())
+    {
+        std::vector<std::string> params = StringUtils::split(scoring, ' ');
+        if (params.empty())
+            return;    
+        m_scoring_type = params[0];
+        for (unsigned i = 1; i < params.size(); i++)
+        {
+            int param;
+            if (!StringUtils::fromString(params[i], param))
+            {
+                Log::warn("ServerLobby", "Unable to parse integer from custom scoring data");
+                return;
+            }
+            m_scoring_int_params.push_back(param);
+        }
+    }
+}   // loadCustomScoring
+//-----------------------------------------------------------------------------   
+void ServerLobby::updateWorldSettings()
+{
+    WorldWithRank *wwr = dynamic_cast<WorldWithRank*>(World::getWorld());
+    if (wwr)
+    {
+        wwr->setCustomScoringSystem(m_scoring_type, m_scoring_int_params);
+    }
+    SoccerWorld *sw = dynamic_cast<SoccerWorld*>(World::getWorld());
+    if (sw)
+    {
+        std::string policy = ServerConfig::m_soccer_goals_policy;
+        if (policy == "standard")
+            sw->setGoalScoringPolicy(0);
+        else if (policy == "no-own-goals")
+            sw->setGoalScoringPolicy(1);
+        else if (policy == "advanced")
+            sw->setGoalScoringPolicy(2);
+        else
+            Log::warn("ServerLobby", "Soccer goals policy %s does not exist", policy.c_str());
+    }
+}   // updateWorldSettings
+//-----------------------------------------------------------------------------   
+void ServerLobby::loadWhiteList()
+{
+    std::vector<std::string> tokens = StringUtils::split(
+        ServerConfig::m_white_list, ' ');
+    for (std::string& s: tokens)
+        m_usernames_white_list.insert(s);
+}   // loadWhiteList
+//-----------------------------------------------------------------------------  
+bool ServerLobby::writeOnePlayerReport(STKPeer* reporter,
+    const std::string& table, const std::string& info)
+{
+#ifdef ENABLE_SQLITE3
+    if (!m_db)
+        return false;
+    if (!reporter->hasPlayerProfiles())
+        return false;
+    auto reporter_npp = reporter->getPlayerProfiles()[0];
+
+    std::string query = StringUtils::insertValues(
+        "INSERT INTO %s "
+        "(server_uid, reporter_online_id, reporter_username, "
+        "info) "
+        "VALUES (?, %u, ?, ?);",
+        table.c_str(),
+        reporter_npp->getOnlineId());
+
+    bool written = easySQLQuery(query,
+        [reporter_npp, info](sqlite3_stmt* stmt)
+        {
+            // SQLITE_TRANSIENT to copy string
+            if (sqlite3_bind_text(stmt, 1, ServerConfig::m_server_uid.c_str(),
+                -1, SQLITE_TRANSIENT) != SQLITE_OK)
+            {
+                Log::error("easySQLQuery", "Failed to bind %s.",
+                    ServerConfig::m_server_uid.c_str());
+            }
+            if (sqlite3_bind_text(stmt, 2,
+                StringUtils::wideToUtf8(reporter_npp->getName()).c_str(),
+                -1, SQLITE_TRANSIENT) != SQLITE_OK)
+            {
+                Log::error("easySQLQuery", "Failed to bind %s.",
+                    StringUtils::wideToUtf8(reporter_npp->getName()).c_str());
+            }
+            if (sqlite3_bind_text(stmt, 3,
+                info.c_str(),
+                -1, SQLITE_TRANSIENT) != SQLITE_OK)
+            {
+                Log::error("easySQLQuery", "Failed to bind %s.",
+                    info.c_str());
+            }
+        });
+    return written;
+#endif
+}   // writeOnePlayerReport
+//-----------------------------------------------------------------------------   
+void ServerLobby::changeLimitForTournament(bool goal_target)
+{
+    m_game_setup->setSoccerGoalTarget(goal_target);
+    NetworkString* server_info = getNetworkString();
+    server_info->setSynchronous(true);
+    server_info->addUInt8(LE_SERVER_INFO);
+    m_game_setup->addServerInfo(server_info);
+    sendMessageToPeers(server_info);
+    delete server_info;
+    updatePlayerList();
+}   // changeLimitForTournament
+//-----------------------------------------------------------------------------
+bool ServerLobby::tournamentGoalsLimit(int game) const
+{
+    return m_tournament_game_limits[game] == 'G';
+}   // tournamentGoalsLimit
+//-----------------------------------------------------------------------------
+bool ServerLobby::tournamentColorsSwapped(int game) const
+{
+    return m_tournament_colors[game] == 'B';
+}   // tournamentColorsSwapped
+//-----------------------------------------------------------------------------
+void ServerLobby::initAvailableTracks()
+{
+    m_global_filter = TrackFilter(ServerConfig::m_only_played_tracks_string);
+    m_must_have_tracks = StringUtils::split(
+        ServerConfig::m_must_have_tracks_string, ' ', false);
+    m_tournament_must_have_tracks = StringUtils::split(
+        ServerConfig::m_soccer_tournament_enforced_tracks_string, ' ', false);
+}   // initAvailableTracks
+//-----------------------------------------------------------------------------
+std::vector<std::string> ServerLobby::getMissingTournamentAssets(std::shared_ptr<STKPeer>& peer) const
+{
+    return getMissingTournamentAssets(peer.get());
+}   // getMissingTournamentAssets
+//-----------------------------------------------------------------------------
+std::vector<std::string> ServerLobby::getMissingTournamentAssets(STKPeer* peer) const
+{
+    std::vector<std::string> ans;
+    for (const std::string& required_track : m_tournament_must_have_tracks)
+        if (peer->getClientAssets().second.count(required_track) == 0)
+            ans.push_back(required_track);
+    return ans;
+}   // getMissingTournamentAssets
+//-----------------------------------------------------------------------------
+void ServerLobby::updateTournamentRole(STKPeer* peer)
+{
+    if (!ServerConfig::m_soccer_tournament)
+        return;
+    if (peer->getPlayerProfiles().empty())
+        return;
+    std::string utf8_online_name = StringUtils::wideToUtf8(
+        peer->getPlayerProfiles()[0]->getName());
+    bool erased_from_tournament_roles = false;
+    std::vector<std::string> missing_assets;
+    missing_assets = getMissingTournamentAssets(peer);
+    if (!missing_assets.empty())
+    {
+        erased_from_tournament_roles |= m_tournament_red_players.count(utf8_online_name) > 0;
+        erased_from_tournament_roles |= m_tournament_blue_players.count(utf8_online_name) > 0;
+        erased_from_tournament_roles |= m_tournament_referees.count(utf8_online_name) > 0;
+        m_tournament_red_players.erase(utf8_online_name);
+        m_tournament_blue_players.erase(utf8_online_name);
+        m_tournament_referees.erase(utf8_online_name);
+    }
+    for (unsigned i = 0; i < peer->getPlayerProfiles().size(); i++)
+    {
+        auto player = peer->getPlayerProfiles()[i];
+        core::stringw name = player->getName();
+        std::string utf8_name = StringUtils::wideToUtf8(name);
+        if (m_tournament_red_players.count(utf8_online_name))
+            player->setTeam(KART_TEAM_RED);
+        else if (m_tournament_blue_players.count(utf8_online_name))
+            player->setTeam(KART_TEAM_BLUE);
+        else
+            player->setTeam(KART_TEAM_NONE);
+        if (tournamentColorsSwapped(m_tournament_game))
+        {
+            if (player->getTeam() == KART_TEAM_BLUE)
+                player->setTeam(KART_TEAM_RED);
+            else if (player->getTeam() == KART_TEAM_RED)
+                player->setTeam(KART_TEAM_BLUE);
+        }
+    }
+    if (erased_from_tournament_roles)
+    {
+        std::string msg = "You are now spectator because you lack the following assets:";
+        for (unsigned i = 0; i < missing_assets.size(); i++)
+        {
+            if (i)
+                msg.push_back(',');
+            msg += " " + missing_assets[i];
+        }
+        sendStringToPeer(msg, peer);
+        updatePlayerList();
+    }
+}   // updateTournamentRole
+//-----------------------------------------------------------------------------
+#ifdef ENABLE_SQLITE3
+std::string ServerLobby::getRecord(std::string& track, std::string& mode,
+    std::string& direction, int laps)
+{
+    std::string records_table_name = ServerConfig::m_records_table_name;
+    if (!records_table_name.empty())
+    {
+        std::string get_query = StringUtils::insertValues("SELECT username, "
+            "result FROM '%s' WHERE venue = ? and reverse = '%s' "
+            "and mode = '%s' and laps = %d order by result asc, time asc limit 1;",
+            records_table_name.c_str(), direction.c_str(), mode.c_str(),
+            laps);
+        auto ret = vectorSQLQuery(get_query, 2,
+        [track](sqlite3_stmt* stmt)
+        {
+            // SQLITE_TRANSIENT to copy string
+            if (sqlite3_bind_text(stmt, 1, track.c_str(),
+                -1, SQLITE_TRANSIENT) != SQLITE_OK)
+            {
+                Log::error("vectorSQLQuery", "Failed to bind %s.",
+                    track.c_str());
+            }
+        });
+        if (!ret.first)
+        {
+            return "Failed to make a query";
+        }
+        else if (ret.second[0].size() > 0)
+        {
+            double best_result = 1e18;
+            if (!StringUtils::parseString<double>(
+                ret.second[1][0], &best_result))
+            {
+                return "A strange error occured, "
+                    "please take a screenshot "
+                    "and contact the server owner.";
+            }
+            else
+            {
+                std::string message = StringUtils::insertValues(
+                    "The record is %s by %s",
+                    StringUtils::timeToString(best_result),
+                    ret.second[0][0]);
+                return message;
+            }
+        }
+        else
+        {
+            return "No time set yet. Or there is a typo.";
+        }
+    }
+    else
+    {
+        return "No table storing records!";
+    }
+}   // getRecord
+#endif
+//-----------------------------------------------------------------------------
+
+#ifdef ENABLE_WEB_SUPPORT
+
+void ServerLobby::loadAllTokens()
+{
+#ifdef ENABLE_SQLITE3
+    std::string tokens_table_name = ServerConfig::m_tokens_table;
+    std::string get_query = StringUtils::insertValues(
+        "SELECT distinct tokens from %s;",
+        tokens_table_name.c_str());
+    auto ret = vectorSQLQuery(get_query, 1);
+    if (!ret.first)
+    {
+        Log::warn("ServerLobby", "Could not make a query to retrieve tokens.");
+    }
+    else if (ret.second[0].size() > 0)
+    {
+        Log::info("ServerLobby", "Successfully loaded %d tokens.", (int)ret.second[0].size());
+        for (std::string& s: ret.second[0])
+            m_web_tokens.insert(s);
+    }
+#endif
+}   // loadAllTokens
+//-----------------------------------------------------------------------------
+
+std::string ServerLobby::getToken()
+{
+    int tries = m_token_generation_tries.load();
+    m_token_generation_tries.store(tries + 1);
+    std::mt19937 mt(time(nullptr) + tries);
+    std::string token;
+    for (int i = 0; i < 16; ++i)
+    {
+        int z = mt() % 36;
+        if (z < 26)
+            token.push_back('a' + z);
+        else
+            token.push_back('0' + z - 26);
+        if ((i & 3) == 3)
+            token.push_back(' ');
+    }
+    token.pop_back();
+    return token;
+}   // getToken
+//-----------------------------------------------------------------------------
+#endif // ENABLE_WEB_SUPPORT
+
+// this is called when collisions of an item are handled
+// so we keep track of hits caused by that item
+void ServerLobby::setTeamMateHitOwner(unsigned int ownerID, uint16_t ticks_since_thrown)
+{
+    m_teammate_current_item_ownerID = ownerID;
+    m_teammate_ticks_since_thrown = ticks_since_thrown;
+    m_teammate_karts_hit.clear();
+    m_teammate_karts_exploded.clear();
+    m_collecting_teammate_hit_info = true;
+}
+
+void ServerLobby::registerTeamMateHit(unsigned int kartID)
+{
+    // only register if we know the item owner and victim is still racing
+    if (m_collecting_teammate_hit_info && !World::getWorld()->getKart(kartID)->hasFinishedRace())
+        m_teammate_karts_hit.push_back(kartID);
+}
+
+void ServerLobby::registerTeamMateExplode(unsigned int kartID)
+{
+    // only register if we know the item owner and victim is still racing
+    if (m_collecting_teammate_hit_info && !World::getWorld()->getKart(kartID)->hasFinishedRace())
+        m_teammate_karts_exploded.push_back(kartID);
+}
+
+void ServerLobby::sendTeamMateHitMsg(std::string& s)
+{
+    if (World* w = World::getWorld())
+    {
+        int ticks = w->getTicksSinceStart();
+        if (ticks - m_last_teammate_hit_msg > stk_config->time2Ticks(1.5f))
+        {
+            m_last_teammate_hit_msg = ticks;
+            sendStringToAllPeers(s);
+        }
+    }
+}
+
+void ServerLobby::handleTeamMateHits()
+{
+    m_collecting_teammate_hit_info = false;
+    // get team of owner of item
+    const std::string ownername = StringUtils::wideToUtf8(
+        RaceManager::get()->getKartInfo(m_teammate_current_item_ownerID).getPlayerName());
+    const int ownerTeam = m_team_for_player[ownername];
+
+    if (ownerTeam == 0) // no team, no punishment
+        return;
+
+    AbstractKart *owner = World::getWorld()->getKart(m_teammate_current_item_ownerID);
+
+    // if item is too old, it doesn't count
+    // currently only bowling balls have their creation time registered
+    // so cakes will always count
+
+    if (m_teammate_ticks_since_thrown > stk_config->time2Ticks(MAX_BOWL_TEAMMATE_HIT_TIME))
+        return;
+
+    // Show message?
+    if (showTeamMateHits())
+    {
+        // prepare string
+        int num_victims = 0;
+        std::string msg = ServerConfig::m_teammate_hit_msg_prefix;
+        std::string victims;
+        msg += ownername;
+        msg += " just shot ";
+
+        for (unsigned int i = 0; i < m_teammate_karts_exploded.size(); i++)
+        {
+            const std::string playername = StringUtils::wideToUtf8(
+                RaceManager::get()->getKartInfo(m_teammate_karts_exploded[i]).getPlayerName());
+            const int playerTeam = m_team_for_player[playername];
+            if (ownerTeam == playerTeam)
+            {
+                // hit teammate
+                if (num_victims > 0)
+                    victims += " and ";
+                victims += StringUtils::wideToUtf8(RaceManager::get()->getKartInfo(m_teammate_karts_exploded[i]).getPlayerName());
+                num_victims++;
+            }
+        }
+        if (num_victims > 0) // we found victims, so send message
+        {
+            msg += (num_victims > 1) ? "teammates " : "teammate ";
+            msg += victims;
+            sendTeamMateHitMsg(msg);
+        }
+    }
+
+    if (useTeamMateHitMode())
+    {
+        bool punished = false;
+        // first check if we exploded at least one teammate
+        for (unsigned int i=0; i < m_teammate_karts_exploded.size() && !punished; i++)
+        {
+            const std::string playername = StringUtils::wideToUtf8(
+                RaceManager::get()->getKartInfo(m_teammate_karts_exploded[i]).getPlayerName());
+            const int playerTeam = m_team_for_player[playername];
+            if (ownerTeam == playerTeam)
+            {
+                // we did, so punish
+                punished = true;
+                if(owner->getAttachment()->getType() == Attachment::ATTACH_BOMB)
+                {
+                    // make bomb explode
+                    owner->getAttachment()->update(10000);
+                }
+                else if (owner->isShielded())
+                {
+                    // if owner is shielded, take away shield
+                    owner->decreaseShieldTime();
+                }
+                else
+                {
+                    int left_over_ticks = 0;
+                    // if owner already has an anvil or a parachute, make new anvil last longer
+                    if (owner->getAttachment()->getType() == Attachment::ATTACH_ANVIL
+                        || owner->getAttachment()->getType() == Attachment::ATTACH_PARACHUTE)
+                    {
+                        left_over_ticks = owner->getAttachment()->getTicksLeft();
+                    }
+                    owner->getAttachment()->set(Attachment::ATTACH_ANVIL,
+                        stk_config->time2Ticks(owner->getKartProperties()->getAnvilDuration()) + left_over_ticks);
+                    owner->adjustSpeed(owner->getKartProperties()->getAnvilSpeedFactor());
+                }
+            }
+        }
+
+        // now check for deshielding teammates
+        for (unsigned int i = 0; i < m_teammate_karts_hit.size() && !punished; i++)
+        {
+            const std::string playername = StringUtils::wideToUtf8(
+                RaceManager::get()->getKartInfo(m_teammate_karts_hit[i]).getPlayerName());
+            const int playerTeam = m_team_for_player[playername];
+            if (ownerTeam == playerTeam)
+            {
+                // we did, so punish
+                punished = true;
+                if (owner->getAttachment()->getType() == Attachment::ATTACH_BOMB)
+                {
+                    // make bomb explode
+                    owner->getAttachment()->update(10000);
+                }
+                else if (owner->isShielded())
+                {
+                    // if owner is shielded, take away shield
+                    owner->decreaseShieldTime();
+                }
+                else
+                {
+                    // since teammate didn't explode, make anvil less severe
+                    int left_over_ticks = 0;
+                    // if owner already has an anvil or a parachute, make new anvil last longer
+                    if (owner->getAttachment()->getType() == Attachment::ATTACH_ANVIL
+                        || owner->getAttachment()->getType() == Attachment::ATTACH_PARACHUTE)
+                    {
+                        left_over_ticks = owner->getAttachment()->getTicksLeft();
+                    }
+                    owner->getAttachment()->set(Attachment::ATTACH_ANVIL,
+                        stk_config->time2Ticks(owner->getKartProperties()->getAnvilDuration()) / 2 + left_over_ticks);
+                    owner->adjustSpeed(owner->getKartProperties()->getAnvilSpeedFactor() * 2.0f);
+                }
+            }
+        }
+    }
+}
+
+void ServerLobby::handleSwatterHit(unsigned int ownerID, unsigned int victimID,
+    bool success, bool has_hit_kart, uint16_t ticks_active)
+{
+    const std::string ownername = StringUtils::wideToUtf8(
+        RaceManager::get()->getKartInfo(ownerID).getPlayerName());
+    const int ownerTeam = m_team_for_player[ownername];
+    if (ownerTeam == 0)
+        return;
+
+    const std::string victimname = StringUtils::wideToUtf8(
+        RaceManager::get()->getKartInfo(victimID).getPlayerName());
+    const int victimTeam = m_team_for_player[victimname];
+    if (victimTeam != ownerTeam)
+        return;
+
+    // should we tell the world?
+    if (showTeamMateHits() && success)
+    {
+        std::string msg = ServerConfig::m_teammate_hit_msg_prefix;
+        msg += ownername;
+        msg += " just swattered teammate ";
+        msg += victimname;
+        sendTeamMateHitMsg(msg);
+    }
+    if (useTeamMateHitMode())
+    {
+        // remove swatter
+        AbstractKart *owner = World::getWorld()->getKart(ownerID);
+        owner->getAttachment()->setTicksLeft(0);
+        // if this is the first kart hit and the swatter is in use for less than 3s
+        // the attacker also gets an anvil
+        if (!has_hit_kart && ticks_active < stk_config->time2Ticks(3.0f) && success)
+            // we cannot do this here, will be done in update()
+            m_teammate_swatter_punish.push_back(owner);
+    }
+}
+
+void ServerLobby::handleAnvilHit(unsigned int ownerID, unsigned int victimID)
+{
+    const std::string ownername = StringUtils::wideToUtf8(
+        RaceManager::get()->getKartInfo(ownerID).getPlayerName());
+    const int ownerTeam = m_team_for_player[ownername];
+    if (ownerTeam == 0)
+        return;
+
+    const std::string victimname = StringUtils::wideToUtf8(
+        RaceManager::get()->getKartInfo(victimID).getPlayerName());
+    const int victimTeam = m_team_for_player[victimname];
+    if (victimTeam != ownerTeam)
+        return;
+
+    AbstractKart *owner = World::getWorld()->getKart(ownerID);
+
+    // should we tell the world?
+    if (showTeamMateHits())
+    {
+        std::string msg = ServerConfig::m_teammate_hit_msg_prefix;
+        msg += ownername;
+        msg += " just gave an anchor to teammate ";
+        msg += victimname;
+        sendTeamMateHitMsg(msg);
+    }
+    if (useTeamMateHitMode())
+    {
+        if (owner->getAttachment()->getType() == Attachment::ATTACH_BOMB)
+        {
+            // make bomb explode
+            owner->getAttachment()->update(10000);
+        }
+        else
+        {
+            if (owner->isShielded())
+            {
+                // if owner is shielded, take away shield
+                // since the anvil will also destroy the shield of the victim
+                // we also punish this severely
+                owner->decreaseShieldTime();
+            }
+
+            // now give anvil to owner
+            int left_over_ticks = 0;
+            // if owner already has an anvil or a parachute, make new anvil last longer
+            if (owner->getAttachment()->getType() == Attachment::ATTACH_ANVIL
+                || owner->getAttachment()->getType() == Attachment::ATTACH_PARACHUTE)
+            {
+                left_over_ticks = owner->getAttachment()->getTicksLeft();
+            }
+            owner->getAttachment()->set(Attachment::ATTACH_ANVIL,
+                                        stk_config->time2Ticks(owner->getKartProperties()->getAnvilDuration()) + left_over_ticks);
+            // the powerup anvil is very strong, copy these values (from powerup.cpp)
+            owner->adjustSpeed(owner->getKartProperties()->getAnvilSpeedFactor() * 0.5f);
+        }
+    }
+}
diff --git a/src/network/protocols/server_lobby.hpp b/src/network/protocols/server_lobby.hpp
index b25386daa12..c3f6a5ad4e6 100644
--- a/src/network/protocols/server_lobby.hpp
+++ b/src/network/protocols/server_lobby.hpp
@@ -22,6 +22,9 @@
 #include "network/protocols/lobby_protocol.hpp"
 #include "utils/cpp2011.hpp"
 #include "utils/time.hpp"
+#include "utils/track_filter.hpp"
+#include "utils/kart_elimination.hpp"
+#include "karts/controller/player_controller.hpp"
 
 #include "irrString.h"
 
@@ -33,6 +36,7 @@
 #include <memory>
 #include <mutex>
 #include <set>
+#include <deque>
 
 #ifdef ENABLE_SQLITE3
 #include <sqlite3.h>
@@ -50,6 +54,23 @@ namespace Online
     class Request;
 }
 
+// I know it should be in a more suitable place, but for now I have no idea
+// how to make this with the current system. Sorry. Hope to refactor later.
+
+struct GPScore
+{
+    int score = 0;
+    double time = 0.;
+    bool operator < (const GPScore& rhs) const
+    {
+        return (score < rhs.score || (score == rhs.score && time > rhs.time));
+    }
+    bool operator > (const GPScore& rhs) const
+    {
+        return (score > rhs.score || (score == rhs.score && time < rhs.time));
+    }
+};
+
 class ServerLobby : public LobbyProtocol
 {
 public:
@@ -85,6 +106,8 @@ class ServerLobby : public LobbyProtocol
 
     std::string m_server_stats_table;
 
+    std::string m_results_table_name;
+
     bool m_ip_ban_table_exists;
 
     bool m_ipv6_ban_table_exists;
@@ -102,6 +125,10 @@ class ServerLobby : public LobbyProtocol
     bool easySQLQuery(const std::string& query,
         std::function<void(sqlite3_stmt* stmt)> bind_function = nullptr) const;
 
+    std::pair<bool, std::vector<std::vector<std::string>>>
+        vectorSQLQuery(const std::string& query, int columns,
+        std::function<void(sqlite3_stmt* stmt)> bind_function = nullptr) const;
+
     void checkTableExists(const std::string& table, bool& result);
 
     std::string ip2Country(const SocketAddress& addr) const;
@@ -155,6 +182,10 @@ class ServerLobby : public LobbyProtocol
      *  with data in server first. */
     std::pair<std::set<std::string>, std::set<std::string> > m_available_kts;
 
+    /** Available karts and tracks for all clients, this will be initialized
+     *  with data in server first. */
+    std::pair<std::set<std::string>, std::set<std::string> > m_entering_kts;
+
     /** Keeps track of the server state. */
     std::atomic_bool m_server_has_loaded_world;
 
@@ -255,6 +286,142 @@ class ServerLobby : public LobbyProtocol
     // Calculated before each game started
     unsigned m_ai_count;
 
+    std::set<STKPeer*> m_spectators_by_limit;
+
+    std::vector<std::string> m_must_have_tracks;
+
+    std::vector<std::string> m_tournament_must_have_tracks;
+
+    bool m_restricting_config;
+
+    bool m_inverted_config_restriction;
+
+    std::set<std::string> m_config_available_tracks;
+
+    std::map<std::string, std::vector<std::string>> m_config_track_limitations;
+
+    irr::core::stringw m_help_message;
+
+    std::string m_available_commands;
+
+    std::map<STKPeer*, std::set<irr::core::stringw>> m_message_receivers;
+
+    std::set<STKPeer*> m_team_speakers;
+
+    KartElimination m_kart_elimination;
+
+    std::set<int> m_available_difficulties;
+
+    std::set<int> m_available_modes;
+
+    std::map<std::string, std::set<std::string>> m_player_categories;
+
+    std::set<std::string> m_hidden_categories;
+
+    std::set<std::string> m_special_categories;
+
+    std::map<std::string, std::set<std::string>> m_categories_for_player;
+
+    std::map<std::string, int> m_team_for_player;
+
+    std::set<std::string> m_tournament_red_players;
+
+    std::set<std::string> m_tournament_blue_players;
+    
+    std::set<std::string> m_tournament_referees;
+
+    std::set<std::string> m_tournament_mutealls;
+
+    std::set<std::string> m_tournament_init_red;
+
+    std::set<std::string> m_tournament_init_blue;
+
+    std::set<std::string> m_tournament_init_ref;
+
+    bool m_tournament_limited_chat;
+
+    int m_tournament_length;
+
+    int m_tournament_max_games;
+
+    std::string m_tournament_game_limits;
+
+    std::string m_tournament_colors;
+
+    std::vector<std::string> m_tournament_arenas;
+
+    std::vector<TrackFilter> m_tournament_track_filters;
+
+    TrackFilter m_global_filter;
+
+    std::set<std::string> m_temp_banned;
+
+    std::deque<std::string> m_tracks_queue;
+
+    std::map<std::string, GPScore> m_gp_scores;
+
+    std::map<int, GPScore> m_gp_team_scores;
+
+    std::vector<std::string> m_team_name;
+
+    int m_tournament_game;
+
+    int m_fixed_lap;
+
+    float m_extra_seconds;
+
+    double m_default_lap_multiplier;
+
+    std::vector<int> m_scoring_int_params;
+
+    std::string m_scoring_type;
+
+    std::set<STKPeer*> m_default_always_spectate_peers;
+
+    std::set<std::string> m_usernames_white_list;
+
+    bool m_allowed_to_start;
+
+    bool m_consent_on_replays;
+    
+    std::map<std::string, int> m_team_name_to_index;
+
+    bool m_shuffle_gp;
+
+#ifdef ENABLE_WEB_SUPPORT
+    std::set<std::string> m_web_tokens;
+
+    std::atomic<int> m_token_generation_tries;
+#endif
+
+    // config for troll system
+    bool  m_troll_active;
+
+    // teammate hits
+    // show messages about team hits?
+    bool m_show_teammate_hits;
+    // give anvils to attackers?
+    bool m_teammate_hit_mode;
+    // time index of last team mate hit
+    // make sure not to send too many of them
+    int m_last_teammate_hit_msg;
+    // we have to keep track of the karts affected by a hit
+    // we store IDs, because we need to find the team by name (by ID)
+    // m_collecting_teammate_hit_info is set to true if we are processing a
+    // cake or bowl hit, so we make sure we never fill the vectors with
+    // unneeded data.
+    bool m_collecting_teammate_hit_info;
+    unsigned int m_teammate_current_item_ownerID;
+    uint16_t m_teammate_ticks_since_thrown;
+    std::vector<unsigned int> m_teammate_karts_hit;
+    std::vector<unsigned int> m_teammate_karts_exploded;
+    // store karts to punish for swattering a teammate
+    std::vector<AbstractKart*> m_teammate_swatter_punish;
+
+    // after a certain time a bowl can be avoided and doesn't
+    // trigger teammate hits anymore
+    const float MAX_BOWL_TEAMMATE_HIT_TIME = 2.0f;
+
     // connection management
     void clientDisconnected(Event* event);
     void connectionRequested(Event* event);
@@ -274,6 +441,8 @@ class ServerLobby : public LobbyProtocol
     void updatePlayerList(bool update_when_reset_server = false);
     void updateServerOwner();
     void handleServerConfiguration(Event* event);
+    void handleServerConfiguration(std::shared_ptr<STKPeer> peer,
+        int difficulty, int mode, bool soccer_goal_target);
     void updateTracksForMode();
     bool checkPeersReady(bool ignore_ai_peer) const;
     void resetPeersReady()
@@ -368,15 +537,40 @@ class ServerLobby : public LobbyProtocol
     void handleKartInfo(Event* event);
     void clientInGameWantsToBackLobby(Event* event);
     void clientSelectingAssetsWantsToBackLobby(Event* event);
-    std::set<std::shared_ptr<STKPeer>> getSpectatorsByLimit();
+    std::set<STKPeer*>& getSpectatorsByLimit(bool update = false);
     void kickPlayerWithReason(STKPeer* peer, const char* reason) const;
     void testBannedForIP(STKPeer* peer) const;
     void testBannedForIPv6(STKPeer* peer) const;
     void testBannedForOnlineId(STKPeer* peer, uint32_t online_id) const;
+    void getMessagesFromHost(STKPeer* peer, int online_id) const;
     void writeDisconnectInfoTable(STKPeer* peer);
     void writePlayerReport(Event* event);
     bool supportsAI();
     void updateAddons();
+    void initCategories();
+    void initTournamentPlayers();
+    void changeColors();
+    bool canRace(std::shared_ptr<STKPeer>& peer) const;
+    bool canRace(STKPeer* peer) const;
+    bool hasHostRights(std::shared_ptr<STKPeer>& peer) const;
+    bool hasHostRights(STKPeer* peer) const;
+    std::vector<std::string> getMissingTournamentAssets(std::shared_ptr<STKPeer>& peer) const;
+    std::vector<std::string> getMissingTournamentAssets(STKPeer* peer) const;
+    void loadTracksQueueFromConfig();
+    std::string getGrandPrixStandings() const;
+    void loadCustomScoring();
+    void updateWorldSettings();
+    void loadWhiteList();
+    void changeLimitForTournament(bool goal_target);
+    bool tournamentGoalsLimit(int game) const;
+    bool tournamentColorsSwapped(int game) const;
+    void updateTournamentRole(STKPeer* peer);
+
+    // bool tournamentHasIcy(int game) const;
+#ifdef ENABLE_WEB_SUPPORT
+    void loadAllTokens();
+    std::string getToken();
+#endif
 public:
              ServerLobby();
     virtual ~ServerLobby();
@@ -411,8 +605,40 @@ class ServerLobby : public LobbyProtocol
         return std::find(m_ai_profiles.begin(), m_ai_profiles.end(), npp) !=
             m_ai_profiles.end();
     }
+    void storeResults();
     uint32_t getServerIdOnline() const           { return m_server_id_online; }
     void setClientServerHostId(uint32_t id)   { m_client_server_host_id = id; }
+    void initAvailableTracks();
+    void initAvailableModes();
+    void resetToDefaultSettings();
+    void writeOwnReport(STKPeer* reporter, STKPeer* reporting,
+        const std::string& info);
+    bool writeOnePlayerReport(STKPeer* reporter, const std::string& table,
+        const std::string& info);
+    // int getTrackMaxPlayers(std::string& name) const;
+    void updateGnuElimination();
+    void sendStringToPeer(std::string& s, std::shared_ptr<STKPeer>& peer) const;
+    void sendStringToPeer(std::string& s, STKPeer* peer) const;
+    void sendStringToAllPeers(std::string& s);
+#ifdef ENABLE_SQLITE3
+    std::string getRecord(std::string& track, std::string& mode,
+        std::string& direction, int laps);
+#endif
+
+    // handle cakes and bowls
+    void setTeamMateHitOwner(unsigned int ownerID, uint16_t ticks_since_thrown = 0);
+    void registerTeamMateHit(unsigned int kartID);
+    void registerTeamMateExplode(unsigned int kartID);
+    void handleTeamMateHits();
+
+    // handle swatters
+    void handleSwatterHit(unsigned int ownerID, unsigned int victimID, bool success, bool has_hit_kart, uint16_t ticks_active);
+    // handle anvil
+    void handleAnvilHit(unsigned int ownerID, unsigned int victimID);
+
+    void sendTeamMateHitMsg(std::string& s);
+    bool showTeamMateHits() const    { return m_show_teammate_hits; }
+    bool useTeamMateHitMode() const { return m_teammate_hit_mode; }
 };   // class ServerLobby
 
 #endif // SERVER_LOBBY_HPP
diff --git a/src/network/server_config.cpp b/src/network/server_config.cpp
index f5e782d6d34..bd52015cc5b 100644
--- a/src/network/server_config.cpp
+++ b/src/network/server_config.cpp
@@ -50,7 +50,8 @@ static std::vector<UserConfigParam*> g_server_params;
 namespace ServerConfig
 {
 // ============================================================================
-std::string g_server_config_path;
+std::string g_server_config_path[2];
+int m_server_config_level = 0;
 std::string m_server_uid;
 // ============================================================================
 FloatServerConfigParam::FloatServerConfigParam(float default_value,
@@ -115,21 +116,25 @@ MapServerConfigParam<T, U>::MapServerConfigParam(const char* param_name,
 // ============================================================================
 void loadServerConfig(const std::string& path)
 {
+    m_loaded_from_external_config = false;
     bool default_config = false;
     if (path.empty())
     {
         default_config = true;
-        g_server_config_path =
+        g_server_config_path[m_server_config_level] =
             file_manager->getUserConfigFile("server_config.xml");
     }
     else
     {
-        g_server_config_path = file_manager->getFileSystem()
+        g_server_config_path[m_server_config_level] =
+            file_manager->getFileSystem()
             ->getAbsolutePath(path.c_str()).c_str();
     }
-    m_server_uid = StringUtils::removeExtension(
-        StringUtils::getBasename(g_server_config_path));
-    const XMLNode* root = file_manager->createXMLTree(g_server_config_path);
+    if (m_server_config_level == 0)
+        m_server_uid = StringUtils::removeExtension(StringUtils::getBasename(
+            g_server_config_path[m_server_config_level]));
+    const XMLNode* root = file_manager->createXMLTree(
+        g_server_config_path[m_server_config_level]);
     loadServerConfigXML(root, default_config);
 }   // loadServerConfig
 
@@ -140,7 +145,8 @@ void loadServerConfigXML(const XMLNode* root, bool default_config)
     {
         Log::info("ServerConfig",
             "Could not read server config file '%s'. "
-            "A new file will be created.", g_server_config_path.c_str());
+            "A new file will be created.",
+            g_server_config_path[m_server_config_level].c_str());
         if (root)
             delete root;
         writeServerConfigToDisk();
@@ -159,6 +165,22 @@ void loadServerConfigXML(const XMLNode* root, bool default_config)
         return;
     }
 
+    std::string external_config_path;
+    if (m_server_config_level == 0)
+    {
+        const XMLNode* child = root->getNode("external-config");
+        if (child != NULL && child->get("value", &external_config_path))
+        {
+            m_server_config_level = 1;
+            loadServerConfig(external_config_path);
+            m_server_config_level = 0;
+        }
+    }
+    else
+    {
+        m_loaded_from_external_config = true;
+    }
+
     for (unsigned i = 0; i < g_server_params.size(); i++)
         g_server_params[i]->findYourDataInAChildOf(root);
 
@@ -183,18 +205,20 @@ std::string getServerConfigXML()
 // ----------------------------------------------------------------------------
 void writeServerConfigToDisk()
 {
+    if (m_loaded_from_external_config) // Don't overwrite if there were 2 files
+        return;
     const std::string& config_xml = getServerConfigXML();
     try
     {
         std::ofstream configfile(FileUtils::getPortableWritingPath(
-            g_server_config_path), std::ofstream::out);
+            g_server_config_path[0]), std::ofstream::out);
         configfile << config_xml;
         configfile.close();
     }
     catch (std::runtime_error& e)
     {
         Log::error("ServerConfig", "Failed to write server config to %s, "
-            "because %s", g_server_config_path.c_str(), e.what());
+            "because %s", g_server_config_path[0].c_str(), e.what());
     }
 }   // writeServerConfigToDisk
 
@@ -322,7 +346,7 @@ void loadServerLobbyFromConfig()
     if (m_official_tracks_threshold > 1.0f)
         m_official_tracks_threshold = 1.0f;
 
-    if (m_live_players)
+    if (m_live_players && !m_sleeping_server)
         m_official_karts_threshold = 1.0f;
     if (m_high_ping_workaround)
         m_kick_high_ping_players = false;
@@ -333,7 +357,7 @@ void loadServerLobbyFromConfig()
     RaceManager::get()->setDifficulty(RaceManager::Difficulty(difficulty));
 
     if (RaceManager::get()->getMinorMode() == RaceManager::MINOR_MODE_FREE_FOR_ALL &&
-        m_server_max_players > 10)
+        m_server_max_players > 10 && !m_server_configurable)
         m_server_max_players = 10;
 
     m_max_players_in_game = (m_max_players_in_game <= 0) ? m_server_max_players :
@@ -346,6 +370,45 @@ void loadServerLobbyFromConfig()
 #endif
     }
 
+    if (m_only_host_riding) {
+        m_max_players_in_game = 1;
+    }
+
+    if (m_soccer_tournament) {
+        m_server_mode = 6;
+        m_server_difficulty = 3;
+        if (m_server_max_players < 9) {
+            m_server_max_players = 9;
+        }
+        // m_voting_timeout = 15;
+        m_soccer_goal_target = false;
+        m_official_tracks_needed = false;
+        // m_owner_less = false;
+        m_official_karts_threshold = 1.0f;
+        m_official_tracks_threshold = 0.0f;
+        m_addon_karts_threshold = 0;
+        m_addon_tracks_threshold = 0;
+        m_addon_arenas_threshold = 0;
+        m_addon_soccers_threshold = 0; // maybe 1 ?
+        m_team_choosing = true;
+        m_ranked = false;
+        m_server_configurable = false;
+        m_live_players = true;
+        m_sleeping_server = false;
+        m_free_teams = true;
+        // m_validating_player = true;
+        m_random_selects_addons = true;
+        if (m_owner_less)
+        {
+            m_min_start_game_players = 1;
+            m_start_game_counter = 1000001;
+        }
+        else
+        {
+
+        }
+    }
+
     if (m_ranked)
     {
         m_validating_player = true;
@@ -353,10 +416,17 @@ void loadServerLobbyFromConfig()
         m_owner_less = true;
         m_strict_players = true;
     }
+    if (m_sleeping_server) {
+        m_owner_less = true;
+    }
     if (m_owner_less)
     {
-        if (m_min_start_game_players > m_max_players_in_game)
-            m_min_start_game_players = 1;
+        if (m_sleeping_server) {
+            m_min_start_game_players = 256;
+        } else {
+            if (m_min_start_game_players > m_max_players_in_game)
+                m_min_start_game_players = 1;
+        }
         if (!m_live_players)
             m_team_choosing = false;
         m_server_configurable = false;
@@ -397,7 +467,6 @@ void loadServerLobbyFromConfig()
             m_time_limit_ctf.revertToDefaults();
         }
     }
-
     // The extra server info has to be set before the server lobby is started
     if (server_lobby)
         server_lobby->requestStart();
@@ -406,8 +475,7 @@ void loadServerLobbyFromConfig()
 // ----------------------------------------------------------------------------
 std::string getConfigDirectory()
 {
-    return StringUtils::getPath(g_server_config_path);
+    return StringUtils::getPath(g_server_config_path[0]);
 }   // getConfigDirectory
 
 }
-
diff --git a/src/network/server_config.hpp b/src/network/server_config.hpp
index 28de109f812..38b80211869 100644
--- a/src/network/server_config.hpp
+++ b/src/network/server_config.hpp
@@ -147,8 +147,13 @@ namespace ServerConfig
 
     SERVER_CFG_PREFIX StringServerConfigParam m_motd
         SERVER_CFG_DEFAULT(StringServerConfigParam("",
-        "motd", "Message of today shown in lobby, you can enter encoded XML "
-        "words here or a file.txt and let STK load it."));
+        "motd", "Message of today shown in lobby, you can enter here "
+        "encoded XML words or a .txt file and let STK load it."));
+
+    SERVER_CFG_PREFIX StringServerConfigParam m_help
+        SERVER_CFG_DEFAULT(StringServerConfigParam("",
+        "help", "Help message shown after sending /help. You can enter here "
+        "the message or a .txt file and let STK load it."));
 
     SERVER_CFG_PREFIX BoolServerConfigParam m_chat
         SERVER_CFG_DEFAULT(BoolServerConfigParam(true, "chat",
@@ -227,6 +232,88 @@ namespace ServerConfig
         "android players from joining this server, because STK android apk "
         "has some official tracks removed."));
 
+    SERVER_CFG_PREFIX IntServerConfigParam m_addon_karts_threshold
+        SERVER_CFG_DEFAULT(IntServerConfigParam(0,
+        "addon_karts_threshold",
+        "Clients below this value will be rejected from joining this server. "
+        "It's determined by number of addon karts in client"));
+
+    SERVER_CFG_PREFIX IntServerConfigParam m_addon_tracks_threshold
+        SERVER_CFG_DEFAULT(IntServerConfigParam(0,
+        "addon_tracks_threshold",
+        "Clients below this value will be rejected from joining this server. "
+        "It's determined by number of addon tracks in client"));
+
+    SERVER_CFG_PREFIX IntServerConfigParam m_addon_arenas_threshold
+        SERVER_CFG_DEFAULT(IntServerConfigParam(0,
+        "addon_arenas_threshold",
+        "Clients below this value will be rejected from joining this server. "
+        "It's determined by number of addon arenas in client"));
+
+    SERVER_CFG_PREFIX IntServerConfigParam m_addon_soccers_threshold
+        SERVER_CFG_DEFAULT(IntServerConfigParam(0,
+        "addon_soccers_threshold",
+        "Clients below this value will be rejected from joining this server. "
+        "It's determined by number of addon soccer fields in client"));
+
+    SERVER_CFG_PREFIX StringServerConfigParam m_must_have_tracks_string
+        SERVER_CFG_DEFAULT(StringServerConfigParam("",
+        "must-have-tracks", "Tracks needed to enter the server, "
+        "leave empty for no restriction."));
+
+    SERVER_CFG_PREFIX StringServerConfigParam m_only_played_tracks_string
+        SERVER_CFG_DEFAULT(StringServerConfigParam("",
+        "only-played-tracks", "List of tracks that can be played on a server, "
+        "leave empty for no restriction or put 'not' before the list "
+        "to name tracks that cannot be played."));
+
+    SERVER_CFG_PREFIX IntServerConfigParam m_fixed_lap_count
+        SERVER_CFG_DEFAULT(IntServerConfigParam(-1, "fixed-lap-count",
+        "Use fixed lap count, negative or zero to disable."));
+
+    SERVER_CFG_PREFIX BoolServerConfigParam m_official_tracks_needed
+        SERVER_CFG_DEFAULT(BoolServerConfigParam(true, "official-tracks-needed",
+        "If this value is set to true, players and the server must have "
+        "at least one common official track."));
+
+    SERVER_CFG_PREFIX BoolServerConfigParam m_troll_active
+        SERVER_CFG_DEFAULT(BoolServerConfigParam(false, "use-anti-troll-system",
+        "If this value is set to true, warn and kick players who troll others."));
+
+    SERVER_CFG_PREFIX StringServerConfigParam m_troll_warn_msg
+        SERVER_CFG_DEFAULT(StringServerConfigParam("WARNING: You troll, you get kicked!",
+        "troll-warn-message",
+        "This message is shown as warning."));
+
+    SERVER_CFG_PREFIX FloatServerConfigParam m_troll_warning_time
+        SERVER_CFG_DEFAULT(FloatServerConfigParam(7.0f, "troll-warning-time",
+        "After this time (in sec) of backwards movement or stopping a warning is issued."));
+
+    SERVER_CFG_PREFIX FloatServerConfigParam m_troll_kick_time
+        SERVER_CFG_DEFAULT(FloatServerConfigParam(10.0f, "troll-kick-time",
+        "After this time (in sec) of backwards movement or stopping the player is kicked."));
+
+    SERVER_CFG_PREFIX FloatServerConfigParam m_troll_min_normal_speed
+        SERVER_CFG_DEFAULT(FloatServerConfigParam(12.0f, "troll-min-normal-speed",
+        "Minimum speed in correct direction to decrease wron_way timer."));
+
+    SERVER_CFG_PREFIX FloatServerConfigParam m_troll_max_stop_speed
+        SERVER_CFG_DEFAULT(FloatServerConfigParam(5.0f, "troll-max-stop-speed",
+        "A player going slower than this is considered stopping."));
+
+    SERVER_CFG_PREFIX BoolServerConfigParam m_show_teammate_hits
+        SERVER_CFG_DEFAULT(BoolServerConfigParam(false, "show-teammate-hits",
+        "If this value is set to true, a message is send to everybody if a player makes a teammate explode."));
+
+    SERVER_CFG_PREFIX BoolServerConfigParam m_teammate_hit_mode
+        SERVER_CFG_DEFAULT(BoolServerConfigParam(false, "teammate-hit-mode",
+        "Punish teammate hits? If set to true players get an anvil when they hit teammates."));
+
+    SERVER_CFG_PREFIX StringServerConfigParam m_teammate_hit_msg_prefix
+        SERVER_CFG_DEFAULT(StringServerConfigParam("LOL: ",
+        "teammate-hit-msg-prefix",
+        "This string is the prefix for the messages if players hit teammates. (Make sure it ends with a whitespace if non-empty.)"));
+
     SERVER_CFG_PREFIX IntServerConfigParam m_min_start_game_players
         SERVER_CFG_DEFAULT(IntServerConfigParam(2, "min-start-game-players",
         "Only auto start kart selection when number of "
@@ -265,6 +352,13 @@ namespace ServerConfig
         "was created using the in-game GUI. The changed difficulty and game "
         "mode will not be saved in this config file."));
 
+    SERVER_CFG_PREFIX StringServerConfigParam m_available_modes
+        SERVER_CFG_DEFAULT(StringServerConfigParam("d0123 m012345678", "available-modes",
+        "Description of modes and difficulties that can be set "
+        "on a configurable server. Doesn't affect initial mode "
+        "and doesn't affect unconfigurable servers. Use the "
+        "format \"d0123 m012345678\"."));
+
     SERVER_CFG_PREFIX BoolServerConfigParam m_live_players
         SERVER_CFG_DEFAULT(BoolServerConfigParam(true, "live-spectate",
         "If true, players can live join or spectate the in-progress game. "
@@ -437,11 +531,161 @@ namespace ServerConfig
         "network-ai=x, which will kick N - 1 bot(s) where N is the number "
         "of human players. Only use this for non-GP racing server."));
 
+    SERVER_CFG_PREFIX BoolServerConfigParam m_sleeping_server
+        SERVER_CFG_DEFAULT(BoolServerConfigParam(false, "sleeping-server",
+        "If true no one can start a race and everyone should use the "
+        "server for sleeping/chatting only."));
+
+    SERVER_CFG_PREFIX IntServerConfigParam m_false_ip
+        SERVER_CFG_DEFAULT(IntServerConfigParam(0, "false-ip",
+        "IP that should be used to connect to a server, set 0 for a "
+        "default IP. You need this only if the server's IP shouldn't be "
+        "used for some reason (e.g. blocking) and there is another IP "
+        "('good') that points to the same server. In this case, you "
+        "should write a good IP here as a number. Only IPv4 is "
+        "supported."));
+
+    SERVER_CFG_PREFIX BoolServerConfigParam m_store_results
+        SERVER_CFG_DEFAULT(BoolServerConfigParam(false, "store-results",
+        "When true, stores race results in a separate table for each "
+        "server."));
+
+    SERVER_CFG_PREFIX StringServerConfigParam m_records_table_name
+        SERVER_CFG_DEFAULT(StringServerConfigParam("", "records-table-name",
+        "When non-empty, server is telling whether a player has beaten "
+        "a server record, records are taken from the table specified "
+        "in this field. So it can be the results table for this server "
+        "or for all servers hosted on the machine."));
+
+    SERVER_CFG_PREFIX BoolServerConfigParam m_track_kicks
+        SERVER_CFG_DEFAULT(BoolServerConfigParam(false, "track-kicks",
+        "When true, stores the info about each forced kick in a database "
+        "(if it exists)."));
+
+    SERVER_CFG_PREFIX BoolServerConfigParam m_free_teams
+        SERVER_CFG_DEFAULT(BoolServerConfigParam(false, "free-teams",
+        "When true, the server allows changing teams freely."));
+
+    SERVER_CFG_PREFIX BoolServerConfigParam m_soccer_tournament
+        SERVER_CFG_DEFAULT(BoolServerConfigParam(false, "soccer-tournament",
+        "When true, the server has the functionality to host soccer "
+        "tournaments. Rules may change so better ask STK players about "
+        "the actual rules."));
+
+    SERVER_CFG_PREFIX StringServerConfigParam m_soccer_tournament_match
+        SERVER_CFG_DEFAULT(StringServerConfigParam("",
+        "soccer-tournament-match",
+        "List of players and judges. Use the format \"R red red "
+        "red B blue blue blue J judge judge\" where "
+        "the category is preceded by its letter. Categories can "
+        "be empty or absent and can go in any order. You can use "
+        "a category (#A) instead of listing all players."));
+
+    SERVER_CFG_PREFIX StringServerConfigParam m_categories
+        SERVER_CFG_DEFAULT(StringServerConfigParam("",
+        "categories",
+        "List of players with categories (teams, etc.). Use the "
+        "format #Category1 player1 ... playerN #Category2 ... "
+        "Use ## to hide the category from the player list."));
+
+    SERVER_CFG_PREFIX StringServerConfigParam m_soccer_tournament_rules
+        SERVER_CFG_DEFAULT(StringServerConfigParam("nochat 10 TTTTG RRBBR;"
+        ";;not %1;"
+        "not %1 "
+        "%2;;;",
+        "soccer-tournament-rules",
+        "A string specifying the match format."));
+
+    SERVER_CFG_PREFIX StringServerConfigParam m_soccer_tournament_enforced_tracks_string
+        SERVER_CFG_DEFAULT(StringServerConfigParam("",
+        "soccer-tournament-enforced-tracks",
+        "List of tracks tournament players should have to enter "
+        "(doesn't apply to spectators)."));
+
+    SERVER_CFG_PREFIX StringServerConfigParam m_incompatible_advice
+        SERVER_CFG_DEFAULT(StringServerConfigParam("",
+        "incompatible-advice",
+        "A string given to a peer if it has incompatible data, so "
+        "that it can know why it cannot enter, empty to disable."));
+
+    SERVER_CFG_PREFIX BoolServerConfigParam m_only_host_riding
+        SERVER_CFG_DEFAULT(BoolServerConfigParam(false, "only-host-riding",
+        "A feature to make others only spectate."));
+
+    SERVER_CFG_PREFIX BoolServerConfigParam m_record_replays
+        SERVER_CFG_DEFAULT(BoolServerConfigParam(false, "record-replays",
+        "If true, normal race and time trial games are recorded into ghost "
+        "replays."));
+
+    SERVER_CFG_PREFIX BoolServerConfigParam m_random_selects_addons
+        SERVER_CFG_DEFAULT(BoolServerConfigParam(false, "random-selects-addons",
+        "If true and no track is selected, then an addon track can be picked."));
+
+    SERVER_CFG_PREFIX StringServerConfigParam m_tracks_order
+        SERVER_CFG_DEFAULT(StringServerConfigParam("", "tracks-queue",
+        "If non-empty, these tracks are played in the order until "
+        "the list ends. Can be useful for grands prix."));
+
+    SERVER_CFG_PREFIX StringServerConfigParam m_gp_scoring
+        SERVER_CFG_DEFAULT(StringServerConfigParam(
+        "fixed 0 1 10 8 6 5 4 3 2 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0",
+        "grand-prix-scoring",
+        "A custom Grand Prix scoring system to be used, "
+        "empty for default."));
+
+    SERVER_CFG_PREFIX StringServerConfigParam m_white_list
+        SERVER_CFG_DEFAULT(StringServerConfigParam("",
+        "white-list",
+        "For a private server, a list of players who can enter with "
+        "any password. Works only for online accounts."));
+
+    SERVER_CFG_PREFIX BoolServerConfigParam m_expose_mobile
+        SERVER_CFG_DEFAULT(BoolServerConfigParam(true, "expose-mobile",
+        "If true, all mobile peers get a corresponding icon into the name."));
+
+    SERVER_CFG_PREFIX StringServerConfigParam m_soccer_goals_policy
+        SERVER_CFG_DEFAULT(StringServerConfigParam("standard",
+        "soccer-goals-policy",
+        "Specifies how to count own goals: standard - last touching player "
+        "is counted, no-own-goals - last touching player of scoring team "
+        "is counted if existing, advanced - as standard for now."));
+
+#ifdef ENABLE_WEB_SUPPORT
+
+    SERVER_CFG_PREFIX StringServerConfigParam m_tokens_table
+        SERVER_CFG_DEFAULT(StringServerConfigParam("",
+        "tokens-table",
+        "A table containing tokens for website authentication using "
+        "STK account only."));
+#endif
+
+    SERVER_CFG_PREFIX StringServerConfigParam m_power_password
+        SERVER_CFG_DEFAULT(StringServerConfigParam("",
+        "power-password",
+        "Allows server owner (not crowned player!) to go to power mode "
+        "to kick players using GUI and not be kicked, empty to disable."));
+
     SERVER_CFG_PREFIX BoolServerConfigParam m_ai_anywhere
         SERVER_CFG_DEFAULT(BoolServerConfigParam(false, "ai-anywhere",
         "If true this server will allow AI instance to be connected from "
         "anywhere. (other than LAN network only)"));
 
+    SERVER_CFG_PREFIX BoolServerConfigParam m_kicks_allowed
+        SERVER_CFG_DEFAULT(BoolServerConfigParam(true, "kicks-allowed",
+        "If true, the server owner can kick players, either via "
+        "the UI button or using /kick command."));
+
+    SERVER_CFG_PREFIX StringServerConfigParam m_register_table_name
+        SERVER_CFG_DEFAULT(StringServerConfigParam("", "registration-table-name",
+        "When non-empty, stores input given by /register command in "
+        "the corresponding table. Otherwise, /register command does "
+        "nothing"));
+
+    SERVER_CFG_PREFIX BoolServerConfigParam m_shuffle_gp
+        SERVER_CFG_DEFAULT(BoolServerConfigParam(false, "shuffle-grand-prix-grid",
+        "If true, the GP grid is shuffled before each race, not only before "
+        "the first one."));
+
     // ========================================================================
     /** Server version, will be advanced if there are protocol changes. */
     static const uint32_t m_server_version = 6;
@@ -453,6 +697,8 @@ namespace ServerConfig
     /** Server uid, extracted from server_config.xml file with .xml removed. */
     extern std::string m_server_uid;
     // ========================================================================
+    static bool m_loaded_from_external_config;
+    // ========================================================================
     void loadServerConfig(const std::string& path = "");
     // ------------------------------------------------------------------------
     void loadServerConfigXML(const XMLNode* root, bool default_config = false);
diff --git a/src/network/stk_host.cpp b/src/network/stk_host.cpp
index 9cfec4adc3e..69920007c35 100644
--- a/src/network/stk_host.cpp
+++ b/src/network/stk_host.cpp
@@ -16,6 +16,8 @@
 //  along with this program; if not, write to the Free Software
 //  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 
+#include <regex>
+
 #include "network/stk_host.hpp"
 
 #include "config/stk_config.hpp"
@@ -1486,6 +1488,44 @@ std::shared_ptr<STKPeer>
     return ret != m_peers.end() ? ret->second : nullptr;
 }   // findPeerByName
 
+//-----------------------------------------------------------------------------
+std::shared_ptr<STKPeer>
+    STKHost::findPeerByWildcard(const core::stringw& name_pattern, std::string& name_found) const
+{
+    std::lock_guard<std::mutex> lock(m_peers_mutex);
+    bool found = false;
+    std::shared_ptr<STKPeer> ret = nullptr;
+    std::map<ENetPeer*, std::shared_ptr<STKPeer>>::const_iterator iter = m_peers.begin();
+    std::map<ENetPeer*, std::shared_ptr<STKPeer>>::const_iterator end  = m_peers.end();
+
+    // change wildcard symbols to regex
+    std::string pat = StringUtils::wideToUtf8(name_pattern);
+    pat = std::regex_replace(pat, std::regex("\\?"), ".");
+    pat = std::regex_replace(pat, std::regex("\\*"), ".*");
+
+    std::regex regexString(pat, std::regex_constants::icase);
+
+    for (; iter != end; iter++)
+    {
+        auto p = iter->second;
+        for (auto& profile : p->getPlayerProfiles())
+        {
+            if (std::regex_match(StringUtils::wideToUtf8(profile->getName()), regexString))
+            {
+                if (found == true) {
+                    // not unique
+                    return nullptr;
+                } else {
+                    found = true;
+                    name_found = StringUtils::wideToUtf8(profile->getName());
+                    ret = p;
+                }
+            }
+        }
+    }
+    return ret;
+}   // findPeerByWildcard
+
 //-----------------------------------------------------------------------------
 void STKHost::initClientNetwork(ENetEvent& event, Network* new_network)
 {
diff --git a/src/network/stk_host.hpp b/src/network/stk_host.hpp
index 3203f9b3d26..3f7829dddea 100644
--- a/src/network/stk_host.hpp
+++ b/src/network/stk_host.hpp
@@ -268,6 +268,7 @@ class STKHost
     std::shared_ptr<STKPeer> findPeerByHostId(uint32_t id) const;
     // ------------------------------------------------------------------------
     std::shared_ptr<STKPeer> findPeerByName(const core::stringw& name) const;
+    std::shared_ptr<STKPeer> findPeerByWildcard(const core::stringw& name_pattern, std::string &name_found) const;
     // ------------------------------------------------------------------------
     void sendPacketExcept(STKPeer* peer, NetworkString *data,
                           bool reliable = true);
diff --git a/src/network/stk_peer.cpp b/src/network/stk_peer.cpp
index bfd6ea1d958..96ce41e8ce2 100644
--- a/src/network/stk_peer.cpp
+++ b/src/network/stk_peer.cpp
@@ -53,6 +53,7 @@ STKPeer::STKPeer(ENetPeer *enet_peer, STKHost* host, uint32_t host_id)
     m_warned_for_high_ping.store(false);
     m_last_activity.store((int64_t)StkTime::getMonoTimeMs());
     m_last_message.store(0);
+    m_angry_host.store(false);
     m_consecutive_messages = 0;
 }   // STKPeer
 
diff --git a/src/network/stk_peer.hpp b/src/network/stk_peer.hpp
index 3678d39de38..25652b50ab9 100644
--- a/src/network/stk_peer.hpp
+++ b/src/network/stk_peer.hpp
@@ -131,6 +131,8 @@ class STKPeer : public NoCopy
     std::set<std::string> m_client_capabilities;
 
     std::array<int, AS_TOTAL> m_addons_scores;
+
+    std::atomic_bool m_angry_host;
 public:
     STKPeer(ENetPeer *enet_peer, STKHost* host, uint32_t host_id);
     // ------------------------------------------------------------------------
@@ -275,6 +277,16 @@ class STKPeer : public NoCopy
     // ------------------------------------------------------------------------
     int getPacketLoss() const                  { return m_packet_loss.load(); }
     // ------------------------------------------------------------------------
+    // next four lines are kimden's part, delete them when it's possible
+    // to limit players by addon number
+    int addon_karts_count = 0;
+    // ------------------------------------------------------------------------
+    int addon_tracks_count = 0;
+    // ------------------------------------------------------------------------
+    int addon_arenas_count = 0;
+    // ------------------------------------------------------------------------
+    int addon_soccers_count = 0;
+    // ------------------------------------------------------------------------
     const std::array<int, AS_TOTAL>& getAddonsScores() const
                                                     { return m_addons_scores; }
     // ------------------------------------------------------------------------
@@ -310,6 +322,11 @@ class STKPeer : public NoCopy
         if (m_always_spectate.load() == ASM_FULL)
             m_always_spectate.store(ASM_NONE);
     }
+    // ------------------------------------------------------------------------
+    bool isAngryHost() const                    { return m_angry_host.load(); }
+    // ------------------------------------------------------------------------
+    void setAngryHost(bool val)                    { m_angry_host.store(val); }
+    // ------------------------------------------------------------------------
 };   // STKPeer
 
 #endif // STK_PEER_HPP
diff --git a/src/race/race_manager.hpp b/src/race/race_manager.hpp
index 67a6ebd5016..46a5cb4fe12 100644
--- a/src/race/race_manager.hpp
+++ b/src/race/race_manager.hpp
@@ -635,6 +635,11 @@ class RaceManager
         return m_kart_status[kart].m_ident;
     }   // getKartIdent
     // ----------------------------------------------------------------------------------------
+    const std::string& getPlayerName(int kart) const
+    {
+        return m_kart_status[kart].m_player_name;
+    }   // getKartName
+    // ----------------------------------------------------------------------------------------
     int getKartScore(int krt) const { return m_kart_status[krt].m_score; }
     // ----------------------------------------------------------------------------------------
     int getKartPrevScore(int krt) const
diff --git a/src/replay/replay_recorder.cpp b/src/replay/replay_recorder.cpp
index 838c20ac1bd..59508f0e079 100644
--- a/src/replay/replay_recorder.cpp
+++ b/src/replay/replay_recorder.cpp
@@ -304,7 +304,7 @@ void ReplayRecorder::update(int ticks)
         r->m_jumping = kart->isJumping();
     }   // for i
 
-    if (world->getPhase() == World::RESULT_DISPLAY_PHASE && !m_complete_replay)
+    if ((world->getPhase() == World::RESULT_DISPLAY_PHASE || world->getPhase() == World::DELAY_FINISH_PHASE) && !m_complete_replay)
     {
         m_complete_replay = true;
         save();
@@ -408,12 +408,12 @@ void ReplayRecorder::save()
         fprintf(fd, "kart: %s %s\n", kart->getIdent().c_str(),
                 StringUtils::xmlEncode(kart->getController()->getName()).c_str());
 
-        if (kart->getController()->isPlayerController())
+/*        if (kart->getController()->isPlayerController())
         {
             fprintf(fd, "kart_color: %f\n", StateManager::get()->getActivePlayer(player_count)->getConstProfile()->getDefaultKartColor());
             player_count++;
         }
-        else
+        else*/
             fprintf(fd, "kart_color: 0\n");
     }
 
diff --git a/src/utils/kart_elimination.cpp b/src/utils/kart_elimination.cpp
new file mode 100644
index 00000000000..56f9815c55c
--- /dev/null
+++ b/src/utils/kart_elimination.cpp
@@ -0,0 +1,160 @@
+//
+//  SuperTuxKart - a fun racing game with go-kart
+//  Copyright (C) 2004-2020  Steve Baker <sjbaker1@airmail.net>,
+//  Copyright (C) 2004-2020  Ingo Ruhnke <grumbel@gmx.de>
+//  Copyright (C) 2006-2020  SuperTuxKart-Team
+//  Copyright (C) 2020  kimden
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 3
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+#include "utils/kart_elimination.hpp"
+
+#include "utils/string_utils.hpp"
+#include "utils/log.hpp"
+#include <algorithm>
+#include <cassert>
+#include <cmath>
+#include <cstdio>
+#include <cstring>
+#include <string>
+#include <exception>
+
+
+//-----------------------------------------------------------------------------
+KartElimination::KartElimination()
+{
+    m_enabled = false;
+    m_remained = 0;
+    m_kart = "";
+}   // KartElimination
+//-----------------------------------------------------------------------------
+bool KartElimination::isEliminated(std::string username) const
+{
+    if (!m_enabled || m_remained < 0)
+        return false;
+    for (int i = 0; i < m_remained; i++)
+        if (m_participants[i] == username)
+            return false;
+    return true;
+}   // isEliminated
+//-----------------------------------------------------------------------------
+std::set<std::string> KartElimination::getRemainingParticipants() const
+{
+    std::set<std::string> ans;
+    if (!m_enabled)
+        return ans;
+    for (int i = 0; i < m_remained; i++)
+        ans.insert(m_participants[i]);
+    return ans;
+}   // getRemainingParticipants
+//-----------------------------------------------------------------------------
+std::string KartElimination::getStandings() const
+{
+    std::string result = "Gnu Elimination ";
+    if (m_enabled)
+        result += "is running";
+    else
+        result += "is disabled";
+    if (!m_participants.empty())
+        result += ", standings:";
+    for (int i = 0; i < (int)m_participants.size(); i++)
+    {
+        std::string line = "\n" + (i < m_remained ?
+            std::to_string(i + 1) : "[" + std::to_string(i + 1) + "]");
+        line += ". " + m_participants[i];
+        result += line;
+    }
+    return result;
+}   // getStandings
+//-----------------------------------------------------------------------------
+void KartElimination::disable()
+{
+    m_kart = "";
+    m_enabled = false;
+    m_remained = 0;
+    m_participants.clear();
+}   // disable
+//-----------------------------------------------------------------------------
+void KartElimination::enable(std::string kart)
+{
+    m_kart = kart;
+    m_enabled = true;
+    m_remained = -1;
+    m_participants.clear();
+}   // enable
+//-----------------------------------------------------------------------------
+std::string KartElimination::getStartingMessage() const
+{
+    if (m_kart == "gnu")
+        return "Gnu Elimination starts now! Use /standings "
+            "after each race for results.";
+    else
+        return StringUtils::insertValues("Gnu Elimination starts now "
+            "(elimination kart: %s)! Use /standings "
+            "after each race for results.", m_kart.c_str());
+}   // getStartingMessage
+//-----------------------------------------------------------------------------
+std::string KartElimination::getWarningMessage() const
+{
+    return StringUtils::insertValues(
+        "Gnu Elimination is played right now on this server, "
+        "you will be forced to use kart %s until it ends. "
+        "Use /standings to see the results.",
+        m_kart.c_str());
+}   // getWarningMessage
+//-----------------------------------------------------------------------------
+
+std::string KartElimination::update(
+    std::map<std::string, double>& order)
+{
+    assert(m_remained != 0);
+    if (m_remained < 0)
+    {
+        m_remained = order.size();
+        for (const auto& p: order)
+            m_participants.push_back(p.first);
+    }
+    for (int i = 0; i < m_remained; i++)
+    {
+        if (order.count(m_participants[i]) == 0)
+            order[m_participants[i]] = KartElimination::INF_TIME;
+    }
+    std::stable_sort(m_participants.begin(), m_participants.begin() + m_remained,
+        [order](const std::string& a, const std::string& b) -> bool {
+            auto it1 = order.find(a);
+            auto it2 = order.find(b);
+            return it1->second < it2->second;
+    });
+    std::string msg = "";
+    msg += m_participants[--m_remained];
+    bool alone = true;
+    while (m_remained - 1 >= 0 && order[m_participants[m_remained - 1]] == KartElimination::INF_TIME)
+    {
+        msg += ", " + m_participants[--m_remained];
+        alone = false;
+    }
+    if (alone)
+        msg += " is now eliminated.";
+    else
+        msg += " are now eliminated.";
+    if (m_remained <= 1) {
+        m_enabled = false;
+        msg += "\nGnu Elimination has finished! Congratulations to " + m_participants[0] + " !";
+    }
+    return msg;
+}   // update
+//-----------------------------------------------------------------------------
+
+/* EOF */
diff --git a/src/utils/kart_elimination.hpp b/src/utils/kart_elimination.hpp
new file mode 100644
index 00000000000..e8d310f8bae
--- /dev/null
+++ b/src/utils/kart_elimination.hpp
@@ -0,0 +1,57 @@
+//
+//  SuperTuxKart - a fun racing game with go-kart
+//  Copyright (C) 2004-2020  Steve Baker <sjbaker1@airmail.net>,
+//  Copyright (C) 2004-2020  Ingo Ruhnke <grumbel@gmx.de>
+//  Copyright (C) 2006-2020  SuperTuxKart-Team
+//  Copyright (C) 2020  kimden
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 3
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+#ifndef HEADER_KART_ELIMINATION_HPP
+#define HEADER_KART_ELIMINATION_HPP
+
+#include "utils/types.hpp"
+#include "utils/string_utils.hpp"
+#include <limits>
+#include <vector>
+#include <set>
+#include <map>
+#include <string>
+
+// A class that contains Gnu Elimination data
+
+class KartElimination {
+private:
+    bool m_enabled;
+    int m_remained;
+    std::string m_kart;
+    std::vector<std::string> m_participants;
+
+public:
+	static constexpr double INF_TIME = 1e9;
+    KartElimination();
+    bool isEliminated(std::string username) const;
+    std::string getKart() const                              {  return m_kart; }
+    std::set<std::string> getRemainingParticipants() const;
+    bool isEnabled() const                                {  return m_enabled; }
+    void enable(std::string kart); // done
+    void disable(); // done
+    std::string getStandings() const; // done
+    std::string getStartingMessage() const; // done
+    std::string getWarningMessage() const; // done
+    std::string update(std::map<std::string, double>& order);
+};
+
+#endif
diff --git a/src/utils/string_utils.hpp b/src/utils/string_utils.hpp
index 4d0db1a85ed..9fb668c5540 100644
--- a/src/utils/string_utils.hpp
+++ b/src/utils/string_utils.hpp
@@ -49,7 +49,7 @@ namespace StringUtils
 
     std::string ticksTimeToString(int time);
     std::string timeToString(float time, unsigned int precision = 3,
-                             bool display_minutes_if_zero = true, bool display_hours = false);
+                             bool display_minutes_if_zero = true, bool display_hours = true);
     irr::core::stringw loadingDots(float interval = 0.5f, int max_dots = 3);
     irr::core::stringw loadingDots(const irr::core::stringw& s);
     std::string                     toUpperCase(const std::string&);
diff --git a/src/utils/track_filter.cpp b/src/utils/track_filter.cpp
new file mode 100644
index 00000000000..0b40b21de86
--- /dev/null
+++ b/src/utils/track_filter.cpp
@@ -0,0 +1,183 @@
+//
+//  SuperTuxKart - a fun racing game with go-kart
+//  Copyright (C) 2004-2020  Steve Baker <sjbaker1@airmail.net>,
+//  Copyright (C) 2004-2020  Ingo Ruhnke <grumbel@gmx.de>
+//  Copyright (C) 2006-2020  SuperTuxKart-Team
+//  Copyright (C) 2020  kimden
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 3
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+#include "utils/track_filter.hpp"
+
+#include "utils/string_utils.hpp"
+#include "utils/log.hpp"
+#include <algorithm>
+#include <cassert>
+#include <cmath>
+#include <cstdio>
+#include <cstring>
+#include <string>
+#include <exception>
+
+TrackFilter::TrackFilter()
+{
+
+}   // TrackFilter
+//-----------------------------------------------------------------------------
+
+TrackFilter::TrackFilter(std::string input)
+{
+    auto tokens = StringUtils::split(input, ' ');
+    bool good = true;
+    others = false;
+    if (tokens.size() == 0)
+        others = true;
+    for (unsigned i = 0; i < tokens.size(); i++)
+    {
+        if (tokens[i] == "" || tokens[i] == " ")
+            continue;
+        else if (tokens[i] == "not" || tokens[i] == "no")
+        {
+            good = false;
+            if (i == 0)
+                others = true;
+        }
+        else if (tokens[i] == "yes" || tokens[i] == "ok")
+        {
+            good = true;
+        }
+        else if (tokens[i] == "other:yes")
+        {
+            others = true;
+        }
+        else if (tokens[i] == "other:no")
+        {
+            others = false;
+        }
+        else if (tokens[i][0] == '%')
+        {
+            int index;
+            std::string cut = tokens[i].substr(1);
+            if (!StringUtils::parseString<int>(cut, &index) || index < 0)
+            {
+                Log::warn("TrackFilter", "Unable to parse wildcard index "
+                    "from \"%s\", omitting it", tokens[i].c_str());
+                continue;
+            }
+            if (good)
+                w_allowed.push_back(index);
+            else
+                w_forbidden.push_back(index);
+        }
+        else
+        {
+            int separator = tokens[i].find(':');
+            if (separator != std::string::npos)
+            {
+                std::string track = tokens[i].substr(0, separator);
+                std::string params_str = tokens[i].substr(separator + 1);
+                int value;
+                if (!StringUtils::parseString<int>(params_str, &value))
+                {
+                    Log::warn("TrackFilter", "Incorrect integer value %s of "
+                        "max-players for track %s", params_str.c_str(),
+                        track.c_str());
+                }
+                max_players[track] = value;
+                // std::vector<std::string> params = StringUtils::split(
+                //     params_str, ',', false);
+                // parameters[track] = params;
+            }
+            else
+            {
+                if (good)
+                    allowed.push_back(tokens[i]);
+                else
+                    forbidden.push_back(tokens[i]);
+            }
+        }
+    }
+}   // TrackFilter
+//-----------------------------------------------------------------------------
+std::string TrackFilter::get(std::vector<std::string>& vec, int index)
+{
+    if (index >= 0 && index < vec.size())
+        return vec[index];
+    return "";
+}   // get
+//-----------------------------------------------------------------------------
+
+void TrackFilter::apply(int num_players, std::set<std::string>& input) const
+{
+    std::vector<std::string> empty;
+    apply(num_players, input, empty);
+}   // apply
+//-----------------------------------------------------------------------------
+
+void TrackFilter::apply(int num_players, std::set<std::string>& input,
+    std::vector<std::string>& wildcards) const
+{
+    std::set<std::string> copy = input;
+    input.clear();
+
+    for (const std::string& s: copy)
+    {
+        bool yes = false;
+        bool no = false;
+        auto it = max_players.find(s);
+        if (it != max_players.end() && it->second < num_players)
+            continue;
+        for (int x: w_allowed)
+            if (get(wildcards, x) == s)
+            {
+                yes = true;
+                break;
+            }
+        for (int x: w_forbidden)
+            if (get(wildcards, x) == s)
+            {
+                no = true;
+                break;
+            }
+        for (std::string x: allowed)
+            if (x == s)
+            {
+                yes = true;
+                break;
+            }
+        for (std::string x: forbidden)
+            if (x == s)
+            {
+                no = true;
+                break;
+            }
+        if (yes && no)
+        {
+            Log::warn("TrackFilter", "Track requirements contradict for %s, "
+                "please check your config. Force allowing it.", s.c_str());
+            no = false;
+        }
+        if (!yes && !no)
+            if (others)
+                yes = true;
+            else
+                no = true;
+        if (yes)
+            input.insert(s);
+    }
+}   // apply (2)
+//-----------------------------------------------------------------------------
+
+/* EOF */
diff --git a/src/utils/track_filter.hpp b/src/utils/track_filter.hpp
new file mode 100644
index 00000000000..e25341799af
--- /dev/null
+++ b/src/utils/track_filter.hpp
@@ -0,0 +1,54 @@
+//
+//  SuperTuxKart - a fun racing game with go-kart
+//  Copyright (C) 2004-2020  Steve Baker <sjbaker1@airmail.net>,
+//  Copyright (C) 2004-2020  Ingo Ruhnke <grumbel@gmx.de>
+//  Copyright (C) 2006-2020  SuperTuxKart-Team
+//  Copyright (C) 2020  kimden
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 3
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+#ifndef HEADER_TRACK_FILTER_HPP
+#define HEADER_TRACK_FILTER_HPP
+
+#include "utils/types.hpp"
+#include <limits>
+#include <string>
+#include <vector>
+#include <sstream>
+#include <map>
+#include <set>
+
+// A structure to apply requirements to the track set. allowed contains 
+// the only tracks to be allowed, forbidden contains the only tracks to be
+// forbidden. Putting one track into both vectors produces undefined behaviour
+// for now. Works with wildcards (indices are integers: %0, %1, ...).
+
+struct TrackFilter
+{
+    std::vector<std::string> allowed;
+    std::vector<std::string> forbidden;
+    std::vector<int> w_allowed; // wildcards
+    std::vector<int> w_forbidden; // wildcards
+    std::map<std::string, int> max_players;
+    bool others; // whether not specified tracks are allowed
+    TrackFilter();
+    TrackFilter(std::string input);
+    static std::string get(std::vector<std::string>& vec, int index);
+    void apply(int num_players, std::set<std::string>& input) const;
+    void apply(int num_players, std::set<std::string>& input,
+        std::vector<std::string>& wildcards) const;
+};
+
+#endif