diff --git a/.gitignore b/.gitignore
index eb7c5624..0a58a6c1 100644
--- a/.gitignore
+++ b/.gitignore
@@ -39,3 +39,7 @@ doc/latex/
 
 # Configuration file
 config.yaml
+
+# Local build script
+localbuild.sh
+localmake.sh
diff --git a/.travis.yml b/.travis.yml
index c6a7c218..4d71a2a4 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -14,7 +14,12 @@ env:
 
 addons:
     apt:
+        sources:
+            - ubuntu-toolchain-r-test
         packages:
+            - gcc-4.9
+            - g++-4.9
+
             - doxygen
             - doxygen-doc
             - doxygen-latex
@@ -23,6 +28,10 @@ addons:
 
 script:
     - ./install.sh
+    
+    - cmake -DCMAKE_BUILD_TYPE=Debug -H. -Bbuild -DCMAKE_CXX_COMPILER=g++-4.9 -DCMAKE_C_COMPILER=gcc-4.9
+    - cd ./build
+    - make
 
 after_success:
     - cd $TRAVIS_BUILD_DIR/doc
diff --git a/CHANGELOG.txt b/CHANGELOG.txt
new file mode 100644
index 00000000..71089dec
--- /dev/null
+++ b/CHANGELOG.txt
@@ -0,0 +1,33 @@
+0.3.0: Database and ManiaLink support
+ * Database support (MySQL)
+   * Includes: maps, players, records, karma, times
+ * ManiaLink support
+   * Easy action handling
+   * Easy-to-use ManiaLink list (UIList)
+ * Chat command support
+ * Support for plugin configuration via .yaml-file
+ * Improved access from plugins to controller features
+ * Added Jukebox/Map list plugin
+ * Added Karma plugin
+   * Karma widget (Eyepiece-style)
+   * WhoKarma overview
+ * Added Local Records plugin
+   * Local Records widget (Eyepiece-style)
+ * Added Map Widget plugin (Eyepiece-style)
+
+0.2.0: Plugin system
+ * Plugin system
+   * (Dynamically) loading shared object files
+   * CallBack events
+   * Access to methods, playerlist and maplist
+ * Proper CallBack handling
+ * Easy way to call server methods (via Methods)
+
+0.1.0: GbxRemote, request/callback handling
+  * GbxRemote
+    * Socket connection with the server
+    * Send requests and receive responses
+    * Receive callbacks
+  * Handling of callbacks
+  * Keeping playerlist up-to-date
+  * Reading configuration file
diff --git a/CMakeLists.txt b/CMakeLists.txt
index b0d975d0..177352db 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -7,11 +7,12 @@ add_definitions(-Wno-deprecated)
 set (EXECUTABLE_OUTPUT_PATH ${PROJECT_SOURCE_DIR})
 link_directories(${PROJECT_SOURCE_DIR}/lib/yaml/build)
 include_directories("${PROJECT_SOURCE_DIR}/lib/yaml/include")
+include_directories("${PROJECT_SOURCE_DIR}/lib/json")
 
 set (PROJECT_SOURCE_DIR ${PROJECT_SOURCE_DIR}/src)
 
 set (VERSION_MAJOR 0)
-set (VERSION_MINOR 2)
+set (VERSION_MINOR 3)
 set (VERSION_PATCH 0)
 
 # configure a header file to pass some of the CMake settings
@@ -27,4 +28,8 @@ file(GLOB_RECURSE SOURCES src/*.cpp)
 
 add_executable(Mania++ ${SOURCES}
                        lib/pugixml/libpugixml.a)
-target_link_libraries(Mania++ yaml-cpp ${EXECUTABLE_OUTPUT_PATH}/lib/pugixml/libpugixml.a dl)
+target_link_libraries(Mania++ yaml-cpp
+                              ${EXECUTABLE_OUTPUT_PATH}/lib/pugixml/libpugixml.a
+                              dl
+                              mysqlcppconn
+                              curl)
diff --git a/README.md b/README.md
index e28fa959..dc37d94f 100644
--- a/README.md
+++ b/README.md
@@ -13,46 +13,51 @@ Mania++ and its sources are available under the [GNU General Public License v3](
 ## Tested environments ##
 * Ubuntu 16.10 (Linux 4.8.0-30), 64-bit with gcc 6.2.0 (development)
 * Ubuntu 16.04.1 LTS (Linux 4.4.0-31), 32-bit with gcc 5.4.0 (testing)
-* Ubuntu 14.04.5 LTS (Linux 4.4.0-51), 64-bit with gcc 4.8.4 (Travis)
+* Ubuntu 14.04.5 LTS (Linux 4.4.0-51), 64-bit with gcc 4.9.4 (Travis)
 * Debian 8.6 (Linux 3.16.0-4), 64-bit with gcc 4.9.2 (production)
+* "Bash on Ubuntu 14.04.5 LTS on Windows 10" (Linux 4.4.0-51), 64-bit with gcc 4.9.4 (development)
 
-Mania++ is (currently) not compatible with Windows systems and the ```./install.sh```-script requires a Debian-like system to function (with ```apt-get```).
+The ```./install.sh```-script requires a Debian-like system to function (with ```apt-get```). The JSON library requires gcc/g++ v4.9+, the 14.04 LTS only comes with 4.8.4, so you will have to [upgrade the version by hand](http://askubuntu.com/a/456849) and tell the build script that you want to use that version: ```-DCMAKE_CXX_COMPILER=g++-4.9 -DCMAKE_C_COMPILER=gcc-4.9```.
 
 ## Requirements ##
-* C++11
-* Git _(if you want the latest develop)_
+* Minimum gcc 4.9 / C++11
+* Git
 * [CMake](https://cmake.org)
 
 ## Aims and working points ##
 * [Be comparable or better than standard PhpRemote](https://themaximum.github.io/mania-pp/comparison.html)
-* Create more usable objects (f.e. `Record`?)
-* Expand usable objects (`Player` and `Map`)
-* Working plugin system
-   * Plugin interface
-   * Callback handling
-   * Access to server, database and ManiaLink
-* Database support
-* ManiaLink support
 
 ## Achieved goals ##
 * Working GbxRemote module
    * Send methods and receive responses
    * Receive callbacks
    * De-XMLify responses and callbacks
-* Create usable objects (f.e. `Player` and `Map`)
+* Easy-to-use objects (f.e. `Player` and `Map`)
 * Working configuration system (YAML)
+* Database support (MySQL)
+* ManiaLink support
+   * ManiaLink handler (`UIManager`)
+   * Easy use of a ManiaLink list (`UIList`)
+* Chat command handling
+* Working plugin system
+   * Plugin interface
+   * Callback handling
+   * Access to server, database, playerlist, maplist and ManiaLink
+   * Chat commands
+   * Receive settings from configuration file
+   * _Welcome/goodbye, maplist/jukebox, local records, map karma and mapinfo widget_
 
 ## Installing for the first time ##
 * ```./install.sh```
     * Installs Boost (requirement for yaml-cpp)
     * Installs [yaml-cpp](https://github.com/jbeder/yaml-cpp/) 0.5.3
     * Installs [pugixml](https://github.com/zeux/pugixml) 1.8.1
-    * Builds the code (via ```build.sh```)
+    * Installs [JSON for Modern C++](https://github.com/nlohmann/json) 2.0.10
 
-## Building (updates) ##
+## Building ##
 * ```./build.sh```
 * Move ```config.dist.yaml``` to ```config.yaml```
-* Edit the configuration file with the server information
+* Edit the configuration file with the server/database information
 
 ## Running ##
 * ```./Mania++```
diff --git a/config.dist.yaml b/config.dist.yaml
index 93ae0021..e81eba66 100644
--- a/config.dist.yaml
+++ b/config.dist.yaml
@@ -5,3 +5,32 @@ config:
         authentication:
             username: 'SuperAdmin'
             password: '***'
+
+    database:
+        address: 'localhost'
+        port: 3306
+        authentication:
+            username: '***'
+            password: '***'
+        database: 'maniapp'
+
+    program:
+        checkVersion: true
+
+plugins:
+    - 'HelloGoodbye'
+    - 'Jukebox':
+        skipMapWhenLeft: true
+    - 'LocalRecords':
+        limit: 100
+        widgetEntries: 22
+        widgetTopCount: 5
+        widgetX: 49.2
+        widgetY: 28.2
+    - 'Karma':
+        widgetX: 49.2
+        widgetY: 39.2
+        voteAfterFinishes: 0
+    - 'MapWidget':
+        widgetX: 49.2
+        widgetY: 48.2
diff --git a/install.sh b/install.sh
index 4b7e00d8..ee55e78c 100755
--- a/install.sh
+++ b/install.sh
@@ -1,5 +1,5 @@
-# Install Boost and xerces
-sudo apt-get -y install libboost-dev
+# Install Git, Boost and MySQL
+sudo apt-get -y install git libboost-dev libmysqlcppconn-dev libcurl4-openssl-dev
 
 # Go to libraries directory
 cd ./lib/
@@ -18,6 +18,17 @@ make yaml-cpp
 # Return to lib directory
 cd ../../
 
+# Create and go to JSON directory
+mkdir json
+cd ./json
+
+# Download version 2.0.10 of the JSON library (remove older/existing version)
+rm ./json.hpp
+wget https://github.com/nlohmann/json/releases/download/v2.0.10/json.hpp
+
+# Return to lib directory
+cd ../
+
 # Download version 1.8.1 of the PugiXML library
 git clone https://github.com/zeux/pugixml.git pugixml/
 cd pugixml/
@@ -29,6 +40,3 @@ make
 
 # Return to root directory
 cd ../../
-
-# Build project as normal
-./build.sh
diff --git a/maniapp.sql b/maniapp.sql
new file mode 100644
index 00000000..ecca09b3
--- /dev/null
+++ b/maniapp.sql
@@ -0,0 +1,99 @@
+SET SQL_MODE = "NO_AUTO_VALUE_ON_ZERO";
+SET time_zone = "+00:00";
+
+--
+-- Database: `maniapp`
+--
+
+-- --------------------------------------------------------
+
+--
+-- Tablestructure for table `karma`
+--
+
+CREATE TABLE IF NOT EXISTS `karma` (
+  `Id` int(11) NOT NULL AUTO_INCREMENT,
+  `MapId` mediumint(9) NOT NULL DEFAULT '0',
+  `PlayerId` mediumint(9) NOT NULL DEFAULT '0',
+  `Score` tinyint(3) NOT NULL DEFAULT '0',
+  PRIMARY KEY (`Id`),
+  UNIQUE KEY `PlayerId` (`PlayerId`,`MapId`),
+  KEY `MapId` (`MapId`),
+  KEY `Score` (`Score`)
+) ENGINE=MyISAM  DEFAULT CHARSET=utf8 ;
+
+-- --------------------------------------------------------
+
+--
+-- Tablestructure for table `maps`
+--
+
+CREATE TABLE IF NOT EXISTS `maps` (
+  `Id` mediumint(9) NOT NULL AUTO_INCREMENT,
+  `Uid` varchar(27) NOT NULL DEFAULT '',
+  `Name` varchar(100) NOT NULL DEFAULT '',
+  `Author` varchar(30) NOT NULL DEFAULT '',
+  `Environment` varchar(10) NOT NULL DEFAULT '',
+  `RoundsJuke` tinyint(1) NOT NULL DEFAULT '0',
+  PRIMARY KEY (`Id`),
+  UNIQUE KEY `Uid` (`Uid`)
+) ENGINE=MyISAM  DEFAULT CHARSET=utf8 ;
+
+-- --------------------------------------------------------
+
+--
+-- Tablestructure for table `players`
+--
+
+CREATE TABLE IF NOT EXISTS `players` (
+  `Id` mediumint(9) NOT NULL AUTO_INCREMENT,
+  `Login` varchar(50) NOT NULL DEFAULT '',
+  `NickName` varchar(100) DEFAULT NULL,
+  `Nation` varchar(150) NOT NULL DEFAULT '',
+  `UpdatedAt` datetime NOT NULL DEFAULT '0000-00-00 00:00:00',
+  `Wins` mediumint(9) NOT NULL DEFAULT '0',
+  `TimePlayed` int(10) unsigned NOT NULL DEFAULT '0',
+  PRIMARY KEY (`Id`),
+  UNIQUE KEY `Login` (`Login`),
+  KEY `Nation` (`Nation`),
+  KEY `Wins` (`Wins`),
+  KEY `UpdatedAt` (`UpdatedAt`)
+) ENGINE=MyISAM  DEFAULT CHARSET=utf8 ;
+
+-- --------------------------------------------------------
+
+--
+-- Tablestructure for table `records`
+--
+
+CREATE TABLE IF NOT EXISTS `records` (
+  `Id` int(11) NOT NULL AUTO_INCREMENT,
+  `MapId` mediumint(9) NOT NULL DEFAULT '0',
+  `PlayerId` mediumint(9) NOT NULL DEFAULT '0',
+  `Score` int(11) NOT NULL DEFAULT '0',
+  `Date` datetime NOT NULL DEFAULT '0000-00-00 00:00:00',
+  `Checkpoints` text NOT NULL,
+  PRIMARY KEY (`Id`),
+  UNIQUE KEY `PlayerId` (`PlayerId`,`MapId`),
+  KEY `MapId` (`MapId`),
+  KEY `Score` (`Score`)
+) ENGINE=MyISAM  DEFAULT CHARSET=utf8 ;
+
+-- --------------------------------------------------------
+
+--
+-- Tablestructure for table `times`
+--
+
+CREATE TABLE IF NOT EXISTS `times` (
+  `Id` int(11) NOT NULL AUTO_INCREMENT,
+  `MapId` mediumint(9) NOT NULL DEFAULT '0',
+  `PlayerId` mediumint(9) NOT NULL DEFAULT '0',
+  `Score` int(11) NOT NULL DEFAULT '0',
+  `Date` int(10) unsigned NOT NULL DEFAULT '0',
+  `Checkpoints` text NOT NULL,
+  PRIMARY KEY (`Id`),
+  KEY `PlayerId` (`PlayerId`,`MapId`),
+  KEY `MapId` (`MapId`),
+  KEY `Score` (`Score`)
+) ENGINE=MyISAM  DEFAULT CHARSET=utf8 ;
diff --git a/plugins/HelloGoodbye/src/HelloGoodbyePlugin.cpp b/plugins/HelloGoodbye/src/HelloGoodbyePlugin.cpp
index cdb01548..eaa80e82 100644
--- a/plugins/HelloGoodbye/src/HelloGoodbyePlugin.cpp
+++ b/plugins/HelloGoodbye/src/HelloGoodbyePlugin.cpp
@@ -11,7 +11,7 @@ HelloGoodbyePlugin::HelloGoodbyePlugin()
 
 void HelloGoodbyePlugin::Init()
 {
-    std::cout << "[  INFO   ] Current amount of maps: " << maps->size() << std::endl;
+
 }
 
 void HelloGoodbyePlugin::OnPlayerConnect(Player player)
@@ -19,12 +19,14 @@ void HelloGoodbyePlugin::OnPlayerConnect(Player player)
     std::cout << "PLUGIN Player Connected: " << player.Login << "!" << std::endl;
 
     std::stringstream chatMessage;
-    chatMessage << "Player joins: ";
+    chatMessage << "$39fPlayer joins: ";
     chatMessage << player.NickName;
-    chatMessage << " $s$Ladder: ";
+    chatMessage << " $z$s$39fNation: $fff";
+    chatMessage << player.Country;
+    chatMessage << " $z$s$39fLadder: $fff";
     chatMessage << player.LadderRanking;
 
-    methods->ChatSendServerMessage(chatMessage.str());
+    controller->Server->ChatSendServerMessage(chatMessage.str());
 }
 
 void HelloGoodbyePlugin::OnPlayerDisconnect(Player player)
@@ -33,7 +35,7 @@ void HelloGoodbyePlugin::OnPlayerDisconnect(Player player)
 
     std::stringstream chatMessage;
     chatMessage << player.NickName;
-    chatMessage << " $s$zhas left the game.";
+    chatMessage << " $z$s$39fhas left the game.";
 
-    methods->ChatSendServerMessage(chatMessage.str());
+    controller->Server->ChatSendServerMessage(chatMessage.str());
 }
diff --git a/plugins/Jukebox/CMakeLists.txt b/plugins/Jukebox/CMakeLists.txt
new file mode 100644
index 00000000..f29c5ac5
--- /dev/null
+++ b/plugins/Jukebox/CMakeLists.txt
@@ -0,0 +1,20 @@
+cmake_minimum_required (VERSION 2.6)
+project (JukeboxPlugin)
+
+add_definitions(-std=c++11)
+add_definitions(-Wno-deprecated)
+add_definitions(-Wl,--export-dynamic)
+add_definitions(-rdynamic)
+
+set (LIBRARY_OUTPUT_PATH ${PROJECT_SOURCE_DIR})
+link_directories(${PROJECT_SOURCE_DIR}/../../lib/yaml/build)
+include_directories("${PROJECT_SOURCE_DIR}/../../lib/yaml/include")
+set (PROJECT_SOURCE_DIR ${PROJECT_SOURCE_DIR}/src)
+
+include_directories("${PROJECT_BINARY_DIR}")
+include_directories("${PROJECT_SOURCE_DIR}/../../../src")
+
+file(GLOB_RECURSE SOURCES src/*.cpp)
+
+add_library(JukeboxPlugin SHARED ${SOURCES})
+target_link_libraries(JukeboxPlugin yaml-cpp mysqlcppconn)
diff --git a/plugins/Jukebox/build.sh b/plugins/Jukebox/build.sh
new file mode 100755
index 00000000..8f88dbb9
--- /dev/null
+++ b/plugins/Jukebox/build.sh
@@ -0,0 +1,4 @@
+cmake -DCMAKE_BUILD_TYPE=Debug -H. -Bbuild
+
+cd ./build
+make
diff --git a/plugins/Jukebox/src/JukeboxPlugin.cpp b/plugins/Jukebox/src/JukeboxPlugin.cpp
new file mode 100644
index 00000000..461dc193
--- /dev/null
+++ b/plugins/Jukebox/src/JukeboxPlugin.cpp
@@ -0,0 +1,177 @@
+#include "JukeboxPlugin.h"
+
+JukeboxPlugin::JukeboxPlugin()
+{
+    Version = "0.1.0";
+    Author = "TheM";
+
+    EndMatch.push_back([this](std::vector<PlayerRanking> rankings, int winnerTeam) { OnEndMatch(); });
+    RegisterCommand("list", [this](Player player, std::vector<std::string> parameters) { DisplayMapList(player); });
+    RegisterCommand("jukebox", [this](Player player, std::vector<std::string> parameters) { ChatJukebox(player, parameters); });
+}
+
+void JukeboxPlugin::Init()
+{
+    loadSettings();
+    controller->UI->RegisterEvent("JukeboxMap", ([this](Player player, std::string answer, std::vector<EntryVal> entries) { JukeboxMap(player, answer); }));
+}
+
+void JukeboxPlugin::loadSettings()
+{
+    std::map<std::string, std::string>::iterator skipMapWhenLeftIt = Settings.find("skipMapWhenLeft");
+    if(skipMapWhenLeftIt != Settings.end())
+        std::istringstream(skipMapWhenLeftIt->second) >> skipMapWhenLeft;
+}
+
+void JukeboxPlugin::OnEndMatch()
+{
+    if(skipMapWhenLeft)
+    {
+        for (std::vector<JukeboxItem>::iterator jukeIt = (jukebox.end() - 1); jukeIt != (jukebox.begin() - 1); --jukeIt)
+        {
+            std::map<std::string, Player>::iterator findPlayer = controller->Players->find(jukeIt->player.Login);
+            if(findPlayer == controller->Players->end())
+            {
+                std::stringstream skipMessage;
+                skipMessage << "$fa0Map $fff" << jukeIt->map.Name << "$z$s$fa0 skipped because requester $fff" << jukeIt->player.NickName << "$z$s$fa0 left.";
+                controller->Server->ChatSendServerMessage(skipMessage.str());
+                jukeIt = jukebox.erase(jukeIt);
+            }
+        }
+    }
+
+    if(jukebox.size() > 0)
+    {
+        JukeboxItem nextMap = jukebox.at(0);
+
+        std::stringstream nextMessage;
+        nextMessage << "$fa0The next map will be $fff" << nextMap.map.Name << "$z$s$fa0 as requested by $fff" << nextMap.player.NickName << "$z$s$fa0.";
+        controller->Server->ChatSendServerMessage(nextMessage.str());
+
+        controller->Server->ChooseNextMap(nextMap.map.FileName);
+        jukebox.erase(jukebox.begin());
+    }
+}
+
+void JukeboxPlugin::ChatJukebox(Player player, std::vector<std::string> parameters)
+{
+    if(parameters.size() > 0)
+    {
+        if(parameters.at(0).find("display") != std::string::npos ||
+           parameters.at(0).find("list") != std::string::npos)
+        {
+            UIList list = UIList();
+            list.Id = "JukeboxList";
+            list.Title = "Maps currently in the Jukebox";
+            list.IconStyle = "Icons64x64_1";
+            list.IconSubstyle = "ToolTree";
+            list.Columns.push_back(std::pair<std::string, int>("#", 5));
+            list.Columns.push_back(std::pair<std::string, int>("Map", 30));
+            list.Columns.push_back(std::pair<std::string, int>("Requested by", 30));
+
+            for(int itemId = 0; itemId < jukebox.size(); itemId++)
+            {
+                JukeboxItem item = jukebox[itemId];
+
+                std::stringstream index;
+                index << (itemId + 1);
+
+                std::map<std::string, std::string> row = std::map<std::string, std::string>();
+                row.insert(std::pair<std::string, std::string>("#", index.str()));
+                row.insert(std::pair<std::string, std::string>("Map", item.map.Name));
+                row.insert(std::pair<std::string, std::string>("Requested by", item.player.NickName));
+                list.Rows.push_back(row);
+            }
+
+            controller->UI->DisplayList(list, player);
+        }
+        else if(parameters.at(0).find("drop") != std::string::npos)
+        {
+            for(int jukeId = 0; jukeId < jukebox.size(); jukeId++)
+            {
+                if(jukebox.at(jukeId).player.Login == player.Login)
+                {
+                    std::stringstream dropMessage;
+                    dropMessage << "$fff" << player.NickName << "$z$s$fa0 dropped $fff" << jukebox.at(jukeId).map.Name << "$z$s$fa0 from the jukebox.";
+                    controller->Server->ChatSendServerMessage(dropMessage.str());
+
+                    jukebox.erase((jukebox.begin() + jukeId));
+                    return;
+                }
+            }
+        }
+    }
+    else
+    {
+        std::stringstream helpMessage;
+        helpMessage << "$fff/jukebox$fa0 options: $fffdisplay/list$fa0 (displays current Jukebox list), $fffdrop$fa0 (drops your Jukebox entry).";
+        controller->Server->ChatSendServerMessageToLogin(helpMessage.str(), player.Login);
+    }
+}
+
+void JukeboxPlugin::JukeboxMap(Player player, std::string answer)
+{
+    int paramBegin = (answer.find('(') + 1);
+    int paramEnd = answer.find(')');
+    std::string mapUid = answer.substr(paramBegin, (paramEnd - paramBegin));
+
+    for(int jukeId = 0; jukeId < jukebox.size(); jukeId++)
+    {
+        if(jukebox.at(jukeId).map.UId == mapUid)
+        {
+            controller->Server->ChatSendServerMessageToLogin("$fa0This map has already been added to the jukebox, pick another one.", player.Login);
+            return;
+        }
+
+        if(jukebox.at(jukeId).player.Login == player.Login)
+        {
+            controller->Server->ChatSendServerMessageToLogin("$fa0You already have a map in the jukebox! Wait till it's been played before adding another.", player.Login);
+            return;
+        }
+    }
+
+    std::map<std::string, Map>::iterator mapIt = controller->Maps->List.find(mapUid);
+    if(mapIt != controller->Maps->List.end())
+    {
+        Map map = mapIt->second;
+        jukebox.push_back({ map, player });
+
+        std::stringstream nextMessage;
+        nextMessage << "$fff" << map.Name << "$z$s$fa0 was added to the jukebox by $fff" << player.NickName << "$z$s$fa0.";
+        controller->Server->ChatSendServerMessage(nextMessage.str());
+    }
+}
+
+void JukeboxPlugin::DisplayMapList(Player player)
+{
+    std::vector<std::pair<std::string, Map>> mapsVector;
+    std::copy(controller->Maps->List.begin(), controller->Maps->List.end(), back_inserter(mapsVector));
+    std::sort(mapsVector.begin(), mapsVector.end(), [=](const std::pair<std::string, Map>& a, const std::pair<std::string, Map>& b) { return a.second.Id > b.second.Id; });
+
+    UIList list = UIList();
+    list.Id = "MapList";
+    list.Title = "Server map list";
+    list.IconStyle = "Icons64x64_1";
+    list.IconSubstyle = "Browser";
+    list.Columns.push_back(std::pair<std::string, int>("#", 5));
+    list.Columns.push_back(std::pair<std::string, int>("Name", 40));
+    list.Columns.push_back(std::pair<std::string, int>("Author", 20));
+    list.Actions.insert(std::pair<std::string, std::pair<std::string, std::string>>("Name", std::pair<std::string, std::string>("JukeboxMap", "UId")));
+
+    for(int mapId = 0; mapId < mapsVector.size(); mapId++)
+    {
+        Map mapInList = mapsVector[mapId].second;
+
+        std::stringstream index;
+        index << (mapId + 1);
+
+        std::map<std::string, std::string> row = std::map<std::string, std::string>();
+        row.insert(std::pair<std::string, std::string>("#", index.str()));
+        row.insert(std::pair<std::string, std::string>("UId", mapInList.UId));
+        row.insert(std::pair<std::string, std::string>("Name", mapInList.Name));
+        row.insert(std::pair<std::string, std::string>("Author", mapInList.Author));
+        list.Rows.push_back(row);
+    }
+
+    controller->UI->DisplayList(list, player);
+}
diff --git a/plugins/Jukebox/src/JukeboxPlugin.h b/plugins/Jukebox/src/JukeboxPlugin.h
new file mode 100644
index 00000000..2d174431
--- /dev/null
+++ b/plugins/Jukebox/src/JukeboxPlugin.h
@@ -0,0 +1,37 @@
+#ifndef KARMAPLUGIN_H_
+#define KARMAPLUGIN_H_
+
+#include <algorithm>
+#include <sstream>
+#include <map>
+#include <vector>
+
+#include "Plugins/Plugin.h"
+#include "UI/UIList.h"
+#include "Utils/Time.h"
+
+struct JukeboxItem
+{
+    Map map;
+    Player player;
+};
+
+class JukeboxPlugin : public Plugin
+{
+public:
+    JukeboxPlugin();
+
+    void Init();
+    void OnEndMatch();
+    void ChatJukebox(Player player, std::vector<std::string> parameters);
+    void JukeboxMap(Player player, std::string answer);
+    void DisplayMapList(Player player);
+
+private:
+    void loadSettings();
+
+    std::vector<JukeboxItem> jukebox;
+    bool skipMapWhenLeft = true;
+};
+
+#endif // KARMAPLUGIN_H_
diff --git a/plugins/Jukebox/src/main.cpp b/plugins/Jukebox/src/main.cpp
new file mode 100644
index 00000000..1b5587f7
--- /dev/null
+++ b/plugins/Jukebox/src/main.cpp
@@ -0,0 +1,25 @@
+#include "JukeboxPlugin.h"
+
+/**
+ * Mania++ is a Server Controller for TrackMania 2 servers, written in C++.
+ * Copyright (C) 2016 Max Klaversma <maxklaversma@gmail.com>
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+extern "C" Plugin* startPlugin()
+{
+    JukeboxPlugin* plugin = new JukeboxPlugin();
+    return (Plugin*)plugin;
+}
diff --git a/plugins/Karma/CMakeLists.txt b/plugins/Karma/CMakeLists.txt
new file mode 100644
index 00000000..6475e5e9
--- /dev/null
+++ b/plugins/Karma/CMakeLists.txt
@@ -0,0 +1,20 @@
+cmake_minimum_required (VERSION 2.6)
+project (KarmaPlugin)
+
+add_definitions(-std=c++11)
+add_definitions(-Wno-deprecated)
+add_definitions(-Wl,--export-dynamic)
+add_definitions(-rdynamic)
+
+set (LIBRARY_OUTPUT_PATH ${PROJECT_SOURCE_DIR})
+link_directories(${PROJECT_SOURCE_DIR}/../../lib/yaml/build)
+include_directories("${PROJECT_SOURCE_DIR}/../../lib/yaml/include")
+set (PROJECT_SOURCE_DIR ${PROJECT_SOURCE_DIR}/src)
+
+include_directories("${PROJECT_BINARY_DIR}")
+include_directories("${PROJECT_SOURCE_DIR}/../../../src")
+
+file(GLOB_RECURSE SOURCES src/*.cpp)
+
+add_library(KarmaPlugin SHARED ${SOURCES})
+target_link_libraries(KarmaPlugin yaml-cpp mysqlcppconn)
diff --git a/plugins/Karma/build.sh b/plugins/Karma/build.sh
new file mode 100755
index 00000000..8f88dbb9
--- /dev/null
+++ b/plugins/Karma/build.sh
@@ -0,0 +1,4 @@
+cmake -DCMAKE_BUILD_TYPE=Debug -H. -Bbuild
+
+cd ./build
+make
diff --git a/plugins/Karma/src/KarmaPlugin.cpp b/plugins/Karma/src/KarmaPlugin.cpp
new file mode 100644
index 00000000..d79623d4
--- /dev/null
+++ b/plugins/Karma/src/KarmaPlugin.cpp
@@ -0,0 +1,396 @@
+#include "KarmaPlugin.h"
+
+KarmaPlugin::KarmaPlugin()
+{
+    Version = "0.1.1";
+    Author = "TheM";
+    karma = MapKarma();
+
+    BeginMap.push_back([this](Map map) { OnBeginMap(map); });
+    PlayerConnect.push_back([this](Player player) { OnPlayerConnect(player); });
+    PlayerChat.push_back([this](Player player, std::string text) { OnPlayerChat(player, text); });
+
+    RegisterCommand("karma", [this](Player player, std::vector<std::string> parameters) { DisplayCurrentKarma(player); });
+    RegisterCommand("whokarma", [this](Player player, std::vector<std::string> parameters) { DisplayWhoKarma(player); });
+    RegisterCommand("++", [this](Player player, std::vector<std::string> parameters) { VotePositive(player); });
+    RegisterCommand("--", [this](Player player, std::vector<std::string> parameters) { VoteNegative(player); });
+}
+
+void KarmaPlugin::Init()
+{
+    loadSettings();
+    widget = KarmaWidget(controller->UI);
+    widget.WidgetX = widgetX;
+    widget.WidgetY = widgetY;
+    controller->UI->RegisterEvent(widget.ActionId, ([this](Player player, std::string answer, std::vector<EntryVal> entries) { DisplayWhoKarma(player); }));
+    controller->UI->RegisterEvent(widget.PositiveAction, ([this](Player player, std::string answer, std::vector<EntryVal> entries) { VotePositive(player); }));
+    controller->UI->RegisterEvent(widget.NegativeAction, ([this](Player player, std::string answer, std::vector<EntryVal> entries) { VoteNegative(player); }));
+
+    retrieveVotes(*controller->Maps->Current);
+    karma.Calculate(votes);
+    displayToAll();
+}
+
+void KarmaPlugin::loadSettings()
+{
+    std::map<std::string, std::string>::iterator widgetXIt = Settings.find("widgetX");
+    if(widgetXIt != Settings.end())
+        widgetX = atof(widgetXIt->second.c_str());
+
+    std::map<std::string, std::string>::iterator widgetYIt = Settings.find("widgetY");
+    if(widgetYIt != Settings.end())
+        widgetY = atof(widgetYIt->second.c_str());
+
+    std::map<std::string, std::string>::iterator voteAfterFinishesIt = Settings.find("voteAfterFinishes");
+    if(voteAfterFinishesIt != Settings.end())
+        voteAfterFinishes = atoi(voteAfterFinishesIt->second.c_str());
+}
+
+void KarmaPlugin::OnBeginMap(Map map)
+{
+    retrieveVotes(*controller->Maps->Current);
+    karma.Calculate(votes);
+    displayToAll();
+}
+
+void KarmaPlugin::OnPlayerConnect(Player player)
+{
+    int personalVote = -1;
+    std::map<std::string, int>::iterator voteIt = votes.find(player.Login);
+    if(voteIt != votes.end())
+        personalVote = voteIt->second;
+
+    if(!widget.DisplayToPlayer(player, &karma, personalVote))
+        Logging::PrintError(controller->Server->GetCurrentError());
+}
+
+void KarmaPlugin::DisplayCurrentKarma(Player player)
+{
+    std::stringstream chatMessage;
+    chatMessage << "$ff0Current map karma: $fff" << (karma.PlusVotes - karma.MinVotes) << "$ff0 [";
+    chatMessage << "$fff" << (karma.PlusVotes + karma.MinVotes) << "$ff0 votes,";
+    chatMessage << " ++: $fff" << karma.PlusVotes << "$ff0 ($fff" << karma.Percentage << "%$ff0),";
+    chatMessage << " --: $fff" << karma.MinVotes << "$ff0 ($fff" << karma.MinPercentage << "%$ff0)]";
+
+    int personalVote = -1;
+    std::map<std::string, int>::iterator voteIt = votes.find(player.Login);
+    if(voteIt != votes.end())
+        personalVote = voteIt->second;
+
+    chatMessage << " {Your vote: $fff";
+    switch(personalVote)
+    {
+        case 1:
+            chatMessage << "++";
+            break;
+        case 0:
+            chatMessage << "--";
+            break;
+        default:
+            chatMessage << "none";
+            break;
+    }
+    chatMessage << "$ff0}";
+
+    controller->Server->ChatSendServerMessageToLogin(chatMessage.str(), player.Login);
+}
+
+void KarmaPlugin::OnPlayerChat(Player player, std::string text)
+{
+    if(text.find("++") == 0)
+    {
+        VotePositive(player);
+    }
+    else if(text.find("--") == 0)
+    {
+        VoteNegative(player);
+    }
+}
+
+void KarmaPlugin::VotePositive(Player player)
+{
+    std::stringstream chatMessage;
+    chatMessage << "$ff0";
+
+    if(voteAfterFinishes > 0)
+    {
+        int timesDriven = retrieveTimesDriven(player);
+        if(timesDriven < voteAfterFinishes)
+        {
+            chatMessage << "You can only vote after $fff" << voteAfterFinishes << "$ff0 finishes (you have: $fff" << timesDriven << "$ff0).";
+            controller->Server->ChatSendServerMessageToLogin(chatMessage.str(), player.Login);
+            return;
+        }
+    }
+
+    int personalVote = -1;
+    std::map<std::string, int>::iterator voteIt = votes.find(player.Login);
+    if(voteIt != votes.end())
+        personalVote = voteIt->second;
+
+    if(personalVote != 1)
+    {
+        sql::PreparedStatement* pstmt;
+        try
+        {
+            pstmt = controller->Database->prepareStatement("INSERT INTO `karma` (`MapId`, `PlayerId`, `Score`) VALUES (?, ?, ?) ON DUPLICATE KEY UPDATE `Score` = VALUES(`Score`)");
+            pstmt->setInt(1, controller->Maps->Current->Id);
+            pstmt->setInt(2, player.Id);
+            pstmt->setInt(3, 1);
+            pstmt->executeQuery();
+
+            retrieveVotes(*controller->Maps->Current);
+            karma.Calculate(votes);
+            displayToAll();
+
+            if(personalVote == -1)
+                chatMessage << "Successfully voted $fff++$ff0 on this map!";
+            else
+                chatMessage << "Changed your $fff--$ff0 vote to a $fff++$ff0 vote on this map!";
+        }
+        catch(sql::SQLException &e)
+        {
+            std::cout << "Failed to save karma for " << player.Login << " on '" << controller->Maps->Current->Name << "' ..." << std::endl;
+            Logging::PrintError(e.getErrorCode(), e.what());
+        }
+
+        if(pstmt != NULL)
+        {
+            delete pstmt;
+            pstmt = NULL;
+        }
+    }
+    else
+    {
+        chatMessage << "You already voted $fff++$ff0 on this map!";
+    }
+
+    controller->Server->ChatSendServerMessageToLogin(chatMessage.str(), player.Login);
+}
+
+void KarmaPlugin::VoteNegative(Player player)
+{
+    std::stringstream chatMessage;
+    chatMessage << "$ff0";
+
+    if(voteAfterFinishes > 0)
+    {
+        int timesDriven = retrieveTimesDriven(player);
+        if(timesDriven < voteAfterFinishes)
+        {
+            chatMessage << "You can only vote after $fff" << voteAfterFinishes << "$ff0 finishes (you have: $fff" << timesDriven << "$ff0).";
+            controller->Server->ChatSendServerMessageToLogin(chatMessage.str(), player.Login);
+            return;
+        }
+    }
+
+    int personalVote = -1;
+    std::map<std::string, int>::iterator voteIt = votes.find(player.Login);
+    if(voteIt != votes.end())
+        personalVote = voteIt->second;
+
+    if(personalVote != 0)
+    {
+        sql::PreparedStatement* pstmt;
+        try
+        {
+            pstmt = controller->Database->prepareStatement("INSERT INTO `karma` (`MapId`, `PlayerId`, `Score`) VALUES (?, ?, ?) ON DUPLICATE KEY UPDATE `Score` = VALUES(`Score`)");
+            pstmt->setInt(1, controller->Maps->Current->Id);
+            pstmt->setInt(2, player.Id);
+            pstmt->setInt(3, 0);
+            pstmt->executeQuery();
+
+            retrieveVotes(*controller->Maps->Current);
+            karma.Calculate(votes);
+            displayToAll();
+
+            if(personalVote == -1)
+                chatMessage << "Successfully voted $fff--$ff0 on this map!";
+            else
+                chatMessage << "Changed your $fff++$ff0 vote to a $fff--$ff0 vote on this map!";
+        }
+        catch(sql::SQLException &e)
+        {
+            std::cout << "Failed to save karma for " << player.Login << " on '" << controller->Maps->Current->Name << "' ..." << std::endl;
+            Logging::PrintError(e.getErrorCode(), e.what());
+        }
+
+        if(pstmt != NULL)
+        {
+            delete pstmt;
+            pstmt = NULL;
+        }
+    }
+    else
+    {
+        chatMessage << "You already voted $fff--$ff0 on this map!";
+    }
+
+    controller->Server->ChatSendServerMessageToLogin(chatMessage.str(), player.Login);
+}
+
+void KarmaPlugin::DisplayWhoKarma(Player player)
+{
+    std::vector<std::pair<std::string, int>> votesVector;
+    std::copy(votes.begin(), votes.end(), back_inserter(votesVector));
+    std::sort(votesVector.begin(), votesVector.end(), [=](const std::pair<std::string, int>& a, const std::pair<std::string, int>& b) { return a.second > b.second; });
+
+    UIList list = UIList();
+    list.Id = "WhoKarma";
+    list.Title = "WhoKarma for: $z$s$fff" + controller->Maps->Current->Name;
+    list.IconStyle = "Icons128x128_1";
+    list.IconSubstyle = "CustomStars";
+    list.Columns.push_back(std::pair<std::string, int>("#", 5));
+    list.Columns.push_back(std::pair<std::string, int>("Player", 40));
+    list.Columns.push_back(std::pair<std::string, int>("Vote", 20));
+
+    for(int voteId = 0; voteId < votesVector.size(); voteId++)
+    {
+        std::string vote = "++";
+        if(votesVector[voteId].second == -1)
+            vote = "--";
+
+        std::string playerName = votesVector[voteId].first;
+        sql::PreparedStatement* pstmt;
+        sql::ResultSet* result;
+        try
+        {
+            pstmt = controller->Database->prepareStatement("SELECT * FROM `players` WHERE `Login` = ?");
+            pstmt->setString(1, playerName);
+            result = pstmt->executeQuery();
+            if(result->next())
+            {
+                playerName = result->getString("NickName");
+            }
+        }
+        catch(sql::SQLException &e) { }
+
+        if(pstmt != NULL)
+            delete pstmt; pstmt = NULL;
+
+        if(result != NULL)
+            delete result; result = NULL;
+
+        std::stringstream index;
+        index << (voteId + 1);
+
+        std::map<std::string, std::string> row = std::map<std::string, std::string>();
+        row.insert(std::pair<std::string, std::string>("#", index.str()));
+        row.insert(std::pair<std::string, std::string>("Player", playerName));
+        row.insert(std::pair<std::string, std::string>("Vote", vote));
+        list.Rows.push_back(row);
+    }
+
+    controller->UI->DisplayList(list, player);
+}
+
+void KarmaPlugin::displayToAll()
+{
+    for(std::map<std::string, Player>::iterator player = controller->Players->begin(); player != controller->Players->end(); ++player)
+    {
+        int personalVote = -1;
+        std::map<std::string, int>::iterator voteIt = votes.find(player->second.Login);
+        if(voteIt != votes.end())
+            personalVote = voteIt->second;
+
+        if(!widget.DisplayToPlayer(player->second, &karma, personalVote))
+            Logging::PrintError(controller->Server->GetCurrentError());
+    }
+}
+
+void KarmaPlugin::retrieveVotes(Map map)
+{
+    votes = std::map<std::string, int>();
+
+    sql::PreparedStatement* pstmt;
+    sql::ResultSet* result;
+    try
+    {
+        pstmt = controller->Database->prepareStatement("SELECT * FROM `karma` WHERE `MapId` = ?");
+        pstmt->setInt(1, map.Id);
+        result = pstmt->executeQuery();
+
+        while(result->next())
+        {
+            delete pstmt; pstmt = NULL;
+            sql::ResultSet* playerResult;
+            try
+            {
+                pstmt = controller->Database->prepareStatement("SELECT * FROM `players` WHERE `Id` = ?");
+                pstmt->setInt(1, result->getInt("PlayerId"));
+                playerResult = pstmt->executeQuery();
+                playerResult->next();
+
+                std::string login = playerResult->getString("Login");
+                int score = result->getInt("Score");
+
+                votes.insert(std::pair<std::string, int>(login, score));
+            }
+            catch(sql::InvalidArgumentException &e)
+            {
+                // Player cannot be found in the database.
+                // Just skip the karma vote.
+            }
+
+            if(playerResult != NULL)
+            {
+                delete playerResult;
+                playerResult = NULL;
+            }
+        }
+    }
+    catch(sql::SQLException &e)
+    {
+        std::cout << "Failed to retrieve karma votes for '" << map.Name << "' ..." << std::endl;
+        Logging::PrintError(e.getErrorCode(), e.what());
+    }
+
+    if(pstmt != NULL)
+    {
+        delete pstmt;
+        pstmt = NULL;
+    }
+
+    if(result != NULL)
+    {
+        delete result;
+        result = NULL;
+    }
+}
+
+int KarmaPlugin::retrieveTimesDriven(Player player)
+{
+    int timesDriven = 0;
+
+    sql::PreparedStatement* pstmt;
+    sql::ResultSet* result;
+    try
+    {
+        pstmt = controller->Database->prepareStatement("SELECT COUNT(*) AS `timesDriven` FROM `times` WHERE `PlayerId` = ? AND `MapId` = ?");
+        pstmt->setInt(1, player.Id);
+        pstmt->setInt(2, controller->Maps->Current->Id);
+        result = pstmt->executeQuery();
+        result->next();
+
+        timesDriven = result->getInt("timesDriven");
+    }
+    catch(sql::SQLException &e)
+    {
+        std::cout << "Failed to retrieve # times driven for player " << player.Login << " on map '" << controller->Maps->Current->Name << "' ..." << std::endl;
+        Logging::PrintError(e.getErrorCode(), e.what());
+    }
+
+    if(pstmt != NULL)
+    {
+        delete pstmt;
+        pstmt = NULL;
+    }
+
+    if(result != NULL)
+    {
+        delete result;
+        result = NULL;
+    }
+
+    return timesDriven;
+}
diff --git a/plugins/Karma/src/KarmaPlugin.h b/plugins/Karma/src/KarmaPlugin.h
new file mode 100644
index 00000000..beccda63
--- /dev/null
+++ b/plugins/Karma/src/KarmaPlugin.h
@@ -0,0 +1,47 @@
+#ifndef KARMAPLUGIN_H_
+#define KARMAPLUGIN_H_
+
+#include <algorithm>
+#include <sstream>
+#include <map>
+
+#include "Plugins/Plugin.h"
+#include "UI/UIList.h"
+#include "Utils/Time.h"
+
+#include "Objects/MapKarma.h"
+#include "Widget/KarmaWidget.h"
+
+class KarmaPlugin : public Plugin
+{
+public:
+    KarmaPlugin();
+
+    void Init();
+    void OnBeginMap(Map map);
+    void OnPlayerConnect(Player player);
+    void OnPlayerChat(Player player, std::string text);
+
+    void DisplayCurrentKarma(Player player);
+    void VoteNegative(Player player);
+    void VotePositive(Player player);
+    void DisplayWhoKarma(Player player);
+
+private:
+    std::map<std::string, int> votes;
+    MapKarma karma;
+
+    KarmaWidget widget;
+
+    double widgetX = 49.2;
+    double widgetY = 39.2;
+    int voteAfterFinishes = 0;
+
+    void loadSettings();
+    void displayToAll();
+    void retrieveVotes(Map map);
+
+    int retrieveTimesDriven(Player player);
+};
+
+#endif // KARMAPLUGIN_H_
diff --git a/plugins/Karma/src/Objects/MapKarma.h b/plugins/Karma/src/Objects/MapKarma.h
new file mode 100644
index 00000000..8642c73e
--- /dev/null
+++ b/plugins/Karma/src/Objects/MapKarma.h
@@ -0,0 +1,36 @@
+#ifndef MAPKARMA_H_
+#define MAPKARMA_H_
+
+struct MapKarma
+{
+public:
+    int MinVotes = 0;
+    int PlusVotes = 0;
+    double Percentage = 0.0;
+    double MinPercentage = 0.0;
+
+    void Calculate(std::map<std::string, int> votes)
+    {
+        MinVotes = 0;
+        PlusVotes = 0;
+        Percentage = 0.0;
+        MinPercentage = 0.0;
+
+        for(std::map<std::string, int>::iterator vote = votes.begin(); vote != votes.end(); ++vote)
+        {
+            if(vote->second == 1)
+            {
+                PlusVotes++;
+            }
+            else
+            {
+                MinVotes++;
+            }
+        }
+
+        Percentage = std::round(((double)PlusVotes / (double)(PlusVotes + MinVotes)) * 1000) / 10;
+        MinPercentage = std::round((100 - Percentage) * 10) / 10;
+    }
+};
+
+#endif // MAPKARMA_H_
diff --git a/plugins/Karma/src/Widget/KarmaWidget.cpp b/plugins/Karma/src/Widget/KarmaWidget.cpp
new file mode 100644
index 00000000..f30bd005
--- /dev/null
+++ b/plugins/Karma/src/Widget/KarmaWidget.cpp
@@ -0,0 +1,142 @@
+#include "KarmaWidget.h"
+
+KarmaWidget::KarmaWidget()
+{
+
+}
+
+KarmaWidget::KarmaWidget(UIManager* uiManager)
+{
+    ui = uiManager;
+
+    frame = UIFrame();
+    frame.ManiaLinkId = manialinkId;
+    frame.Timeout = 0;
+    frame.CloseOnClick = false;
+}
+
+bool KarmaWidget::DisplayToPlayer(Player player, MapKarma* karma, int personalScore)
+{
+    double widgetWidth = 15.5;
+    double widgetHeight = 11;
+    double columnHeight = (widgetHeight - 3.1);
+    double backgroundWidth = (widgetWidth - 0.2);
+    double backgroundHeight = (widgetHeight - 0.2);
+    double borderWidth = (widgetWidth + 0.4);
+    double borderHeight = (widgetHeight + 0.6);
+
+    double left_IconX = 0.6;
+    double left_IconY = 0;
+    double left_TitleX = 3.2;
+    double left_TitleY = -0.65;
+    std::string left_TitleHalign = "left";
+    double left_ImageOpenX = -0.3;
+    std::string left_ImageOpen = "http://static.undef.name/ingame/records-eyepiece/edge-open-ld-dark.png";
+
+    double right_IconX = 12.5;
+    double right_IconY = 0;
+    double right_TitleX = 12.4;
+    double right_TitleY = -0.65;
+    std::string right_TitleHalign = "right";
+    double right_ImageOpenX = 12.2;
+    std::string right_ImageOpen = "http://static.undef.name/ingame/records-eyepiece/edge-open-rd-dark.png";
+
+    std::string backgroundColor = "3342";
+    std::string backgroundFocus = "09F6";
+
+    std::string backgroundStyle = "Bgs1";
+    std::string backgroundSubstyle = "BgTitleGlow";
+    std::string borderStyle = "Bgs1";
+    std::string borderSubstyle = "BgTitleShadow";
+
+    double imageOpenX = (WidgetX < 0) ? (right_ImageOpenX + (widgetWidth - 15.5)) : left_ImageOpenX;
+    double imageOpenY = -(widgetHeight - 3.18);
+    std::string imageOpen = (WidgetX < 0) ? right_ImageOpen : left_ImageOpen;
+
+    double titleBackgroundWidth = (widgetWidth - 0.8);
+    std::string titleStyle = "BgsPlayerCard";
+    std::string titleSubstyle = "BgRacePlayerName";
+    double titleX = (WidgetX < 0) ? (right_TitleX + (widgetWidth - 15.5)) : left_TitleX;
+    double titleY = (WidgetX < 0) ? right_TitleY : left_TitleY;
+    std::string titleHalign = (WidgetX < 0) ? right_TitleHalign : left_TitleHalign;
+
+    double iconX = (WidgetX < 0) ? (right_IconX + (widgetWidth - 15.5)) : left_IconX;
+    double iconY = (WidgetX < 0) ? right_IconY : left_IconY;
+    std::string iconStyle = "Icons128x128_1";
+    std::string iconSubstyle = "CustomStars";
+
+    std::string textColor = "FFFF";
+
+    std::stringstream widget;
+    widget << "    <frame posn=\"" << WidgetX << " " << WidgetY << " 0\" id=\"Widget" << manialinkId << "\">";
+
+    widget << "        <label posn=\"0.1 -0.1 0\" sizen=\"" << backgroundWidth << " " << backgroundHeight << "\" text=\" \" action=\"" << ActionId << "\" focusareacolor1=\"" << backgroundColor << "\" focusareacolor2=\"" << backgroundFocus << "\"/>";
+    widget << "        <quad posn=\"-0.2 0.3 0.001\" sizen=\"" << borderWidth << " " << borderHeight << "\" style=\"" << borderStyle << "\" substyle=\"" << borderSubstyle << "\"/>";
+    widget << "        <quad posn=\"0 0 0.002\" sizen=\"" << backgroundWidth << " " << backgroundHeight << "\" style=\"" << backgroundStyle << "\" substyle=\"" << backgroundSubstyle << "\"/>";
+
+    widget << "        <quad posn=\"" << imageOpenX << " " << imageOpenY << " 0.05\" sizen=\"3.5 3.5\" image=\"" << imageOpen << "\"/>";
+
+    widget << "        <quad posn=\"0.4 -0.36 0.003\" sizen=\"" << titleBackgroundWidth << " 2\" style=\"" << titleStyle << "\" substyle=\"" << titleSubstyle << "\"/>";
+    widget << "        <quad posn=\"" << iconX << " " << iconY << " 0.004\" sizen=\"2.5 2.5\" style=\"" << iconStyle << "\" substyle=\"" << iconSubstyle << "\"/>";
+    widget << "        <label posn=\"" << titleX << " " << titleY << " 0.004\" sizen=\"10.2 0\" halign=\"" << titleHalign << "\" textsize=\"1\" text=\"" << title << "\"/>";
+    widget << "        <format textsize=\"1\" textcolor=\"" << textColor << "\"/>";
+
+    if(personalScore == 0)
+        widget << "        <quad posn=\"1.75 -5.25 1.6\" sizen=\"3.5 3.5\" style=\"Icons64x64_1\" substyle=\"LvlRed\"/>";
+
+    widget << "        <quad posn=\"2 -5.5 1.75\" sizen=\"3 3\" style=\"Icons64x64_1\" substyle=\"Sub\" action=\"" << NegativeAction << "\" />";
+    widget << "        <label posn=\"3.5 -8.5 1.75\" halign=\"center\" sizen=\"3 1\" text=\"$s$f00" << karma->MinVotes << "\" />";
+
+    if(personalScore == 1)
+        widget << "        <quad posn=\"9.75 -5.25 1.6\" sizen=\"3.5 3.5\" style=\"Icons64x64_1\" substyle=\"LvlGreen\"/>";
+
+    widget << "        <quad posn=\"10 -5.5 1.75\" sizen=\"3 3\" style=\"Icons64x64_1\" substyle=\"Add\" action=\"" << PositiveAction << "\" />";
+    widget << "        <label posn=\"11.5 -8.5 1.75\" halign=\"center\" sizen=\"3 1\"  text=\"$s$0f0" << karma->PlusVotes << "\"/>";
+
+    widget << "        <label posn=\"7.5 -8.5 1.75\" halign=\"center\" sizen=\"5 1\" text=\"$s$fff" << karma->Percentage << "%\"/>";
+
+    int mapKarma = (karma->PlusVotes - karma->MinVotes);
+    std::string colour = "$fff";
+    std::string prefix = "";
+    if(mapKarma < 0)
+    {
+        colour = "$f00";
+    }
+    else if(mapKarma > 0)
+    {
+        colour = "$0f0";
+        prefix = "+";
+    }
+
+    widget << "        <label posn=\"7.5 -6.35 1.75\" halign=\"center\" sizen=\"5 1\" text=\"" << colour << "$o$s" << prefix << mapKarma << "\"/>";
+
+    double barX = 1.5;
+    if(karma->Percentage == 0)
+    {
+        for(int i = 0; i < 10; i++)
+        {
+            widget << "        <quad posn=\"" << barX << " -3 1.5\" sizen=\"1.2 2.4\" image=\"http://kreipe.patrick.coolserverhosting.de/local/grey.jpg\"/>";
+            barX += 1.2;
+        }
+    }
+    else
+    {
+        int plus = std::round(((double)karma->PlusVotes / ((double)karma->PlusVotes + (double)karma->MinVotes)) * 10);
+        for(int i = 0; i < plus; i++)
+        {
+            widget << "        <quad posn=\"" << barX << " -3 1.5\" sizen=\"1.2 2.4\" image=\"http://kreipe.patrick.coolserverhosting.de/local/green.jpg\"/>";
+            barX += 1.2;
+        }
+
+        for(int i = plus; i < 10; i++)
+        {
+            widget << "        <quad posn=\"" << barX << " -3 1.5\" sizen=\"1.2 2.4\" image=\"http://kreipe.patrick.coolserverhosting.de/local/red.jpg\"/>";
+            barX += 1.2;
+        }
+    }
+
+    widget << "    </frame>";
+
+    frame.Page = widget.str();
+    return ui->Display(frame, player);
+}
diff --git a/plugins/Karma/src/Widget/KarmaWidget.h b/plugins/Karma/src/Widget/KarmaWidget.h
new file mode 100644
index 00000000..19c73daa
--- /dev/null
+++ b/plugins/Karma/src/Widget/KarmaWidget.h
@@ -0,0 +1,39 @@
+#ifndef MAPWIDGET_H_
+#define MAPWIDGET_H_
+
+#include <string>
+#include <vector>
+#include <map>
+
+#include "Methods/Methods.h"
+#include "Objects/Map.h"
+#include "Objects/Player.h"
+#include "UI/UIManager.h"
+#include "Utils/Logging.h"
+#include "Utils/Time.h"
+
+#include "../Objects/MapKarma.h"
+
+class KarmaWidget
+{
+public:
+    KarmaWidget();
+    KarmaWidget(UIManager* uiManager);
+    bool DisplayToPlayer(Player player, MapKarma* karma, int personalScore);
+
+    double WidgetX = 49.2;
+    double WidgetY = 39.2;
+
+    std::string ActionId = "OpenWhoKarma";
+    std::string PositiveAction = "KarmaVotePositive";
+    std::string NegativeAction = "KarmaVoteNegative";
+
+private:
+    UIManager* ui;
+    UIFrame frame;
+
+    std::string title = "Karma";
+    std::string manialinkId = "Karma";
+};
+
+#endif // MAPWIDGET_H_
diff --git a/plugins/Karma/src/main.cpp b/plugins/Karma/src/main.cpp
new file mode 100644
index 00000000..4526fb5d
--- /dev/null
+++ b/plugins/Karma/src/main.cpp
@@ -0,0 +1,25 @@
+#include "KarmaPlugin.h"
+
+/**
+ * Mania++ is a Server Controller for TrackMania 2 servers, written in C++.
+ * Copyright (C) 2016 Max Klaversma <maxklaversma@gmail.com>
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+extern "C" Plugin* startPlugin()
+{
+    KarmaPlugin* plugin = new KarmaPlugin();
+    return (Plugin*)plugin;
+}
diff --git a/plugins/LocalRecords/CMakeLists.txt b/plugins/LocalRecords/CMakeLists.txt
new file mode 100644
index 00000000..0e0bc815
--- /dev/null
+++ b/plugins/LocalRecords/CMakeLists.txt
@@ -0,0 +1,20 @@
+cmake_minimum_required (VERSION 2.6)
+project (LocalRecordsPlugin)
+
+add_definitions(-std=c++11)
+add_definitions(-Wno-deprecated)
+add_definitions(-Wl,--export-dynamic)
+add_definitions(-rdynamic)
+
+set (LIBRARY_OUTPUT_PATH ${PROJECT_SOURCE_DIR})
+link_directories(${PROJECT_SOURCE_DIR}/../../lib/yaml/build)
+include_directories("${PROJECT_SOURCE_DIR}/../../lib/yaml/include")
+set (PROJECT_SOURCE_DIR ${PROJECT_SOURCE_DIR}/src)
+
+include_directories("${PROJECT_BINARY_DIR}")
+include_directories("${PROJECT_SOURCE_DIR}/../../../src")
+
+file(GLOB_RECURSE SOURCES src/*.cpp)
+
+add_library(LocalRecordsPlugin SHARED ${SOURCES})
+target_link_libraries(LocalRecordsPlugin yaml-cpp mysqlcppconn)
diff --git a/plugins/LocalRecords/build.sh b/plugins/LocalRecords/build.sh
new file mode 100755
index 00000000..8f88dbb9
--- /dev/null
+++ b/plugins/LocalRecords/build.sh
@@ -0,0 +1,4 @@
+cmake -DCMAKE_BUILD_TYPE=Debug -H. -Bbuild
+
+cd ./build
+make
diff --git a/plugins/LocalRecords/src/LocalRecordsList.h b/plugins/LocalRecords/src/LocalRecordsList.h
new file mode 100644
index 00000000..2bd3f470
--- /dev/null
+++ b/plugins/LocalRecords/src/LocalRecordsList.h
@@ -0,0 +1,42 @@
+#ifndef LOCALRECORDSLIST_H_
+#define LOCALRECORDSLIST_H_
+
+class LocalRecordsList
+{
+public:
+    std::vector<LocalRecord> List;
+
+    int GetPlayerRecordIndex(Player player)
+    {
+        int playerRecord = 0;
+        for(int recordId = 0; recordId < List.size(); recordId++)
+        {
+            LocalRecord localRecord = List.at(recordId);
+            if(localRecord.Login == player.Login)
+            {
+                playerRecord = (recordId + 1);
+                break;
+            }
+        }
+
+        return playerRecord;
+    }
+
+    LocalRecord GetPlayerRecord(Player player)
+    {
+        LocalRecord playerRecord = LocalRecord();
+        for(int recordId = 0; recordId < List.size(); recordId++)
+        {
+            LocalRecord localRecord = List.at(recordId);
+            if(localRecord.Login == player.Login)
+            {
+                playerRecord = localRecord;
+                break;
+            }
+        }
+
+        return playerRecord;
+    }
+};
+
+#endif // LOCALRECORDSLIST_H_
diff --git a/plugins/LocalRecords/src/LocalRecordsPlugin.cpp b/plugins/LocalRecords/src/LocalRecordsPlugin.cpp
new file mode 100644
index 00000000..836a210a
--- /dev/null
+++ b/plugins/LocalRecords/src/LocalRecordsPlugin.cpp
@@ -0,0 +1,324 @@
+#include "LocalRecordsPlugin.h"
+
+LocalRecordsPlugin::LocalRecordsPlugin()
+{
+    Version = "0.2.0";
+    Author = "TheM";
+
+    BeginMap.push_back([this](Map map) { OnBeginMap(map); });
+    PlayerConnect.push_back([this](Player player) { OnPlayerConnect(player); });
+    PlayerFinish.push_back([this](Player player, int playerTime) { OnPlayerFinish(player, playerTime); });
+
+    RegisterCommand("records", [this](Player player, std::vector<std::string> parameters) { OpenLocalRecords(player); });
+}
+
+void LocalRecordsPlugin::Init()
+{
+    loadSettings();
+    retrieveRecords(*controller->Maps->Current);
+    std::cout << "[  INFO   ] " << localRecords.List.size() << " records found for " << controller->Maps->Current->Name << "." << std::endl;
+
+    widget = LocalRecordsWidget(controller->UI, &localRecords);
+    widget.WidgetEntries = widgetEntries;
+    widget.WidgetTopCount = widgetTopCount;
+    widget.WidgetX = widgetX;
+    widget.WidgetY = widgetY;
+    controller->UI->RegisterEvent("OpenLocalRecords", ([this](Player player, std::string answer, std::vector<EntryVal> entries) { OpenLocalRecords(player); }));
+
+    if(!widget.DisplayToAll(controller->Players))
+    {
+        Logging::PrintError(controller->Server->GetCurrentError());
+    }
+}
+
+void LocalRecordsPlugin::loadSettings()
+{
+    std::map<std::string, std::string>::iterator limitIt = Settings.find("limit");
+    if(limitIt != Settings.end())
+        recordLimit = atoi(limitIt->second.c_str());
+
+    std::map<std::string, std::string>::iterator widgetEntriesIt = Settings.find("widgetEntries");
+    if(widgetEntriesIt != Settings.end())
+        widgetEntries = atoi(widgetEntriesIt->second.c_str());
+
+    std::map<std::string, std::string>::iterator widgetTopCountIt = Settings.find("widgetTopCount");
+    if(widgetTopCountIt != Settings.end())
+        widgetTopCount = atoi(widgetTopCountIt->second.c_str());
+
+    std::map<std::string, std::string>::iterator widgetXIt = Settings.find("widgetX");
+    if(widgetXIt != Settings.end())
+        widgetX = atof(widgetXIt->second.c_str());
+
+    std::map<std::string, std::string>::iterator widgetYIt = Settings.find("widgetY");
+    if(widgetYIt != Settings.end())
+        widgetY = atof(widgetYIt->second.c_str());
+}
+
+void LocalRecordsPlugin::OnBeginMap(Map map)
+{
+    retrieveRecords(*controller->Maps->Current);
+    std::cout << "[  INFO   ] " << localRecords.List.size() << " records found for " << controller->Maps->Current->Name << "." << std::endl;
+
+    for(std::map<std::string, Player>::iterator player = controller->Players->begin(); player != controller->Players->end(); ++player)
+    {
+        Player currentPlayer = player->second;
+        displayPersonalRecord(currentPlayer);
+        if(!widget.DisplayToPlayer(currentPlayer))
+        {
+            Logging::PrintError(controller->Server->GetCurrentError());
+        }
+    }
+}
+
+void LocalRecordsPlugin::OnPlayerConnect(Player player)
+{
+    displayPersonalRecord(player);
+    if(!widget.DisplayToPlayer(player))
+    {
+        Logging::PrintError(controller->Server->GetCurrentError());
+    }
+}
+
+void LocalRecordsPlugin::OnPlayerFinish(Player player, int playerTime)
+{
+    if(playerTime > 0 && player.CurrentCheckpoints.size() == controller->Maps->Current->NbCheckpoints)
+    {
+        LocalRecord currentLocal = localRecords.GetPlayerRecord(player);
+        int currentLocalIndex = localRecords.GetPlayerRecordIndex(player);
+
+        std::stringstream checkpoints;
+        for(int checkPointId = 0; checkPointId < player.CurrentCheckpoints.size(); checkPointId++)
+        {
+            if(checkPointId > 0) checkpoints << ",";
+            checkpoints << player.CurrentCheckpoints.at(checkPointId);
+        }
+
+        sql::PreparedStatement* pstmtTimes;
+
+        try
+        {
+            pstmtTimes = controller->Database->prepareStatement("INSERT INTO `times` (`MapId`, `PlayerId`, `Score`, `Date`, `Checkpoints`) VALUES (?, ?, ?, ?, ?)");
+            pstmtTimes->setInt(1, controller->Maps->Current->Id);
+            pstmtTimes->setInt(2, player.Id);
+            pstmtTimes->setInt(3, playerTime);
+            pstmtTimes->setInt(4, time(NULL));
+            pstmtTimes->setString(5, checkpoints.str());
+            pstmtTimes->execute();
+        }
+        catch(sql::SQLException &e)
+        {
+            std::cout << "Failed to save time for " << player.Login << " on '" << controller->Maps->Current->Name << "' ..." << std::endl;
+            Logging::PrintError(e.getErrorCode(), e.what());
+        }
+
+        if(pstmtTimes != NULL)
+        {
+            delete pstmtTimes;
+            pstmtTimes = NULL;
+        }
+
+        bool updateRecord = false;
+        bool recordInserted = false;
+
+        if(currentLocal.Id == 0)
+        {
+            // Player has no local.
+            if(localRecords.List.size() == recordLimit)
+            {
+                // Records list is full.
+                LocalRecord lastRecord = localRecords.List.back();
+                if(playerTime < lastRecord.Time)
+                {
+                    // Time is better than last record, so insert in database.
+                    updateRecord = true;
+                }
+            }
+            else
+            {
+                // Records list isn't full, so can always be added.
+                updateRecord = true;
+            }
+        }
+        else
+        {
+            // Player has a local.
+            if(playerTime < currentLocal.Time)
+            {
+                // Player improved his record.
+                updateRecord = true;
+            }
+            else if(playerTime == currentLocal.Time)
+            {
+                // Player equalled his record.
+                std::stringstream chatMessage;
+                chatMessage << "$fff" << player.NickName << "$z$s$0f3 equalled the $fff" << currentLocalIndex << ".$0f3 record ($fff" << currentLocal.FormattedTime << "$0f3).";
+                controller->Server->ChatSendServerMessage(chatMessage.str());
+            }
+        }
+
+        if(updateRecord)
+        {
+            sql::PreparedStatement* pstmt;
+            try
+            {
+                pstmt = controller->Database->prepareStatement("INSERT INTO `records` (`MapId`, `PlayerId`, `Score`, `Date`, `Checkpoints`) VALUES (?, ?, ?, ?, ?) ON DUPLICATE KEY UPDATE `Score` = VALUES(`Score`), `Date` = VALUES(`Date`), `Checkpoints` = VALUES(`Checkpoints`)");
+                pstmt->setInt(1, controller->Maps->Current->Id);
+                pstmt->setInt(2, player.Id);
+                pstmt->setInt(3, playerTime);
+                pstmt->setString(4, Time::Current());
+                pstmt->setString(5, checkpoints.str());
+                pstmt->execute();
+
+                recordInserted = true;
+            }
+            catch(sql::SQLException &e)
+            {
+                std::cout << "Failed to save record for " << player.Login << " on '" << controller->Maps->Current->Name << "' ..." << std::endl;
+                Logging::PrintError(e.getErrorCode(), e.what());
+            }
+
+            if(pstmt != NULL)
+            {
+                delete pstmt;
+                pstmt = NULL;
+            }
+        }
+
+        if(recordInserted)
+        {
+            retrieveRecords(*controller->Maps->Current);
+
+            LocalRecord newLocal = localRecords.GetPlayerRecord(player);
+            int newLocalIndex = localRecords.GetPlayerRecordIndex(player);
+
+            std::stringstream chatMessage;
+            chatMessage << "$fff" << player.NickName << "$z$s$0f3 ";
+            chatMessage << "drove the $fff" << newLocalIndex << ".$0f3 record with a time of: $fff" << newLocal.FormattedTime << "$0f3";
+            if(currentLocal.Id == 0)
+            {
+                chatMessage << "!";
+            }
+            else
+            {
+                chatMessage << " ($fff" << currentLocalIndex << ".$0f3, $fff-" << Time::FormatTime((currentLocal.Time - newLocal.Time)) << "$0f3)!";
+            }
+
+            controller->Server->ChatSendServerMessage(chatMessage.str());
+
+            if(!widget.DisplayToAll(controller->Players))
+            {
+                Logging::PrintError(controller->Server->GetCurrentError());
+            }
+        }
+    }
+}
+
+void LocalRecordsPlugin::OpenLocalRecords(Player player)
+{
+    UIList list = UIList();
+    list.Id = "LocalRecords";
+    list.Title = "Local Records for: $z$s$fff" + controller->Maps->Current->Name;
+    list.IconStyle = "BgRaceScore2";
+    list.IconSubstyle = "LadderRank";
+    list.Columns.push_back(std::pair<std::string, int>("#", 5));
+    list.Columns.push_back(std::pair<std::string, int>("Player", 40));
+    list.Columns.push_back(std::pair<std::string, int>("Time", 20));
+
+    for(int recordId = 0; recordId < localRecords.List.size(); recordId++)
+    {
+        LocalRecord record = localRecords.List.at(recordId);
+
+        std::stringstream index;
+        index << (recordId + 1);
+
+        std::map<std::string, std::string> row = std::map<std::string, std::string>();
+        row.insert(std::pair<std::string, std::string>("#", index.str()));
+        row.insert(std::pair<std::string, std::string>("Player", record.NickName));
+        row.insert(std::pair<std::string, std::string>("Time", record.FormattedTime));
+        list.Rows.push_back(row);
+    }
+
+    controller->UI->DisplayList(list, player);
+}
+
+void LocalRecordsPlugin::displayPersonalRecord(Player player)
+{
+    bool playerFound = false;
+    for(int recordId = 0; recordId < localRecords.List.size(); recordId++)
+    {
+        LocalRecord localRecord = localRecords.List.at(recordId);
+        if(localRecord.Login == player.Login)
+        {
+            std::stringstream chatMessage;
+            chatMessage << "$0f3Your current Local Record:$fff " << localRecord.FormattedTime << " $0f3($fff" << (recordId + 1) << ".$0f3)";
+            controller->Server->ChatSendServerMessageToLogin(chatMessage.str(), player.Login);
+            playerFound = true;
+        }
+    }
+
+    if(!playerFound)
+        controller->Server->ChatSendServerMessageToLogin("$0f3You currently don't have a Local Record on this map.", player.Login);
+}
+
+void LocalRecordsPlugin::retrieveRecords(Map map)
+{
+    localRecords.List = std::vector<LocalRecord>();
+
+    sql::PreparedStatement* pstmt;
+    sql::ResultSet* result;
+
+    try
+    {
+        pstmt = controller->Database->prepareStatement("SELECT * FROM `records` WHERE `MapId` = ? ORDER BY `Score` ASC LIMIT ?");
+        pstmt->setInt(1, map.Id);
+        pstmt->setInt(2, recordLimit);
+        result = pstmt->executeQuery();
+
+        while(result->next())
+        {
+            delete pstmt; pstmt = NULL;
+            LocalRecord localRecord = LocalRecord(result);
+
+            pstmt = controller->Database->prepareStatement("SELECT * FROM `players` WHERE `Id` = ?");
+            pstmt->setInt(1, result->getInt("PlayerId"));
+            sql::ResultSet* playerResult = pstmt->executeQuery();
+            playerResult->next();
+
+            try
+            {
+                localRecord.Login = playerResult->getString("Login");
+                localRecord.NickName = playerResult->getString("NickName");
+            }
+            catch(sql::InvalidArgumentException &e)
+            {
+                // Player cannot be found in the database.
+                localRecord.Login = "";
+                localRecord.NickName = "";
+            }
+
+            localRecords.List.push_back(localRecord);
+
+            if(playerResult != NULL)
+            {
+                delete playerResult;
+                playerResult = NULL;
+            }
+        }
+    }
+    catch(sql::SQLException &e)
+    {
+        std::cout << "Failed to retrieve records for '" << map.Name << "' ..." << std::endl;
+        Logging::PrintError(e.getErrorCode(), e.what());
+    }
+
+    if(pstmt != NULL)
+    {
+        delete pstmt;
+        pstmt = NULL;
+    }
+
+    if(result != NULL)
+    {
+        delete result; result = NULL;
+    }
+}
diff --git a/plugins/LocalRecords/src/LocalRecordsPlugin.h b/plugins/LocalRecords/src/LocalRecordsPlugin.h
new file mode 100644
index 00000000..58b54123
--- /dev/null
+++ b/plugins/LocalRecords/src/LocalRecordsPlugin.h
@@ -0,0 +1,41 @@
+#ifndef LOCALRECORDSPLUGIN_H_
+#define LOCALRECORDSPLUGIN_H_
+
+#include <algorithm>
+#include <sstream>
+
+#include "Plugins/Plugin.h"
+#include "Utils/Time.h"
+
+#include "Objects/LocalRecord.h"
+#include "LocalRecordsList.h"
+#include "Widget/LocalRecordsWidget.h"
+
+class LocalRecordsPlugin : public Plugin
+{
+public:
+    LocalRecordsPlugin();
+
+    void Init();
+    void OnBeginMap(Map map);
+    void OnPlayerConnect(Player player);
+    void OnPlayerFinish(Player player, int time);
+    void OnPlayerCheckpoint(Player player, int time, int currentLap, int checkpointIndex);
+    void OpenLocalRecords(Player player);
+
+private:
+    LocalRecordsList localRecords;
+    LocalRecordsWidget widget;
+
+    int recordLimit = 100;
+    int widgetEntries = 28;
+    int widgetTopCount = 5;
+    double widgetX = 49.2;
+    double widgetY = 28.2;
+
+    void retrieveRecords(Map map);
+    void displayPersonalRecord(Player player);
+    void loadSettings();
+};
+
+#endif // LOCALRECORDSPLUGIN_H_
diff --git a/plugins/LocalRecords/src/Objects/LocalRecord.h b/plugins/LocalRecords/src/Objects/LocalRecord.h
new file mode 100644
index 00000000..76580aab
--- /dev/null
+++ b/plugins/LocalRecords/src/Objects/LocalRecord.h
@@ -0,0 +1,44 @@
+#ifndef LOCALRECORD_H_
+#define LOCALRECORD_H_
+
+#include <cppconn/resultset.h>
+
+#include "Utils/Time.h"
+
+class LocalRecord
+{
+public:
+    int Id = 0;
+    Map RecordMap;
+    std::string Login;
+    std::string NickName;
+
+    int Time;
+    std::string FormattedTime;
+    std::vector<int> Checkpoints;
+
+    std::string Date;
+
+    LocalRecord()
+    {
+        
+    }
+
+    LocalRecord(sql::ResultSet* result)
+    {
+        Id = result->getInt("Id");
+        Time = result->getInt("Score");
+        FormattedTime = Time::FormatTime(Time);
+        std::stringstream checkpoints(result->getString("Checkpoints"));
+        while(checkpoints.good())
+        {
+            std::string checkpoint;
+            getline(checkpoints, checkpoint, ',');
+            Checkpoints.push_back(atoi(checkpoint.c_str()));
+        }
+
+        Date = result->getString("Date");
+    }
+};
+
+#endif // LOCALRECORD_H_
diff --git a/plugins/LocalRecords/src/Widget/LocalRecordsWidget.cpp b/plugins/LocalRecords/src/Widget/LocalRecordsWidget.cpp
new file mode 100644
index 00000000..463e402d
--- /dev/null
+++ b/plugins/LocalRecords/src/Widget/LocalRecordsWidget.cpp
@@ -0,0 +1,200 @@
+#include "LocalRecordsWidget.h"
+
+LocalRecordsWidget::LocalRecordsWidget()
+{
+
+}
+
+LocalRecordsWidget::LocalRecordsWidget(UIManager* uiManager, LocalRecordsList* localRecords)
+{
+    ui = uiManager;
+    records = localRecords;
+
+    frame = UIFrame();
+    frame.ManiaLinkId = manialinkId;
+    frame.Timeout = 0;
+    frame.CloseOnClick = false;
+}
+
+bool LocalRecordsWidget::DisplayToAll(std::map<std::string, Player>* players)
+{
+    bool response = true;
+
+    for(std::map<std::string, Player>::iterator player = players->begin(); player != players->end(); ++player)
+    {
+        if(!DisplayToPlayer(player->second))
+            response = false;
+    }
+
+    return response;
+}
+
+bool LocalRecordsWidget::DisplayToPlayer(Player player)
+{
+    double widgetWidth = 15.5;
+    double widgetHeight = ((1.8 * WidgetEntries) + 3.2);
+    double columnHeight = (widgetHeight - 3.1);
+    double backgroundWidth = (widgetWidth - 0.2);
+    double backgroundHeight = (widgetHeight - 0.2);
+    double borderWidth = (widgetWidth + 0.4);
+    double borderHeight = (widgetHeight + 0.6);
+    double columnNameWidth = (widgetWidth - 6.45);
+
+    double left_IconX = 0.6;
+    double left_IconY = 0;
+    double left_TitleX = 3.2;
+    double left_TitleY = -0.65;
+    std::string left_TitleHalign = "left";
+    double left_ImageOpenX = -0.3;
+    std::string left_ImageOpen = "http://static.undef.name/ingame/records-eyepiece/edge-open-ld-dark.png";
+
+    double right_IconX = 12.5;
+    double right_IconY = 0;
+    double right_TitleX = 12.4;
+    double right_TitleY = -0.65;
+    std::string right_TitleHalign = "right";
+    double right_ImageOpenX = 12.2;
+    std::string right_ImageOpen = "http://static.undef.name/ingame/records-eyepiece/edge-open-rd-dark.png";
+
+    std::string backgroundColor = "3342";
+    std::string backgroundFocus = "09F6";
+    std::string backgroundRank = "06F5";
+    std::string backgroundScore = "09F3";
+    std::string backgroundName = "09F1";
+
+    std::string backgroundStyle = "Bgs1";
+    std::string backgroundSubstyle = "BgTitleGlow";
+    std::string borderStyle = "Bgs1";
+    std::string borderSubstyle = "BgTitleShadow";
+
+    double imageOpenX = (WidgetX < 0) ? (right_ImageOpenX + (widgetWidth - 15.5)) : left_ImageOpenX;
+    double imageOpenY = -(widgetHeight - 3.18);
+    std::string imageOpen = (WidgetX < 0) ? right_ImageOpen : left_ImageOpen;
+
+    double titleBackgroundWidth = (widgetWidth - 0.8);
+    std::string titleStyle = "BgsPlayerCard";
+    std::string titleSubstyle = "BgRacePlayerName";
+    double titleX = (WidgetX < 0) ? (right_TitleX + (widgetWidth - 15.5)) : left_TitleX;
+    double titleY = (WidgetX < 0) ? right_TitleY : left_TitleY;
+    std::string titleHalign = (WidgetX < 0) ? right_TitleHalign : left_TitleHalign;
+
+    double iconX = (WidgetX < 0) ? (right_IconX + (widgetWidth - 15.5)) : left_IconX;
+    double iconY = (WidgetX < 0) ? right_IconY : left_IconY;
+    std::string iconStyle = "BgRaceScore2";
+    std::string iconSubstyle = "LadderRank";
+
+    std::string textColor = "FFFF";
+
+    double topWidth = (widgetWidth - 0.8);
+    double topHeight = ((WidgetTopCount * 1.8) + 0.2);
+    std::string topStyle = "BgsPlayerCard";
+    std::string topSubstyle = "BgCardSystem";
+
+    double playerIconBoxX = (WidgetX < 0) ? widgetWidth : -2;
+    double playerIconX = (WidgetX < 0) ? (widgetWidth + 0.2) : -1.8;
+    std::string playerIcon = (WidgetX < 0) ? "ShowLeft2" : "ShowRight2";
+
+    std::stringstream widget;
+    widget << "    <frame posn=\"" << WidgetX << " " << WidgetY << " 0\" id=\"Widget" << manialinkId << "\">";
+    widget << "        <label posn=\"0.1 -0.1 0\" sizen=\"" << backgroundWidth << " " << backgroundHeight << "\" action=\"" << actionId << "\" text=\" \" focusareacolor1=\"" << backgroundColor << "\" focusareacolor2=\"" << backgroundFocus << "\"/>";
+    widget << "        <quad posn=\"-0.2 0.3 0.001\" sizen=\"" << borderWidth << " " << borderHeight << "\" style=\"" << borderStyle << "\" substyle=\"" << borderSubstyle << "\"/>";
+    widget << "        <quad posn=\"0 0 0.002\" sizen=\"" << backgroundWidth << " " << backgroundHeight << "\" style=\"" << backgroundStyle << "\" substyle=\"" << backgroundSubstyle << "\"/>";
+
+    widget << "        <quad posn=\"0.4 -2.6 0.003\" sizen=\"2 " << columnHeight << "\" bgcolor=\"" << backgroundRank << "\"/>";
+    widget << "        <quad posn=\"2.4 -2.6 0.003\" sizen=\"3.65 " << columnHeight << "\" bgcolor=\"" << backgroundScore << "\"/>";
+    widget << "        <quad posn=\"6.05 -2.6 0.003\" sizen=\"" << columnNameWidth << " " << columnHeight << "\" bgcolor=\"" << backgroundName << "\"/>";
+
+    widget << "        <quad posn=\"" << imageOpenX << " " << imageOpenY << " 0.05\" sizen=\"3.5 3.5\" image=\"" << imageOpen << "\"/>";
+
+    widget << "        <quad posn=\"0.4 -0.36 0.003\" sizen=\"" << titleBackgroundWidth << " 2\" style=\"" << titleStyle << "\" substyle=\"" << titleSubstyle << "\"/>";
+    widget << "        <quad posn=\"" << iconX << " " << iconY << " 0.004\" sizen=\"2.5 2.5\" style=\"" << iconStyle << "\" substyle=\"" << iconSubstyle << "\"/>";
+    widget << "        <label posn=\"" << titleX << " " << titleY << " 0.004\" sizen=\"10.2 0\" halign=\"" << titleHalign << "\" textsize=\"1\" text=\"" << title << "\"/>";
+    widget << "        <format textsize=\"1\" textcolor=\"" << textColor << "\"/>";
+
+    widget << "        <quad posn=\"0.4 -2.6 0.004\" sizen=\"" << topWidth << " " << topHeight << "\" style=\"" << topStyle << "\" substyle=\"" << topSubstyle << "\"/>";
+
+    double recordY = -3;
+
+    std::string scoreColor = "F00F";
+    std::string topColor = "FF0F";
+
+    for(int recordId = 0; recordId < records->List.size(); recordId++)
+    {
+        LocalRecord record = records->List.at(recordId);
+        if(record.Login == player.Login)
+        {
+            scoreColor = "0F3F";
+            topColor = "0F3F";
+            widget << "        <quad posn=\"" << playerIconBoxX << " " << (recordY + 0.35) << " 0.004\" sizen=\"2 1.95\" style=\"BgsPlayerCard\" substyle=\"BgCardSystem\"/>";
+            widget << "        <quad posn=\"" << playerIconX << " " << (recordY + 0.15) << " 0.005\" sizen=\"1.6 1.6\" style=\"Icons64x64_1\" substyle=\"" << playerIcon << "\"/>";
+        }
+
+        widget << "        <label posn=\"2.3 " << recordY << " 0.005\" sizen=\"1.7 1.7\" halign=\"right\" scale=\"0.9\" text=\"" << (recordId + 1) << ".\"/>";
+        widget << "        <label posn=\"6 " << recordY << " 0.005\" sizen=\"3.9 1.7\" halign=\"right\" scale=\"0.9\" textcolor=\"" << topColor << "\" text=\"" << record.FormattedTime << "\"/>";
+        widget << "        <label posn=\"6.2 " << recordY << " 0.005\" sizen=\"9.50 1.7\" scale=\"0.9\" text=\"" << Text::EscapeXML(record.NickName) << "\"/>";
+
+        if(record.Login == player.Login)
+        {
+            scoreColor = "999F";
+            topColor = "FF0F";
+        }
+
+        recordY -= 1.8;
+
+        if((recordId + 2) > WidgetTopCount) break;
+    }
+
+    int recordCount = records->List.size();
+    int startPoint = (recordCount - (WidgetEntries - WidgetTopCount));
+    if(startPoint < WidgetTopCount)
+        startPoint = WidgetTopCount;
+    int playerRecord = records->GetPlayerRecordIndex(player);
+
+    if(playerRecord > 0)
+    {
+        int recordsToFill = ((WidgetEntries - WidgetTopCount) - 1);
+        int fillAbove = std::ceil(recordsToFill / 2.0);
+        int fillBelow = std::floor(recordsToFill / 2.0);
+        int roomAbove = (playerRecord - WidgetTopCount);
+        int roomBelow = (recordCount - playerRecord);
+
+        if(fillBelow > roomBelow)
+        {
+            fillAbove += (fillBelow - roomBelow);
+        }
+
+        startPoint = ((playerRecord - fillAbove) - 1);
+        if(startPoint < WidgetTopCount)
+            startPoint = WidgetTopCount;
+    }
+
+    for(int recordId = startPoint; recordId < (startPoint + (WidgetEntries - WidgetTopCount)); recordId++)
+    {
+        LocalRecord record = records->List.at(recordId);
+        if(record.Login == player.Login)
+        {
+            scoreColor = "0F3F";
+            widget << "        <quad posn=\"" << playerIconBoxX << " " << (recordY + 0.35) << " 0.004\" sizen=\"2 1.95\" style=\"BgsPlayerCard\" substyle=\"BgCardSystem\"/>";
+            widget << "        <quad posn=\"" << playerIconX << " " << (recordY + 0.15) << " 0.005\" sizen=\"1.6 1.6\" style=\"Icons64x64_1\" substyle=\"" << playerIcon << "\"/>";
+            widget << "        <quad posn=\"0.4 " << (recordY + 0.35) << " 0.004\" sizen=\"" << topWidth << " 1.95\" style=\"" << topStyle << "\" substyle=\"" << topSubstyle << "\"/>";
+        }
+
+        widget << "        <label posn=\"2.3 " << recordY << " 0.005\" sizen=\"1.7 1.7\" halign=\"right\" scale=\"0.9\" text=\"" << (recordId + 1) << ".\"/>";
+        widget << "        <label posn=\"6 " << recordY << " 0.005\" sizen=\"3.9 1.7\" halign=\"right\" scale=\"0.9\" textcolor=\"" << scoreColor << "\" text=\"" << record.FormattedTime << "\"/>";
+        widget << "        <label posn=\"6.2 " << recordY << " 0.005\" sizen=\"9.50 1.7\" scale=\"0.9\" text=\"" << Text::EscapeXML(record.NickName) << "\"/>";
+
+        if(record.Login == player.Login)
+        {
+            scoreColor = "BBBF";
+        }
+
+        recordY -= 1.8;
+
+        if((recordId + 2) > recordCount) break;
+    }
+
+    widget << "    </frame>";
+
+    frame.Page = widget.str();
+    return ui->Display(frame, player);
+}
diff --git a/plugins/LocalRecords/src/Widget/LocalRecordsWidget.h b/plugins/LocalRecords/src/Widget/LocalRecordsWidget.h
new file mode 100644
index 00000000..4bd3d2fa
--- /dev/null
+++ b/plugins/LocalRecords/src/Widget/LocalRecordsWidget.h
@@ -0,0 +1,41 @@
+#ifndef LOCALRECORDSWIDGET_H_
+#define LOCALRECORDSWIDGET_H_
+
+#include <string>
+#include <vector>
+#include <map>
+
+#include "Methods/Methods.h"
+#include "Objects/Player.h"
+#include "UI/UIManager.h"
+#include "Utils/Logging.h"
+#include "Utils/Text.h"
+
+#include "../Objects/LocalRecord.h"
+#include "../LocalRecordsList.h"
+
+class LocalRecordsWidget
+{
+public:
+    LocalRecordsWidget();
+    LocalRecordsWidget(UIManager* uiManager, LocalRecordsList* localRecords);
+    bool DisplayToAll(std::map<std::string, Player>* players);
+    bool DisplayToPlayer(Player player);
+
+    int WidgetEntries = 28;
+    int WidgetTopCount = 5;
+    double WidgetX = 49.2;
+    double WidgetY = 28.2;
+
+private:
+    UIManager* ui;
+    LocalRecordsList* records;
+
+    UIFrame frame;
+
+    std::string manialinkId = "LocalRecords";
+    std::string title = "Local Records";
+    std::string actionId = "OpenLocalRecords";
+};
+
+#endif // LOCALRECORDSWIDGET_H_
diff --git a/plugins/LocalRecords/src/main.cpp b/plugins/LocalRecords/src/main.cpp
new file mode 100644
index 00000000..5dee7b54
--- /dev/null
+++ b/plugins/LocalRecords/src/main.cpp
@@ -0,0 +1,25 @@
+#include "LocalRecordsPlugin.h"
+
+/**
+ * Mania++ is a Server Controller for TrackMania 2 servers, written in C++.
+ * Copyright (C) 2016 Max Klaversma <maxklaversma@gmail.com>
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+extern "C" Plugin* startPlugin()
+{
+    LocalRecordsPlugin* plugin = new LocalRecordsPlugin();
+    return (Plugin*)plugin;
+}
diff --git a/plugins/MapWidget/CMakeLists.txt b/plugins/MapWidget/CMakeLists.txt
new file mode 100644
index 00000000..fe970eed
--- /dev/null
+++ b/plugins/MapWidget/CMakeLists.txt
@@ -0,0 +1,20 @@
+cmake_minimum_required (VERSION 2.6)
+project (MapWidgetPlugin)
+
+add_definitions(-std=c++11)
+add_definitions(-Wno-deprecated)
+add_definitions(-Wl,--export-dynamic)
+add_definitions(-rdynamic)
+
+set (LIBRARY_OUTPUT_PATH ${PROJECT_SOURCE_DIR})
+link_directories(${PROJECT_SOURCE_DIR}/../../lib/yaml/build)
+include_directories("${PROJECT_SOURCE_DIR}/../../lib/yaml/include")
+set (PROJECT_SOURCE_DIR ${PROJECT_SOURCE_DIR}/src)
+
+include_directories("${PROJECT_BINARY_DIR}")
+include_directories("${PROJECT_SOURCE_DIR}/../../../src")
+
+file(GLOB_RECURSE SOURCES src/*.cpp)
+
+add_library(MapWidgetPlugin SHARED ${SOURCES})
+target_link_libraries(MapWidgetPlugin yaml-cpp mysqlcppconn)
diff --git a/plugins/MapWidget/build.sh b/plugins/MapWidget/build.sh
new file mode 100755
index 00000000..8f88dbb9
--- /dev/null
+++ b/plugins/MapWidget/build.sh
@@ -0,0 +1,4 @@
+cmake -DCMAKE_BUILD_TYPE=Debug -H. -Bbuild
+
+cd ./build
+make
diff --git a/plugins/MapWidget/src/MapWidgetPlugin.cpp b/plugins/MapWidget/src/MapWidgetPlugin.cpp
new file mode 100644
index 00000000..6cb2c257
--- /dev/null
+++ b/plugins/MapWidget/src/MapWidgetPlugin.cpp
@@ -0,0 +1,63 @@
+#include "MapWidgetPlugin.h"
+
+MapWidgetPlugin::MapWidgetPlugin()
+{
+    Version = "0.1.0";
+    Author = "TheM";
+
+    BeginMap.push_back([this](Map map) { OnBeginMap(); });
+    PlayerConnect.push_back([this](Player player) { OnPlayerConnect(player); });
+    BeginMatch.push_back([this]() { OnBeginMap(); });
+    EndMatch.push_back([this](std::vector<PlayerRanking> rankings, int winnerTeam) { OnEndMatch(rankings, winnerTeam); });
+}
+
+void MapWidgetPlugin::Init()
+{
+    loadSettings();
+    widget = MapWidget(controller->UI);
+    widget.WidgetX = widgetX;
+    widget.WidgetY = widgetY;
+
+    if(!widget.DisplayToAll(controller->Players, controller->Maps->Current))
+    {
+        Logging::PrintError(controller->Server->GetCurrentError());
+    }
+}
+
+void MapWidgetPlugin::loadSettings()
+{
+    std::map<std::string, std::string>::iterator widgetXIt = Settings.find("widgetX");
+    if(widgetXIt != Settings.end())
+        widgetX = atof(widgetXIt->second.c_str());
+
+    std::map<std::string, std::string>::iterator widgetYIt = Settings.find("widgetY");
+    if(widgetYIt != Settings.end())
+        widgetY = atof(widgetYIt->second.c_str());
+}
+
+void MapWidgetPlugin::OnBeginMap()
+{
+    widget.Title = "Current Map";
+    if(!widget.DisplayToAll(controller->Players, controller->Maps->Current))
+    {
+        Logging::PrintError(controller->Server->GetCurrentError());
+    }
+}
+
+void MapWidgetPlugin::OnEndMatch(std::vector<PlayerRanking> rankings, int winnerTeam)
+{
+    widget.Title = "Next Map";
+    Map nextMap = controller->Server->GetNextMapInfo();
+    if(!widget.DisplayToAll(controller->Players, &nextMap))
+    {
+        Logging::PrintError(controller->Server->GetCurrentError());
+    }
+}
+
+void MapWidgetPlugin::OnPlayerConnect(Player player)
+{
+    if(!widget.DisplayToPlayer(player, controller->Maps->Current))
+    {
+        Logging::PrintError(controller->Server->GetCurrentError());
+    }
+}
diff --git a/plugins/MapWidget/src/MapWidgetPlugin.h b/plugins/MapWidget/src/MapWidgetPlugin.h
new file mode 100644
index 00000000..ef5fb1f1
--- /dev/null
+++ b/plugins/MapWidget/src/MapWidgetPlugin.h
@@ -0,0 +1,29 @@
+#ifndef MAPWIDGETPLUGIN_H_
+#define MAPWIDGETPLUGIN_H_
+
+#include <sstream>
+#include "Plugins/Plugin.h"
+#include "Utils/Time.h"
+
+#include "Widget/MapWidget.h"
+
+class MapWidgetPlugin : public Plugin
+{
+public:
+    MapWidgetPlugin();
+
+    void Init();
+    void OnBeginMap();
+    void OnPlayerConnect(Player player);
+    void OnEndMatch(std::vector<PlayerRanking> rankings, int winnerTeam);
+
+private:
+    MapWidget widget;
+
+    double widgetX = 49.2;
+    double widgetY = 48.2;
+
+    void loadSettings();
+};
+
+#endif // MAPWIDGETPLUGIN_H_
diff --git a/plugins/MapWidget/src/Widget/MapWidget.cpp b/plugins/MapWidget/src/Widget/MapWidget.cpp
new file mode 100644
index 00000000..3b360ab1
--- /dev/null
+++ b/plugins/MapWidget/src/Widget/MapWidget.cpp
@@ -0,0 +1,109 @@
+#include "MapWidget.h"
+
+MapWidget::MapWidget()
+{
+
+}
+
+MapWidget::MapWidget(UIManager* uiManager)
+{
+    ui = uiManager;
+
+    frame = UIFrame();
+    frame.ManiaLinkId = manialinkId;
+    frame.Timeout = 0;
+    frame.CloseOnClick = false;
+    frame.CustomUI.insert(std::pair<std::string, bool>("challenge_info", false));
+}
+
+bool MapWidget::DisplayToAll(std::map<std::string, Player>* players, Map* currentMap)
+{
+    bool response = true;
+
+    for(std::map<std::string, Player>::iterator player = players->begin(); player != players->end(); ++player)
+    {
+        if(!DisplayToPlayer(player->second, currentMap))
+            response = false;
+    }
+
+    return response;
+}
+
+bool MapWidget::DisplayToPlayer(Player player, Map* currentMap)
+{
+    double widgetWidth = 15.5;
+    double widgetHeight = 8.9;
+    double columnHeight = (widgetHeight - 3.1);
+    double backgroundWidth = (widgetWidth - 0.2);
+    double backgroundHeight = (widgetHeight - 0.2);
+    double borderWidth = (widgetWidth + 0.4);
+    double borderHeight = (widgetHeight + 0.6);
+
+    double left_IconX = 0.6;
+    double left_IconY = 0;
+    double left_TitleX = 3.2;
+    double left_TitleY = -0.65;
+    std::string left_TitleHalign = "left";
+    double left_ImageOpenX = -0.3;
+    std::string left_ImageOpen = "http://static.undef.name/ingame/records-eyepiece/edge-open-ld-dark.png";
+
+    double right_IconX = 12.5;
+    double right_IconY = 0;
+    double right_TitleX = 12.4;
+    double right_TitleY = -0.65;
+    std::string right_TitleHalign = "right";
+    double right_ImageOpenX = 12.2;
+    std::string right_ImageOpen = "http://static.undef.name/ingame/records-eyepiece/edge-open-rd-dark.png";
+
+    std::string backgroundColor = "3342";
+    std::string backgroundFocus = "09F6";
+
+    std::string backgroundStyle = "Bgs1";
+    std::string backgroundSubstyle = "BgTitleGlow";
+    std::string borderStyle = "Bgs1";
+    std::string borderSubstyle = "BgTitleShadow";
+
+    double imageOpenX = (WidgetX < 0) ? (right_ImageOpenX + (widgetWidth - 15.5)) : left_ImageOpenX;
+    double imageOpenY = -(widgetHeight - 3.18);
+    std::string imageOpen = (WidgetX < 0) ? right_ImageOpen : left_ImageOpen;
+
+    double titleBackgroundWidth = (widgetWidth - 0.8);
+    std::string titleStyle = "BgsPlayerCard";
+    std::string titleSubstyle = "BgRacePlayerName";
+    double titleX = (WidgetX < 0) ? (right_TitleX + (widgetWidth - 15.5)) : left_TitleX;
+    double titleY = (WidgetX < 0) ? right_TitleY : left_TitleY;
+    std::string titleHalign = (WidgetX < 0) ? right_TitleHalign : left_TitleHalign;
+
+    double iconX = (WidgetX < 0) ? (right_IconX + (widgetWidth - 15.5)) : left_IconX;
+    double iconY = (WidgetX < 0) ? right_IconY : left_IconY;
+    std::string iconStyle = "Icons128x128_1";
+    std::string iconSubstyle = "Challenge";
+
+    std::string textColor = "FFFF";
+
+    std::stringstream widget;
+    widget << "    <frame posn=\"" << WidgetX << " " << WidgetY << " 0\" id=\"Widget" << manialinkId << "\">";
+    widget << "        <label posn=\"0.1 -0.1 0\" sizen=\"" << backgroundWidth << " " << backgroundHeight << "\" text=\" \" focusareacolor1=\"" << backgroundColor << "\" focusareacolor2=\"" << backgroundFocus << "\"/>";
+    widget << "        <quad posn=\"-0.2 0.3 0.001\" sizen=\"" << borderWidth << " " << borderHeight << "\" style=\"" << borderStyle << "\" substyle=\"" << borderSubstyle << "\"/>";
+    widget << "        <quad posn=\"0 0 0.002\" sizen=\"" << backgroundWidth << " " << backgroundHeight << "\" style=\"" << backgroundStyle << "\" substyle=\"" << backgroundSubstyle << "\"/>";
+
+    widget << "        <quad posn=\"0.4 -0.36 0.003\" sizen=\"" << titleBackgroundWidth << " 2\" style=\"" << titleStyle << "\" substyle=\"" << titleSubstyle << "\"/>";
+    widget << "        <quad posn=\"" << iconX << " " << iconY << " 0.004\" sizen=\"2.5 2.5\" style=\"" << iconStyle << "\" substyle=\"" << iconSubstyle << "\"/>";
+    widget << "        <label posn=\"" << titleX << " " << titleY << " 0.004\" sizen=\"10.2 0\" halign=\"" << titleHalign << "\" textsize=\"1\" text=\"" << Title << "\"/>";
+    widget << "        <format textsize=\"1\" textcolor=\"" << textColor << "\"/>";
+
+    widget << "        <label posn=\"1 -2.7 0.04\" sizen=\"13.55 2\" scale=\"1\" text=\"" << currentMap->Name << "\"/>";
+    widget << "        <quad posn=\"0.7 -4.35 0.04\" sizen=\"1.7 1.7\" style=\"Icons128x128_1\" substyle=\"ChallengeAuthor\"/>";
+    widget << "        <label posn=\"2.7 -4.6 0.04\" sizen=\"13 2\" scale=\"0.85\" text=\"" << currentMap->Author << "\"/>";
+
+    widget << "        <quad posn=\"0.7 -6.25 0.04\" sizen=\"1.7 1.7\" style=\"BgRaceScore2\" substyle=\"ScoreReplay\"/>";
+    widget << "        <label posn=\"2.7 -6.55 0.04\" sizen=\"4.5 2\" scale=\"0.85\" text=\"" << Time::FormatTime(currentMap->AuthorTime) << "\"/>";
+
+    widget << "        <quad posn=\"7.2 -6.25 0.04\" sizen=\"1.7 1.7\" style=\"Icons128x128_1\" substyle=\"United\"/>";
+    widget << "        <label posn=\"9.2 -6.55 0.04\" sizen=\"4.5 2\" scale=\"0.85\" text=\"" << currentMap->Environment << "\"/>";
+
+    widget << "    </frame>";
+
+    frame.Page = widget.str();
+    return ui->Display(frame, player);
+}
diff --git a/plugins/MapWidget/src/Widget/MapWidget.h b/plugins/MapWidget/src/Widget/MapWidget.h
new file mode 100644
index 00000000..8b2523be
--- /dev/null
+++ b/plugins/MapWidget/src/Widget/MapWidget.h
@@ -0,0 +1,35 @@
+#ifndef MAPWIDGET_H_
+#define MAPWIDGET_H_
+
+#include <string>
+#include <vector>
+#include <map>
+
+#include "Methods/Methods.h"
+#include "Objects/Map.h"
+#include "Objects/Player.h"
+#include "UI/UIManager.h"
+#include "Utils/Logging.h"
+#include "Utils/Time.h"
+
+class MapWidget
+{
+public:
+    MapWidget();
+    MapWidget(UIManager* uiManager);
+    bool DisplayToAll(std::map<std::string, Player>* players, Map* currentMap);
+    bool DisplayToPlayer(Player player, Map* currentMap);
+
+    std::string Title = "Current Map";
+
+    double WidgetX = 49.2;
+    double WidgetY = 48.2;
+
+private:
+    UIManager* ui;
+    UIFrame frame;
+
+    std::string manialinkId = "MapInfo";
+};
+
+#endif // MAPWIDGET_H_
diff --git a/plugins/MapWidget/src/main.cpp b/plugins/MapWidget/src/main.cpp
new file mode 100644
index 00000000..d3ebee22
--- /dev/null
+++ b/plugins/MapWidget/src/main.cpp
@@ -0,0 +1,25 @@
+#include "MapWidgetPlugin.h"
+
+/**
+ * Mania++ is a Server Controller for TrackMania 2 servers, written in C++.
+ * Copyright (C) 2016 Max Klaversma <maxklaversma@gmail.com>
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+extern "C" Plugin* startPlugin()
+{
+    MapWidgetPlugin* plugin = new MapWidgetPlugin();
+    return (Plugin*)plugin;
+}
diff --git a/src/CallBacks/CallBackManager.cpp b/src/CallBacks/CallBackManager.cpp
index d38dd8cf..049dc0c3 100644
--- a/src/CallBacks/CallBackManager.cpp
+++ b/src/CallBacks/CallBackManager.cpp
@@ -1,9 +1,11 @@
 #include "CallBackManager.h"
 
-CallBackManager::CallBackManager(GbxRemote* serverPtr, EventManager* eventManagerPtr, std::map<std::string, Player>* playerList, std::map<std::string, Map>* mapList)
+CallBackManager::CallBackManager(GbxRemote* serverPtr, CommandManager* commandManagerPtr, EventManager* eventManagerPtr, sql::Connection* databasePtr, std::map<std::string, Player>* playerList, MapList* mapList)
 {
     server = serverPtr;
+    commands = commandManagerPtr;
     events = eventManagerPtr;
+    database = databasePtr;
 
     players = playerList;
     maps = mapList;
@@ -12,11 +14,11 @@ CallBackManager::CallBackManager(GbxRemote* serverPtr, EventManager* eventManage
 void CallBackManager::HandleCallBack(std::string methodName, std::vector<GbxResponseParameter> parameters)
 {
     std::cout << "CALLBACK: " << methodName << " (parameters: " << parameters.size() << ")" << std::endl;
-    for(int paramId = 0; paramId < parameters.size(); paramId++)
+    /*for(int paramId = 0; paramId < parameters.size(); paramId++)
     {
         GbxResponseParameter parameter = parameters.at(paramId);
         Logging::PrintParameter(parameter, paramId);
-    }
+    }*/
 
     if(methodName.find("ManiaPlanet.PlayerConnect") != std::string::npos)
     {
@@ -32,6 +34,11 @@ void CallBackManager::HandleCallBack(std::string methodName, std::vector<GbxResp
     }
     else if(methodName.find("ManiaPlanet.PlayerManialinkPageAnswer") != std::string::npos)
     {
+        for(int paramId = 0; paramId < parameters.size(); paramId++)
+        {
+            GbxResponseParameter parameter = parameters.at(paramId);
+            Logging::PrintParameter(parameter, paramId);
+        }
         HandlePlayerManialinkPageAnswer(parameters);
     }
     else if(methodName.find("ManiaPlanet.Echo") != std::string::npos)
@@ -90,21 +97,78 @@ void CallBackManager::HandleCallBack(std::string methodName, std::vector<GbxResp
 
 void CallBackManager::HandlePlayerConnect(std::vector<GbxResponseParameter> parameters)
 {
-    GbxParameters* params = new GbxParameters();
+    GbxParameters params = GbxParameters();
     std::string login = parameters.at(0).GetString();
-    params->Put(&login);
+    params.Put(&login);
 
-    GbxMessage* message = new GbxMessage("GetPlayerInfo", params);
+    GbxMessage message = GbxMessage("GetPlayerInfo", params);
     server->Query(message);
     Player newPlayer = Player(server->GetResponse()->GetParameters().at(0).GetStruct());
+
+    message = GbxMessage("GetDetailedPlayerInfo", params);
+    server->Query(message);
+    newPlayer.PlayerDetailed(server->GetResponse()->GetParameters().at(0).GetStruct());
+
+    if(database != NULL)
+    {
+        sql::PreparedStatement* insertPstmt;
+        try
+        {
+            insertPstmt = database->prepareStatement("INSERT INTO `players` (`Login`, `NickName`, `Nation`, `UpdatedAt`) VALUES (?, ?, ?, ?) ON DUPLICATE KEY UPDATE `NickName` = VALUES(`NickName`), `Nation` = VALUES(`Nation`), `UpdatedAt` = VALUES(`UpdatedAt`)");
+            insertPstmt->setString(1, newPlayer.Login);
+            insertPstmt->setString(2, newPlayer.NickName);
+            insertPstmt->setString(3, newPlayer.Country);
+            insertPstmt->setString(4, Time::Current());
+            insertPstmt->executeQuery();
+        }
+        catch(sql::SQLException &e)
+        {
+            std::cout << "Failed to save database information for player '" << newPlayer.Login << "' ..." << std::endl;
+            Logging::PrintError(e.getErrorCode(), e.what());
+        }
+
+        if(insertPstmt != NULL)
+        {
+            delete insertPstmt;
+            insertPstmt = NULL;
+        }
+
+        sql::PreparedStatement* pstmt;
+        sql::ResultSet* result;
+        try
+        {
+            pstmt = database->prepareStatement("SELECT * FROM `players` WHERE `Login` = ?");
+            pstmt->setString(1, newPlayer.Login);
+            result = pstmt->executeQuery();
+            if(result->next())
+            {
+                newPlayer.SetId(result->getInt("Id"));
+            }
+        }
+        catch(sql::SQLException &e)
+        {
+            std::cout << "Failed to retrieve database information for player '" << newPlayer.Login << "' ..." << std::endl;
+            Logging::PrintError(e.getErrorCode(), e.what());
+        }
+
+        if(pstmt != NULL)
+        {
+            delete pstmt;
+            pstmt = NULL;
+        }
+
+        if(result != NULL)
+        {
+            delete result;
+            result = NULL;
+        }
+    }
+
     players->insert(std::pair<std::string, Player>(newPlayer.Login, newPlayer));
 
     std::cout << "Player connected: " << newPlayer.Login << " (# players: " << players->size() << ")" << std::endl;
 
     events->CallPlayerConnect(newPlayer);
-
-    delete params; params = NULL;
-    delete message; message = NULL;
 }
 
 void CallBackManager::HandlePlayerDisconnect(std::vector<GbxResponseParameter> parameters)
@@ -120,14 +184,25 @@ void CallBackManager::HandlePlayerDisconnect(std::vector<GbxResponseParameter> p
 
 void CallBackManager::HandlePlayerChat(std::vector<GbxResponseParameter> parameters)
 {
-    std::string playerUid = parameters.at(0).GetString();
-    std::string login = parameters.at(1).GetString();
-    std::string text = parameters.at(2).GetString();
-    bool isRegisteredCmd;
-    std::istringstream(parameters.at(3).GetString()) >> isRegisteredCmd;
+    int playerUid = atoi(parameters.at(0).GetString().c_str());
 
-    Player player = players->at(login);
-    events->CallPlayerChat(player, text, isRegisteredCmd);
+    if(playerUid != 0)
+    {
+        std::string login = parameters.at(1).GetString();
+        std::string text = parameters.at(2).GetString();
+        bool isRegisteredCmd;
+        std::istringstream(parameters.at(3).GetString()) >> isRegisteredCmd;
+
+        Player player = players->at(login);
+        if(isRegisteredCmd)
+        {
+            commands->HandleCommand(player, text);
+        }
+        else
+        {
+            events->CallPlayerChat(player, text, isRegisteredCmd);
+        }
+    }
 }
 
 void CallBackManager::HandlePlayerManialinkPageAnswer(std::vector<GbxResponseParameter> parameters)
@@ -210,15 +285,18 @@ void CallBackManager::HandleEndMatch(std::vector<GbxResponseParameter> parameter
 
 void CallBackManager::HandleBeginMap(std::vector<GbxResponseParameter> parameters)
 {
-    Map map = Map();
-    map.MapDetailed(parameters.at(0).GetStruct());
-    events->CallBeginMap(map);
+    std::map<std::string, GbxResponseParameter> mapStruct = parameters.at(0).GetStruct();
+    Map* map = &(maps->List.at(mapStruct.at("UId").GetString()));
+    map->MapDetailed(parameters.at(0).GetStruct());
+
+    maps->SetCurrentMap(mapStruct.at("UId").GetString());
+    events->CallBeginMap(*map);
 }
 
 void CallBackManager::HandleEndMap(std::vector<GbxResponseParameter> parameters)
 {
-    Map map = Map();
-    map.MapDetailed(parameters.at(0).GetStruct());
+    std::map<std::string, GbxResponseParameter> mapStruct = parameters.at(0).GetStruct();
+    Map map = maps->List.at(mapStruct.at("UId").GetString());
     events->CallEndMap(map);
 }
 
@@ -233,22 +311,23 @@ void CallBackManager::HandleStatusChanged(std::vector<GbxResponseParameter> para
 void CallBackManager::HandlePlayerCheckpoint(std::vector<GbxResponseParameter> parameters)
 {
     std::string login = parameters.at(1).GetString();
-    Player player = players->at(login);
+    Player* player = &players->at(login);
     int time = atoi(parameters.at(2).GetString().c_str());
+    player->CurrentCheckpoints.push_back(time);
     int currentLap = atoi(parameters.at(3).GetString().c_str());
     int checkpointIndex = atoi(parameters.at(4).GetString().c_str());
 
-    events->CallPlayerCheckpoint(player, time, currentLap, checkpointIndex);
+    events->CallPlayerCheckpoint(*player, time, currentLap, checkpointIndex);
 }
 
 void CallBackManager::HandlePlayerFinish(std::vector<GbxResponseParameter> parameters)
 {
     std::string login = parameters.at(1).GetString();
-    Player player = players->at(login);
+    Player* player = &players->at(login);
     int time = atoi(parameters.at(2).GetString().c_str());
 
-    if(time > 0)
-        events->CallPlayerFinish(player, time);
+    events->CallPlayerFinish(*player, time);
+    player->CurrentCheckpoints.clear();
 }
 
 void CallBackManager::HandlePlayerIncoherence(std::vector<GbxResponseParameter> parameters)
diff --git a/src/CallBacks/CallBackManager.h b/src/CallBacks/CallBackManager.h
index f6970425..a250fb5b 100644
--- a/src/CallBacks/CallBackManager.h
+++ b/src/CallBacks/CallBackManager.h
@@ -5,13 +5,22 @@
 #include <map>
 #include <vector>
 
+#include <cppconn/driver.h>
+#include <cppconn/exception.h>
+#include <cppconn/resultset.h>
+#include <cppconn/statement.h>
+#include <cppconn/prepared_statement.h>
+
+#include "../Commands/CommandManager.h"
 #include "../Events/EventManager.h"
 #include "../GbxRemote/GbxRemote.h"
 #include "../GbxRemote/Message/GbxMessage.h"
 #include "../GbxRemote/Parameters/GbxParameters.h"
+#include "../Maps/MapList.h"
 #include "../Objects/Map.h"
 #include "../Objects/Player.h"
 #include "../Utils/Logging.h"
+#include "../Utils/Time.h"
 
 //* CallBackManager
 /**
@@ -25,12 +34,14 @@ class CallBackManager
      *
      * \todo Replace pointer to GbxRemote with pointer to Methods.
      *
-     * \param serverPtr       Pointer to the GbxRemote.
-     * \param eventManagerPtr Pointer to the EventManager.
-     * \param playerList      Pointer to playerlist.
-     * \param mapList         Pointer to maplist.
+     * \param serverPtr         Pointer to the GbxRemote.
+     * \param commandManagerPtr Pointer to the CommandManager.
+     * \param eventManagerPtr   Pointer to the EventManager.
+     * \param databasePtr       Pointer to the database connection.
+     * \param playerList        Pointer to playerlist.
+     * \param mapList           Pointer to maplist.
      */
-    CallBackManager(GbxRemote* serverPtr, EventManager* eventManagerPtr, std::map<std::string, Player>* playerList, std::map<std::string, Map>* mapList);
+    CallBackManager(GbxRemote* serverPtr, CommandManager* commandManagerPtr, EventManager* eventManagerPtr, sql::Connection* databasePtr, std::map<std::string, Player>* playerList, MapList* mapList);
 
     /*!
      * \brief Handles callback (updates lists, calls plugin functions).
@@ -161,9 +172,11 @@ class CallBackManager
 
 private:
     GbxRemote* server;                      /**< \brief Contains the serverconnection. */
+    CommandManager* commands;               /**< \brief Contains the command manager. */
     EventManager* events;                   /**< \brief Contains the event manager. */
+    sql::Connection* database;              /**< \brief Contains the database connection. */
     std::map<std::string, Player>* players; /**< \brief Contains the list of players currently on the server. */
-    std::map<std::string, Map>* maps;       /**< \brief Contains the list of players currently on the server. */
+    MapList* maps;       /**< \brief Contains the list of players currently on the server. */
 };
 
 #endif // CALLBACKMANAGER_H_
diff --git a/src/Commands/CommandManager.cpp b/src/Commands/CommandManager.cpp
new file mode 100644
index 00000000..246f4f4e
--- /dev/null
+++ b/src/Commands/CommandManager.cpp
@@ -0,0 +1,78 @@
+#include "CommandManager.h"
+
+CommandManager::CommandManager()
+{
+    commands = std::map<std::string, std::function<void(Player, std::vector<std::string>)>>();
+    adminCommands = std::map<std::string, std::function<void(Player, std::vector<std::string>)>>();
+}
+
+int CommandManager::RegisterCommands(std::map<std::string, std::function<void(Player, std::vector<std::string>)>> methods)
+{
+    int functionsAdded = 0;
+    for(std::map<std::string, std::function<void(Player, std::vector<std::string>)>>::iterator method = methods.begin(); method != methods.end(); ++method)
+    {
+        if(commands.find(method->first) == commands.end())
+        {
+            commands.insert(std::pair<std::string, std::function<void(Player, std::vector<std::string>)>>(method->first, method->second));
+            functionsAdded++;
+        }
+        else
+        {
+            std::cout << "[ WARNING ] Tried to register command '" << method->first << "', which is already registered!" << std::endl;
+        }
+    }
+    return functionsAdded;
+}
+
+int CommandManager::RegisterAdminCommands(std::map<std::string, std::function<void(Player, std::vector<std::string>)>> methods)
+{
+    int functionsAdded = 0;
+    for(std::map<std::string, std::function<void(Player, std::vector<std::string>)>>::iterator method = methods.begin(); method != methods.end(); ++method)
+    {
+        if(commands.find(method->first) == commands.end())
+        {
+            adminCommands.insert(std::pair<std::string, std::function<void(Player, std::vector<std::string>)>>(method->first, method->second));
+            functionsAdded++;
+        }
+        else
+        {
+            std::cout << "[ WARNING ] Tried to register admin-command '" << method->first << "', which is already registered!" << std::endl;
+        }
+    }
+    return functionsAdded;
+}
+
+void CommandManager::HandleCommand(Player player, std::string text)
+{
+    std::stringstream ss(text);
+    std::istream_iterator<std::string> begin(ss);
+    std::istream_iterator<std::string> end;
+    std::vector<std::string> parameters(begin, end);
+    std::string command = parameters.at(0).substr(1);
+    parameters.erase(parameters.begin());
+
+    if(command.find("admin") != std::string::npos)
+    {
+        std::string adminCommand = parameters.at(0);
+        parameters.erase(parameters.begin());
+        std::cout << "'" << player.Login << "' called admin-command '" << adminCommand << "' with # parameters: " << parameters.size() << std::endl;
+
+        std::map<std::string, std::function<void(Player, std::vector<std::string>)>>::iterator commandIt = adminCommands.find(adminCommand);
+        if(commandIt != adminCommands.end())
+        {
+            std::function<void(Player, std::vector<std::string>)> commandMethod = commandIt->second;
+            commandMethod(player, parameters);
+        }
+    }
+    else
+    {
+        std::cout << "'" << player.Login << "' called command '" << command << "' with # parameters: " << parameters.size() << std::endl;
+
+        std::map<std::string, std::function<void(Player, std::vector<std::string>)>>::iterator commandIt = commands.find(command);
+        if(commandIt != commands.end())
+        {
+            std::function<void(Player, std::vector<std::string>)> commandMethod = commandIt->second;
+            commandMethod(player, parameters);
+        }
+    }
+}
diff --git a/src/Commands/CommandManager.h b/src/Commands/CommandManager.h
new file mode 100644
index 00000000..d718707a
--- /dev/null
+++ b/src/Commands/CommandManager.h
@@ -0,0 +1,49 @@
+#ifndef COMMANDMANAGER_H_
+#define COMMANDMANAGER_H_
+
+#include <string>
+#include <map>
+#include <functional>
+
+#include "../Objects/Player.h"
+
+//* CommandManager
+/**
+ * \brief Manages the chat commands.
+ */
+class CommandManager
+{
+public:
+    /*!
+     * \brief Initializes the command-maps.
+     */
+    CommandManager();
+
+    /*!
+     * \brief Registers the chat commands (from the plugins).
+     *
+     * \param methods Plugin methods with command name.
+     */
+    int RegisterCommands(std::map<std::string, std::function<void(Player, std::vector<std::string>)>> methods);
+
+    /*!
+     * \brief Registers the admin chat commands (from the plugins).
+     *
+     * \param methods Plugin methods with admin command name.
+     */
+    int RegisterAdminCommands(std::map<std::string, std::function<void(Player, std::vector<std::string>)>> methods);
+
+    /*!
+     * \brief Handles chat commands (from PlayerChat callback).
+     *
+     * \param player  Author of the command request.
+     * \param text    Chat message.
+     */
+    void HandleCommand(Player player, std::string text);
+
+private:
+    std::map<std::string, std::function<void(Player, std::vector<std::string>)>> commands;      /**< \brief Map with normal chat commands. */
+    std::map<std::string, std::function<void(Player, std::vector<std::string>)>> adminCommands; /**< \brief Map with admin chat commands. */
+};
+
+#endif // COMMANDMANAGER_H_
diff --git a/src/Config/Config.cpp b/src/Config/Config.cpp
index f1220177..dc10229d 100644
--- a/src/Config/Config.cpp
+++ b/src/Config/Config.cpp
@@ -8,8 +8,10 @@ Config::Config(std::string configFile)
 
 Config::~Config()
 {
-    delete Server;
-    Server = NULL;
+    delete Server; Server = NULL;
+    delete Database; Database = NULL;
+    delete Program; Program = NULL;
+    delete Plugins; Plugins = NULL;
 }
 
 void Config::parseConfig()
@@ -17,6 +19,9 @@ void Config::parseConfig()
     std::cout << "[         ] Loading configuration file '" << configFile << "' ... " << '\r' << std::flush;
     YAML::Node config = YAML::LoadFile(configFile);
     YAML::Node server = config["config"]["server"];
+    YAML::Node database = config["config"]["database"];
+    YAML::Node program = config["config"]["program"];
+    YAML::Node plugins = config["plugins"];
     std::cout << "[   \033[0;32mOK.\033[0;0m" << std::endl;
 
     Server = new ServerConfig();
@@ -24,4 +29,46 @@ void Config::parseConfig()
     Server->port = server["port"].as<int>();
     Server->username = server["authentication"]["username"].as<std::string>();
     Server->password = server["authentication"]["password"].as<std::string>();
+
+    Database = new DatabaseConfig();
+    Database->address = database["address"].as<std::string>();
+    Database->port = database["port"].as<int>();
+    Database->username = database["authentication"]["username"].as<std::string>();
+    Database->password = database["authentication"]["password"].as<std::string>();
+    Database->database = database["database"].as<std::string>();
+
+    Program = new ProgramConfig();
+    Program->checkVersion = program["checkVersion"].as<bool>();
+
+    parsePlugins(plugins);
+}
+
+void Config::parsePlugins(YAML::Node plugins)
+{
+    Plugins = new std::map<std::string, PluginConfig>();
+
+    for(int pluginId = 0; pluginId < plugins.size(); pluginId++)
+    {
+        PluginConfig pluginConfig = PluginConfig();
+        pluginConfig.settings = std::map<std::string, std::string>();
+
+        YAML::Node plugin = plugins[pluginId];
+        if(plugin.Type() == YAML::NodeType::Scalar)
+        {
+            pluginConfig.name = plugin.as<std::string>();
+        }
+        else
+        {
+            for (YAML::const_iterator pluginIt = plugin.begin(); pluginIt != plugin.end(); ++pluginIt)
+            {
+                pluginConfig.name = pluginIt->first.as<std::string>();
+                for (YAML::const_iterator settingIt = pluginIt->second.begin(); settingIt != pluginIt->second.end(); ++settingIt)
+                {
+                    pluginConfig.settings.insert(std::pair<std::string, std::string>(settingIt->first.as<std::string>(), settingIt->second.as<std::string>()));
+                }
+            }
+        }
+
+        Plugins->insert(std::pair<std::string, PluginConfig>(pluginConfig.name, pluginConfig));
+    }
 }
diff --git a/src/Config/Config.h b/src/Config/Config.h
index 99b4b345..c4381d69 100644
--- a/src/Config/Config.h
+++ b/src/Config/Config.h
@@ -14,10 +14,48 @@
  */
 struct ServerConfig
 {
-    std::string address;  /**< \brief Server address (either hostname or IP Address). */
-    int port;             /**< \brief Server XML-RPC port. */
-    std::string username; /**< \brief Username with which to authenticate on the server. */
-    std::string password; /**< \brief Password with which to authenticate on the server. */
+    std::string address;      /**< \brief Server address (either hostname or IP Address). */
+    int port;                 /**< \brief Server XML-RPC port. */
+    std::string username;     /**< \brief Username with which to authenticate on the server. */
+    std::string password;     /**< \brief Password with which to authenticate on the server. */
+};
+
+//* DatabaseConfig
+/**
+ * \brief Database connection settings.
+ *
+ * Editing information in this struct will not result in a change in the configuration file.
+ */
+struct DatabaseConfig
+{
+    std::string address;      /**< \brief Database address (either hostname or IP Address). */
+    int port;                 /**< \brief Database serverport. */
+    std::string username;     /**< \brief Username with which to authenticate on the database server. */
+    std::string password;     /**< \brief Password with which to authenticate on the database server. */
+    std::string database;     /**< \brief Name of the database that should be used. */
+};
+
+//* ProgramConfig
+/**
+ * \brief Program settings.
+ *
+ * Editing information in this struct will not result in a change in the configuration file.
+ */
+struct ProgramConfig
+{
+    bool checkVersion = true; /**< \brief Check for updates on start-up. */
+};
+
+//* PluginConfig
+/**
+ * \brief Plugin settings.
+ *
+ * Editing information in this struct will not result in a change in the configuration file.
+ */
+struct PluginConfig
+{
+    std::string name;                            /**< \brief Plugin name (directory name). */
+    std::map<std::string, std::string> settings; /**< \brief Plugin settings. */
 };
 
 //* Config
@@ -39,7 +77,10 @@ class Config
      */
     ~Config();
 
-    ServerConfig* Server; /**< \brief Instance of ServerConfig which stores the server connection settings. */
+    ServerConfig* Server;               /**< \brief Instance of ServerConfig which stores the server connection settings. */
+    DatabaseConfig* Database;           /**< \brief Instance of DatabaseConfig which stores the database server connection settings. */
+    ProgramConfig* Program;             /**< \brief Instance of ProgramConfig which stores program settings. */
+    std::map<std::string, PluginConfig>* Plugins; /**< \brief List of plugin configurations. */
 
 private:
     /*!
@@ -47,6 +88,13 @@ class Config
      */
     void parseConfig();
 
+    /*!
+     * \brief Reads plugin information from YAML file.
+     *
+     * \param plugins YAML node that contains the plugin information.
+     */
+    void parsePlugins(YAML::Node plugins);
+
     std::string configFile; /**< \brief Name of the configuration file, set by constructor. */
 };
 
diff --git a/src/Database/Database.cpp b/src/Database/Database.cpp
new file mode 100644
index 00000000..817af880
--- /dev/null
+++ b/src/Database/Database.cpp
@@ -0,0 +1,29 @@
+#include "Database.h"
+
+Database::Database(std::string serverAddress, int serverPort)
+{
+    address = serverAddress;
+    port = serverPort;
+}
+
+Database::~Database()
+{
+    if(Driver != NULL)
+    {
+        Driver->threadEnd();
+        Driver = NULL;
+    }
+}
+
+sql::Connection* Database::Connect(std::string username, std::string password, std::string database)
+{
+    std::stringstream host;
+    host << "tcp://" << address << ":" << port;
+
+    Driver = get_driver_instance();
+    Connection = Driver->connect(host.str(), username, password);
+
+    Connection->setSchema(database);
+
+    return Connection;
+}
diff --git a/src/Database/Database.h b/src/Database/Database.h
new file mode 100644
index 00000000..3754cd14
--- /dev/null
+++ b/src/Database/Database.h
@@ -0,0 +1,50 @@
+#ifndef DATABASE_H_
+#define DATABASE_H_
+
+#include <string>
+#include <sstream>
+
+#include "mysql_connection.h"
+#include <cppconn/driver.h>
+#include <cppconn/exception.h>
+#include <cppconn/resultset.h>
+#include <cppconn/statement.h>
+
+//* Database
+/**
+ * \brief Handles the connection to the database.
+ */
+class Database
+{
+public:
+    /*!
+     * \brief Sets a few settings.
+     *
+     * \param serverAddress IP Address of the database server.
+     * \param serverPort    Port of the database server.
+     */
+    Database(std::string serverAddress, int serverPort = 3306);
+
+    /*!
+     * Deconstructor closes driver thread.
+     */
+    ~Database();
+
+    /*!
+     * \brief Connects to the database.
+     *
+     * \param username      Database user name.
+     * \param password      Database user password.
+     * \param database      Database name.
+     */
+    sql::Connection* Connect(std::string username, std::string password, std::string database);
+
+    sql::Driver* Driver;         /**< \brief Database server driver. */
+    sql::Connection* Connection; /**< \brief Database server driver. */
+
+private:
+    std::string address;         /**< \brief IP Address of the database server. */
+    int port;                    /**< \brief Port of the database server. */
+};
+
+#endif // DATABASE_H_
diff --git a/src/Events/EventManager.cpp b/src/Events/EventManager.cpp
index 450a167c..feee6e56 100644
--- a/src/Events/EventManager.cpp
+++ b/src/Events/EventManager.cpp
@@ -4,7 +4,7 @@ EventManager::EventManager()
 {
     methodsPlayerConnect = std::vector<std::function<void(Player)>>();
     methodsPlayerDisconnect = std::vector<std::function<void(Player)>>();
-    methodsPlayerChat = std::vector<std::function<void(Player, std::string, bool)>>();
+    methodsPlayerChat = std::vector<std::function<void(Player, std::string)>>();
     methodsPlayerManialinkPageAnswer = std::vector<std::function<void(Player, std::string, std::vector<EntryVal>)>>();
     methodsEcho = std::vector<std::function<void(std::string, std::string)>> ();
     methodsBeginMatch = std::vector<std::function<void()>>();
@@ -43,7 +43,7 @@ int EventManager::RegisterPlayerDisconnect(std::vector<std::function<void(Player
     return functionsAdded;
 }
 
-int EventManager::RegisterPlayerChat(std::vector<std::function<void(Player, std::string, bool)>> functions)
+int EventManager::RegisterPlayerChat(std::vector<std::function<void(Player, std::string)>> functions)
 {
     int functionsAdded = 0;
     for(int functionId = 0; functionId < functions.size(); functionId++)
@@ -230,8 +230,8 @@ void EventManager::CallPlayerChat(Player player, std::string text, bool isRegist
 {
     for(int methodId = 0; methodId < methodsPlayerChat.size(); methodId++)
     {
-        std::function<void(Player, std::string, bool)> method = methodsPlayerChat.at(methodId);
-        method(player, text, isRegisteredCommand);
+        std::function<void(Player, std::string)> method = methodsPlayerChat.at(methodId);
+        method(player, text);
     }
 }
 
diff --git a/src/Events/EventManager.h b/src/Events/EventManager.h
index dea38afa..2f1c34c5 100644
--- a/src/Events/EventManager.h
+++ b/src/Events/EventManager.h
@@ -45,7 +45,7 @@ class EventManager
      *
      * \param functions Vector with functions to be added.
      */
-    int RegisterPlayerChat(std::vector<std::function<void(Player, std::string, bool)>> functions);
+    int RegisterPlayerChat(std::vector<std::function<void(Player, std::string)>> functions);
 
     /*!
      * \brief Register functions for the PlayerManialinkPageAnswer callback.
@@ -312,7 +312,7 @@ class EventManager
 private:
     std::vector<std::function<void(Player)>> methodsPlayerConnect;                     /**< \brief Vector with functions for the PlayerConnect event. */
     std::vector<std::function<void(Player)>> methodsPlayerDisconnect;                  /**< \brief Vector with functions for the PlayerDisconnect event. */
-    std::vector<std::function<void(Player, std::string, bool)>> methodsPlayerChat;     /**< \brief Vector with functions for the PlayerChat event. */
+    std::vector<std::function<void(Player, std::string)>> methodsPlayerChat;           /**< \brief Vector with functions for the PlayerChat event. */
     std::vector<std::function<void(Player, std::string, std::vector<EntryVal>)>> methodsPlayerManialinkPageAnswer; /**< \brief Vector with functions for the PlayerManialinkPageAnswer event. */
     std::vector<std::function<void(std::string, std::string)>> methodsEcho;            /**< \brief Vector with functions for the Echo event. */
     std::vector<std::function<void()>> methodsBeginMatch;                              /**< \brief Vector with functions for the BeginMatch event. */
diff --git a/src/GbxRemote/GbxRemote.cpp b/src/GbxRemote/GbxRemote.cpp
index 150c8f92..daf02c03 100644
--- a/src/GbxRemote/GbxRemote.cpp
+++ b/src/GbxRemote/GbxRemote.cpp
@@ -4,9 +4,6 @@ GbxRemote::~GbxRemote()
 {
     Terminate();
 
-    delete currentError;
-    currentError = NULL;
-
     delete currentResponse;
     currentResponse = NULL;
 }
@@ -27,18 +24,18 @@ bool GbxRemote::InitWithIp(std::string address, int port)
         int size = (int)response->size;
         if(size > 64)
         {
-            currentError->number = -32300;
+            currentError.number = -32300;
             std::stringstream messageStream;
             messageStream << "transport error - wrong lowlevel protocol header (" << size << ")";
-            currentError->message = messageStream.str();
+            currentError.message = messageStream.str();
             return false;
         }
 
         std::string protocolRes = server.Receive(size);
         if(protocolRes.find("GBXRemote 1") != std::string::npos)
         {
-            currentError->number = -32300;
-            currentError->message = "transport error - old version of trackmania server detected";
+            currentError.number = -32300;
+            currentError.message = "transport error - old version of trackmania server detected";
             return false;
         }
         else if(protocolRes.find("GBXRemote 2") != std::string::npos)
@@ -47,10 +44,10 @@ bool GbxRemote::InitWithIp(std::string address, int port)
         }
         else
         {
-            currentError->number = -32300;
+            currentError.number = -32300;
             std::stringstream messageStream;
             messageStream << "transport error - wrong lowlevel protocol version (" << protocolRes << ")";
-            currentError->message = messageStream.str();
+            currentError.message = messageStream.str();
             return false;
         }
 
@@ -59,8 +56,8 @@ bool GbxRemote::InitWithIp(std::string address, int port)
     }
     else
     {
-        currentError->number = -10;
-        currentError->message = "connection error - could not establish connection";
+        currentError.number = -10;
+        currentError.message = "connection error - could not establish connection";
         return false;
     }
 }
@@ -72,21 +69,23 @@ void GbxRemote::Terminate()
     connected = false;
 }
 
-bool GbxRemote::Query(GbxMessage* query)
+bool GbxRemote::Query(GbxMessage query)
 {
-    delete currentError;
-    delete currentResponse;
+    if(currentResponse != NULL)
+    {
+        delete currentResponse; currentResponse = NULL;
+    }
 
     if(!connected)
         return false;
 
-    currentError = new GbxError();
+    currentError = GbxError();
     currentResponse = new GbxResponse();
 
-    if(!server.Send(query->GetXml()))
+    if(!server.Send(query.GetXml()))
     {
-        currentError->number = -32300;
-        currentError->message = "transport error - connection interrupted!";
+        currentError.number = -32300;
+        currentError.message = "transport error - connection interrupted!";
         return false;
     }
 
@@ -97,10 +96,10 @@ bool GbxRemote::Query(GbxMessage* query)
 
         if(message->size > (4096*1024))
         {
-            currentError->number = -32300;
+            currentError.number = -32300;
             std::stringstream errorMessage;
             errorMessage << "transport error - response too large " << message->size;
-            currentError->message = errorMessage.str();
+            currentError.message = errorMessage.str();
             return false;
         }
 
@@ -115,7 +114,7 @@ bool GbxRemote::Query(GbxMessage* query)
             }
 
             currentResponse->SetRaw(rawResponse);
-            if(currentResponse->GetFault() != NULL)
+            if(currentResponse->GetFault().number != 0)
             {
                 currentError = currentResponse->GetFault();
                 return false;
@@ -143,10 +142,10 @@ bool GbxRemote::ReadCallBacks()
 
         if(size > (4096*1024))
         {
-            currentError->number = -32300;
+            currentError.number = -32300;
             std::stringstream errorMessage;
             errorMessage << "transport error - response too large " << size;
-            currentError->message = errorMessage.str();
+            currentError.message = errorMessage.str();
             return false;
         }
 
@@ -181,13 +180,8 @@ void GbxRemote::ResetCBResponses()
     currentCallBacks = std::vector<GbxCallBack>();
 }
 
-GbxError* GbxRemote::GetCurrentError()
+GbxError GbxRemote::GetCurrentError()
 {
-    if(currentError->number == 0)
-    {
-        return NULL;
-    }
-
     return currentError;
 }
 
diff --git a/src/GbxRemote/GbxRemote.h b/src/GbxRemote/GbxRemote.h
index 85102b94..99261a99 100644
--- a/src/GbxRemote/GbxRemote.h
+++ b/src/GbxRemote/GbxRemote.h
@@ -52,7 +52,7 @@ class GbxRemote
      *
      * \param query    Query to be send.
      */
-    bool Query(GbxMessage* query);
+    bool Query(GbxMessage query);
 
     /*!
      * \brief Read callbacks from the server.
@@ -86,9 +86,9 @@ class GbxRemote
     /*!
      * \brief Returns the current server error.
      *
-     * Returns NULL when there currently is no error.
+     * Returns empty GbxError when there currently is no error.
      */
-    GbxError* GetCurrentError();
+    GbxError GetCurrentError();
 
     /*!
      * \brief Returns the current version number of the server protocol (1 or 2).
@@ -107,7 +107,7 @@ class GbxRemote
     std::string apiVersion;                         /**< \brief Server API version. */
     TcpClient server;                               /**< \brief Socket connection with the server. */
 
-    GbxError* currentError = new GbxError;          /**< \brief Current server error. */
+    GbxError currentError = GbxError();          /**< \brief Current server error. */
     GbxResponse* currentResponse = new GbxResponse; /**< \brief Current server response. */
     std::vector<GbxCallBack> currentCallBacks = std::vector<GbxCallBack>(); /**< \brief List of currently received callbacks. */
 };
diff --git a/src/GbxRemote/GbxStructs.h b/src/GbxRemote/GbxStructs.h
index e52d0c62..325b791a 100644
--- a/src/GbxRemote/GbxStructs.h
+++ b/src/GbxRemote/GbxStructs.h
@@ -26,8 +26,8 @@ struct GbxQueryResponse
  */
 struct GbxError
 {
-    int number = 0;       /**< \brief Number of the error (default: 0, no error). */
-    std::string message;  /**< \brief Error message. */
+    int number = 0;            /**< \brief Number of the error (default: 0, no error). */
+    std::string message = "";  /**< \brief Error message. */
 };
 
 #endif // GBXSTRUCTS_H_
diff --git a/src/GbxRemote/Message/GbxMessage.cpp b/src/GbxRemote/Message/GbxMessage.cpp
index dd60b7ed..58e11b01 100644
--- a/src/GbxRemote/Message/GbxMessage.cpp
+++ b/src/GbxRemote/Message/GbxMessage.cpp
@@ -1,23 +1,18 @@
 #include "GbxMessage.h"
 
-GbxMessage::GbxMessage(std::string methodName, GbxParameters* parameters)
+GbxMessage::GbxMessage(std::string methodName, GbxParameters parameters)
     : method(methodName)
 {
     xml  = "<?xml version=\"1.0\" encoding=\"utf-8\" ?>";
     xml += "<methodCall>";
     xml += "<methodName>" + method + "</methodName>";
     xml += "<params>";
-    if(parameters != NULL)
+    for(int paramId = 0; paramId < parameters.GetParameters().size(); paramId++)
     {
-        for(int paramId = 0; paramId < parameters->GetParameters()->size(); paramId++)
-        {
-            xml += "<param><value>";
-            GbxParameter* param = new GbxParameter(parameters->GetParameters()->at(paramId));
-            xml += param->GetXml();
-            xml += "</value></param>";
-
-            delete param; param = NULL;
-        }
+        xml += "<param><value>";
+        GbxParameter param = GbxParameter(parameters.GetParameters().at(paramId));
+        xml += param.GetXml();
+        xml += "</value></param>";
     }
     xml += "</params>";
     xml += "</methodCall>";
diff --git a/src/GbxRemote/Message/GbxMessage.h b/src/GbxRemote/Message/GbxMessage.h
index 7145c081..035c74c3 100644
--- a/src/GbxRemote/Message/GbxMessage.h
+++ b/src/GbxRemote/Message/GbxMessage.h
@@ -20,7 +20,7 @@ class GbxMessage
      * \param methodName Server method name.
      * \param parameters Params which belong to the method.
      */
-    GbxMessage(std::string methodName, GbxParameters* parameters = NULL);
+    GbxMessage(std::string methodName, GbxParameters parameters = GbxParameters());
 
     /*!
      * \brief Returns the method name.
diff --git a/src/GbxRemote/Parameters/GbxParameter.cpp b/src/GbxRemote/Parameters/GbxParameter.cpp
index ba4fa958..3969c8dd 100644
--- a/src/GbxRemote/Parameters/GbxParameter.cpp
+++ b/src/GbxRemote/Parameters/GbxParameter.cpp
@@ -22,7 +22,11 @@ void GbxParameter::determineType(const std::type_info* param)
     char* realParamName = abi::__cxa_demangle(param->name(), 0, 0, &status);
     type = std::string(realParamName);
 
-    if(type.find("GbxParameters*") != std::string::npos)
+    if(type.find("GbxStructParameters") != std::string::npos)
+    {
+        xmlType = "struct";
+    }
+    else if(type.find("GbxParameters") != std::string::npos)
     {
         xmlType = "array";
     }
@@ -58,17 +62,30 @@ void GbxParameter::determineType(const std::type_info* param)
 
 void GbxParameter::dereferenceData(void* pointer)
 {
-    if(type.find("GbxParameters*") != std::string::npos)
+    if(type.find("GbxStructParameters") != std::string::npos)
+    {
+        GbxStructParameters* paramPtr = static_cast<GbxStructParameters*>(pointer);
+        GbxStructParameters parameters = *paramPtr;
+        std::vector<std::string> gbxParams = parameters.GetParameters();
+
+        for(int paramId = 0; paramId < gbxParams.size(); paramId++)
+        {
+            if(paramId > 0) data += "</struct></value><value><struct>";
+            data += gbxParams.at(paramId);
+        }
+    }
+    else if(type.find("GbxParameters") != std::string::npos)
     {
         data += "<data>";
-        GbxParameters** paramPtr = static_cast<GbxParameters**>(pointer);
-        GbxParameters* parameters = *paramPtr;
-        std::vector<GbxParam>* gbxParams = parameters->GetParameters();
-        for(int paramId = 0; paramId < gbxParams->size(); paramId++)
+        GbxParameters* paramPtr = static_cast<GbxParameters*>(pointer);
+        GbxParameters parameters = *paramPtr;
+        std::vector<GbxParam> gbxParams = parameters.GetParameters();
+
+        for(int paramId = 0; paramId < gbxParams.size(); paramId++)
         {
             data += "<value>";
-            GbxParameter* param = new GbxParameter(gbxParams->at(paramId));
-            data += param->GetXml();
+            GbxParameter param = GbxParameter(gbxParams.at(paramId));
+            data += param.GetXml();
             data += "</value>";
         }
         data += "</data>";
diff --git a/src/GbxRemote/Parameters/GbxParameter.h b/src/GbxRemote/Parameters/GbxParameter.h
index df837e08..e5578c82 100644
--- a/src/GbxRemote/Parameters/GbxParameter.h
+++ b/src/GbxRemote/Parameters/GbxParameter.h
@@ -10,6 +10,8 @@
 //* GbxParameter
 /**
  * \brief XML-fies the parameter for communication with the server.
+ *
+ * \todo Handle structs.
  */
 class GbxParameter
 {
diff --git a/src/GbxRemote/Parameters/GbxParameters.h b/src/GbxRemote/Parameters/GbxParameters.h
index 5dadcf5e..0b852ac4 100644
--- a/src/GbxRemote/Parameters/GbxParameters.h
+++ b/src/GbxRemote/Parameters/GbxParameters.h
@@ -3,6 +3,7 @@
 
 #include <string>
 #include <vector>
+#include <map>
 #include <typeinfo>
 
 //* GbxParam
@@ -15,22 +16,42 @@ struct GbxParam
     const std::type_info* typeinfo; /**< \brief Type information of the parameter. */
 };
 
-//* GbxParameters
+//* GbxStructParameters
 /**
- * \brief List of parameters.
+ * \brief List of struct parameters.
  */
-class GbxParameters
+class GbxStructParameters
 {
 public:
     /*!
-     * \brief Deletes + nullifies parameters pointer.
+     * \brief Add parameter to the list.
+     *
+     * \param text Parameter XML.
+     */
+    void Put(std::string text)
+    {
+        parameters.push_back(text);
+    }
+
+    /*!
+     * \brief Return the current list of parameters.
      */
-    ~GbxParameters()
+    std::vector<std::string> GetParameters()
     {
-        delete parameters;
-        parameters = NULL;
+        return parameters;
     }
 
+private:
+    std::vector<std::string> parameters = std::vector<std::string>(); /**< \brief List of parameters. */
+};
+
+//* GbxParameters
+/**
+ * \brief List of parameters.
+ */
+class GbxParameters
+{
+public:
     /*!
      * \brief Add parameter to the list.
      *
@@ -40,19 +61,19 @@ class GbxParameters
     void Put(T* pointer)
     {
         GbxParam paramStruct = { pointer, &typeid(T) };
-        parameters->push_back(paramStruct);
+        parameters.push_back(paramStruct);
     }
 
     /*!
      * \brief Return the current list of parameters.
      */
-    std::vector<GbxParam>* GetParameters()
+    std::vector<GbxParam> GetParameters()
     {
         return parameters;
     }
 
 private:
-    std::vector<GbxParam>* parameters = new std::vector<GbxParam>(); /**< \brief List of parameters. */
+    std::vector<GbxParam> parameters = std::vector<GbxParam>(); /**< \brief List of parameters. */
 };
 
 #endif // GBXPARAMETERS_H_
diff --git a/src/GbxRemote/Response/GbxResponse.cpp b/src/GbxRemote/Response/GbxResponse.cpp
index cfc141ce..2147cb31 100644
--- a/src/GbxRemote/Response/GbxResponse.cpp
+++ b/src/GbxRemote/Response/GbxResponse.cpp
@@ -5,17 +5,11 @@
 
 GbxResponse::~GbxResponse()
 {
-    delete fault;
-    fault = NULL;
+
 }
 
-GbxError* GbxResponse::GetFault()
+GbxError GbxResponse::GetFault()
 {
-    if(fault->number == 0)
-    {
-        return NULL;
-    }
-
     return fault;
 }
 
@@ -61,11 +55,11 @@ void GbxResponse::extractParameters()
 
             if(std::string(name.child_value()).find("faultCode") != std::string::npos)
             {
-                fault->number = atoi(value.child_value());
+                fault.number = atoi(value.child_value());
             }
             else if(std::string(name.child_value()).find("faultString") != std::string::npos)
             {
-                fault->message = value.child_value();
+                fault.message = value.child_value();
             }
         }
 
diff --git a/src/GbxRemote/Response/GbxResponse.h b/src/GbxRemote/Response/GbxResponse.h
index 1fba28cc..8b25ab57 100644
--- a/src/GbxRemote/Response/GbxResponse.h
+++ b/src/GbxRemote/Response/GbxResponse.h
@@ -11,11 +11,11 @@ class GbxResponse : public GbxServerResponse
 {
 public:
     ~GbxResponse();
-    
+
     /*!
      * Returns whether the response is a fault.
      */
-    GbxError* GetFault();
+    GbxError GetFault();
 
     /*!
      * \brief Sets the raw message value.
@@ -25,7 +25,7 @@ class GbxResponse : public GbxServerResponse
     void SetRaw(std::string response);
 
 private:
-    GbxError* fault = new GbxError; /**< \brief Current fault (error). */
+    GbxError fault = GbxError(); /**< \brief Current fault (error). */
 
     /*!
      * \brief Extracts parameters from the raw data (XML).
diff --git a/src/ManiaPP.cpp b/src/ManiaPP.cpp
index 4472ebfa..46282cd7 100644
--- a/src/ManiaPP.cpp
+++ b/src/ManiaPP.cpp
@@ -5,16 +5,22 @@ ManiaPP::ManiaPP()
     std::cout << "## Running Mania++ v" << VERSION << " #####################################################" << std::endl;
 
     config = new Config("config.yaml");
+
+    if(config->Program->checkVersion)
+    {
+        VersionChecker versionChecker = VersionChecker();
+        versionChecker.CheckForUpdates("TheMaximum/mania-pp", VERSION);
+    }
+
     logging = new Logging();
     server = new GbxRemote();
-    methods = new Methods(server);
     players = new std::map<std::string, Player>();
-    maps = new std::map<std::string, Map>();
-
+    maps = new MapList();
     events = new EventManager();
-    plugins = new PluginManager(logging, methods, players, maps);
-    plugins->SetEventManager(events);
-    callbacks = new CallBackManager(server, events, players, maps);
+    commands = new CommandManager();
+
+    methods = new Methods(server, players);
+    ui = new UIManager(methods, events, players);
 }
 
 ManiaPP::~ManiaPP()
@@ -27,8 +33,18 @@ ManiaPP::~ManiaPP()
 
     delete plugins; plugins = NULL;
     delete events; events = NULL;
+    delete commands; commands = NULL;
     delete callbacks; callbacks = NULL;
     delete methods; methods = NULL;
+
+    delete ui; ui = NULL;
+
+    if(database != NULL)
+    {
+        database->close();
+        delete database; database = NULL;
+    }
+    delete db; db = NULL;
 }
 
 bool ManiaPP::ConnectToServer()
@@ -73,22 +89,37 @@ bool ManiaPP::ConnectToServer()
 
                             std::cout << "[   \033[0;32mOK.\033[0;0m   ] Retrieved system info, server login: '" << systemInfo.ServerLogin << "'." << std::endl;
 
-                            methods->GetChatLines();
-
-                            retrievePlayerList();
-                            retrieveMapList();
+                            methods->SendHideManialinkPage();
 
                             std::cout << "[         ] Enabling CallBacks ... " << '\r' << std::flush;
                             if(methods->EnableCallbacks(true))
                             {
                                 logging->PrintOKFlush();
 
-                                plugins->LoadPlugins();
-                                plugins->InitializePlugins();
+                                if(ConnectToDatabase())
+                                {
+                                    retrievePlayerList();
+                                    retrieveMapList();
+
+                                    Map currentMap = methods->GetCurrentMapInfo();
+                                    maps->SetCurrentMap(currentMap.UId);
+                                    maps->Current->CopyDetailedMap(currentMap);
+
+                                    plugins = new PluginManager(config, methods, commands, players, maps, database, ui);
+                                    plugins->SetEventManager(events);
+                                    callbacks = new CallBackManager(server, commands, events, database, players, maps);
 
-                                PrintServerInfo();
+                                    plugins->LoadPlugins();
+                                    plugins->InitializePlugins();
 
-                                return true;
+                                    PrintServerInfo();
+
+                                    return true;
+                                }
+                                else
+                                {
+                                    return false;
+                                }
                             }
                         }
                     }
@@ -103,6 +134,31 @@ bool ManiaPP::ConnectToServer()
     return false;
 }
 
+bool ManiaPP::ConnectToDatabase()
+{
+    std::cout << "[         ] Connecting to the database on '" << config->Database->address << ":" << config->Database->port << "' ... " << '\r' << std::flush;
+    try
+    {
+        db = new Database(config->Database->address, config->Database->port);
+        sql::Connection* dbConnection = db->Connect(config->Database->username, config->Database->password, config->Database->database);
+        if(dbConnection != NULL)
+        {
+            logging->PrintOKFlush();
+            database = dbConnection;
+            return true;
+        }
+    }
+    catch(sql::SQLException &e)
+    {
+        logging->PrintFailedFlush();
+        logging->PrintError(e.getErrorCode(), e.what());
+        return false;
+    }
+
+    logging->PrintFailedFlush();
+    return false;
+}
+
 void ManiaPP::PrintServerInfo()
 {
     std::cout << "###############################################################################" << std::endl;
@@ -138,16 +194,14 @@ void ManiaPP::MainLoop()
 void ManiaPP::retrievePlayerList()
 {
     std::cout << "[         ] Retrieving current player list ... " << '\r' << std::flush;
+
     int playerListLimit = 512; int playerListIndex = 0;
-    GbxParameters* params = new GbxParameters();
-    params->Put(&playerListLimit);
-    params->Put(&playerListIndex);
-    GbxMessage* getPlayerList = new GbxMessage("GetPlayerList", params);
+    GbxParameters params = GbxParameters();
+    params.Put(&playerListLimit);
+    params.Put(&playerListIndex);
+    GbxMessage getPlayerList = GbxMessage("GetPlayerList", params);
     if(server->Query(getPlayerList))
     {
-        delete getPlayerList; getPlayerList = NULL;
-        delete params; params = NULL;
-
         std::vector<GbxResponseParameter> responseParams = server->GetResponse()->GetParameters();
         std::vector<GbxResponseParameter> playerList = responseParams.at(0).GetArray();
 
@@ -156,7 +210,70 @@ void ManiaPP::retrievePlayerList()
             std::map<std::string, GbxResponseParameter> player = playerList.at(playerId).GetStruct();
             if(player.find("Login")->second.GetString() != systemInfo.ServerLogin)
             {
+                GbxParameters params = GbxParameters();
+                std::string login = player.find("Login")->second.GetString();
+                params.Put(&(login));
+
+                GbxMessage message = GbxMessage("GetDetailedPlayerInfo", params);
+                server->Query(message);
                 Player newPlayer = Player(player);
+                newPlayer.PlayerDetailed(server->GetResponse()->GetParameters().at(0).GetStruct());
+
+                if(database != NULL)
+                {
+                    sql::PreparedStatement* insertPstmt;
+                    try
+                    {
+                        insertPstmt = database->prepareStatement("INSERT INTO `players` (`Login`, `NickName`, `Nation`, `UpdatedAt`) VALUES (?, ?, ?, ?) ON DUPLICATE KEY UPDATE `NickName` = VALUES(`NickName`), `Nation` = VALUES(`Nation`), `UpdatedAt` = VALUES(`UpdatedAt`)");
+                        insertPstmt->setString(1, newPlayer.Login);
+                        insertPstmt->setString(2, newPlayer.NickName);
+                        insertPstmt->setString(3, newPlayer.Country);
+                        insertPstmt->setString(4, Time::Current());
+                        insertPstmt->executeQuery();
+                    }
+                    catch(sql::SQLException &e)
+                    {
+                        std::cout << "Failed to save database information for player '" << newPlayer.Login << "' ..." << std::endl;
+                        Logging::PrintError(e.getErrorCode(), e.what());
+                    }
+
+                    if(insertPstmt != NULL)
+                    {
+                        delete insertPstmt;
+                        insertPstmt = NULL;
+                    }
+
+                    sql::PreparedStatement* pstmt;
+                    sql::ResultSet* result;
+                    try
+                    {
+                        pstmt = database->prepareStatement("SELECT * FROM `players` WHERE `Login` = ?");
+                        pstmt->setString(1, newPlayer.Login);
+                        result = pstmt->executeQuery();
+                        if(result->next())
+                        {
+                            newPlayer.SetId(result->getInt("Id"));
+                        }
+                    }
+                    catch(sql::SQLException &e)
+                    {
+                        std::cout << "Failed to retrieve database information for player '" << newPlayer.Login << "' ..." << std::endl;
+                        Logging::PrintError(e.getErrorCode(), e.what());
+                    }
+
+                    if(pstmt != NULL)
+                    {
+                        delete pstmt;
+                        pstmt = NULL;
+                    }
+
+                    if(result != NULL)
+                    {
+                        delete result;
+                        result = NULL;
+                    }
+                }
+
                 players->insert(std::pair<std::string, Player>(newPlayer.Login, newPlayer));
             }
         }
@@ -174,27 +291,72 @@ void ManiaPP::retrieveMapList()
 {
     std::cout << "[         ] Retrieving current map list ... " << '\r' << std::flush;
 
-    int mapListLimit = 2048; int mapListIndex = 0;
-    GbxParameters* params = new GbxParameters();
-    params->Put(&mapListLimit);
-    params->Put(&mapListIndex);
-    GbxMessage* getMapList = new GbxMessage("GetMapList", params);
-    if(server->Query(getMapList))
+    std::vector<Map> list = methods->GetMapList(2048, 0);
+    if(list.size() > 0)
     {
-        delete getMapList; getMapList = NULL;
-        delete params; params = NULL;
+        for(int mapId = 0; mapId < list.size(); mapId++)
+        {
+            Map newMap = list.at(mapId);
 
-        std::vector<GbxResponseParameter> responseParams = server->GetResponse()->GetParameters();
-        std::vector<GbxResponseParameter> mapList = responseParams.at(0).GetArray();
+            if(database != NULL)
+            {
+                sql::PreparedStatement* insertPstmt;
+                try
+                {
+                    insertPstmt = database->prepareStatement("INSERT IGNORE INTO `maps` (`Uid`, `Name`, `Author`, `Environment`) VALUES (?, ?, ?, ?)");
+                    insertPstmt->setString(1, newMap.UId);
+                    insertPstmt->setString(2, newMap.Name);
+                    insertPstmt->setString(3, newMap.Author);
+                    insertPstmt->setString(4, newMap.Environment);
+                    insertPstmt->executeQuery();
+                }
+                catch(sql::SQLException &e)
+                {
+                    std::cout << "Failed to save database information for map '" << newMap.Name << "' ..." << std::endl;
+                    Logging::PrintError(e.getErrorCode(), e.what());
+                }
 
-        for(int mapId = 0; mapId < mapList.size(); mapId++)
-        {
-            std::map<std::string, GbxResponseParameter> map = mapList.at(mapId).GetStruct();
-            Map newMap = Map(map);
-            maps->insert(std::pair<std::string, Map>(newMap.UId, newMap));
+                if(insertPstmt != NULL)
+                {
+                    delete insertPstmt;
+                    insertPstmt = NULL;
+                }
+
+                sql::PreparedStatement* pstmt;
+                sql::ResultSet* result;
+                try
+                {
+                    pstmt = database->prepareStatement("SELECT * FROM `maps` WHERE `UId` = ?");
+                    pstmt->setString(1, newMap.UId);
+                    result = pstmt->executeQuery();
+                    if(result->next())
+                    {
+                        newMap.SetId(result->getInt("Id"));
+                    }
+                }
+                catch(sql::SQLException &e)
+                {
+                    std::cout << "Failed to retrieve database information for map '" << newMap.Name << "' ..." << std::endl;
+                    Logging::PrintError(e.getErrorCode(), e.what());
+                }
+
+                if(pstmt != NULL)
+                {
+                    delete pstmt;
+                    pstmt = NULL;
+                }
+
+                if(result != NULL)
+                {
+                    delete result;
+                    result = NULL;
+                }
+            }
+
+            maps->List.insert(std::pair<std::string, Map>(newMap.UId, newMap));
         }
 
-        std::cout << "[   \033[0;32mOK.\033[0;0m   ] Retrieved current map list: " << maps->size() << " found." << std::endl;
+        std::cout << "[   \033[0;32mOK.\033[0;0m   ] Retrieved current map list: " << maps->List.size() << " found." << std::endl;
     }
     else
     {
diff --git a/src/ManiaPP.h b/src/ManiaPP.h
index c7012765..4b8f08ab 100644
--- a/src/ManiaPP.h
+++ b/src/ManiaPP.h
@@ -6,13 +6,19 @@
 #include "CallBacks/CallBackManager.h"
 #include "Config/Version.h"
 #include "Config/Config.h"
+#include "Commands/CommandManager.h"
+#include "Database/Database.h"
 #include "Events/EventManager.h"
 #include "GbxRemote/GbxRemote.h"
+#include "Maps/MapList.h"
 #include "Methods/Methods.h"
 #include "Objects/Map.h"
 #include "Objects/Player.h"
 #include "Plugins/PluginManager.h"
+#include "UI/UIManager.h"
 #include "Utils/Logging.h"
+#include "Utils/Time.h"
+#include "Version/VersionChecker.h"
 
 //* ManiaPP
 /**
@@ -36,6 +42,11 @@ class ManiaPP
      */
     bool ConnectToServer();
 
+    /*!
+     * \brief Connects and authenticates with the database server.
+     */
+    bool ConnectToDatabase();
+
     /*!
      * \brief Prints information about the server.
      */
@@ -56,23 +67,32 @@ class ManiaPP
     Logging* logging;                       /**< \brief Contains functions to log information. */
     GbxRemote* server;                      /**< \brief Contains the connection with the server and its methods. */
     std::map<std::string, Player>* players; /**< \brief Contains the list of players currently on the server. */
-    std::map<std::string, Map>* maps;       /**< \brief Contains the list of players currently on the server. */
+    MapList* maps;                          /**< \brief Contains the list of maps on the server. */
 
     EventManager* events;                   /**< \brief Contains the event manager. */
     PluginManager* plugins;                 /**< \brief Contains the plugin manager. */
     CallBackManager* callbacks;             /**< \brief Contains the callback manager. */
+    CommandManager* commands;               /**< \brief Contains the command manager. */
     Methods* methods;                       /**< \brief Server method caller. */
+    UIManager* ui;                          /**< \brief UI manager (ManiaLink). */
+
+    Database* db = NULL;                    /**< \brief Contains database connection and driver (needed on destruction). */
+    sql::Connection* database = NULL;       /**< \brief Contains database driver. */
 
     ServerVersion serverVersion;            /**< \brief Struct with server version information. */
     SystemInfo systemInfo;                  /**< \brief Struct with system information. */
 
     /*!
      * \brief Gets a list of current players from the server.
+     *
+     * \todo Insert player into database if needed.
      */
     void retrievePlayerList();
 
     /*!
      * \brief Gets a list of current maps from the server.
+     *
+     * \todo Insert map into database if needed.
      */
     void retrieveMapList();
 };
diff --git a/src/Maps/MapList.cpp b/src/Maps/MapList.cpp
new file mode 100644
index 00000000..6ba0d9bc
--- /dev/null
+++ b/src/Maps/MapList.cpp
@@ -0,0 +1,7 @@
+#include "MapList.h"
+
+void MapList::SetCurrentMap(std::string uid)
+{
+    Map* map = &(List.at(uid));
+    Current = map;
+}
diff --git a/src/Maps/MapList.h b/src/Maps/MapList.h
new file mode 100644
index 00000000..1aa578da
--- /dev/null
+++ b/src/Maps/MapList.h
@@ -0,0 +1,24 @@
+#ifndef MAPLIST_H_
+#define MAPLIST_H_
+
+#include "../Objects/Map.h"
+
+//* MapList
+/**
+ * \brief Contains the maplist and a pointer to the current map.
+ */
+class MapList
+{
+public:
+    std::map<std::string, Map> List; /**< \brief List of all maps on the server. */
+    Map* Current = NULL;             /**< \brief Pointer to the current map (in the list). */
+
+    /*!
+     * \brief Sets the current map to the one belonging to the unique identifier.
+     *
+     * \param uid Map identifier (from game/server).
+     */
+    void SetCurrentMap(std::string uid);
+};
+
+#endif // MAPLIST_H_
diff --git a/src/Methods/Maps/MapActions.cpp b/src/Methods/Maps/MapActions.cpp
new file mode 100644
index 00000000..f3d861db
--- /dev/null
+++ b/src/Methods/Maps/MapActions.cpp
@@ -0,0 +1,129 @@
+#include "../Methods.h"
+
+bool Methods::AddMap(std::string fileName)
+{
+    bool response = false;
+
+    GbxParameters params = GbxParameters();
+    params.Put(&fileName);
+
+    if(server->Query(GbxMessage("AddMap", params)))
+    {
+        std::vector<GbxResponseParameter> responseParams = server->GetResponse()->GetParameters();
+        std::istringstream(responseParams.at(0).GetString()) >> response;
+    }
+
+    return response;
+}
+
+int Methods::AddMapList(std::vector<std::string> fileNames)
+{
+    int response = 0;
+
+    GbxParameters params = GbxParameters();
+    params.Put(&fileNames);
+
+    if(server->Query(GbxMessage("AddMapList", params)))
+    {
+        std::vector<GbxResponseParameter> responseParams = server->GetResponse()->GetParameters();
+        response = atoi(responseParams.at(0).GetString().c_str());
+    }
+
+    return response;
+}
+
+bool Methods::RemoveMap(std::string fileName)
+{
+    bool response = false;
+
+    GbxParameters params = GbxParameters();
+    params.Put(&fileName);
+
+    if(server->Query(GbxMessage("RemoveMap", params)))
+    {
+        std::vector<GbxResponseParameter> responseParams = server->GetResponse()->GetParameters();
+        std::istringstream(responseParams.at(0).GetString()) >> response;
+    }
+
+    return response;
+}
+
+int Methods::RemoveMapList(std::vector<std::string> fileNames)
+{
+    int response = 0;
+
+    GbxParameters params = GbxParameters();
+    params.Put(&fileNames);
+
+    if(server->Query(GbxMessage("RemoveMapList", params)))
+    {
+        std::vector<GbxResponseParameter> responseParams = server->GetResponse()->GetParameters();
+        response = atoi(responseParams.at(0).GetString().c_str());
+    }
+
+    return response;
+}
+
+bool Methods::InsertMap(std::string fileName)
+{
+    bool response = false;
+
+    GbxParameters params = GbxParameters();
+    params.Put(&fileName);
+
+    if(server->Query(GbxMessage("InsertMap", params)))
+    {
+        std::vector<GbxResponseParameter> responseParams = server->GetResponse()->GetParameters();
+        std::istringstream(responseParams.at(0).GetString()) >> response;
+    }
+
+    return response;
+}
+
+int Methods::InsertMapList(std::vector<std::string> fileNames)
+{
+    int response = 0;
+
+    GbxParameters params = GbxParameters();
+    params.Put(&fileNames);
+
+    if(server->Query(GbxMessage("InsertMapList", params)))
+    {
+        std::vector<GbxResponseParameter> responseParams = server->GetResponse()->GetParameters();
+        response = atoi(responseParams.at(0).GetString().c_str());
+    }
+
+    return response;
+}
+
+bool Methods::ChooseNextMap(std::string fileName)
+{
+    bool response = false;
+
+    GbxParameters params = GbxParameters();
+    params.Put(&fileName);
+
+    if(server->Query(GbxMessage("ChooseNextMap", params)))
+    {
+        std::vector<GbxResponseParameter> responseParams = server->GetResponse()->GetParameters();
+        std::istringstream(responseParams.at(0).GetString()) >> response;
+    }
+
+    return response;
+}
+
+int Methods::ChooseNextMapList(std::vector<std::string> fileNames)
+{
+    int response = 0;
+
+    GbxParameters params = GbxParameters();
+    params.Put(&fileNames);
+
+    if(server->Query(GbxMessage("ChooseNextMapList", params)))
+    {
+        std::vector<GbxResponseParameter> responseParams = server->GetResponse()->GetParameters();
+        response = atoi(responseParams.at(0).GetString().c_str());
+    }
+
+    return response;
+}
diff --git a/src/Methods/Maps/MapInfo.cpp b/src/Methods/Maps/MapInfo.cpp
new file mode 100644
index 00000000..e71d67ef
--- /dev/null
+++ b/src/Methods/Maps/MapInfo.cpp
@@ -0,0 +1,89 @@
+#include "../Methods.h"
+
+Map Methods::GetCurrentMapInfo()
+{
+    Map currentMap = Map();
+
+    if(server->Query(GbxMessage("GetCurrentMapInfo")))
+    {
+        std::vector<GbxResponseParameter> responseParams = server->GetResponse()->GetParameters();
+        std::map<std::string, GbxResponseParameter> mapStruct = responseParams.at(0).GetStruct();
+
+        currentMap.MapDetailed(mapStruct);
+    }
+
+    return currentMap;
+}
+
+Map Methods::GetNextMapInfo()
+{
+    Map nextMap = Map();
+
+    if(server->Query(GbxMessage("GetNextMapInfo")))
+    {
+        std::vector<GbxResponseParameter> responseParams = server->GetResponse()->GetParameters();
+        std::map<std::string, GbxResponseParameter> mapStruct = responseParams.at(0).GetStruct();
+
+        nextMap.MapDetailed(mapStruct);
+    }
+
+    return nextMap;
+}
+
+Map Methods::GetMapInfo(std::string fileName)
+{
+    Map mapInfo = Map();
+
+    GbxParameters params = GbxParameters();
+    params.Put(&fileName);
+
+    if(server->Query(GbxMessage("GetMapInfo", params)))
+    {
+        std::vector<GbxResponseParameter> responseParams = server->GetResponse()->GetParameters();
+        std::map<std::string, GbxResponseParameter> mapStruct = responseParams.at(0).GetStruct();
+
+        mapInfo.MapDetailed(mapStruct);
+    }
+
+    return mapInfo;
+}
+
+bool Methods::CheckMapForCurrentServerParams(std::string fileName)
+{
+    bool response = false;
+
+    GbxParameters params = GbxParameters();
+    params.Put(&fileName);
+
+    if(server->Query(GbxMessage("CheckMapForCurrentServerParams", params)))
+    {
+        std::vector<GbxResponseParameter> responseParams = server->GetResponse()->GetParameters();
+        std::istringstream(responseParams.at(0).GetString()) >> response;
+    }
+
+    return response;
+}
+
+std::vector<Map> Methods::GetMapList(int limit, int index)
+{
+    std::vector<Map> list = std::vector<Map>();
+
+    GbxParameters params = GbxParameters();
+    params.Put(&limit);
+    params.Put(&index);
+
+    if(server->Query(GbxMessage("GetMapList", params)))
+    {
+        std::vector<GbxResponseParameter> responseParams = server->GetResponse()->GetParameters();
+        std::vector<GbxResponseParameter> mapList = responseParams.at(0).GetArray();
+
+        for(int mapId = 0; mapId < mapList.size(); mapId++)
+        {
+            std::map<std::string, GbxResponseParameter> map = mapList.at(mapId).GetStruct();
+            Map newMap = Map(map);
+            list.push_back(newMap);
+        }
+    }
+
+    return list;
+}
diff --git a/src/Methods/Methods.cpp b/src/Methods/Methods.cpp
index b25c0cc7..8746dc4f 100644
--- a/src/Methods/Methods.cpp
+++ b/src/Methods/Methods.cpp
@@ -1,6 +1,12 @@
 #include "Methods.h"
 
-Methods::Methods(GbxRemote* serverPtr)
+Methods::Methods(GbxRemote* serverPtr, std::map<std::string, Player>* playerListPtr)
 {
     server = serverPtr;
+    playerList = playerListPtr;
+}
+
+GbxError Methods::GetCurrentError()
+{
+    return server->GetCurrentError();
 }
diff --git a/src/Methods/Methods.h b/src/Methods/Methods.h
index 95a21f89..83e010ec 100644
--- a/src/Methods/Methods.h
+++ b/src/Methods/Methods.h
@@ -2,7 +2,9 @@
 #define METHODS_H_
 
 #include "../GbxRemote/GbxRemote.h"
+#include "../Objects/Map.h"
 #include "../Objects/Player.h"
+#include "../Utils/Text.h"
 #include "Structs.h"
 
 //* Methods
@@ -15,9 +17,15 @@ class Methods
     /*!
      * \brief Constructor with link to server connection.
      *
-     * \param serverPtr Pointer to server connection.
+     * \param serverPtr     Pointer to server connection.
+     * \param playerListPtr Pointer to the playerlist.
      */
-    Methods(GbxRemote* serverPtr);
+    Methods(GbxRemote* serverPtr, std::map<std::string, Player>* playerListPtr);
+
+    /*!
+     * \brief Returns the current server error (from GbxRemote).
+     */
+    GbxError GetCurrentError();
 
     /*!
      * \brief Authenticates with the server. Returns whether authentication was successful.
@@ -70,6 +78,14 @@ class Methods
      */
     SystemInfo GetSystemInfo();
 
+    /*!
+     * \brief Sets the server connection rates.
+     *
+     * \param downloadRate New download rate.
+     * \param uploadRate   New upload rate.
+     */
+    bool SetConnectionRates(int downloadRate, int uploadRate);
+
     /*!
      * \brief Returns server status.
      *
@@ -146,28 +162,130 @@ class Methods
      */
     bool SendNoticeToLogin(std::string login, std::string text, std::string avatarLogin = "", int variant = 0);
 
-    // bool CallVote(std::string xmlRequest);
-    // bool CallVoteEx(std::string xmlRequest, double ratio, int timeout, int whoVotes);
-    // bool CancelVote();
-    // struct{CallerLogin, CmdName, CmdParam} GetCurrentCallVote();
-    // bool SetCallVoteTimeOut(int timeout);
-    // array[CurrentValue, NextValue] GetCallVoteTimeOut();
-    // bool SetCallVoteRatio(double ratio);
-    // double GetCallVoteRatio();
-    // bool SetCallVoteRatios(array[ratios]);
-    // array[ratios] GetCallVoteRatios();
-    // bool SetCallVoteRatiosEx(bool replaceAll, array[struct{Command, Param, Ratio}]);
-    // array[struct{Command, Param, Ratio}] GetCallVoteRatiosEx();
-
-    /*bool SendDisplayManialinkPage(std::string page, int timeout, bool hideOnClick);
+    /*!
+     * \brief Send link to player login.
+     *
+     * \param login       Player login.
+     * \param link        Link address.
+     * \param linkType    Link type (0 = external, 1 = ManiaLink).
+     */
+    bool SendOpenLinkToLogin(std::string login, std::string link, int linkType);
+
+    /*!
+     * \brief Start callvote.
+     *
+     * \param xmlRequest  Callvote request.
+     */
+    bool CallVote(std::string xmlRequest);
+
+    /*!
+     * \brief Start callvote.
+     *
+     * \param xmlRequest  Callvote request.
+     * \param ratio       Passing ratio (between 0 and 1, -1 = default).
+     * \param timeout     Timeout for the callvote (0 = default, 1 = indefinite).
+     * \param whoVotes    Who votes for the callvote (0 = active players, 1 = all players, 2 = everyone, including spectators).
+     */
+    bool CallVoteEx(std::string xmlRequest, double ratio, int timeout, int whoVotes);
+
+    /*!
+     * \brief Cancels the current callvote.
+     */
+    bool CancelVote();
+
+    /*!
+     * \brief Returns the current callvote.
+     */
+    CurrentCallVote GetCurrentCallVote();
+
+    /*!
+     * \brief Sets the default callvote timeout.
+     *
+     * \param timeout     Default timeout.
+     */
+    bool SetCallVoteTimeOut(int timeout);
+
+    /*!
+     * \brief Gets the default callvote timeout.
+     */
+    CurrentNextValue GetCallVoteTimeOut();
+
+    /*!
+     * \brief Sets the default callvote ratio.
+     *
+     * \param ratio       Default timeout.
+     */
+    bool SetCallVoteRatio(double ratio);
+
+    /*!
+     * \brief Gets the default callvote ratio.
+     */
+    double GetCallVoteRatio();
+
+    /*!
+     * \brief Sets the callvote ratios.
+     *
+     * \param ratios      List of callvote ratios.
+     */
+    bool SetCallVoteRatios(std::vector<CallVoteRatio> ratios);
+
+    /*!
+     * \brief Gets the callvote ratios.
+     */
+    std::vector<CallVoteRatio> GetCallVoteRatios();
+
+    /*!
+     * \brief Sets the callvote ratios.
+     *
+     * \param replaceAll  Replace all current callvote ratios?
+     * \param ratios      List of callvote ratios.
+     *
+     * \todo Implement when GbxParameters supports structs.
+     */
+    bool SetCallVoteRatiosEx(bool replaceAll, std::vector<ExtendedCallVoteRatio> ratios);
+
+    /*!
+     * \brief Gets the callvote ratios.
+     */
+    std::vector<ExtendedCallVoteRatio> GetCallVoteRatiosEx();
+
+    /*!
+     * \brief Displays ManiaLink page to all players.
+     *
+     * \param page        XML page to be displayed.
+     * \param timeout     Timeout to autohide (0 = permanent).
+     * \param hideOnClick Hide the page if a page option is clicked.
+     */
+    bool SendDisplayManialinkPage(std::string page, int timeout, bool hideOnClick);
+
+    /*!
+     * \brief Displays ManiaLink page to a player.
+     *
+     * \param login       Player login.
+     * \param page        XML page to be displayed.
+     * \param timeout     Timeout to autohide (0 = permanent).
+     * \param hideOnClick Hide the page if a page option is clicked.
+     */
     bool SendDisplayManialinkPageToLogin(std::string login, std::string page, int timeout, bool hideOnClick);
 
+    /*!
+     * \brief Hides all ManiaLink pages for all players.
+     */
     bool SendHideManialinkPage();
+
+    /*!
+     * \brief Hides all ManiaLink pages for a player.
+     *
+     * \param login       Player login.
+     */
     bool SendHideManialinkPageToLogin(std::string login);
 
-    // array[struct{Login,PlayerId,Result}] GetManialinkPageAnswers();
+    /*!
+     * \brief Returns the latest results from the current ManiaLink page.
+     */
+    std::vector<ManiaLinkPageAnswer> GetManialinkPageAnswers();
 
-    bool SendOpenLinkToLogin(std::string login, std::string link, int linkType);
+    /*bool SendOpenLinkToLogin(std::string login, std::string link, int linkType);
 
     bool Kick(std::string login, std::string message = "");
     bool Ban(std::string login, std::string message = "");
@@ -206,9 +324,6 @@ class Methods
     // struct{State, StateName, TransactionId} GetBillState(int billId);
     int GetServerPlanets();
 
-    //struct{?} GetSystemInfo();
-    bool SetConnectionRates(int download, int upload);
-
     //array[struct{Name, Value}] GetServerTags();
     bool SetServerTag(std::string name, std::string value);
     bool UnsetServerTag(std::string name);
@@ -250,8 +365,100 @@ class Methods
     std::string GetMapsDirectory();
     std::string GetSkinsDirectory();*/
 
+    /*!
+     * \brief Provides a map object for the map being played next on the server.
+     */
+    Map GetNextMapInfo();
+
+    /*!
+     * \brief Provides a map object for the map currently being played on the server.
+     *
+     * This is mainly meant for the start-up of the controller.
+     * The current map can always be request via the Current property of MapList.
+     */
+    Map GetCurrentMapInfo();
+
+    /*!
+     * \brief Provides a map object for the map with the specified file name.
+     *
+     * \param fileName  File name of the map.
+     */
+    Map GetMapInfo(std::string fileName);
+
+    /*!
+     * \brief Checks if the map matches the current server settings.
+     *
+     * \param fileName  File name of the map.
+     */
+    bool CheckMapForCurrentServerParams(std::string fileName);
+
+    /*!
+     * \brief Gets the maplist from the server.
+     *
+     * \param limit     Maximum amount of maps to be retrieved.
+     * \param index     Map index on which to start the retrieval.
+     */
+    std::vector<Map> GetMapList(int limit, int index);
+
+    /*!
+     * \brief Add the map with the specified filename at the end of the current selection.
+     *
+     * \param fileName  Filename of the map.
+     */
+    bool AddMap(std::string fileName);
+
+    /*!
+     * \brief Add the list of maps with the specified filenames at the end of the current selection.
+     *
+     * \param fileNames List of map filenames.
+     */
+    int AddMapList(std::vector<std::string> fileNames);
+
+    /*!
+     * \brief Remove the map with the specified filename from the current selection.
+     *
+     * \param fileName  Filename of the map.
+     */
+    bool RemoveMap(std::string fileName);
+
+    /*!
+     * \brief Remove the list of maps with the specified filenames from the current selection.
+     *
+     * \param fileNames List of map filenames.
+     */
+    int RemoveMapList(std::vector<std::string> fileNames);
+
+    /*!
+     * \brief Insert the map with the specified filename after the current map.
+     *
+     * \param fileName  Filename of the map.
+     */
+    bool InsertMap(std::string fileName);
+
+    /*!
+     * \brief Insert the list of maps with the specified filenames after the current map.
+     *
+     * \param fileNames List of map filenames.
+     */
+    int InsertMapList(std::vector<std::string> fileNames);
+
+    /*!
+     * \brief Set as next map the one with the specified filename, if it is present in the selection.
+     *
+     * \param fileName  Filename of the map.
+     */
+    bool ChooseNextMap(std::string fileName);
+
+    /*!
+     * \brief Set as next maps the list of maps with the specified filenames, if they are present in the selection.
+     *
+     * \param fileNames List of map filenames.
+     */
+    int ChooseNextMapList(std::vector<std::string> fileNames);
+
 private:
-    GbxRemote* server; /**< \brief Pointer to GbxRemote. */
+    GbxRemote* server;                         /**< \brief Pointer to GbxRemote. */
+    std::map<std::string, Player>* playerList; /**< \brief Pointer to the playerlist. */
 };
 
 #endif // METHODS_H_
diff --git a/src/Methods/Server/CallVote.cpp b/src/Methods/Server/CallVote.cpp
new file mode 100644
index 00000000..b6edcf6a
--- /dev/null
+++ b/src/Methods/Server/CallVote.cpp
@@ -0,0 +1,218 @@
+#include "../Methods.h"
+
+bool Methods::CallVote(std::string xmlRequest)
+{
+    bool response = false;
+
+    GbxParameters params = GbxParameters();
+    params.Put(&xmlRequest);
+
+    if(server->Query(GbxMessage("CallVote", params)))
+    {
+        std::vector<GbxResponseParameter> responseParams = server->GetResponse()->GetParameters();
+        std::istringstream(responseParams.at(0).GetString()) >> response;
+    }
+
+    return response;
+}
+
+bool Methods::CallVoteEx(std::string xmlRequest, double ratio, int timeout, int whoVotes)
+{
+    bool response = false;
+
+    GbxParameters params = GbxParameters();
+    params.Put(&xmlRequest);
+    params.Put(&ratio);
+    params.Put(&timeout);
+    params.Put(&whoVotes);
+
+    if(server->Query(GbxMessage("CallVoteEx", params)))
+    {
+        std::vector<GbxResponseParameter> responseParams = server->GetResponse()->GetParameters();
+        std::istringstream(responseParams.at(0).GetString()) >> response;
+    }
+
+    return response;
+}
+
+bool Methods::CancelVote()
+{
+    bool response = false;
+
+    if(server->Query(GbxMessage("CancelVote")))
+    {
+        std::vector<GbxResponseParameter> responseParams = server->GetResponse()->GetParameters();
+        std::istringstream(responseParams.at(0).GetString()) >> response;
+    }
+
+    return response;
+}
+
+CurrentCallVote Methods::GetCurrentCallVote()
+{
+    CurrentCallVote response = CurrentCallVote();
+
+    if(server->Query(GbxMessage("GetCurrentCallVote")))
+    {
+        std::vector<GbxResponseParameter> responseParams = server->GetResponse()->GetParameters();
+        std::map<std::string, GbxResponseParameter> currentStruct = responseParams.at(0).GetStruct();
+        response.CallerLogin = currentStruct.find("CallerLogin")->second.GetString();
+        response.CmdName = currentStruct.find("CmdName")->second.GetString();
+        response.CmdParam = currentStruct.find("CmdParam")->second.GetString();
+    }
+
+    return response;
+}
+
+bool Methods::SetCallVoteTimeOut(int timeout)
+{
+    bool response = false;
+
+    GbxParameters params = GbxParameters();
+    params.Put(&timeout);
+
+    if(server->Query(GbxMessage("SetCallVoteTimeOut", params)))
+    {
+        std::vector<GbxResponseParameter> responseParams = server->GetResponse()->GetParameters();
+        std::istringstream(responseParams.at(0).GetString()) >> response;
+    }
+
+    return response;
+}
+
+CurrentNextValue Methods::GetCallVoteTimeOut()
+{
+    CurrentNextValue response = CurrentNextValue();
+
+    if(server->Query(GbxMessage("GetCallVoteTimeOut")))
+    {
+        std::vector<GbxResponseParameter> responseParams = server->GetResponse()->GetParameters();
+        std::map<std::string, GbxResponseParameter> currentStruct = responseParams.at(0).GetStruct();
+        response.CurrentValue = atoi(currentStruct.find("CurrentValue")->second.GetString().c_str());
+        response.NextValue = atoi(currentStruct.find("NextValue")->second.GetString().c_str());
+    }
+
+    return response;
+}
+
+bool Methods::SetCallVoteRatio(double ratio)
+{
+    bool response = false;
+
+    GbxParameters params = GbxParameters();
+    params.Put(&ratio);
+
+    if(server->Query(GbxMessage("SetCallVoteRatio", params)))
+    {
+        std::vector<GbxResponseParameter> responseParams = server->GetResponse()->GetParameters();
+        std::istringstream(responseParams.at(0).GetString()) >> response;
+    }
+
+    return response;
+}
+
+double Methods::GetCallVoteRatio()
+{
+    double response;
+
+    if(server->Query(GbxMessage("GetCallVoteRatio")))
+    {
+        std::vector<GbxResponseParameter> responseParams = server->GetResponse()->GetParameters();
+        response = atof(responseParams.at(0).GetString().c_str());
+    }
+
+    return response;
+}
+
+bool Methods::SetCallVoteRatios(std::vector<CallVoteRatio> ratios)
+{
+    bool response = false;
+
+    GbxParameters params = GbxParameters();
+    params.Put(&ratios);
+
+    if(server->Query(GbxMessage("SetCallVoteRatios", params)))
+    {
+        std::vector<GbxResponseParameter> responseParams = server->GetResponse()->GetParameters();
+        std::istringstream(responseParams.at(0).GetString()) >> response;
+    }
+
+    return response;
+}
+
+std::vector<CallVoteRatio> Methods::GetCallVoteRatios()
+{
+    std::vector<CallVoteRatio> response = std::vector<CallVoteRatio>();
+
+    if(server->Query(GbxMessage("GetCallVoteRatios")))
+    {
+        std::vector<GbxResponseParameter> responseParams = server->GetResponse()->GetParameters();
+        std::vector<GbxResponseParameter> responseArray = responseParams.at(0).GetArray();
+
+        for(int responseId = 0; responseId < responseArray.size(); responseId++)
+        {
+            std::map<std::string, GbxResponseParameter> ratioStruct = responseArray.at(responseId).GetStruct();
+
+            CallVoteRatio ratio = CallVoteRatio();
+            ratio.Command = ratioStruct.find("Command")->second.GetString();
+            ratio.Ratio = atof(ratioStruct.find("Ratio")->second.GetString().c_str());
+            response.push_back(ratio);
+        }
+    }
+
+    return response;
+}
+
+bool Methods::SetCallVoteRatiosEx(bool replaceAll, std::vector<ExtendedCallVoteRatio> ratios)
+{
+    bool response = false;
+
+    GbxParameters params = GbxParameters();
+    params.Put(&replaceAll);
+
+    GbxParameters structArray = GbxParameters();
+    GbxStructParameters structRatios = GbxStructParameters();
+    for(int ratioId = 0; ratioId < ratios.size(); ratioId++)
+    {
+        ExtendedCallVoteRatio ratio = ratios.at(ratioId);
+        std::stringstream stringStruct;
+        stringStruct << "<member><name>Command</name><value><string>" << ratio.Command << "</string></value></member>";
+        stringStruct << "<member><name>Param</name><value><string>" << ratio.Param << "</string></value></member>";
+        stringStruct << "<member><name>Ratio</name><value><double>" << ratio.Ratio << "</double></value></member>";
+        structRatios.Put(stringStruct.str());
+    }
+    structArray.Put(&structRatios);
+    params.Put(&structArray);
+
+    if(server->Query(GbxMessage("SetCallVoteRatiosEx", params)))
+    {
+        std::vector<GbxResponseParameter> responseParams = server->GetResponse()->GetParameters();
+        std::istringstream(responseParams.at(0).GetString()) >> response;
+    }
+
+    return response;
+}
+
+std::vector<ExtendedCallVoteRatio> Methods::GetCallVoteRatiosEx()
+{
+    std::vector<ExtendedCallVoteRatio> response = std::vector<ExtendedCallVoteRatio>();
+
+    if(server->Query(GbxMessage("GetCallVoteRatiosEx")))
+    {
+        std::vector<GbxResponseParameter> responseParams = server->GetResponse()->GetParameters();
+        std::vector<GbxResponseParameter> responseArray = responseParams.at(0).GetArray();
+
+        for(int responseId = 0; responseId < responseArray.size(); responseId++)
+        {
+            std::map<std::string, GbxResponseParameter> ratioStruct = responseArray.at(responseId).GetStruct();
+
+            ExtendedCallVoteRatio ratio = ExtendedCallVoteRatio();
+            ratio.Command = ratioStruct.find("Command")->second.GetString();
+            ratio.Param = ratioStruct.find("Param")->second.GetString();
+            ratio.Ratio = atof(ratioStruct.find("Ratio")->second.GetString().c_str());
+            response.push_back(ratio);
+        }
+    }
+
+    return response;
+}
diff --git a/src/Methods/Server/Chat.cpp b/src/Methods/Server/Chat.cpp
index 281d1dd7..1998337a 100644
--- a/src/Methods/Server/Chat.cpp
+++ b/src/Methods/Server/Chat.cpp
@@ -6,19 +6,15 @@ bool Methods::ChatSendServerMessage(std::string text)
 
     std::string sendText = "»» " + text;
 
-    GbxParameters* params = new GbxParameters();
-    params->Put(&sendText);
+    GbxParameters params = GbxParameters();
+    params.Put(&sendText);
 
-    GbxMessage* message = new GbxMessage("ChatSendServerMessage", params);
-
-    if(server->Query(message))
+    if(server->Query(GbxMessage("ChatSendServerMessage", params)))
     {
         std::vector<GbxResponseParameter> responseParams = server->GetResponse()->GetParameters();
         std::istringstream(responseParams.at(0).GetString()) >> response;
     }
 
-    delete params; params = NULL;
-    delete message; message = NULL;
     return response;
 }
 
@@ -28,20 +24,16 @@ bool Methods::ChatSendServerMessageToLogin(std::string text, std::string login)
 
     std::string sendText = "» " + text;
 
-    GbxParameters* params = new GbxParameters();
-    params->Put(&sendText);
-    params->Put(&login);
-
-    GbxMessage* message = new GbxMessage("ChatSendServerMessageToLogin", params);
+    GbxParameters params = GbxParameters();
+    params.Put(&sendText);
+    params.Put(&login);
 
-    if(server->Query(message))
+    if(server->Query(GbxMessage("ChatSendServerMessageToLogin", params)))
     {
         std::vector<GbxResponseParameter> responseParams = server->GetResponse()->GetParameters();
         std::istringstream(responseParams.at(0).GetString()) >> response;
     }
 
-    delete params; params = NULL;
-    delete message; message = NULL;
     return response;
 }
 
@@ -53,9 +45,8 @@ bool Methods::ChatSendServerMessageToPlayer(std::string text, Player player)
 std::vector<std::string> Methods::GetChatLines()
 {
     std::vector<std::string> chatLines = std::vector<std::string>();
-    GbxMessage* message = new GbxMessage("GetChatLines");
 
-    if(server->Query(message))
+    if(server->Query(GbxMessage("GetChatLines")))
     {
         std::vector<GbxResponseParameter> responseParams = server->GetResponse()->GetParameters().at(0).GetArray();
         for(int paramId = 0; paramId < responseParams.size(); paramId++)
@@ -64,7 +55,6 @@ std::vector<std::string> Methods::GetChatLines()
         }
     }
 
-    delete message; message = NULL;
     return chatLines;
 }
 
@@ -72,20 +62,16 @@ bool Methods::ChatEnableManualRouting(bool enable, bool autoForward)
 {
     bool response = false;
 
-    GbxParameters* params = new GbxParameters();
-    params->Put(&enable);
-    params->Put(&autoForward);
+    GbxParameters params = GbxParameters();
+    params.Put(&enable);
+    params.Put(&autoForward);
 
-    GbxMessage* message = new GbxMessage("ChatEnableManualRouting", params);
-
-    if(server->Query(message))
+    if(server->Query(GbxMessage("ChatEnableManualRouting", params)))
     {
         std::vector<GbxResponseParameter> responseParams = server->GetResponse()->GetParameters();
         std::istringstream(responseParams.at(0).GetString()) >> response;
     }
 
-    delete params; params = NULL;
-    delete message; message = NULL;
     return response;
 }
 
@@ -93,21 +79,17 @@ bool Methods::ChatForwardToLogin(std::string text, std::string sender, std::stri
 {
     bool response = false;
 
-    GbxParameters* params = new GbxParameters();
-    params->Put(&text);
-    params->Put(&sender);
+    GbxParameters params = GbxParameters();
+    params.Put(&text);
+    params.Put(&sender);
     if(!destination.empty())
-        params->Put(&destination);
-
-    GbxMessage* message = new GbxMessage("ChatForwardToLogin", params);
+        params.Put(&destination);
 
-    if(server->Query(message))
+    if(server->Query(GbxMessage("ChatForwardToLogin", params)))
     {
         std::vector<GbxResponseParameter> responseParams = server->GetResponse()->GetParameters();
         std::istringstream(responseParams.at(0).GetString()) >> response;
     }
 
-    delete params; params = NULL;
-    delete message; message = NULL;
     return response;
 }
diff --git a/src/Methods/Server/Global.cpp b/src/Methods/Server/Global.cpp
index 7f0eee15..8f9ec655 100644
--- a/src/Methods/Server/Global.cpp
+++ b/src/Methods/Server/Global.cpp
@@ -4,20 +4,16 @@ bool Methods::Authenticate(std::string username, std::string password)
 {
     bool response = false;
 
-    GbxParameters* params = new GbxParameters();
-    params->Put(&username);
-    params->Put(&password);
+    GbxParameters params = GbxParameters();
+    params.Put(&username);
+    params.Put(&password);
 
-    GbxMessage* message = new GbxMessage("Authenticate", params);
-
-    if(server->Query(message))
+    if(server->Query(GbxMessage("Authenticate", params)))
     {
         std::vector<GbxResponseParameter> responseParams = server->GetResponse()->GetParameters();
         std::istringstream(responseParams.at(0).GetString()) >> response;
     }
 
-    delete params; params = NULL;
-    delete message; message = NULL;
     return response;
 }
 
@@ -25,20 +21,16 @@ bool Methods::ChangeAuthPassword(std::string username, std::string password)
 {
     bool response = false;
 
-    GbxParameters* params = new GbxParameters();
-    params->Put(&username);
-    params->Put(&password);
-
-    GbxMessage* message = new GbxMessage("ChangeAuthPassword", params);
+    GbxParameters params = GbxParameters();
+    params.Put(&username);
+    params.Put(&password);
 
-    if(server->Query(message))
+    if(server->Query(GbxMessage("ChangeAuthPassword", params)))
     {
         std::vector<GbxResponseParameter> responseParams = server->GetResponse()->GetParameters();
         std::istringstream(responseParams.at(0).GetString()) >> response;
     }
 
-    delete params; params = NULL;
-    delete message; message = NULL;
     return response;
 }
 
@@ -46,19 +38,15 @@ bool Methods::EnableCallbacks(bool enable)
 {
     bool response = false;
 
-    GbxParameters* params = new GbxParameters();
-    params->Put(&enable);
-
-    GbxMessage* message = new GbxMessage("EnableCallbacks", params);
+    GbxParameters params = GbxParameters();
+    params.Put(&enable);
 
-    if(server->Query(message))
+    if(server->Query(GbxMessage("EnableCallbacks", params)))
     {
         std::vector<GbxResponseParameter> responseParams = server->GetResponse()->GetParameters();
         std::istringstream(responseParams.at(0).GetString()) >> response;
     }
 
-    delete params; params = NULL;
-    delete message; message = NULL;
     return response;
 }
 
@@ -66,27 +54,23 @@ bool Methods::SetApiVersion(std::string version)
 {
     bool response = false;
 
-    GbxParameters* params = new GbxParameters();
-    params->Put(&version);
+    GbxParameters params = GbxParameters();
+    params.Put(&version);
 
-    GbxMessage* message = new GbxMessage("SetApiVersion", params);
-
-    if(server->Query(message))
+    if(server->Query(GbxMessage("SetApiVersion", params)))
     {
         std::vector<GbxResponseParameter> responseParams = server->GetResponse()->GetParameters();
         std::istringstream(responseParams.at(0).GetString()) >> response;
     }
 
-    delete params; params = NULL;
-    delete message; message = NULL;
     return response;
 }
 
 std::vector<std::string> Methods::ListMethods()
 {
     std::vector<std::string> methods = std::vector<std::string>();
-    GbxMessage* message = new GbxMessage("system.listMethods");
-    if(server->Query(message))
+
+    if(server->Query(GbxMessage("system.listMethods")))
     {
         std::vector<GbxResponseParameter> responseParams = server->GetResponse()->GetParameters();
         std::vector<GbxResponseParameter> methodsArray = responseParams.at(0).GetArray();
@@ -97,7 +81,6 @@ std::vector<std::string> Methods::ListMethods()
         }
     }
 
-    delete message; message = NULL;
     return methods;
 }
 
@@ -105,11 +88,8 @@ ServerVersion Methods::GetVersion()
 {
     ServerVersion serverVersion = ServerVersion();
 
-    GbxMessage* message = new GbxMessage("GetVersion");
-    if(server->Query(message))
+    if(server->Query(GbxMessage("GetVersion")))
     {
-        delete message; message = NULL;
-
         std::vector<GbxResponseParameter> responseParams = server->GetResponse()->GetParameters();
         std::map<std::string, GbxResponseParameter> versionStruct = responseParams.at(0).GetStruct();
 
@@ -127,11 +107,8 @@ SystemInfo Methods::GetSystemInfo()
 {
     SystemInfo systemInfo = SystemInfo();
 
-    GbxMessage* message = new GbxMessage("GetSystemInfo");
-    if(server->Query(message))
+    if(server->Query(GbxMessage("GetSystemInfo")))
     {
-        delete message; message = NULL;
-
         std::vector<GbxResponseParameter> responseParams = server->GetResponse()->GetParameters();
         std::map<std::string, GbxResponseParameter> infoStruct = responseParams.at(0).GetStruct();
 
@@ -150,15 +127,29 @@ SystemInfo Methods::GetSystemInfo()
     return systemInfo;
 }
 
+bool Methods::SetConnectionRates(int downloadRate, int uploadRate)
+{
+    bool response = false;
+
+    GbxParameters params = GbxParameters();
+    params.Put(&downloadRate);
+    params.Put(&uploadRate);
+
+    if(server->Query(GbxMessage("SetConnectionRates", params)))
+    {
+        std::vector<GbxResponseParameter> responseParams = server->GetResponse()->GetParameters();
+        std::istringstream(responseParams.at(0).GetString()) >> response;
+    }
+
+    return response;
+}
+
 ServerStatus Methods::GetStatus()
 {
     ServerStatus serverStatus = ServerStatus();
 
-    GbxMessage* message = new GbxMessage("GetStatus");
-    if(server->Query(message))
+    if(server->Query(GbxMessage("GetStatus")))
     {
-        delete message; message = NULL;
-
         std::vector<GbxResponseParameter> responseParams = server->GetResponse()->GetParameters();
         std::map<std::string, GbxResponseParameter> statusStruct = responseParams.at(0).GetStruct();
 
@@ -173,14 +164,11 @@ bool Methods::QuitGame()
 {
     bool response = false;
 
-    GbxMessage* message = new GbxMessage("QuitGame");
-
-    if(server->Query(message))
+    if(server->Query(GbxMessage("QuitGame")))
     {
         std::vector<GbxResponseParameter> responseParams = server->GetResponse()->GetParameters();
         std::istringstream(responseParams.at(0).GetString()) >> response;
     }
 
-    delete message; message = NULL;
     return response;
 }
diff --git a/src/Methods/Server/ManiaLink.cpp b/src/Methods/Server/ManiaLink.cpp
new file mode 100644
index 00000000..fe507b8c
--- /dev/null
+++ b/src/Methods/Server/ManiaLink.cpp
@@ -0,0 +1,93 @@
+#include "../Methods.h"
+
+bool Methods::SendDisplayManialinkPage(std::string page, int timeout, bool hideOnClick)
+{
+    bool response = false;
+
+    GbxParameters params = GbxParameters();
+    params.Put(&page);
+    params.Put(&timeout);
+    params.Put(&hideOnClick);
+
+    if(server->Query(GbxMessage("SendDisplayManialinkPage", params)))
+    {
+        std::vector<GbxResponseParameter> responseParams = server->GetResponse()->GetParameters();
+        std::istringstream(responseParams.at(0).GetString()) >> response;
+    }
+
+    return response;
+}
+
+bool Methods::SendDisplayManialinkPageToLogin(std::string login, std::string page, int timeout, bool hideOnClick)
+{
+    bool response = false;
+    std::string escapedPage = Text::EscapeXML(page);
+
+    GbxParameters params = GbxParameters();
+    params.Put(&login);
+    params.Put(&escapedPage);
+    params.Put(&timeout);
+    params.Put(&hideOnClick);
+
+    if(server->Query(GbxMessage("SendDisplayManialinkPageToLogin", params)))
+    {
+        std::vector<GbxResponseParameter> responseParams = server->GetResponse()->GetParameters();
+        std::istringstream(responseParams.at(0).GetString()) >> response;
+    }
+
+    return response;
+}
+
+bool Methods::SendHideManialinkPage()
+{
+    bool response = false;
+
+    if(server->Query(GbxMessage("SendHideManialinkPage")))
+    {
+        std::vector<GbxResponseParameter> responseParams = server->GetResponse()->GetParameters();
+        std::istringstream(responseParams.at(0).GetString()) >> response;
+    }
+
+    return response;
+}
+
+bool Methods::SendHideManialinkPageToLogin(std::string login)
+{
+    bool response = false;
+
+    GbxParameters params = GbxParameters();
+    params.Put(&login);
+
+    if(server->Query(GbxMessage("SendHideManialinkPageToLogin", params)))
+    {
+        std::vector<GbxResponseParameter> responseParams = server->GetResponse()->GetParameters();
+        std::istringstream(responseParams.at(0).GetString()) >> response;
+    }
+
+    return response;
+}
+
+std::vector<ManiaLinkPageAnswer> Methods::GetManialinkPageAnswers()
+{
+    std::vector<ManiaLinkPageAnswer> answers = std::vector<ManiaLinkPageAnswer>();
+
+    if(server->Query(GbxMessage("GetManialinkPageAnswers")))
+    {
+        std::vector<GbxResponseParameter> responseParams = server->GetResponse()->GetParameters().at(0).GetArray();
+        for(int paramId = 0; paramId < responseParams.size(); paramId++)
+        {
+            std::map<std::string, GbxResponseParameter> answer = responseParams.at(paramId).GetStruct();
+            std::string login = answer.find("Login")->second.GetString();
+            Player player = playerList->find(login)->second;
+            int result = atoi(answer.find("Result")->second.GetString().c_str());
+
+            ManiaLinkPageAnswer linkAnswer = ManiaLinkPageAnswer();
+            linkAnswer.AnsweringPlayer = player;
+            linkAnswer.Result = result;
+
+            answers.push_back(linkAnswer);
+        }
+    }
+
+    return answers;
+}
diff --git a/src/Methods/Server/Notice.cpp b/src/Methods/Server/Notice.cpp
index b051474c..624fea30 100644
--- a/src/Methods/Server/Notice.cpp
+++ b/src/Methods/Server/Notice.cpp
@@ -4,21 +4,17 @@ bool Methods::SendNotice(std::string text, std::string avatarLogin, int variant)
 {
     bool response = false;
 
-    GbxParameters* params = new GbxParameters();
-    params->Put(&text);
-    params->Put(&avatarLogin);
-    params->Put(&variant);
+    GbxParameters params = GbxParameters();
+    params.Put(&text);
+    params.Put(&avatarLogin);
+    params.Put(&variant);
 
-    GbxMessage* message = new GbxMessage("SendNotice", params);
-
-    if(server->Query(message))
+    if(server->Query(GbxMessage("SendNotice", params)))
     {
         std::vector<GbxResponseParameter> responseParams = server->GetResponse()->GetParameters();
         std::istringstream(responseParams.at(0).GetString()) >> response;
     }
 
-    delete params; params = NULL;
-    delete message; message = NULL;
     return response;
 }
 
@@ -26,21 +22,35 @@ bool Methods::SendNoticeToLogin(std::string login, std::string text, std::string
 {
     bool response = false;
 
-    GbxParameters* params = new GbxParameters();
-    params->Put(&login);
-    params->Put(&text);
-    params->Put(&avatarLogin);
-    params->Put(&variant);
+    GbxParameters params = GbxParameters();
+    params.Put(&login);
+    params.Put(&text);
+    params.Put(&avatarLogin);
+    params.Put(&variant);
+
+    if(server->Query(GbxMessage("SendNoticeToLogin", params)))
+    {
+        std::vector<GbxResponseParameter> responseParams = server->GetResponse()->GetParameters();
+        std::istringstream(responseParams.at(0).GetString()) >> response;
+    }
+
+    return response;
+}
+
+bool Methods::SendOpenLinkToLogin(std::string login, std::string link, int linkType)
+{
+    bool response = false;
 
-    GbxMessage* message = new GbxMessage("SendNoticeToLogin", params);
+    GbxParameters params = GbxParameters();
+    params.Put(&login);
+    params.Put(&link);
+    params.Put(&linkType);
 
-    if(server->Query(message))
+    if(server->Query(GbxMessage("SendOpenLinkToLogin", params)))
     {
         std::vector<GbxResponseParameter> responseParams = server->GetResponse()->GetParameters();
         std::istringstream(responseParams.at(0).GetString()) >> response;
     }
 
-    delete params; params = NULL;
-    delete message; message = NULL;
     return response;
 }
diff --git a/src/Methods/Structs.h b/src/Methods/Structs.h
index 4785617f..531caebd 100644
--- a/src/Methods/Structs.h
+++ b/src/Methods/Structs.h
@@ -42,4 +42,56 @@ struct ServerStatus
     std::string Name; /**< \brief Current status name. */
 };
 
+//* ManiaLinkPageAnswer
+/**
+ * \brief Struct with a ManiaLink page answer.
+ */
+struct ManiaLinkPageAnswer
+{
+    Player AnsweringPlayer; /**< \brief Player answering. */
+    int Result;             /**< \brief Answering result. */
+};
+
+//* CurrentCallVote
+/**
+ * \brief Struct with a current callvote.
+ */
+struct CurrentCallVote
+{
+    std::string CallerLogin; /**< \brief Player login who created the vote. */
+    std::string CmdName;     /**< \brief Name of the callvote. */
+    std::string CmdParam;    /**< \brief Callvote parameter. */
+};
+
+//* CallVoteRatio
+/**
+ * \brief Struct with a callvote ratio.
+ */
+struct CallVoteRatio
+{
+    std::string Command; /**< \brief Command for the ratio. */
+    double Ratio;        /**< \brief Vote passing ratio (between 0 and 1, -1 for disable). */
+};
+
+//* CallVote
+/**
+ * \brief Struct with a callvote.
+ */
+struct ExtendedCallVoteRatio
+{
+    std::string Command; /**< \brief Name of the callvote. */
+    std::string Param;   /**< \brief Parameter of the callvote. */
+    double Ratio;        /**< \brief Vote passing ratio (between 0 and 1, -1 for disable). */
+};
+
+//* CurrentNextValue
+/**
+ * \brief Struct with a current and next value.
+ */
+struct CurrentNextValue
+{
+    int CurrentValue; /**< \brief Current value of the setting. */
+    int NextValue;    /**< \brief Next value of the setting. */
+};
+
 #endif // METHODS_STRUCTS_H_
diff --git a/src/Objects/Map.h b/src/Objects/Map.h
index 641c6fa4..74783d15 100644
--- a/src/Objects/Map.h
+++ b/src/Objects/Map.h
@@ -9,6 +9,9 @@
  */
 struct Map
 {
+    // === Mania++ information ===
+    int Id = 0;               /**< \brief Map identifier (on database). */
+
     // === Basic information ===
     std::string UId;          /**< \brief Unique map identifier. */
     std::string Name;         /**< \brief Map name. */
@@ -62,11 +65,40 @@ struct Map
     {
         if(serverStruct.find("Mood") != serverStruct.end())
         {
-            setBasicInfo(serverStruct);
             setDetailedInfo(serverStruct);
         }
     }
 
+    /*!
+     * \brief Copies information from map object.
+     *
+     * \param map          Map object to be copied into this.
+     */
+    void CopyDetailedMap(Map map)
+    {
+        if(!map.Mood.empty())
+        {
+            Mood = map.Mood;
+            BronzeTime = map.BronzeTime;
+            SilverTime = map.SilverTime;
+            AuthorTime = map.AuthorTime;
+
+            LapRace = map.LapRace;
+            NbLaps = map.NbLaps;
+            NbCheckpoints = map.NbCheckpoints;
+        }
+    }
+
+    /*!
+     * \brief Set database identifier value.
+     *
+     * \param id           Database ID.
+     */
+    void SetId(int id)
+    {
+        Id = id;
+    }
+
 private:
     /*!
      * \brief Sets the basic map information from the struct.
@@ -95,26 +127,16 @@ struct Map
      */
     void setDetailedInfo(std::map<std::string, GbxResponseParameter> serverStruct)
     {
-        UId = serverStruct.find("UId")->second.GetString().c_str();
-        Name = serverStruct.find("Name")->second.GetString().c_str();
-        FileName = serverStruct.find("FileName")->second.GetString();
-        Environment = serverStruct.find("Environnement")->second.GetString();
-        Author = serverStruct.find("Author")->second.GetString();
-
-        GoldTime = atoi(serverStruct.find("GoldTime")->second.GetString().c_str());
-        CopperPrice = atoi(serverStruct.find("CopperPrice")->second.GetString().c_str());
-
-        MapType = serverStruct.find("MapType")->second.GetString().c_str();
-        MapStyle = serverStruct.find("MapStyle")->second.GetString().c_str();
+        setBasicInfo(serverStruct);
 
-        std::string Mood = serverStruct.find("Mood")->second.GetString();
-        int BronzeTime = atoi(serverStruct.find("BronzeTime")->second.GetString().c_str());
-        int SilverTime = atoi(serverStruct.find("SilverTime")->second.GetString().c_str());
-        int AuthorTime = atoi(serverStruct.find("AuthorTime")->second.GetString().c_str());
+        Mood = serverStruct.find("Mood")->second.GetString();
+        BronzeTime = atoi(serverStruct.find("BronzeTime")->second.GetString().c_str());
+        SilverTime = atoi(serverStruct.find("SilverTime")->second.GetString().c_str());
+        AuthorTime = atoi(serverStruct.find("AuthorTime")->second.GetString().c_str());
 
         std::istringstream(serverStruct.find("LapRace")->second.GetString()) >> LapRace;
-        int NbLaps = atoi(serverStruct.find("NbLaps")->second.GetString().c_str());
-        int NbCheckpoints = atoi(serverStruct.find("NbCheckpoints")->second.GetString().c_str());
+        NbLaps = atoi(serverStruct.find("NbLaps")->second.GetString().c_str());
+        NbCheckpoints = atoi(serverStruct.find("NbCheckpoints")->second.GetString().c_str());
     }
 };
 
diff --git a/src/Objects/Player.h b/src/Objects/Player.h
index c4c7935d..7011ce85 100644
--- a/src/Objects/Player.h
+++ b/src/Objects/Player.h
@@ -9,23 +9,43 @@
  */
 struct Player
 {
-    int PlayerId;          /**< \brief Player identifier (on server). */
-    int TeamId;            /**< \brief Team identifier (on server). */
+    // === Mania++ information ===
+    int Id = 0;                          /**< \brief Player identifier (on database). */
+    std::vector<int> CurrentCheckpoints; /**< \brief Checkpoint passes on current try. */
 
-    std::string Login;     /**< \brief Player login. */
-    std::string NickName;  /**< \brief Player nickname.*/
+    // === Basic information ===
+    int PlayerId;                        /**< \brief Player identifier (on server). */
+    int TeamId;                          /**< \brief Team identifier (on server). */
 
-    int SpectatorStatus;   /**< \brief Spectator status of player. */
-    int Flags;             /**< \brief Player flags. */
+    std::string Login;                   /**< \brief Player login. */
+    std::string NickName;                /**< \brief Player nickname.*/
 
-    int LadderRanking;     /**< \brief Current ladder ranking of the player. */
+    int SpectatorStatus;                 /**< \brief Spectator status of player. */
+    int Flags;                           /**< \brief Player flags. */
+
+    int LadderRanking;                   /**< \brief Current ladder ranking of the player. */
+
+    // === Detailed information ===
+    std::string IPAddress;               /**< \brief IP Address of the player. */
+    int DownloadRate;                    /**< \brief Download rate in Kbps. */
+    int UploadRate;                      /**< \brief Upload rate in Kbps. */
+
+    std::string Language;                /**< \brief Application language. */
+
+    bool IsSpectator;                    /**< \brief Is in spectatormode? */
+    bool IsInOfficialMode;               /**< \brief Is in official mode? */
+
+    std::string ClientVersion;           /**< \brief Client version (f.e. 'v2015-06-18_15_10 (3.3.0)'). */
+    std::string ClubLink;                /**< \brief Club URL (website, entered by player). */
+    std::string Path;                    /**< \brief Player location without "world". */
+    std::string Country;                 /**< \brief Path without continent. */
 
     /*!
      * \brief Constructs a Player object without input.
      */
     Player()
     {
-
+        CurrentCheckpoints = std::vector<int>();
     }
 
     /*!
@@ -35,19 +55,88 @@ struct Player
      */
     Player(std::map<std::string, GbxResponseParameter> serverStruct)
     {
+        CurrentCheckpoints = std::vector<int>();
         if(serverStruct.find("Login") != serverStruct.end())
         {
-            PlayerId = atoi(serverStruct.find("PlayerId")->second.GetString().c_str());
-            TeamId = atoi(serverStruct.find("TeamId")->second.GetString().c_str());
+            setBasicInfo(serverStruct);
+        }
+    }
+
+    /*!
+     * \brief Formats a server response into a usable form.
+     *
+     * \param serverStruct The struct with detailed player information received from the server.
+     */
+    void PlayerDetailed(std::map<std::string, GbxResponseParameter> serverStruct)
+    {
+        if(serverStruct.find("Language") != serverStruct.end())
+        {
+            setDetailedInfo(serverStruct);
+        }
+    }
+
+    /*!
+     * \brief Set database identifier value.
+     *
+     * \param id           Database ID.
+     */
+    void SetId(int id)
+    {
+        Id = id;
+    }
 
-            Login = serverStruct.find("Login")->second.GetString();
-            NickName = serverStruct.find("NickName")->second.GetString();
+private:
+    /*!
+     * \brief Sets the basic player information from the struct.
+     *
+     * \param serverStruct The struct with player information received from the server.
+     */
+    void setBasicInfo(std::map<std::string, GbxResponseParameter> serverStruct)
+    {
+        PlayerId = atoi(serverStruct.find("PlayerId")->second.GetString().c_str());
+        TeamId = atoi(serverStruct.find("TeamId")->second.GetString().c_str());
+
+        Login = serverStruct.find("Login")->second.GetString();
+        NickName = serverStruct.find("NickName")->second.GetString();
 
-            SpectatorStatus = atoi(serverStruct.find("SpectatorStatus")->second.GetString().c_str());
-            Flags = atoi(serverStruct.find("Flags")->second.GetString().c_str());
+        SpectatorStatus = atoi(serverStruct.find("SpectatorStatus")->second.GetString().c_str());
+        Flags = atoi(serverStruct.find("Flags")->second.GetString().c_str());
 
-            LadderRanking = atoi(serverStruct.find("LadderRanking")->second.GetString().c_str());
+        LadderRanking = atoi(serverStruct.find("LadderRanking")->second.GetString().c_str());
+    }
+
+    /*!
+     * \brief Sets the detailed player information from the struct.
+     *
+     * \param serverStruct The struct with detailed player information received from the server.
+     */
+    void setDetailedInfo(std::map<std::string, GbxResponseParameter> serverStruct)
+    {
+        IPAddress = serverStruct.find("IPAddress")->second.GetString();
+        DownloadRate = atoi(serverStruct.find("DownloadRate")->second.GetString().c_str());
+        UploadRate = atoi(serverStruct.find("UploadRate")->second.GetString().c_str());
+
+        Language = serverStruct.find("Language")->second.GetString();
+
+        std::istringstream(serverStruct.find("IsSpectator")->second.GetString()) >> IsSpectator;
+        std::istringstream(serverStruct.find("IsInOfficialMode")->second.GetString()) >> IsInOfficialMode;
+
+        ClientVersion = serverStruct.find("ClientVersion")->second.GetString();
+        ClubLink = serverStruct.find("ClubLink")->second.GetString();
+
+        std::string path = serverStruct.find("Path")->second.GetString().substr(6); // Remove World|
+        Path = path; // Remove World|
+
+        std::vector<std::string> continents = { "Europe|", "Africa|", "Asia|", "Middle East|", "North America|", "South America|", "Oceania|" };
+        for(int continentId = 0; continentId < continents.size(); continentId++)
+        {
+            std::string continent = continents.at(continentId);
+            std::string::size_type i = path.find(continent);
+            if (i != std::string::npos)
+               path.erase(i, continent.length());
         }
+
+        Country = path;
     }
 };
 
diff --git a/src/Plugins/Plugin.h b/src/Plugins/Plugin.h
index 1eb57a6b..a0d7df37 100644
--- a/src/Plugins/Plugin.h
+++ b/src/Plugins/Plugin.h
@@ -4,17 +4,39 @@
 #include <stdio.h>
 #include <cstring>
 #include <string>
+#include <map>
 #include <iostream>
 #include <sstream>
 #include <cstdlib>
 #include <functional>
 
+#include <cppconn/driver.h>
+#include <cppconn/exception.h>
+#include <cppconn/resultset.h>
+#include <cppconn/statement.h>
+#include <cppconn/prepared_statement.h>
+
 #include "../Events/Structs.h"
+#include "../Maps/MapList.h"
 #include "../Methods/Methods.h"
 #include "../Objects/Player.h"
 #include "../Objects/Map.h"
+#include "../UI/UIManager.h"
 #include "../Utils/Logging.h"
 
+//* Controller
+/**
+ * \brief Struct with all instances needed for plugins.
+ */
+struct Controller
+{
+    Methods* Server;                        /**< \brief Methods instance. */
+    std::map<std::string, Player>* Players; /**< \brief Playerlist instance. */
+    MapList* Maps;                          /**< \brief Maplist instance. */
+    sql::Connection* Database;              /**< \brief Database instance. */
+    UIManager* UI;                          /**< \brief UI manager instance. */
+};
+
 //* Plugin
 /**
  * \brief Plugin interface, inherited by all plugins.
@@ -28,49 +50,20 @@ class Plugin
     virtual void Init() = 0;
 
     /*!
-     * \brief Sets the logging instance.
-     *
-     * \param loggingPtr Pointer to the logging instance.
-     */
-    void SetLogging(Logging* loggingPtr)
-    {
-        logging = loggingPtr;
-    }
-
-    /*!
-     * \brief Sets the server instance.
-     *
-     * \param methodsPtr Pointer to the Methods instance.
-     */
-    void SetMethods(Methods* methodsPtr)
-    {
-        methods = methodsPtr;
-    }
-
-    /*!
-     * \brief Sets the playerlist instance.
+     * \brief Sets the controller instance.
      *
-     * \param playersPtr Pointer to the playerlist instance.
+     * \param controllerPtr Pointer to the controller instance.
      */
-    void SetPlayers(std::map<std::string, Player>* playersPtr)
+    void SetController(Controller* controllerPtr)
     {
-        players = playersPtr;
+        controller = controllerPtr;
     }
 
-    /*!
-     * \brief Sets the maplist instance.
-     *
-     * \param mapsPtr    Pointer to the maplist instance.
-     */
-    void SetMaps(std::map<std::string, Map>* mapsPtr)
-    {
-        maps = mapsPtr;
-    }
+    std::map<std::string, std::string> Settings;                                /**< \brief Plugin settings (from the config file). */
 
     std::vector<std::function<void(Player)>> PlayerConnect;                     /**< \brief Vector with functions for the PlayerConnect event. */
     std::vector<std::function<void(Player)>> PlayerDisconnect;                  /**< \brief Vector with functions for the PlayerDisconnect event. */
-    std::vector<std::function<void(Player, std::string, bool)>> PlayerChat;     /**< \brief Vector with functions for the PlayerChat event. */
-    std::vector<std::function<void(Player, std::string, std::vector<EntryVal>)>> PlayerManialinkPageAnswer; /**< \brief Vector with functions for the PlayerManialinkPageAnswer event. */
+    std::vector<std::function<void(Player, std::string)>> PlayerChat;           /**< \brief Vector with functions for the PlayerChat event. */
     std::vector<std::function<void(std::string, std::string)>> Echo;            /**< \brief Vector with functions for the Echo event. */
     std::vector<std::function<void()>> BeginMatch;                              /**< \brief Vector with functions for the BeginMatch event. */
     std::vector<std::function<void(std::vector<PlayerRanking>, int)>> EndMatch; /**< \brief Vector with functions for the EndMatch event. */
@@ -85,14 +78,38 @@ class Plugin
     std::vector<std::function<void(Player)>> PlayerInfoChanged;                 /**< \brief Vector with functions for the PlayerInfoChanged event. */
     std::vector<std::function<void(std::string, std::string, std::string, std::string)>> VoteUpdated; /**< \brief Vector with functions for the VoteUpdated event. */
 
+    std::map<std::string, std::function<void(Player, std::vector<std::string>)>> Commands =
+        std::map<std::string, std::function<void(Player, std::vector<std::string>)>>(); /**< \brief Map with normal chat commands for the plugin. */
+    std::map<std::string, std::function<void(Player, std::vector<std::string>)>> AdminCommands =
+        std::map<std::string, std::function<void(Player, std::vector<std::string>)>>(); /**< \brief Map with admin chat commands for the plugin. */
+
     std::string Version; /**< \brief Plugin version. */
     std::string Author;  /**< \brief Plugin author. */
 
 protected:
-    Logging* logging;                       /**< \brief Logging instance. */
-    Methods* methods;                       /**< \brief Methods instance. */
-    std::map<std::string, Player>* players; /**< \brief Playerlist instance. */
-    std::map<std::string, Map>* maps;       /**< \brief Maplist instance. */
+    Controller* controller;                  /**< \brief Struct with needed instances. */
+
+    /*!
+     * \brief Register chat command.
+     *
+     * \param name   Chat command name.
+     * \param method Method to be called for the command.
+     */
+    void RegisterCommand(std::string name, std::function<void(Player, std::vector<std::string>)> method)
+    {
+        Commands.insert(std::pair<std::string, std::function<void(Player, std::vector<std::string>)>>(name, method));
+    }
+
+    /*!
+     * \brief Register admin chat command.
+     *
+     * \param name   Admin chat command name.
+     * \param method Method to be called for the command.
+     */
+    void RegisterAdminCommand(std::string name, std::function<void(Player, std::vector<std::string>)> method)
+    {
+        AdminCommands.insert(std::pair<std::string, std::function<void(Player, std::vector<std::string>)>>(name, method));
+    }
 };
 
 #endif // PLUGIN_H_
diff --git a/src/Plugins/PluginManager.cpp b/src/Plugins/PluginManager.cpp
index ed757b79..c1c77380 100644
--- a/src/Plugins/PluginManager.cpp
+++ b/src/Plugins/PluginManager.cpp
@@ -1,14 +1,24 @@
 #include "PluginManager.h"
 
-PluginManager::PluginManager(Logging* loggingPtr, Methods* methodsPtr, std::map<std::string, Player>* playersPtr, std::map<std::string, Map>* mapsPtr)
+PluginManager::PluginManager(Config* configPtr,
+                             Methods* methodsPtr,
+                             CommandManager* commandsPtr,
+                             std::map<std::string, Player>* playersPtr,
+                             MapList* mapsPtr,
+                             sql::Connection* databasePtr,
+                             UIManager* uiPtr)
 {
+    config = configPtr;
     plugins = std::map<std::string, PluginInfo>();
     events = NULL;
-
-    logging = loggingPtr;
-    methods = methodsPtr;
-    players = playersPtr;
-    maps = mapsPtr;
+    commands = commandsPtr;
+
+    controller = new Controller();
+    controller->Server = methodsPtr;
+    controller->Players = playersPtr;
+    controller->Maps = mapsPtr;
+    controller->Database = databasePtr;
+    controller->UI = uiPtr;
 }
 
 PluginManager::~PluginManager()
@@ -38,6 +48,8 @@ void PluginManager::LoadPlugins(std::string pluginsFolder)
     std::cout << "[   \033[0;32mOK.\033[0;0m   ] Discovered plugins: " << pluginFiles.size() << " found." << std::endl;
     std::cout << "[ ======= ] Loading plugins ... " << std::endl;
 
+    std::set<std::string> loadedPlugins = std::set<std::string>();
+
     for(std::map<std::string, std::string>::iterator pluginId = pluginFiles.begin(); pluginId != pluginFiles.end(); ++pluginId)
     {
         std::cout << "[         ] Loading plugin '" << pluginId->first << "' ... " << '\r' << std::flush;
@@ -46,12 +58,12 @@ void PluginManager::LoadPlugins(std::string pluginsFolder)
         {
             Logging::PrintFailedFlush();
 
-            GbxError* error = new GbxError();
-            error->number = -201;
+            GbxError error = GbxError();
+            error.number = -201;
             std::stringstream message;
-            message << "Could not load '" << pluginId->first << "'...";
-            error->message = message.str();
-            logging->PrintError(error);
+            message << "Could not load '" << pluginId->first << "': " << dlerror() << "...";
+            error.message = message.str();
+            Logging::PrintError(error);
         }
         else
         {
@@ -61,20 +73,20 @@ void PluginManager::LoadPlugins(std::string pluginsFolder)
             {
                 Logging::PrintFailedFlush();
 
-                GbxError* error = new GbxError();
-                error->number = -202;
+                GbxError error = GbxError();
+                error.number = -202;
                 std::stringstream message;
                 message << "Could not call 'startPlugin'-function for '" << pluginId->first << "'...";
-                error->message = message.str();
-                logging->PrintError(error);
+                error.message = message.str();
+                Logging::PrintError(error);
             }
             else
             {
                 Plugin* plugin = startPlugin();
-                plugin->SetLogging(logging);
-                plugin->SetMethods(methods);
-                plugin->SetPlayers(players);
-                plugin->SetMaps(maps);
+                plugin->SetController(controller);
+
+                PluginConfig pluginConfig = config->Plugins->find(pluginId->first)->second;
+                plugin->Settings = pluginConfig.settings;
 
                 std::cout << "[   \033[0;32mOK.\033[0;0m   ] Loaded plugin '" << pluginId->first << "': v" << plugin->Version << " by " << plugin->Author << "." << std::endl;
 
@@ -85,7 +97,6 @@ void PluginManager::LoadPlugins(std::string pluginsFolder)
                     eventCount += events->RegisterPlayerConnect(plugin->PlayerConnect);
                     eventCount += events->RegisterPlayerDisconnect(plugin->PlayerDisconnect);
                     eventCount += events->RegisterPlayerChat(plugin->PlayerChat);
-                    eventCount += events->RegisterPlayerManialinkPageAnswer(plugin->PlayerManialinkPageAnswer);
                     eventCount += events->RegisterEcho(plugin->Echo);
                     eventCount += events->RegisterBeginMatch(plugin->BeginMatch);
                     eventCount += events->RegisterEndMatch(plugin->EndMatch);
@@ -103,12 +114,31 @@ void PluginManager::LoadPlugins(std::string pluginsFolder)
                     std::cout << "[   \033[0;32mOK.\033[0;0m   ] Loaded events for '" << pluginId->first << "': " << eventCount << " found." << std::endl;
                 }
 
+                std::cout << "[         ] Loading commands for '" << pluginId->first << "' ... " << '\r' << std::flush;
+                int commandCount = 0;
+                commandCount += commands->RegisterCommands(plugin->Commands);
+                commandCount += commands->RegisterAdminCommands(plugin->AdminCommands);
+
+                std::cout << "[   \033[0;32mOK.\033[0;0m   ] Loaded commands for '" << pluginId->first << "': " << commandCount << " found." << std::endl;
+
                 plugins.insert(std::pair<std::string, PluginInfo>(pluginId->first, { plugin->Version, plugin->Author, plugin, pluginHandle }));
+
+                loadedPlugins.insert(pluginId->first);
             }
         }
     }
 
-    std::cout << "[ ======= ] Plugins: " << plugins.size() << " loaded." << std::endl;
+    int notFound = 0;
+    for(std::map<std::string, PluginConfig>::iterator configPluginId = config->Plugins->begin(); configPluginId != config->Plugins->end(); ++configPluginId)
+    {
+        if(loadedPlugins.find(configPluginId->first) == loadedPlugins.end())
+        {
+            std::cout << "[ \033[0;31mFAILED!\033[0;0m ] Plugin '" << configPluginId->first << "' does not exist." << std::endl;
+            notFound++;
+        }
+    }
+
+    std::cout << "[ ======= ] Plugins: " << plugins.size() << " loaded, " << notFound << " not found." << std::endl;
 }
 
 void PluginManager::InitializePlugins()
@@ -138,27 +168,30 @@ std::map<std::string, std::string> PluginManager::discoverPlugins(std::string pl
             {
                 std::string pluginName = entry->d_name;
 
-                std::string pluginFolder = pluginsFolder;
-                pluginFolder.append("/").append(entry->d_name);
-
-                DIR* pluginDirectory = opendir(pluginFolder.c_str());
-                struct dirent* pluginEntry = readdir(pluginDirectory);
-                while(pluginEntry != NULL)
+                if(config->Plugins->find(pluginName) != config->Plugins->end())
                 {
-                    if(pluginEntry->d_type != DT_DIR)
+                    std::string pluginFolder = pluginsFolder;
+                    pluginFolder.append("/").append(entry->d_name);
+
+                    DIR* pluginDirectory = opendir(pluginFolder.c_str());
+                    struct dirent* pluginEntry = readdir(pluginDirectory);
+                    while(pluginEntry != NULL)
                     {
-                        if(std::string(pluginEntry->d_name).find(".so") != std::string::npos)
+                        if(pluginEntry->d_type != DT_DIR)
                         {
-                            std::string filePath = pluginFolder;
-                            filePath.append("/").append(pluginEntry->d_name);
-                            pluginFiles.insert(std::pair<std::string, std::string>(pluginName, filePath));
+                            if(std::string(pluginEntry->d_name).find(".so") != std::string::npos)
+                            {
+                                std::string filePath = pluginFolder;
+                                filePath.append("/").append(pluginEntry->d_name);
+                                pluginFiles.insert(std::pair<std::string, std::string>(pluginName, filePath));
+                            }
                         }
+
+                        pluginEntry = readdir(pluginDirectory);
                     }
 
-                    pluginEntry = readdir(pluginDirectory);
+                    closedir(pluginDirectory);
                 }
-
-                closedir(pluginDirectory);
             }
         }
 
diff --git a/src/Plugins/PluginManager.h b/src/Plugins/PluginManager.h
index 3852c8e8..935b79a9 100644
--- a/src/Plugins/PluginManager.h
+++ b/src/Plugins/PluginManager.h
@@ -8,8 +8,11 @@
 #include <stdio.h>
 #include <dlfcn.h>
 
-#include "../Methods/Methods.h"
+#include "../Config/Config.h"
 #include "../Events/EventManager.h"
+#include "../Commands/CommandManager.h"
+#include "../Methods/Methods.h"
+
 #include "Plugin.h"
 
 //* PluginInfo
@@ -35,12 +38,15 @@ class PluginManager
     /*!
      * \brief Initializes the pointers the plugins need.
      *
-     * \param loggingPtr      Current instance of Logging.
+     * \param configPtr       Current instance of Config.
      * \param methodsPtr      Current instance of Methods.
+     * \param commandsPtr     Current instance of the CommandManager.
      * \param playersPtr      Current instance of the playerlist.
      * \param mapsPtr         Current instance of the maplist.
+     * \param databasePtr     Current instance of the database connection.
+     * \param uiPtr           Current instance of the interface manager.
      */
-    PluginManager(Logging* loggingPtr, Methods* methodsPtr, std::map<std::string, Player>* playersPtr, std::map<std::string, Map>* mapsPtr);
+    PluginManager(Config* configPtr, Methods* methodsPtr, CommandManager* commandsPtr, std::map<std::string, Player>* playersPtr, MapList* mapsPtr, sql::Connection* databasePtr, UIManager* uiPtr);
 
     /*!
      * \brief Destructor closes all open plugins.
@@ -73,12 +79,10 @@ class PluginManager
     std::map<std::string, std::string> discoverPlugins(std::string pluginsFolder);
 
     std::map<std::string, PluginInfo> plugins; /**< \brief Vector of loaded plugins. */
+    Config* config;                            /**< \brief Current instance of the Config. */
+    CommandManager* commands;                  /**< \brief Current instance of the CommandManager. */
     EventManager* events;                      /**< \brief Current instance of the EventManager. */
-
-    Logging* logging;                          /**< \brief Current instance of Logging. */
-    Methods* methods;                         /**< \brief Current instance of Methods. */
-    std::map<std::string, Player>* players;    /**< \brief Current instance of the playerlist. */
-    std::map<std::string, Map>* maps;          /**< \brief Current instance of the maplist. */
+    Controller* controller;                    /**< \brief Current instance of the controller. */
 };
 
 #endif // PLUGINMANAGER_H_
diff --git a/src/Socket/TcpClient.cpp b/src/Socket/TcpClient.cpp
index 02abcec8..23407b04 100644
--- a/src/Socket/TcpClient.cpp
+++ b/src/Socket/TcpClient.cpp
@@ -11,9 +11,12 @@ TcpClient::TcpClient()
 
 void TcpClient::Close()
 {
-    shutdown(sock, 2);
-    close(sock);
-    sock = -1;
+    if(sock != -1)
+    {
+        shutdown(sock, 2);
+        close(sock);
+        sock = -1;
+    }
 }
 
 bool TcpClient::Connect(std::string address, int port)
diff --git a/src/UI/UIFrame.h b/src/UI/UIFrame.h
new file mode 100644
index 00000000..4a6630ad
--- /dev/null
+++ b/src/UI/UIFrame.h
@@ -0,0 +1,26 @@
+#ifndef UIFRAME_H_
+#define UIFRAME_H_
+
+#include <functional>
+#include <map>
+#include "../Events/Structs.h"
+
+//* UIFrame
+/**
+ * \brief ManiaLink for UI.
+ */
+struct UIFrame
+{
+    std::string ManiaLinkId;              /**< \brief ManiaLink identifier. */
+    std::string Page;                     /**< \brief XML ManiaLink page. */
+    int Timeout;                          /**< \brief Timeout of the page. */
+    bool CloseOnClick;                    /**< \brief Close the page when being clicked. */
+    std::map<std::string, bool> CustomUI; /**< \brief Enable/Disable default game UI. */
+
+    UIFrame()
+    {
+        CustomUI = std::map<std::string, bool>();
+    }
+};
+
+#endif // UIFRAME_H_
diff --git a/src/UI/UIList.h b/src/UI/UIList.h
new file mode 100644
index 00000000..79d8eb11
--- /dev/null
+++ b/src/UI/UIList.h
@@ -0,0 +1,30 @@
+#ifndef UILIST_H_
+#define UILIST_H_
+
+#include <map>
+#include <vector>
+
+//* UILIST
+/**
+ * \brief ManiaLink for UI list.
+ */
+struct UIList
+{
+    std::string Id;                        /**< \brief ManiaLink identifier. */
+    std::string Title;                     /**< \brief List title. */
+    std::string IconStyle;                 /**< \brief Header icon style. */
+    std::string IconSubstyle;              /**< \brief Header icon substyle. */
+
+    std::vector<std::pair<std::string, int>> Columns;     /**< \brief List columns. */
+    std::vector<std::map<std::string, std::string>> Rows; /**< \brief List rows. */
+    std::map<std::string, std::pair<std::string, std::string>> Actions; /**< \brief List of column/row actions.  */
+
+    UIList()
+    {
+        Columns = std::vector<std::pair<std::string, int>>();
+        Rows = std::vector<std::map<std::string, std::string>>();
+        Actions = std::map<std::string, std::pair<std::string, std::string>>();
+    }
+};
+
+#endif // UILIST_H_
diff --git a/src/UI/UIManager.cpp b/src/UI/UIManager.cpp
new file mode 100644
index 00000000..2795b324
--- /dev/null
+++ b/src/UI/UIManager.cpp
@@ -0,0 +1,235 @@
+#include "UIManager.h"
+
+UIManager::UIManager(Methods* serverPtr, EventManager* eventsPtr, std::map<std::string, Player>* playersPtr)
+{
+    server = serverPtr;
+    events = eventsPtr;
+    players = playersPtr;
+    answers = std::map<std::string, std::function<void(Player, std::string, std::vector<EntryVal>)>>();
+    currentLists = std::map<std::string, UIList>();
+
+    std::vector<std::function<void(Player, std::string, std::vector<EntryVal>)>> functions = std::vector<std::function<void(Player, std::string, std::vector<EntryVal>)>>();
+    functions.push_back([this](Player player, std::string answer, std::vector<EntryVal> entries) { OnPlayerManialinkPageAnswer(player, answer, entries); });
+    events->RegisterPlayerManialinkPageAnswer(functions);
+
+    std::vector<std::function<void(std::vector<PlayerRanking>, int)>> functionsEndMatch = std::vector<std::function<void(std::vector<PlayerRanking>, int)>>();
+    functionsEndMatch.push_back([this](std::vector<PlayerRanking> rankings, int winnerTeam) { OnEndMatch(); });
+    events->RegisterEndMatch(functionsEndMatch);
+
+    std::vector<std::function<void(Player)>> functionsPlayerDisconnect = std::vector<std::function<void(Player)>>();
+    functionsPlayerDisconnect.push_back([this](Player player) { CloseList(player); });
+    events->RegisterPlayerDisconnect(functionsPlayerDisconnect);
+
+    RegisterEvent("CloseCenterList", ([this](Player player, std::string answer, std::vector<EntryVal> entries) { CloseList(player); }));
+}
+
+void UIManager::OnPlayerManialinkPageAnswer(Player player, std::string answer, std::vector<EntryVal> entries)
+{
+    if(answer.find("PageCenterList(") != std::string::npos)
+    {
+        std::map<std::string, UIList>::iterator playerUIList = currentLists.find(player.Login);
+        if(playerUIList != currentLists.end())
+        {
+            answer.erase(0, strlen("PageCenterList("));
+            std::string answerPage = answer.substr(0, (answer.size() - 1));
+            int page = atoi(answerPage.c_str());
+            DisplayList(playerUIList->second, player, page);
+        }
+    }
+    else
+    {
+        if(answers.find(answer) != answers.end())
+        {
+            std::function<void(Player, std::string, std::vector<EntryVal>)> method = answers.find(answer)->second;
+            method(player, answer, entries);
+        }
+        else
+        {
+            size_t positionParam = answer.find('(');
+            if(positionParam != std::string::npos)
+            {
+                std::string answerWithoutParam = answer.substr(0, positionParam);
+                if(answers.find(answerWithoutParam) != answers.end())
+                {
+                    std::function<void(Player, std::string, std::vector<EntryVal>)> method = answers.find(answerWithoutParam)->second;
+                    method(player, answer, entries);
+                }
+            }
+        }
+    }
+}
+
+bool UIManager::Display(UIFrame frame)
+{
+    return server->SendDisplayManialinkPage(formatPage(frame), frame.Timeout, frame.CloseOnClick);
+}
+
+bool UIManager::Display(UIFrame frame, Player player)
+{
+    return server->SendDisplayManialinkPageToLogin(player.Login, formatPage(frame), frame.Timeout, frame.CloseOnClick);
+}
+
+bool UIManager::DisplayList(UIList list, Player player, int currentPage)
+{
+    std::map<std::string, UIList>::iterator playerUIList = currentLists.find(player.Login);
+    if(playerUIList == currentLists.end())
+    {
+        currentLists.insert(std::pair<std::string, UIList>(player.Login, list));
+    }
+    else if(playerUIList->second.Id != list.Id)
+    {
+        currentLists.erase(player.Login);
+        currentLists.insert(std::pair<std::string, UIList>(player.Login, list));
+    }
+
+    UIFrame frame = UIFrame();
+    frame.ManiaLinkId = "CenterList";
+    frame.Timeout = 0;
+    frame.CloseOnClick = false;
+
+    int pages = std::ceil((list.Rows.size() / 20.0));
+    if(pages == 0) pages = 1;
+
+    std::stringstream widget;
+    widget << "<frame posn=\"-42 38 0\" id=\"List" << list.Id << "\">";
+    widget << "        <quad posn=\"0 0 0.002\" sizen=\"84 63.5\" style=\"Bgs1InRace\" substyle=\"BgCardList\"/>";
+    widget << "        <quad posn=\"0.5 -0.5 0.003\" sizen=\"83 5\" style=\"Bgs1InRace\" substyle=\"BgCardList\"/>";
+    widget << "        <quad posn=\"78.5 -0.5 0.004\" sizen=\"5 5\" style=\"Icons64x64_1\" substyle=\"Close\" action=\"CloseCenterList\"/>";
+    widget << "        <quad posn=\"1 -0.8 0.004\" sizen=\"4 4\" style=\"" << list.IconStyle << "\" substyle=\"" << list.IconSubstyle << "\"/>";
+
+    widget << "        <label posn=\"5.5 -2 0.004\" sizen=\"55 3\" halign=\"left\" textsize=\"2.5\" text=\"$o" << list.Title << "\"/>";
+    widget << "        <label posn=\"78.5 -2.3 0.004\" sizen=\"55 3\" halign=\"right\" textsize=\"1.5\" text=\"$o(" << list.Rows.size() << " entries)\"/>";
+
+    widget << "        <frame posn=\"0.5 -6 0\" id=\"ListWhoKarmaList\">";
+    widget << "                <quad posn=\"0 0 0.005\" sizen=\"83 53\" style=\"Bgs1InRace\" substyle=\"BgCardList\"/>";
+    widget << "                <quad posn=\"0 0 0.006\" sizen=\"83 3\" style=\"Bgs1InRace\" substyle=\"BgCardList\"/>";
+
+    int columnX = 1;
+    for(int columnId = 0; columnId < list.Columns.size(); columnId++)
+    {
+        std::pair<std::string, int> column = list.Columns.at(columnId);
+        widget << "                        <label posn=\"" << columnX << " -0.7 0.007\" sizen=\"" << column.second << " 1.5\" halign=\"left\" textsize=\"1.8\" text=\"$o" << Text::EscapeXML(column.first) << "\"/>";
+        columnX += column.second;
+    }
+
+    double entryY = -3.5;
+    int entry = 1;
+    int startRow = ((currentPage - 1) * 20);
+
+    for(int rowId = startRow; rowId < list.Rows.size(); rowId++)
+    {
+        std::map<std::string, std::string> currentRow = list.Rows.at(rowId);
+
+        if(entry % 2 == 0)
+            widget << "                <quad posn=\"0.05 " << (entryY + 0.55) << " 0.006\" sizen=\"82.9 2.6\" bgcolor=\"0003\"/>";
+
+        int rowColumnX = 1;
+        for(int columnId = 0; columnId < list.Columns.size(); columnId++)
+        {
+            std::pair<std::string, int> column = list.Columns.at(columnId);
+            std::map<std::string, std::string>::iterator columnRowIt = currentRow.find(column.first);
+            std::string labelAction = "";
+            if(columnRowIt != currentRow.end())
+            {
+                std::map<std::string, std::pair<std::string, std::string>>::iterator actionColumnIt = list.Actions.find(column.first);
+                if(actionColumnIt != list.Actions.end())
+                {
+                    std::pair<std::string, std::string> actionInfo = actionColumnIt->second;
+                    std::map<std::string, std::string>::iterator actionRowIt = currentRow.find(actionInfo.second);
+                    if(actionRowIt != currentRow.end())
+                    {
+                        labelAction = " action=\"" + actionInfo.first + "(" + actionRowIt->second + ")\" focusareacolor1=\"0000\" focusareacolor2=\"0000\"";
+                    }
+                }
+
+                widget << "                        <label posn=\"" << rowColumnX << " " << (entryY - 0.65) << " 0.007\" sizen=\"" << (column.second - 0.5) <<" 2.47\" halign=\"left\" valign=\"center\" textsize=\"1.8\"" << labelAction << " text=\" " << Text::EscapeXML(columnRowIt->second) << "\"/>";
+            }
+
+            rowColumnX += column.second;
+        }
+
+        entryY -= 2.5;
+        entry++;
+
+        if(entry > 20) break;
+    }
+
+    widget << "        </frame>";
+
+    widget << "        <quad posn=\"0.5 -59.5 0.003\" sizen=\"83 3.5\" style=\"Bgs1InRace\" substyle=\"BgCardList\"/>";
+
+    if(currentPage > 1)
+    {
+        widget << "        <quad posn=\"0.5 -59.5 0.004\" sizen=\"3.5 3.5\" style=\"Icons64x64_1\" substyle=\"ArrowFirst\" action=\"PageCenterList(1)\"/>";
+        widget << "        <quad posn=\"3 -59.5 0.004\" sizen=\"3.5 3.5\" style=\"Icons64x64_1\" substyle=\"ArrowPrev\" action=\"PageCenterList(" << (currentPage - 1) << ")\"/>";
+    }
+
+    widget << "        <label posn=\"42 -60.5 0.004\" sizen=\"20 1.5\" halign=\"center\" textsize=\"1.5\" text=\"$oPage " << currentPage << "/" << pages << "\"/>";
+    if(currentPage != pages)
+    {
+        widget << "        <quad posn=\"77.5 -59.5 0.004\" sizen=\"3.5 3.5\" style=\"Icons64x64_1\" substyle=\"ArrowNext\" action=\"PageCenterList(" << (currentPage + 1) << ")\"/>";
+        widget << "        <quad posn=\"80 -59.5 0.004\" sizen=\"3.5 3.5\" style=\"Icons64x64_1\" substyle=\"ArrowLast\" action=\"PageCenterList(" << pages << ")\"/>";
+    }
+
+    widget << "</frame>";
+
+    frame.Page = widget.str();
+    return Display(frame, player);
+}
+
+void UIManager::CloseList(Player player)
+{
+    currentLists.erase(player.Login);
+
+    UIFrame frame = UIFrame();
+    frame.ManiaLinkId = "CenterList";
+    frame.Timeout = 1;
+    frame.CloseOnClick = false;
+    frame.Page = "";
+    Display(frame, player);
+}
+
+void UIManager::OnEndMatch()
+{
+    for(std::map<std::string, Player>::iterator playerIt = players->begin(); playerIt != players->end(); ++playerIt)
+    {
+        CloseList(playerIt->second);
+    }
+}
+
+bool UIManager::RegisterEvent(std::string answer, std::function<void(Player, std::string, std::vector<EntryVal>)> function)
+{
+    if(answers.find(answer) == answers.end())
+    {
+        answers.insert(std::pair<std::string, std::function<void(Player, std::string, std::vector<EntryVal>)>>(answer, function));
+        return true;
+    }
+    else
+    {
+        std::cout << "[ WARNING ] Trying to register action '" << answer << "', which is already taken." << std::endl;
+    }
+
+    return false;
+}
+
+std::string UIManager::formatPage(UIFrame frame)
+{
+    std::stringstream page;
+    page << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>";
+    page << "<manialink id=\"" << frame.ManiaLinkId << "\">";
+    page << frame.Page;
+    page << "</manialink>";
+
+    if(frame.CustomUI.size() > 0)
+    {
+        page << "<custom_ui>";
+        for(std::map<std::string, bool>::iterator customUI = frame.CustomUI.begin(); customUI != frame.CustomUI.end(); ++customUI)
+        {
+            std::string uiBool = (customUI->second) ? "true" : "false";
+            page << "    <" << customUI->first << " visible=\"" << uiBool << "\" />";
+        }
+        page << "</custom_ui>";
+    }
+
+    return page.str();
+}
diff --git a/src/UI/UIManager.h b/src/UI/UIManager.h
new file mode 100644
index 00000000..94003da1
--- /dev/null
+++ b/src/UI/UIManager.h
@@ -0,0 +1,97 @@
+#ifndef UIMANAGER_H_
+#define UIMANAGER_H_
+
+#include <cmath>
+
+#include "../Events/EventManager.h"
+#include "../Methods/Methods.h"
+#include "../Utils/Text.h"
+
+#include "UIFrame.h"
+#include "UIList.h"
+
+//* UIManager
+/**
+ * \brief Manages the user interface on the server (ManiaLinks).
+ */
+class UIManager
+{
+public:
+    /*!
+     * \brief Constructor takes needed controller pointers.
+     *
+     * \param serverPtr  Pointer to the server methods.
+     * \param eventsPtr  Pointer to the event manager.
+     * \param playersPtr Pointer to the player list.
+     */
+    UIManager(Methods* serverPtr, EventManager* eventsPtr, std::map<std::string, Player>* playersPtr);
+
+    /*!
+     * \brief Callback handler voor ManiaLink page answers.
+     *
+     * \param player     Player who interacted with the page.
+     * \param answer     Page answer.
+     * \param entries    Entries.
+     */
+    void OnPlayerManialinkPageAnswer(Player player, std::string answer, std::vector<EntryVal> entries);
+
+    /*!
+     * \brief Display frame.
+     *
+     * \param frame      Frame to be displayed.
+     */
+    bool Display(UIFrame frame);
+
+    /*!
+     * \brief Display frame to player.
+     *
+     * \param frame      Frame to be displayed.
+     * \param player     Player who should receive the frame.
+     */
+    bool Display(UIFrame frame, Player player);
+
+    /*!
+     * \brief Display list to player.
+     *
+     * \param list       List to be displayed.
+     * \param player     Player who should receive the list.
+     */
+    bool DisplayList(UIList list, Player player, int currentPage = 1);
+
+    /*!
+     * \brief Close list for player and removes from memory.
+     *
+     * \param player     Player which center list should be closed.
+     */
+    void CloseList(Player player);
+
+    /*!
+     * \brief Event listener for EndMatch, closes center lists.
+     */
+    void OnEndMatch();
+
+    /*!
+     * \brief Register event to be handled on page answer.
+     *
+     * \param answer     Name of the answer.
+     * \param function   Function to be called on callback.
+     */
+    bool RegisterEvent(std::string answer, std::function<void(Player, std::string, std::vector<EntryVal>)> function);
+
+private:
+    Methods* server;                            /**< \brief Pointer to the server methods. */
+    EventManager* events;                       /**< \brief Pointer to the event manager. */
+    std::map<std::string, Player>* players;     /**< \brief Pointer to the player list. */
+    std::map<std::string, std::function<void(Player, std::string, std::vector<EntryVal>)>> answers; /**< \brief List with ManiaLink answers to handle. */
+
+    std::map<std::string, UIList> currentLists; /**< \brief Current lists displayed to players. */
+
+    /*!
+     * \brief Formats the page, including custom UI.
+     *
+     * \param frame     Frame to be formatted.
+     */
+    std::string formatPage(UIFrame frame);
+};
+
+#endif // UIMANAGER_H_
diff --git a/src/Utils/Logging.h b/src/Utils/Logging.h
index e27c04b5..90f488b2 100644
--- a/src/Utils/Logging.h
+++ b/src/Utils/Logging.h
@@ -4,6 +4,7 @@
 #include <cstring>
 #include <cmath>
 #include "../GbxRemote/GbxStructs.h"
+#include "../GbxRemote/ServerResponse/GbxServerResponse.h"
 
 //* Logging
 /**
@@ -17,10 +18,10 @@ class Logging
      *
      * \param error        Error structure.
      */
-    static void PrintError(GbxError* error)
+    static void PrintError(GbxError error)
     {
         std::stringstream numberString;
-        numberString << error->number;
+        numberString << error.number;
         const char* errorNumber = numberString.str().c_str();
         int errorNumberLength = strlen(errorNumber);
         int spaces = (9 - errorNumberLength);
@@ -35,22 +36,36 @@ class Logging
             {
                 output << " ";
             }
-            output << error->number;
+            output << error.number;
             for(int i = 0; i < floor(halfSpaces); i++)
             {
                 output << " ";
             }
 
-            output << "\033[0;0m] ERROR: " + error->message;
+            output << "\033[0;0m] ERROR: " + error.message;
 
             std::cout << output.str() << std::endl;
         }
         else
         {
-            std::cout << "[\033[0;31m" << errorNumber << "\033[0;0m] ERROR: " << error->message << std::endl;
+            std::cout << "[\033[0;31m" << errorNumber << "\033[0;0m] ERROR: " << error.message << std::endl;
         }
     }
 
+    /*!
+     * \brief Prints error to console.
+     *
+     * \param number       Error number.
+     * \param message      Error message.
+     */
+    static void PrintError(int number, std::string message)
+    {
+        GbxError error = GbxError();
+        error.number = number;
+        error.message = message;
+        PrintError(error);
+    }
+
     /*!
      * \brief Prints OK. in [         ]-spaces in console.
      */
diff --git a/src/Utils/Text.h b/src/Utils/Text.h
new file mode 100644
index 00000000..dadedaec
--- /dev/null
+++ b/src/Utils/Text.h
@@ -0,0 +1,39 @@
+#ifndef TEXT_H_
+#define TEXT_H_
+
+#include <string>
+#include <sstream>
+
+//* Text
+/**
+ * \brief Contains utilities to format text.
+ */
+class Text
+{
+public:
+    /*!
+     * \brief Escapes XML signs, to send XML strings.
+     *
+     * \param src Source XML to be escaped.
+     */
+    static std::string EscapeXML(const std::string& src)
+    {
+        std::stringstream dst;
+        for(char ch : src)
+        {
+            switch (ch)
+            {
+                case '&': dst << "&amp;"; break;
+                case '\'': dst << "&apos;"; break;
+                case '"': dst << "&quot;"; break;
+                case '<': dst << "&lt;"; break;
+                case '>': dst << "&gt;"; break;
+                default: dst << ch; break;
+            }
+        }
+
+        return dst.str();
+    }
+};
+
+#endif // TEXT_H_
diff --git a/src/Utils/Time.h b/src/Utils/Time.h
new file mode 100644
index 00000000..cffe2d97
--- /dev/null
+++ b/src/Utils/Time.h
@@ -0,0 +1,60 @@
+#ifndef TIME_H_
+#define TIME_H_
+
+#include <string>
+#include <sstream>
+#include <math.h>
+
+//* Time
+/**
+ * \brief Contains utilities to format map times.
+ */
+class Time
+{
+public:
+    /*!
+     * \brief Formats time to 0:00.000 format.
+     *
+     * \param time         Time to be formatted.
+     */
+    static std::string FormatTime(int time)
+    {
+        std::string formattedTime = "0:00.000";
+
+        if(time > 0)
+        {
+            std::stringstream timeAsStringstream;
+            timeAsStringstream << time;
+            std::string timeAsString = timeAsStringstream.str();
+
+            int minutes = floor(time / (1000 * 60));
+            int seconds = floor((time - (minutes * 60 * 1000)) / 1000);
+            int tseconds = time;
+            if(timeAsString.length() > 3)
+            {
+                tseconds = atoi(timeAsString.substr((timeAsString.length() - 3)).c_str());
+            }
+
+            char formattedCharArray[8];
+            sprintf(formattedCharArray, "%d:%02d.%03d", minutes, seconds, tseconds);
+
+            return std::string(formattedCharArray);
+        }
+
+        return formattedTime;
+    }
+
+    /*!
+     * \brief Returns the current time in yyyy-mm-dd hh:mm:ss format.
+     */
+    static std::string Current()
+    {
+        char buffer[20];
+        time_t now = time(NULL);
+        strftime(buffer, 20, "%Y-%m-%d %H:%M:%S", localtime(&now));
+
+        return std::string(buffer);
+    }
+};
+
+#endif // TIME_H_
diff --git a/src/Version/VersionChecker.cpp b/src/Version/VersionChecker.cpp
new file mode 100644
index 00000000..5cb330ab
--- /dev/null
+++ b/src/Version/VersionChecker.cpp
@@ -0,0 +1,174 @@
+#include "VersionChecker.h"
+
+bool VersionChecker::CheckForUpdates(std::string repository, std::string currentVersion)
+{
+    std::cout << "[         ] Retrieving versions for '" << repository << "' ... " << '\r' << std::flush;
+    std::string rateLimit;
+    std::string url = "https://api.github.com/rate_limit";
+    retrieveData(url, &rateLimit);
+    json j = json::parse(rateLimit);
+    json rate = j.at("rate");
+
+    std::stringstream limitStr;
+    limitStr << rate.at("limit");
+    int limit = atoi(limitStr.str().c_str());
+    std::stringstream remainingStr;
+    remainingStr << rate.at("remaining");
+    int remaining = atoi(remainingStr.str().c_str());
+    std::stringstream resetStr;
+    resetStr << rate.at("reset");
+    int reset = atoi(resetStr.str().c_str());
+
+    if(remaining == 0)
+    {
+        Logging::PrintFailedFlush();
+        std::time_t currentTime = std::time(0);
+        int timeDifference = reset - currentTime;
+        int minutesDifference = floor(timeDifference / 60);
+        int secondsDifference = timeDifference - (minutesDifference * 60);
+
+        std::stringstream rateError;
+        rateError << "Hit Github rate limiter (" << limit << "), reset in " << minutesDifference << ":" << secondsDifference << ".";
+        Logging::PrintError(-1, rateError.str());
+    }
+    else
+    {
+        std::vector<GitVersion> versions = retrieveVersions(repository);
+        Logging::PrintOKFlush();
+
+        std::vector<GitVersion> newVersions = std::vector<GitVersion>();
+        for(int versionId = 0; versionId < versions.size(); versionId++)
+        {
+            GitVersion version = versions.at(versionId);
+            version.Repository = repository;
+            bool newer = VersionCompare::NewerThanCurrent(currentVersion, version.Tag);
+            if(newer)
+            {
+                retrieveRelease(&version);
+                newVersions.push_back(version);
+            }
+
+            /*std::cout << "Repository : " << version.Repository << std::endl;
+            std::cout << "Tag        : " << version.Tag << std::endl;
+            std::cout << "Name       : " << version.Name << std::endl;
+            std::cout << "Commit     : " << version.Commit << std::endl;
+            std::cout << "PreRelease : " << version.PreRelease << std::endl;
+            std::cout << "Newer      : " << newer << std::endl;*/
+        }
+
+        if(newVersions.size() > 0)
+        {
+            std::cout << "[ VERSION ] Got " << newVersions.size() << " new versions available for '" << repository << "':" << std::endl;
+            for(int newVersionId = 0; newVersionId < newVersions.size(); newVersionId++)
+            {
+                GitVersion version = newVersions.at(newVersionId);
+                std::cout << "[   NEW   ]   " << version.Name << " (" << version.Tag << ")";
+                if(version.PreRelease)
+                    std::cout << " (pre-release)";
+                std::cout << std::endl;
+            }
+        }
+        else
+        {
+            std::cout << "[ VERSION ] No new version available for '" << repository << "'." << std::endl;
+        }
+    }
+}
+
+size_t VersionChecker::receiveData(void* contents, size_t size, size_t nmemb, std::string* s)
+{
+    size_t newLength = size*nmemb;
+    size_t oldLength = s->size();
+    try
+    {
+        s->resize(oldLength + newLength);
+    }
+    catch(std::bad_alloc &e)
+    {
+        //handle memory problem
+        return 0;
+    }
+
+    std::copy((char*)contents,(char*)contents+newLength,s->begin()+oldLength);
+    return size*nmemb;
+}
+
+void VersionChecker::retrieveData(std::string url, std::string* data)
+{
+    CURL* curl;
+    CURLcode result;
+    std::stringstream userAgent;
+    userAgent << "Mania++/" << VERSION;
+    std::string tags;
+
+    curl = curl_easy_init();
+    curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
+    curl_easy_setopt(curl, CURLOPT_USERAGENT, userAgent.str().c_str());
+    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, VersionChecker::receiveData);
+    curl_easy_setopt(curl, CURLOPT_WRITEDATA, data);
+
+    result = curl_easy_perform(curl);
+    if(result != CURLE_OK)
+    {
+        fprintf(stderr, "curl_easy_perform() failed: %s\n",
+                curl_easy_strerror(result));
+    }
+
+    curl_easy_cleanup(curl);
+}
+
+std::vector<GitVersion> VersionChecker::retrieveVersions(std::string repository)
+{
+    std::string versions;
+    std::string url = "https://api.github.com/repos/" + repository + "/tags";
+    retrieveData(url, &versions);
+    return decodeVersions(versions);
+}
+
+std::vector<GitVersion> VersionChecker::decodeVersions(std::string response)
+{
+    std::vector<GitVersion> versions = std::vector<GitVersion>();
+
+    json j = json::parse(response);
+
+    for (json::iterator it = j.begin(); it != j.end(); ++it) {
+        json jsonName = it.value()["name"];
+        std::string name = jsonName.get<std::string>();
+        json jsonCommit = it.value()["commit"]["sha"];
+        std::string commit = jsonCommit.get<std::string>();
+
+        GitVersion version = GitVersion();
+        version.Tag = name;
+        version.Commit = commit;
+        versions.push_back(version);
+    }
+
+    return versions;
+}
+
+void VersionChecker::retrieveRelease(GitVersion* version)
+{
+    std::string release;
+    std::string url = "https://api.github.com/repos/" + version->Repository + "/releases/tags/" + version->Tag;
+    retrieveData(url, &release);
+    return decodeRelease(version, release);
+}
+
+void VersionChecker::decodeRelease(GitVersion* version, std::string response)
+{
+    json j = json::parse(response);
+
+    json::iterator nameIt = j.find("name");
+    if(nameIt != j.end())
+    {
+        json jsonName = nameIt.value();
+        version->Name = jsonName.get<std::string>();
+    }
+
+    json::iterator prereleaseIt = j.find("prerelease");
+    if(prereleaseIt != j.end())
+    {
+        json jsonPrerelease = prereleaseIt.value();
+        version->PreRelease = jsonPrerelease.get<bool>();
+    }
+}
diff --git a/src/Version/VersionChecker.h b/src/Version/VersionChecker.h
new file mode 100644
index 00000000..1131bfbf
--- /dev/null
+++ b/src/Version/VersionChecker.h
@@ -0,0 +1,129 @@
+#ifndef VERSIONCHECKER_H_
+#define VERSIONCHECKER_H_
+
+#include <curl/curl.h>
+#include "json.hpp"
+
+#include "Config/Version.h"
+#include "../Utils/Logging.h"
+
+using json = nlohmann::json;
+
+//* GitVersion
+/**
+ * \brief Contains information about a Git release (version).
+ */
+struct GitVersion
+{
+    std::string Repository; /**< \brief Name of the GitHub repository. */
+    std::string Tag;        /**< \brief Tag version. */
+    std::string Name;       /**< \brief Tag name (description). */
+    std::string Commit;     /**< \brief SHA commit. */
+    bool PreRelease;        /**< \brief Is pre-release?. */
+};
+
+//* VersionCompare
+/**
+ * \brief Compares string versions.
+ */
+class VersionCompare
+{
+public:
+    /*!
+     * Compares two string versions.
+     *
+     * \param current Current string version.
+     * \param other   String version to compare.
+     */
+    static bool NewerThanCurrent(const std::string& current, const std::string& other)
+    {
+        int parsedCurrent[3], parsedOther[3];
+        parseVersion(parsedCurrent, current);
+        parseVersion(parsedOther, other);
+        return std::lexicographical_compare(parsedCurrent, parsedCurrent + 3, parsedOther, parsedOther + 3);
+    }
+
+private:
+    /*!
+     * Converts version string into comparable integer array.
+     *
+     * \param result  Integer array for the comparable result.
+     * \param input   String input to be parsed.
+     */
+    static void parseVersion(int result[3], const std::string& input)
+    {
+        std::istringstream parser(input);
+        parser >> result[0];
+        for(int idx = 1; idx < 3; idx++)
+        {
+            parser.get();
+            parser >> result[idx];
+        }
+    }
+};
+
+//* VersionChecker
+/**
+ * \brief Checks Mania++ version (and possibly plugin versions).
+ */
+class VersionChecker
+{
+public:
+    /*!
+     * \brief Returns whether there are updates available.
+     *
+     * \param repository     Name of the GitHub repository.
+     * \param currentVersion Version to which the repository to.
+     */
+    bool CheckForUpdates(std::string repository, std::string currentVersion);
+
+private:
+    /*!
+     * \brief Receives data from cURL input.
+     *
+     * \param contents       Contents from cURL.
+     * \param size           Size of contents.
+     * \param nmemb          Number of members (?).
+     * \param tags           Output string.
+     */
+    static size_t receiveData(void* contents, size_t size, size_t nmemb, std::string* tags);
+
+    /*!
+     * \brief Retrieves data via cURL.
+     *
+     * \param url            URL to retrieve.
+     * \param data           Received data (return).
+     */
+    void retrieveData(std::string url, std::string* data);
+
+    /*!
+     * \brief Retrieves versions (tags) of repository.
+     *
+     * \param repository     Repository name.
+     */
+    std::vector<GitVersion> retrieveVersions(std::string repository);
+
+    /*!
+     * \brief Decodes the JSON response with versions (tags) of repository.
+     *
+     * \param response       Server response (JSON).
+     */
+    std::vector<GitVersion> decodeVersions(std::string response);
+
+    /*!
+     * \brief Retrieves release information.
+     *
+     * \param version        Version struct.
+     */
+    void retrieveRelease(GitVersion* version);
+
+    /*!
+     * \brief Decodes the JSON response with release and inputs info into version struct.
+     *
+     * \param version        Version struct.
+     * \param response       Server response (JSON).
+     */
+    void decodeRelease(GitVersion* version, std::string response);
+};
+
+#endif // VERSIONCHECKER_H_