SHA1
--- a/Makefile
+++ b/Makefile
@@ -8,7 +8,7 @@ LIBS = blkid freetype2 glew libenet libjpeg liblzma OpenCL xi zlib
 
 CXXFLAGS = -std=c++17 -fmessage-length=0 -Wno-sign-compare -Wno-unused-local-typedefs -Wno-reorder -Wno-switch -Wall
 
 CXXFLAGS += `pkgconf --static --cflags $(LIBS)` `curl-config --cflags`
 
 CXXFLAGS += -Isrc/App -Isrc/App/Osu -Isrc/Engine -Isrc/GUI -Isrc/GUI/Windows -Isrc/GUI/Windows/VinylScratcher -Isrc/Engine/Input -Isrc/Engine/Platform -Isrc/Engine/Main -Isrc/Engine/Renderer -Isrc/Util
 
-CXXFLAGS += -Ilibraries/bassasio/include -Ilibraries/bassmix/include -Ilibraries/basswasapi/include -Ilibraries/bassloud/include
 
+CXXFLAGS += -Ilibraries/bass/include -Ilibraries/bassasio/include -Ilibraries/bassfx/include -Ilibraries/bassmix/include -Ilibraries/basswasapi/include -Ilibraries/bassloud/include
 
 CXXFLAGS += -g3
 
 
 
 LDFLAGS = -ldiscord-rpc -lbass -lbassmix -lbass_fx -lbassloud -lpthread -lstdc++
--- a/README.md
+++ b/README.md
@@ -21,6 +21,7 @@ Required dependencies:
 
 - [bass_fx](https://www.un4seen.com/download.php?z/0/bass_fx24-linux)
 
 - [BASSloud](https://www.un4seen.com/download.php?bassloud24-linux)
 
 - blkid
 
+- discord-rpc
 
 - freetype2
 
 - glew
 
 - libenet
--- a/src/App/Osu/OsuBackgroundImageHandler.cpp
+++ b/src/App/Osu/OsuBackgroundImageHandler.cpp
@@ -5,11 +5,11 @@
 
 // $NoKeywords: $osubgldr
 
 //===============================================================================//
 
 
 
-#include "OsuBackgroundImageHandler.h"
 
+#include "BackgroundImageHandler.h"
 
 
 
 #include "ConVar.h"
 
+#include "DatabaseBeatmap.h"
 
 #include "Engine.h"
 
-#include "OsuDatabaseBeatmap.h"
 
 #include "ResourceManager.h"
 
 
 
 ConVar osu_load_beatmap_background_images("osu_load_beatmap_background_images", true, FCVAR_NONE);
@@ -26,9 +26,9 @@ ConVar osu_background_image_eviction_delay_frames(
 
     "osu_background_image_eviction_delay_frames", 0, FCVAR_NONE,
 
     "how many frames to keep stale background images in the cache before deleting them (if seconds && frames)");
 
 
 
-OsuBackgroundImageHandler::OsuBackgroundImageHandler() { m_bFrozen = false; }
 
+BackgroundImageHandler::BackgroundImageHandler() { m_bFrozen = false; }
 
 
 
-OsuBackgroundImageHandler::~OsuBackgroundImageHandler() {
 
+BackgroundImageHandler::~BackgroundImageHandler() {
 
     for(size_t i = 0; i < m_cache.size(); i++) {
 
         engine->getResourceManager()->destroyResource(m_cache[i].backgroundImagePathLoader);
 
         engine->getResourceManager()->destroyResource(m_cache[i].image);
@@ -36,7 +36,7 @@ OsuBackgroundImageHandler::~OsuBackgroundImageHandler() {
 
     m_cache.clear();
 
 }
 
 
 
-void OsuBackgroundImageHandler::update(bool allowEviction) {
 
+void BackgroundImageHandler::update(bool allowEviction) {
 
     for(size_t i = 0; i < m_cache.size(); i++) {
 
         ENTRY &entry = m_cache[i];
 
 
@@ -73,7 +73,7 @@ void OsuBackgroundImageHandler::update(bool allowEviction) {
 
 
 
                     if(entry.backgroundImageFileName.length() < 2) {
 
                         // if the backgroundImageFileName is not loaded, then we have to create a full
 
-                        // OsuDatabaseBeatmapBackgroundImagePathLoader
 
+                        // DatabaseBeatmapBackgroundImagePathLoader
 
                         entry.image = NULL;
 
                         handleLoadPathForEntry(entry);
 
                     } else {
@@ -107,15 +107,15 @@ void OsuBackgroundImageHandler::update(bool allowEviction) {
 
     // debugLog("m_cache.size() = %i\n", (int)m_cache.size());
 
 }
 
 
 
-void OsuBackgroundImageHandler::handleLoadPathForEntry(ENTRY &entry) {
 
-    entry.backgroundImagePathLoader = new OsuDatabaseBeatmapBackgroundImagePathLoader(entry.osuFilePath);
 
+void BackgroundImageHandler::handleLoadPathForEntry(ENTRY &entry) {
 
+    entry.backgroundImagePathLoader = new DatabaseBeatmapBackgroundImagePathLoader(entry.osuFilePath);
 
 
 
     // start path load
 
     engine->getResourceManager()->requestNextLoadAsync();
 
     engine->getResourceManager()->loadResource(entry.backgroundImagePathLoader);
 
 }
 
 
 
-void OsuBackgroundImageHandler::handleLoadImageForEntry(ENTRY &entry) {
 
+void BackgroundImageHandler::handleLoadImageForEntry(ENTRY &entry) {
 
     std::string fullBackgroundImageFilePath = entry.folder;
 
     fullBackgroundImageFilePath.append(entry.backgroundImageFileName);
 
 
@@ -125,11 +125,11 @@ void OsuBackgroundImageHandler::handleLoadImageForEntry(ENTRY &entry) {
 
     entry.image = engine->getResourceManager()->loadImageAbsUnnamed(fullBackgroundImageFilePath);
 
 }
 
 
 
-Image *OsuBackgroundImageHandler::getLoadBackgroundImage(const OsuDatabaseBeatmap *beatmap) {
 
+Image *BackgroundImageHandler::getLoadBackgroundImage(const DatabaseBeatmap *beatmap) {
 
     if(beatmap == NULL || !osu_load_beatmap_background_images.getBool()) return NULL;
 
 
 
     // NOTE: no references to beatmap are kept anywhere (database can safely be deleted/reloaded without having to
 
-    // notify the OsuBackgroundImageHandler)
 
+    // notify the BackgroundImageHandler)
 
 
 
     const float newLoadingTime = engine->getTime() + osu_background_image_loading_delay.getFloat();
 
     const float newEvictionTime = engine->getTime() + osu_background_image_eviction_delay_seconds.getFloat();
@@ -151,10 +151,9 @@ Image *OsuBackgroundImageHandler::getLoadBackgroundImage(const OsuDatabaseBeatma
 
             // worked before the rework, but 100% safe(r) since we are not async
 
             if(m_cache[i].image != NULL && m_cache[i].backgroundImageFileName.length() > 1 &&
 
                beatmap->getBackgroundImageFileName().length() < 2) {
 
-                const_cast<OsuDatabaseBeatmap *>(beatmap)->m_sBackgroundImageFileName =
 
-                    m_cache[i].backgroundImageFileName;
 
-                const_cast<OsuDatabaseBeatmap *>(beatmap)->m_sFullBackgroundImageFilePath = beatmap->getFolder();
 
-                const_cast<OsuDatabaseBeatmap *>(beatmap)->m_sFullBackgroundImageFilePath.append(
 
+                const_cast<DatabaseBeatmap *>(beatmap)->m_sBackgroundImageFileName = m_cache[i].backgroundImageFileName;
 
+                const_cast<DatabaseBeatmap *>(beatmap)->m_sFullBackgroundImageFilePath = beatmap->getFolder();
 
+                const_cast<DatabaseBeatmap *>(beatmap)->m_sFullBackgroundImageFilePath.append(
 
                     m_cache[i].backgroundImageFileName);
 
             }
 
 
--- a/src/App/Osu/OsuBackgroundImageHandler.h
+++ b/src/App/Osu/OsuBackgroundImageHandler.h
@@ -12,19 +12,19 @@
 
 
 
 class Image;
 
 
 
-class OsuDatabaseBeatmap;
 
-class OsuDatabaseBeatmapBackgroundImagePathLoader;
 
+class DatabaseBeatmap;
 
+class DatabaseBeatmapBackgroundImagePathLoader;
 
 
 
-class OsuBackgroundImageHandler {
 
+class BackgroundImageHandler {
 
    public:
 
-    OsuBackgroundImageHandler();
 
-    ~OsuBackgroundImageHandler();
 
+    BackgroundImageHandler();
 
+    ~BackgroundImageHandler();
 
 
 
     void update(bool allowEviction);
 
 
 
     void scheduleFreezeCache() { m_bFrozen = true; }
 
 
 
-    Image *getLoadBackgroundImage(const OsuDatabaseBeatmap *beatmap);
 
+    Image *getLoadBackgroundImage(const DatabaseBeatmap *beatmap);
 
 
 
    private:
 
     struct ENTRY {
@@ -38,7 +38,7 @@ class OsuBackgroundImageHandler {
 
         std::string folder;
 
         std::string backgroundImageFileName;
 
 
 
-        OsuDatabaseBeatmapBackgroundImagePathLoader *backgroundImagePathLoader;
 
+        DatabaseBeatmapBackgroundImagePathLoader *backgroundImagePathLoader;
 
         Image *image;
 
     };
 
 
--- a/src/App/Osu/OsuBackgroundStarCacheLoader.cpp
+++ b/src/App/Osu/OsuBackgroundStarCacheLoader.cpp
@@ -1,33 +1,33 @@
 
 //================ Copyright (c) 2020, PG, All rights reserved. =================//
 
 //
 
-// Purpose:		used by OsuBeatmap for populating the live pp star cache
 
+// Purpose:		used by Beatmap for populating the live pp star cache
 
 //
 
 // $NoKeywords: $osubgscache
 
 //===============================================================================//
 
 
 
-#include "OsuBackgroundStarCacheLoader.h"
 
+#include "BackgroundStarCacheLoader.h"
 
 
 
-#include "OsuBeatmap.h"
 
-#include "OsuDatabaseBeatmap.h"
 
-#include "OsuDifficultyCalculator.h"
 
+#include "Beatmap.h"
 
+#include "DatabaseBeatmap.h"
 
+#include "DifficultyCalculator.h"
 
 
 
-OsuBackgroundStarCacheLoader::OsuBackgroundStarCacheLoader(OsuBeatmap *beatmap) : Resource() {
 
+BackgroundStarCacheLoader::BackgroundStarCacheLoader(Beatmap *beatmap) : Resource() {
 
     m_beatmap = beatmap;
 
 
 
     m_bDead = true;  // NOTE: start dead! need to revive() before use
 
     m_iProgress = 0;
 
 }
 
 
 
-void OsuBackgroundStarCacheLoader::init() { m_bReady = true; }
 
+void BackgroundStarCacheLoader::init() { m_bReady = true; }
 
 
 
-void OsuBackgroundStarCacheLoader::initAsync() {
 
+void BackgroundStarCacheLoader::initAsync() {
 
     if(m_bDead.load()) {
 
         m_bAsyncReady = true;
 
         return;
 
     }
 
 
 
     // recalculate star cache
 
-    OsuDatabaseBeatmap *diff2 = m_beatmap->getSelectedDifficulty2();
 
+    DatabaseBeatmap *diff2 = m_beatmap->getSelectedDifficulty2();
 
     if(diff2 != NULL) {
 
         // precalculate cut star values for live pp
 
 
@@ -46,8 +46,8 @@ void OsuBackgroundStarCacheLoader::initAsync() {
 
         const bool relax = m_beatmap->getOsu()->getModRelax();
 
         const bool touchDevice = m_beatmap->getOsu()->getModTD();
 
 
 
-        OsuDatabaseBeatmap::LOAD_DIFFOBJ_RESULT diffres =
 
-            OsuDatabaseBeatmap::loadDifficultyHitObjects(osuFilePath, AR, CS, speedMultiplier, false, m_bDead);
 
+        DatabaseBeatmap::LOAD_DIFFOBJ_RESULT diffres =
 
+            DatabaseBeatmap::loadDifficultyHitObjects(osuFilePath, AR, CS, speedMultiplier, false, m_bDead);
 
 
 
         for(size_t i = 0; i < diffres.diffobjects.size(); i++) {
 
             double aimStars = 0.0;
@@ -55,9 +55,9 @@ void OsuBackgroundStarCacheLoader::initAsync() {
 
             double speedStars = 0.0;
 
             double speedNotes = 0.0;
 
 
 
-            OsuDifficultyCalculator::calculateStarDiffForHitObjects(diffres.diffobjects, CS, OD, speedMultiplier, relax,
 
-                                                                    touchDevice, &aimStars, &aimSliderFactor,
 
-                                                                    &speedStars, &speedNotes, i, NULL, NULL, m_bDead);
 
+            DifficultyCalculator::calculateStarDiffForHitObjects(diffres.diffobjects, CS, OD, speedMultiplier, relax,
 
+                                                                 touchDevice, &aimStars, &aimSliderFactor, &speedStars,
 
+                                                                 &speedNotes, i, NULL, NULL, m_bDead);
 
 
 
             m_beatmap->m_aimStarsForNumHitObjects.push_back(aimStars);
 
             m_beatmap->m_aimSliderFactorForNumHitObjects.push_back(aimSliderFactor);
--- a/src/App/Osu/OsuBackgroundStarCacheLoader.h
+++ b/src/App/Osu/OsuBackgroundStarCacheLoader.h
@@ -1,6 +1,6 @@
 
 //================ Copyright (c) 2020, PG, All rights reserved. =================//
 
 //
 
-// Purpose:		used by OsuBeatmap for populating the live pp star cache
 
+// Purpose:		used by Beatmap for populating the live pp star cache
 
 //
 
 // $NoKeywords: $osubgscache
 
 //===============================================================================//
@@ -10,11 +10,11 @@
 
 
 
 #include "Resource.h"
 
 
 
-class OsuBeatmap;
 
+class Beatmap;
 
 
 
-class OsuBackgroundStarCacheLoader : public Resource {
 
+class BackgroundStarCacheLoader : public Resource {
 
    public:
 
-    OsuBackgroundStarCacheLoader(OsuBeatmap *beatmap);
 
+    BackgroundStarCacheLoader(Beatmap *beatmap);
 
 
 
     bool isDead() { return m_bDead.load(); }
 
     void kill() {
@@ -34,7 +34,7 @@ class OsuBackgroundStarCacheLoader : public Resource {
 
     virtual void destroy() { ; }
 
 
 
    private:
 
-    OsuBeatmap *m_beatmap;
 
+    Beatmap *m_beatmap;
 
 
 
     std::atomic<bool> m_bDead;
 
     std::atomic<int> m_iProgress;
--- a/src/App/Osu/Bancho.cpp
+++ b/src/App/Osu/Bancho.cpp
@@ -18,19 +18,19 @@
 
 #include "BanchoNetworking.h"
 
 #include "BanchoProtocol.h"
 
 #include "BanchoUsers.h"
 
+#include "Chat.h"
 
 #include "ConVar.h"
 
 #include "Engine.h"
 
+#include "Lobby.h"
 
 #include "MD5.h"
 
+#include "NotificationOverlay.h"
 
+#include "OptionsMenu.h"
 
 #include "Osu.h"
 
-#include "OsuChat.h"
 
-#include "OsuLobby.h"
 
-#include "OsuNotificationOverlay.h"
 
-#include "OsuOptionsMenu.h"
 
-#include "OsuRoom.h"
 
-#include "OsuSongBrowser.h"
 
-#include "OsuUIAvatar.h"
 
-#include "OsuUIButton.h"
 
-#include "OsuUISongBrowserUserButton.h"
 
+#include "RoomScreen.h"
 
+#include "SongBrowser.h"
 
+#include "UIAvatar.h"
 
+#include "UIButton.h"
 
+#include "UISongBrowserUserButton.h"
 
 
 
 Bancho bancho;
 
 std::unordered_map<std::string, Channel *> chat_channels;
@@ -46,7 +46,7 @@ bool Bancho::submit_scores() {
 
     }
 
 }
 
 
 
-void update_channel(UString name, UString topic, int32_t nb_members) {
 
+void update_channel(UString name, UString topic, i32 nb_members) {
 
     Channel *chan;
 
     auto name_str = std::string(name.toUtf8());
 
     auto it = chat_channels.find(name_str);
@@ -72,12 +72,12 @@ void update_channel(UString name, UString topic, int32_t nb_members) {
 
     chan->nb_members = nb_members;
 
 }
 
 
 
-MD5Hash md5(uint8_t *msg, size_t msg_len) {
 
+MD5Hash md5(u8 *msg, size_t msg_len) {
 
     MD5 hasher;
 
     hasher.update(msg, msg_len);
 
     hasher.finalize();
 
 
 
-    uint8_t *digest = hasher.getDigest();
 
+    u8 *digest = hasher.getDigest();
 
     MD5Hash out;
 
     for(int i = 0; i < 16; i++) {
 
         out.hash[i * 2] = "0123456789abcdef"[digest[i] >> 4];
@@ -186,8 +186,9 @@ UString get_disk_uuid() {
 
 }
 
 
 
 void handle_packet(Packet *packet) {
 
+    // XXX: This is a bit of a mess, should at least group packets by type for readability
 
     if(packet->id == USER_ID) {
 
-        bancho.user_id = read_int32(packet);
 
+        bancho.user_id = read<u32>(packet);
 
         if(bancho.user_id > 0) {
 
             debugLog("Logged in as user #%d.\n", bancho.user_id);
 
             bancho.osu->m_optionsMenu->logInButton->setText("Disconnect");
@@ -215,13 +216,16 @@ void handle_packet(Packet *packet) {
 
 
 
             // close your eyes
 
             SAFE_DELETE(bancho.osu->m_songBrowser2->m_userButton->m_avatar);
 
-            bancho.osu->m_songBrowser2->m_userButton->m_avatar = new OsuUIAvatar(bancho.user_id, 0.f, 0.f, 0.f, 0.f);
 
+            bancho.osu->m_songBrowser2->m_userButton->m_avatar = new UIAvatar(bancho.user_id, 0.f, 0.f, 0.f, 0.f);
 
             bancho.osu->m_songBrowser2->m_userButton->m_avatar->on_screen = true;
 
 
 
             // XXX: We should toggle between "offline" sorting options and "online" ones
 
             //      Online ones would be "Local scores", "Global", "Country", "Selected mods" etc
 
             //      While offline ones would be "By score", "By pp", etc
 
             bancho.osu->m_songBrowser2->onSortScoresChange(UString("Online Leaderboard"), 0);
 
+
 
+            // If server sent a score submission policy, update options menu to hide the checkbox
 
+            bancho.osu->m_optionsMenu->updateLayout();
 
         } else {
 
             convar->getConVarByName("mp_autologin")->setValue(false);
 
             bancho.osu->m_optionsMenu->logInButton->setText("Log in");
@@ -259,7 +263,7 @@ void handle_packet(Packet *packet) {
 
         UString sender = read_string(packet);
 
         UString text = read_string(packet);
 
         UString recipient = read_string(packet);
 
-        int32_t sender_id = read_int32(packet);
 
+        i32 sender_id = read<u32>(packet);
 
 
 
         bancho.osu->m_chat->addMessage(recipient, ChatMessage{
 
                                                       .tms = time(NULL),
@@ -270,44 +274,44 @@ void handle_packet(Packet *packet) {
 
     } else if(packet->id == PONG) {
 
         // (nothing to do)
 
     } else if(packet->id == USER_STATS) {
 
-        int32_t stats_user_id = read_int32(packet);
 
-        uint8_t action = read_byte(packet);
 
+        i32 stats_user_id = read<u32>(packet);
 
+        u8 action = read<u8>(packet);
 
 
 
         UserInfo *user = get_user_info(stats_user_id);
 
         user->action = (Action)action;
 
         user->info_text = read_string(packet);
 
         user->map_md5 = read_string(packet);
 
-        user->mods = read_int32(packet);
 
-        user->mode = (GameMode)read_byte(packet);
 
-        user->map_id = read_int32(packet);
 
-        user->ranked_score = read_int64(packet);
 
-        user->accuracy = read_float32(packet);
 
-        user->plays = read_int32(packet);
 
-        user->total_score = read_int64(packet);
 
-        user->global_rank = read_int32(packet);
 
-        user->pp = read_short(packet);
 
+        user->mods = read<u32>(packet);
 
+        user->mode = (GameMode)read<u8>(packet);
 
+        user->map_id = read<u32>(packet);
 
+        user->ranked_score = read<u64>(packet);
 
+        user->accuracy = read<f32>(packet);
 
+        user->plays = read<u32>(packet);
 
+        user->total_score = read<u64>(packet);
 
+        user->global_rank = read<u32>(packet);
 
+        user->pp = read<u16>(packet);
 
 
 
         if(stats_user_id == bancho.user_id) {
 
             bancho.osu->m_songBrowser2->m_userButton->updateUserStats();
 
         }
 
     } else if(packet->id == USER_LOGOUT) {
 
-        int32_t logged_out_id = read_int32(packet);
 
-        read_byte(packet);
 
+        i32 logged_out_id = read<u32>(packet);
 
+        read<u8>(packet);
 
         if(logged_out_id == bancho.user_id) {
 
             debugLog("Logged out.\n");
 
             disconnect();
 
         }
 
     } else if(packet->id == SPECTATOR_JOINED) {
 
-        int32_t spectator_id = read_int32(packet);
 
+        i32 spectator_id = read<u32>(packet);
 
         debugLog("Spectator joined: user id %d\n", spectator_id);
 
     } else if(packet->id == SPECTATOR_LEFT) {
 
-        int32_t spectator_id = read_int32(packet);
 
+        i32 spectator_id = read<u32>(packet);
 
         debugLog("Spectator left: user id %d\n", spectator_id);
 
     } else if(packet->id == VERSION_UPDATE) {
 
         disconnect();
 
         bancho.osu->getNotificationOverlay()->addNotification("Server uses an unsupported protocol version.");
 
     } else if(packet->id == SPECTATOR_CANT_SPECTATE) {
 
-        int32_t spectator_id = read_int32(packet);
 
+        i32 spectator_id = read<u32>(packet);
 
         debugLog("Spectator can't spectate: user id %d\n", spectator_id);
 
     } else if(packet->id == GET_ATTENTION) {
 
         // (nothing to do)
@@ -329,7 +333,7 @@ void handle_packet(Packet *packet) {
 
         auto room = new Room(packet);
 
         bancho.osu->m_lobby->addRoom(room);
 
     } else if(packet->id == ROOM_CLOSED) {
 
-        int32_t room_id = read_int32(packet);
 
+        i32 room_id = read<u32>(packet);
 
         bancho.osu->m_lobby->removeRoom(room_id);
 
     } else if(packet->id == ROOM_JOIN_SUCCESS) {
 
         auto room = Room(packet);
@@ -338,10 +342,10 @@ void handle_packet(Packet *packet) {
 
         bancho.osu->getNotificationOverlay()->addNotification("Failed to join room.");
 
         bancho.osu->m_lobby->on_room_join_failed();
 
     } else if(packet->id == FELLOW_SPECTATOR_JOINED) {
 
-        uint32_t spectator_id = read_int32(packet);
 
+        u32 spectator_id = read<u32>(packet);
 
         (void)spectator_id;  // (spectating not implemented; nothing to do)
 
     } else if(packet->id == FELLOW_SPECTATOR_LEFT) {
 
-        uint32_t spectator_id = read_int32(packet);
 
+        u32 spectator_id = read<u32>(packet);
 
         (void)spectator_id;  // (spectating not implemented; nothing to do)
 
     } else if(packet->id == MATCH_STARTED) {
 
         auto room = Room(packet);
@@ -353,7 +357,7 @@ void handle_packet(Packet *packet) {
 
     } else if(packet->id == MATCH_ALL_PLAYERS_LOADED) {
 
         bancho.osu->m_room->on_all_players_loaded();
 
     } else if(packet->id == MATCH_PLAYER_FAILED) {
 
-        int32_t slot_id = read_int32(packet);
 
+        i32 slot_id = read<u32>(packet);
 
         bancho.osu->m_room->on_player_failed(slot_id);
 
     } else if(packet->id == MATCH_FINISHED) {
 
         bancho.osu->m_room->on_match_finished();
@@ -371,7 +375,7 @@ void handle_packet(Packet *packet) {
 
     } else if(packet->id == CHANNEL_INFO) {
 
         UString channel_name = read_string(packet);
 
         UString channel_topic = read_string(packet);
 
-        int32_t nb_members = read_int32(packet);
 
+        i32 nb_members = read<u32>(packet);
 
         update_channel(channel_name, channel_topic, nb_members);
 
     } else if(packet->id == LEFT_CHANNEL) {
 
         UString name = read_string(packet);
@@ -379,21 +383,21 @@ void handle_packet(Packet *packet) {
 
     } else if(packet->id == CHANNEL_AUTO_JOIN) {
 
         UString channel_name = read_string(packet);
 
         UString channel_topic = read_string(packet);
 
-        int32_t nb_members = read_int32(packet);
 
+        i32 nb_members = read<u32>(packet);
 
         update_channel(channel_name, channel_topic, nb_members);
 
     } else if(packet->id == PRIVILEGES) {
 
-        read_int32(packet);
 
+        read<u32>(packet);
 
         // (nothing to do)
 
     } else if(packet->id == FRIENDS_LIST) {
 
         friends.clear();
 
 
 
-        uint16_t nb_friends = read_short(packet);
 
+        u16 nb_friends = read<u16>(packet);
 
         for(int i = 0; i < nb_friends; i++) {
 
-            uint32_t friend_id = read_int32(packet);
 
+            u32 friend_id = read<u32>(packet);
 
             friends.push_back(friend_id);
 
         }
 
     } else if(packet->id == PROTOCOL_VERSION) {
 
-        int protocol_version = read_int32(packet);
 
+        int protocol_version = read<u32>(packet);
 
         if(protocol_version != 19) {
 
             disconnect();
 
             bancho.osu->getNotificationOverlay()->addNotification("Server uses an unsupported protocol version.");
@@ -405,7 +409,7 @@ void handle_packet(Packet *packet) {
 
             bancho.server_icon_url = urls[0];
 
         }
 
     } else if(packet->id == MATCH_PLAYER_SKIPPED) {
 
-        int32_t user_id = read_int32(packet);
 
+        i32 user_id = read<u32>(packet);
 
         bancho.osu->m_room->on_player_skip(user_id);
 
 
 
         // I'm not sure the server ever sends MATCH_SKIP... So, double-checking here.
@@ -421,20 +425,20 @@ void handle_packet(Packet *packet) {
 
             bancho.osu->m_room->on_all_players_skipped();
 
         }
 
     } else if(packet->id == USER_PRESENCE) {
 
-        int32_t presence_user_id = read_int32(packet);
 
+        i32 presence_user_id = read<u32>(packet);
 
         UString presence_username = read_string(packet);
 
 
 
         UserInfo *user = get_user_info(presence_user_id);
 
         user->name = presence_username;
 
-        user->utc_offset = read_byte(packet);
 
-        user->country = read_byte(packet);
 
-        user->privileges = read_byte(packet);
 
-        user->longitude = read_float32(packet);
 
-        user->latitude = read_float32(packet);
 
-        user->global_rank = read_int32(packet);
 
+        user->utc_offset = read<u8>(packet);
 
+        user->country = read<u8>(packet);
 
+        user->privileges = read<u8>(packet);
 
+        user->longitude = read<f32>(packet);
 
+        user->latitude = read<f32>(packet);
 
+        user->global_rank = read<u32>(packet);
 
     } else if(packet->id == RESTART) {
 
         // XXX: wait 'ms' milliseconds before reconnecting
 
-        int32_t ms = read_int32(packet);
 
+        i32 ms = read<u32>(packet);
 
         (void)ms;
 
 
 
         // Some servers send "restart" packets when password is incorrect
@@ -447,7 +451,7 @@ void handle_packet(Packet *packet) {
 
         UString text = read_string(packet);
 
         UString recipient = read_string(packet);
 
         (void)recipient;
 
-        int32_t sender_id = read_int32(packet);
 
+        i32 sender_id = read<u32>(packet);
 
         bancho.osu->m_chat->addMessage(recipient, ChatMessage{
 
                                                       .tms = time(NULL),
 
                                                       .author_id = sender_id,
@@ -463,23 +467,23 @@ void handle_packet(Packet *packet) {
 
         debugLog("Room changed password to %s\n", new_password.toUtf8());
 
         bancho.room.password = new_password;
 
     } else if(packet->id == SILENCE_END) {
 
-        int32_t delta = read_int32(packet);
 
+        i32 delta = read<u32>(packet);
 
         debugLog("Silence ends in %d seconds.\n", delta);
 
         // XXX: Prevent user from sending messages while silenced
 
     } else if(packet->id == USER_SILENCED) {
 
-        int32_t user_id = read_int32(packet);
 
+        i32 user_id = read<u32>(packet);
 
         debugLog("User #%d silenced.\n", user_id);
 
     } else if(packet->id == USER_DM_BLOCKED) {
 
         read_string(packet);
 
         read_string(packet);
 
         UString blocked = read_string(packet);
 
-        read_int32(packet);
 
+        read<u32>(packet);
 
         debugLog("Blocked %s.\n", blocked.toUtf8());
 
     } else if(packet->id == TARGET_IS_SILENCED) {
 
         read_string(packet);
 
         read_string(packet);
 
         UString blocked = read_string(packet);
 
-        read_int32(packet);
 
+        read<u32>(packet);
 
         debugLog("Silenced %s.\n", blocked.toUtf8());
 
     } else if(packet->id == VERSION_UPDATE_FORCED) {
 
         disconnect();
@@ -499,14 +503,14 @@ Packet build_login_packet() {
 
     // username\npasswd_md5\nosu_version|utc_offset|display_city|client_hashes|pm_private\n
 
     Packet packet;
 
 
 
-    write_bytes(&packet, (uint8_t *)bancho.username.toUtf8(), bancho.username.lengthUtf8());
 
-    write_byte(&packet, '\n');
 
+    write_bytes(&packet, (u8 *)bancho.username.toUtf8(), bancho.username.lengthUtf8());
 
+    write_u8(&packet, '\n');
 
 
 
-    write_bytes(&packet, (uint8_t *)bancho.pw_md5.hash, 32);
 
-    write_byte(&packet, '\n');
 
+    write_bytes(&packet, (u8 *)bancho.pw_md5.hash, 32);
 
+    write_u8(&packet, '\n');
 
 
 
-    write_bytes(&packet, (uint8_t *)OSU_VERSION, strlen(OSU_VERSION));
 
-    write_byte(&packet, '|');
 
+    write_bytes(&packet, (u8 *)OSU_VERSION, strlen(OSU_VERSION));
 
+    write_u8(&packet, '|');
 
 
 
     // UTC offset
 
     time_t now = time(NULL);
@@ -514,15 +518,15 @@ Packet build_login_packet() {
 
     auto local_time = localtime(&now);
 
     int utc_offset = difftime(mktime(local_time), mktime(gmt)) / 3600;
 
     if(utc_offset < 0) {
 
-        write_byte(&packet, '-');
 
+        write_u8(&packet, '-');
 
         utc_offset *= -1;
 
     }
 
-    write_byte(&packet, '0' + utc_offset);
 
-    write_byte(&packet, '|');
 
+    write_u8(&packet, '0' + utc_offset);
 
+    write_u8(&packet, '|');
 
 
 
     // Don't dox the user's city
 
-    write_byte(&packet, '0');
 
-    write_byte(&packet, '|');
 
+    write_u8(&packet, '0');
 
+    write_u8(&packet, '|');
 
 
 
     char osu_path[PATH_MAX] = {0};
 
 #ifdef _WIN32
@@ -531,30 +535,30 @@ Packet build_login_packet() {
 
     readlink("/proc/self/exe", osu_path, PATH_MAX - 1);
 
 #endif
 
 
 
-    MD5Hash osu_path_md5 = md5((uint8_t *)osu_path, strlen(osu_path));
 
+    MD5Hash osu_path_md5 = md5((u8 *)osu_path, strlen(osu_path));
 
 
 
     // XXX: Should get MAC addresses from network adapters
 
     // NOTE: Not sure how the MD5 is computed - does it include final "." ?
 
     const char *adapters = "runningunderwine";
 
-    MD5Hash adapters_md5 = md5((uint8_t *)adapters, strlen(adapters));
 
+    MD5Hash adapters_md5 = md5((u8 *)adapters, strlen(adapters));
 
 
 
     // XXX: Should remove '|' from the disk UUID just to be safe
 
     bancho.disk_uuid = get_disk_uuid();
 
-    MD5Hash disk_md5 = md5((uint8_t *)bancho.disk_uuid.toUtf8(), bancho.disk_uuid.lengthUtf8());
 
+    MD5Hash disk_md5 = md5((u8 *)bancho.disk_uuid.toUtf8(), bancho.disk_uuid.lengthUtf8());
 
 
 
     // XXX: Not implemented, I'm lazy so just reusing disk signature
 
     bancho.install_id = bancho.disk_uuid;
 
-    MD5Hash install_md5 = md5((uint8_t *)bancho.install_id.toUtf8(), bancho.install_id.lengthUtf8());
 
+    MD5Hash install_md5 = md5((u8 *)bancho.install_id.toUtf8(), bancho.install_id.lengthUtf8());
 
     ;
 
 
 
     bancho.client_hashes = UString::format("%s:%s:%s:%s:%s:", osu_path_md5.hash, adapters, adapters_md5.hash,
 
                                            install_md5.hash, disk_md5.hash);
 
-    write_bytes(&packet, (uint8_t *)bancho.client_hashes.toUtf8(), bancho.client_hashes.lengthUtf8());
 
+    write_bytes(&packet, (u8 *)bancho.client_hashes.toUtf8(), bancho.client_hashes.lengthUtf8());
 
 
 
     // Allow PMs from strangers
 
-    write_byte(&packet, '|');
 
-    write_byte(&packet, '0');
 
+    write_u8(&packet, '|');
 
+    write_u8(&packet, '0');
 
 
 
-    write_byte(&packet, '\n');
 
+    write_u8(&packet, '\n');
 
     return packet;
 
 }
--- a/src/App/Osu/Bancho.h
+++ b/src/App/Osu/Bancho.h
@@ -1,6 +1,4 @@
 
 #pragma once
 
-#include <stdint.h>
 
-
 
 #include <unordered_map>
 
 
 
 #include "BanchoProtocol.h"
@@ -20,7 +18,7 @@ struct Bancho {
 
 
 
     Osu *osu = nullptr;
 
     UString endpoint;
 
-    int32_t user_id = 0;
 
+    i32 user_id = 0;
 
     UString username;
 
     MD5Hash pw_md5;
 
     Room room;
@@ -54,10 +52,10 @@ struct Bancho {
 
 struct Channel {
 
     UString name;
 
     UString topic;
 
-    uint32_t nb_members;
 
+    u32 nb_members;
 
 };
 
 
 
-MD5Hash md5(uint8_t *msg, size_t msg_len);
 
+MD5Hash md5(u8 *msg, size_t msg_len);
 
 
 
 void handle_packet(Packet *packet);
 
 
--- a/src/App/Osu/BanchoAes.cpp
+++ b/src/App/Osu/BanchoAes.cpp
@@ -6,167 +6,162 @@
 
 #include "BanchoNetworking.h"
 
 #include "UString.h"
 
 
 
-uint8_t r_con[] = {1,  2,  4,   8,  16,  32,  64, 128, 27,  54,  108, 216, 171, 77,  154,
 
-                   47, 94, 188, 99, 198, 151, 53, 106, 212, 179, 125, 250, 239, 197, 145};
 
-uint8_t S[] = {99,  124, 119, 123, 242, 107, 111, 197, 48,  1,   103, 43,  254, 215, 171, 118, 202, 130, 201, 125,
 
-               250, 89,  71,  240, 173, 212, 162, 175, 156, 164, 114, 192, 183, 253, 147, 38,  54,  63,  247, 204,
 
-               52,  165, 229, 241, 113, 216, 49,  21,  4,   199, 35,  195, 24,  150, 5,   154, 7,   18,  128, 226,
 
-               235, 39,  178, 117, 9,   131, 44,  26,  27,  110, 90,  160, 82,  59,  214, 179, 41,  227, 47,  132,
 
-               83,  209, 0,   237, 32,  252, 177, 91,  106, 203, 190, 57,  74,  76,  88,  207, 208, 239, 170, 251,
 
-               67,  77,  51,  133, 69,  249, 2,   127, 80,  60,  159, 168, 81,  163, 64,  143, 146, 157, 56,  245,
 
-               188, 182, 218, 33,  16,  255, 243, 210, 205, 12,  19,  236, 95,  151, 68,  23,  196, 167, 126, 61,
 
-               100, 93,  25,  115, 96,  129, 79,  220, 34,  42,  144, 136, 70,  238, 184, 20,  222, 94,  11,  219,
 
-               224, 50,  58,  10,  73,  6,   36,  92,  194, 211, 172, 98,  145, 149, 228, 121, 231, 200, 55,  109,
 
-               141, 213, 78,  169, 108, 86,  244, 234, 101, 122, 174, 8,   186, 120, 37,  46,  28,  166, 180, 198,
 
-               232, 221, 116, 31,  75,  189, 139, 138, 112, 62,  181, 102, 72,  3,   246, 14,  97,  53,  87,  185,
 
-               134, 193, 29,  158, 225, 248, 152, 17,  105, 217, 142, 148, 155, 30,  135, 233, 206, 85,  40,  223,
 
-               140, 161, 137, 13,  191, 230, 66,  104, 65,  153, 45,  15,  176, 84,  187, 22};
 
-uint32_t T1[] = {
 
-    3328402341, 4168907908, 4000806809, 4135287693, 4294111757, 3597364157, 3731845041, 2445657428, 1613770832,
 
-    33620227,   3462883241, 1445669757, 3892248089, 3050821474, 1303096294, 3967186586, 2412431941, 528646813,
 
-    2311702848, 4202528135, 4026202645, 2992200171, 2387036105, 4226871307, 1101901292, 3017069671, 1604494077,
 
-    1169141738, 597466303,  1403299063, 3832705686, 2613100635, 1974974402, 3791519004, 1033081774, 1277568618,
 
-    1815492186, 2118074177, 4126668546, 2211236943, 1748251740, 1369810420, 3521504564, 4193382664, 3799085459,
 
-    2883115123, 1647391059, 706024767,  134480908,  2512897874, 1176707941, 2646852446, 806885416,  932615841,
 
-    168101135,  798661301,  235341577,  605164086,  461406363,  3756188221, 3454790438, 1311188841, 2142417613,
 
-    3933566367, 302582043,  495158174,  1479289972, 874125870,  907746093,  3698224818, 3025820398, 1537253627,
 
-    2756858614, 1983593293, 3084310113, 2108928974, 1378429307, 3722699582, 1580150641, 327451799,  2790478837,
 
-    3117535592, 0,          3253595436, 1075847264, 3825007647, 2041688520, 3059440621, 3563743934, 2378943302,
 
-    1740553945, 1916352843, 2487896798, 2555137236, 2958579944, 2244988746, 3151024235, 3320835882, 1336584933,
 
-    3992714006, 2252555205, 2588757463, 1714631509, 293963156,  2319795663, 3925473552, 67240454,   4269768577,
 
-    2689618160, 2017213508, 631218106,  1269344483, 2723238387, 1571005438, 2151694528, 93294474,   1066570413,
 
-    563977660,  1882732616, 4059428100, 1673313503, 2008463041, 2950355573, 1109467491, 537923632,  3858759450,
 
-    4260623118, 3218264685, 2177748300, 403442708,  638784309,  3287084079, 3193921505, 899127202,  2286175436,
 
-    773265209,  2479146071, 1437050866, 4236148354, 2050833735, 3362022572, 3126681063, 840505643,  3866325909,
 
-    3227541664, 427917720,  2655997905, 2749160575, 1143087718, 1412049534, 999329963,  193497219,  2353415882,
 
-    3354324521, 1807268051, 672404540,  2816401017, 3160301282, 369822493,  2916866934, 3688947771, 1681011286,
 
-    1949973070, 336202270,  2454276571, 201721354,  1210328172, 3093060836, 2680341085, 3184776046, 1135389935,
 
-    3294782118, 965841320,  831886756,  3554993207, 4068047243, 3588745010, 2345191491, 1849112409, 3664604599,
 
-    26054028,   2983581028, 2622377682, 1235855840, 3630984372, 2891339514, 4092916743, 3488279077, 3395642799,
 
-    4101667470, 1202630377, 268961816,  1874508501, 4034427016, 1243948399, 1546530418, 941366308,  1470539505,
 
-    1941222599, 2546386513, 3421038627, 2715671932, 3899946140, 1042226977, 2521517021, 1639824860, 227249030,
 
-    260737669,  3765465232, 2084453954, 1907733956, 3429263018, 2420656344, 100860677,  4160157185, 470683154,
 
-    3261161891, 1781871967, 2924959737, 1773779408, 394692241,  2579611992, 974986535,  664706745,  3655459128,
 
-    3958962195, 731420851,  571543859,  3530123707, 2849626480, 126783113,  865375399,  765172662,  1008606754,
 
-    361203602,  3387549984, 2278477385, 2857719295, 1344809080, 2782912378, 59542671,   1503764984, 160008576,
 
-    437062935,  1707065306, 3622233649, 2218934982, 3496503480, 2185314755, 697932208,  1512910199, 504303377,
 
-    2075177163, 2824099068, 1841019862, 739644986};
 
-uint32_t T2[] = {
 
-    2781242211, 2230877308, 2582542199, 2381740923, 234877682,  3184946027, 2984144751, 1418839493, 1348481072,
 
-    50462977,   2848876391, 2102799147, 434634494,  1656084439, 3863849899, 2599188086, 1167051466, 2636087938,
 
-    1082771913, 2281340285, 368048890,  3954334041, 3381544775, 201060592,  3963727277, 1739838676, 4250903202,
 
-    3930435503, 3206782108, 4149453988, 2531553906, 1536934080, 3262494647, 484572669,  2923271059, 1783375398,
 
-    1517041206, 1098792767, 49674231,   1334037708, 1550332980, 4098991525, 886171109,  150598129,  2481090929,
 
-    1940642008, 1398944049, 1059722517, 201851908,  1385547719, 1699095331, 1587397571, 674240536,  2704774806,
 
-    252314885,  3039795866, 151914247,  908333586,  2602270848, 1038082786, 651029483,  1766729511, 3447698098,
 
-    2682942837, 454166793,  2652734339, 1951935532, 775166490,  758520603,  3000790638, 4004797018, 4217086112,
 
-    4137964114, 1299594043, 1639438038, 3464344499, 2068982057, 1054729187, 1901997871, 2534638724, 4121318227,
 
-    1757008337, 0,          750906861,  1614815264, 535035132,  3363418545, 3988151131, 3201591914, 1183697867,
 
-    3647454910, 1265776953, 3734260298, 3566750796, 3903871064, 1250283471, 1807470800, 717615087,  3847203498,
 
-    384695291,  3313910595, 3617213773, 1432761139, 2484176261, 3481945413, 283769337,  100925954,  2180939647,
 
-    4037038160, 1148730428, 3123027871, 3813386408, 4087501137, 4267549603, 3229630528, 2315620239, 2906624658,
 
-    3156319645, 1215313976, 82966005,   3747855548, 3245848246, 1974459098, 1665278241, 807407632,  451280895,
 
-    251524083,  1841287890, 1283575245, 337120268,  891687699,  801369324,  3787349855, 2721421207, 3431482436,
 
-    959321879,  1469301956, 4065699751, 2197585534, 1199193405, 2898814052, 3887750493, 724703513,  2514908019,
 
-    2696962144, 2551808385, 3516813135, 2141445340, 1715741218, 2119445034, 2872807568, 2198571144, 3398190662,
 
-    700968686,  3547052216, 1009259540, 2041044702, 3803995742, 487983883,  1991105499, 1004265696, 1449407026,
 
-    1316239930, 504629770,  3683797321, 168560134,  1816667172, 3837287516, 1570751170, 1857934291, 4014189740,
 
-    2797888098, 2822345105, 2754712981, 936633572,  2347923833, 852879335,  1133234376, 1500395319, 3084545389,
 
-    2348912013, 1689376213, 3533459022, 3762923945, 3034082412, 4205598294, 133428468,  634383082,  2949277029,
 
-    2398386810, 3913789102, 403703816,  3580869306, 2297460856, 1867130149, 1918643758, 607656988,  4049053350,
 
-    3346248884, 1368901318, 600565992,  2090982877, 2632479860, 557719327,  3717614411, 3697393085, 2249034635,
 
-    2232388234, 2430627952, 1115438654, 3295786421, 2865522278, 3633334344, 84280067,   33027830,   303828494,
 
-    2747425121, 1600795957, 4188952407, 3496589753, 2434238086, 1486471617, 658119965,  3106381470, 953803233,
 
-    334231800,  3005978776, 857870609,  3151128937, 1890179545, 2298973838, 2805175444, 3056442267, 574365214,
 
-    2450884487, 550103529,  1233637070, 4289353045, 2018519080, 2057691103, 2399374476, 4166623649, 2148108681,
 
-    387583245,  3664101311, 836232934,  3330556482, 3100665960, 3280093505, 2955516313, 2002398509, 287182607,
 
-    3413881008, 4238890068, 3597515707, 975967766};
 
-uint32_t T3[] = {
 
-    1671808611, 2089089148, 2006576759, 2072901243, 4061003762, 1807603307, 1873927791, 3310653893, 810573872,
 
-    16974337,   1739181671, 729634347,  4263110654, 3613570519, 2883997099, 1989864566, 3393556426, 2191335298,
 
-    3376449993, 2106063485, 4195741690, 1508618841, 1204391495, 4027317232, 2917941677, 3563566036, 2734514082,
 
-    2951366063, 2629772188, 2767672228, 1922491506, 3227229120, 3082974647, 4246528509, 2477669779, 644500518,
 
-    911895606,  1061256767, 4144166391, 3427763148, 878471220,  2784252325, 3845444069, 4043897329, 1905517169,
 
-    3631459288, 827548209,  356461077,  67897348,   3344078279, 593839651,  3277757891, 405286936,  2527147926,
 
-    84871685,   2595565466, 118033927,  305538066,  2157648768, 3795705826, 3945188843, 661212711,  2999812018,
 
-    1973414517, 152769033,  2208177539, 745822252,  439235610,  455947803,  1857215598, 1525593178, 2700827552,
 
-    1391895634, 994932283,  3596728278, 3016654259, 695947817,  3812548067, 795958831,  2224493444, 1408607827,
 
-    3513301457, 0,          3979133421, 543178784,  4229948412, 2982705585, 1542305371, 1790891114, 3410398667,
 
-    3201918910, 961245753,  1256100938, 1289001036, 1491644504, 3477767631, 3496721360, 4012557807, 2867154858,
 
-    4212583931, 1137018435, 1305975373, 861234739,  2241073541, 1171229253, 4178635257, 33948674,   2139225727,
 
-    1357946960, 1011120188, 2679776671, 2833468328, 1374921297, 2751356323, 1086357568, 2408187279, 2460827538,
 
-    2646352285, 944271416,  4110742005, 3168756668, 3066132406, 3665145818, 560153121,  271589392,  4279952895,
 
-    4077846003, 3530407890, 3444343245, 202643468,  322250259,  3962553324, 1608629855, 2543990167, 1154254916,
 
-    389623319,  3294073796, 2817676711, 2122513534, 1028094525, 1689045092, 1575467613, 422261273,  1939203699,
 
-    1621147744, 2174228865, 1339137615, 3699352540, 577127458,  712922154,  2427141008, 2290289544, 1187679302,
 
-    3995715566, 3100863416, 339486740,  3732514782, 1591917662, 186455563,  3681988059, 3762019296, 844522546,
 
-    978220090,  169743370,  1239126601, 101321734,  611076132,  1558493276, 3260915650, 3547250131, 2901361580,
 
-    1655096418, 2443721105, 2510565781, 3828863972, 2039214713, 3878868455, 3359869896, 928607799,  1840765549,
 
-    2374762893, 3580146133, 1322425422, 2850048425, 1823791212, 1459268694, 4094161908, 3928346602, 1706019429,
 
-    2056189050, 2934523822, 135794696,  3134549946, 2022240376, 628050469,  779246638,  472135708,  2800834470,
 
-    3032970164, 3327236038, 3894660072, 3715932637, 1956440180, 522272287,  1272813131, 3185336765, 2340818315,
 
-    2323976074, 1888542832, 1044544574, 3049550261, 1722469478, 1222152264, 50660867,   4127324150, 236067854,
 
-    1638122081, 895445557,  1475980887, 3117443513, 2257655686, 3243809217, 489110045,  2662934430, 3778599393,
 
-    4162055160, 2561878936, 288563729,  1773916777, 3648039385, 2391345038, 2493985684, 2612407707, 505560094,
 
-    2274497927, 3911240169, 3460925390, 1442818645, 678973480,  3749357023, 2358182796, 2717407649, 2306869641,
 
-    219617805,  3218761151, 3862026214, 1120306242, 1756942440, 1103331905, 2578459033, 762796589,  252780047,
 
-    2966125488, 1425844308, 3151392187, 372911126};
 
-uint32_t T4[] = {
 
-    1667474886, 2088535288, 2004326894, 2071694838, 4075949567, 1802223062, 1869591006, 3318043793, 808472672,
 
-    16843522,   1734846926, 724270422,  4278065639, 3621216949, 2880169549, 1987484396, 3402253711, 2189597983,
 
-    3385409673, 2105378810, 4210693615, 1499065266, 1195886990, 4042263547, 2913856577, 3570689971, 2728590687,
 
-    2947541573, 2627518243, 2762274643, 1920112356, 3233831835, 3082273397, 4261223649, 2475929149, 640051788,
 
-    909531756,  1061110142, 4160160501, 3435941763, 875846760,  2779116625, 3857003729, 4059105529, 1903268834,
 
-    3638064043, 825316194,  353713962,  67374088,   3351728789, 589522246,  3284360861, 404236336,  2526454071,
 
-    84217610,   2593830191, 117901582,  303183396,  2155911963, 3806477791, 3958056653, 656894286,  2998062463,
 
-    1970642922, 151591698,  2206440989, 741110872,  437923380,  454765878,  1852748508, 1515908788, 2694904667,
 
-    1381168804, 993742198,  3604373943, 3014905469, 690584402,  3823320797, 791638366,  2223281939, 1398011302,
 
-    3520161977, 0,          3991743681, 538992704,  4244381667, 2981218425, 1532751286, 1785380564, 3419096717,
 
-    3200178535, 960056178,  1246420628, 1280103576, 1482221744, 3486468741, 3503319995, 4025428677, 2863326543,
 
-    4227536621, 1128514950, 1296947098, 859002214,  2240123921, 1162203018, 4193849577, 33687044,   2139062782,
 
-    1347481760, 1010582648, 2678045221, 2829640523, 1364325282, 2745433693, 1077985408, 2408548869, 2459086143,
 
-    2644360225, 943212656,  4126475505, 3166494563, 3065430391, 3671750063, 555836226,  269496352,  4294908645,
 
-    4092792573, 3537006015, 3452783745, 202118168,  320025894,  3974901699, 1600119230, 2543297077, 1145359496,
 
-    387397934,  3301201811, 2812801621, 2122220284, 1027426170, 1684319432, 1566435258, 421079858,  1936954854,
 
-    1616945344, 2172753945, 1330631070, 3705438115, 572679748,  707427924,  2425400123, 2290647819, 1179044492,
 
-    4008585671, 3099120491, 336870440,  3739122087, 1583276732, 185277718,  3688593069, 3772791771, 842159716,
 
-    976899700,  168435220,  1229577106, 101059084,  606366792,  1549591736, 3267517855, 3553849021, 2897014595,
 
-    1650632388, 2442242105, 2509612081, 3840161747, 2038008818, 3890688725, 3368567691, 926374254,  1835907034,
 
-    2374863873, 3587531953, 1313788572, 2846482505, 1819063512, 1448540844, 4109633523, 3941213647, 1701162954,
 
-    2054852340, 2930698567, 134748176,  3132806511, 2021165296, 623210314,  774795868,  471606328,  2795958615,
 
-    3031746419, 3334885783, 3907527627, 3722280097, 1953799400, 522133822,  1263263126, 3183336545, 2341176845,
 
-    2324333839, 1886425312, 1044267644, 3048588401, 1718004428, 1212733584, 50529542,   4143317495, 235803164,
 
-    1633788866, 892690282,  1465383342, 3115962473, 2256965911, 3250673817, 488449850,  2661202215, 3789633753,
 
-    4177007595, 2560144171, 286339874,  1768537042, 3654906025, 2391705863, 2492770099, 2610673197, 505291324,
 
-    2273808917, 3924369609, 3469625735, 1431699370, 673740880,  3755965093, 2358021891, 2711746649, 2307489801,
 
-    218961690,  3217021541, 3873845719, 1111672452, 1751693520, 1094828930, 2576986153, 757954394,  252645662,
 
-    2964376443, 1414855848, 3149649517, 370555436};
 
+u8 r_con[] = {1,  2,  4,   8,  16,  32,  64, 128, 27,  54,  108, 216, 171, 77,  154,
 
+              47, 94, 188, 99, 198, 151, 53, 106, 212, 179, 125, 250, 239, 197, 145};
 
+u8 S[] = {99,  124, 119, 123, 242, 107, 111, 197, 48,  1,   103, 43,  254, 215, 171, 118, 202, 130, 201, 125, 250, 89,
 
+          71,  240, 173, 212, 162, 175, 156, 164, 114, 192, 183, 253, 147, 38,  54,  63,  247, 204, 52,  165, 229, 241,
 
+          113, 216, 49,  21,  4,   199, 35,  195, 24,  150, 5,   154, 7,   18,  128, 226, 235, 39,  178, 117, 9,   131,
 
+          44,  26,  27,  110, 90,  160, 82,  59,  214, 179, 41,  227, 47,  132, 83,  209, 0,   237, 32,  252, 177, 91,
 
+          106, 203, 190, 57,  74,  76,  88,  207, 208, 239, 170, 251, 67,  77,  51,  133, 69,  249, 2,   127, 80,  60,
 
+          159, 168, 81,  163, 64,  143, 146, 157, 56,  245, 188, 182, 218, 33,  16,  255, 243, 210, 205, 12,  19,  236,
 
+          95,  151, 68,  23,  196, 167, 126, 61,  100, 93,  25,  115, 96,  129, 79,  220, 34,  42,  144, 136, 70,  238,
 
+          184, 20,  222, 94,  11,  219, 224, 50,  58,  10,  73,  6,   36,  92,  194, 211, 172, 98,  145, 149, 228, 121,
 
+          231, 200, 55,  109, 141, 213, 78,  169, 108, 86,  244, 234, 101, 122, 174, 8,   186, 120, 37,  46,  28,  166,
 
+          180, 198, 232, 221, 116, 31,  75,  189, 139, 138, 112, 62,  181, 102, 72,  3,   246, 14,  97,  53,  87,  185,
 
+          134, 193, 29,  158, 225, 248, 152, 17,  105, 217, 142, 148, 155, 30,  135, 233, 206, 85,  40,  223, 140, 161,
 
+          137, 13,  191, 230, 66,  104, 65,  153, 45,  15,  176, 84,  187, 22};
 
+u32 T1[] = {3328402341, 4168907908, 4000806809, 4135287693, 4294111757, 3597364157, 3731845041, 2445657428, 1613770832,
 
+            33620227,   3462883241, 1445669757, 3892248089, 3050821474, 1303096294, 3967186586, 2412431941, 528646813,
 
+            2311702848, 4202528135, 4026202645, 2992200171, 2387036105, 4226871307, 1101901292, 3017069671, 1604494077,
 
+            1169141738, 597466303,  1403299063, 3832705686, 2613100635, 1974974402, 3791519004, 1033081774, 1277568618,
 
+            1815492186, 2118074177, 4126668546, 2211236943, 1748251740, 1369810420, 3521504564, 4193382664, 3799085459,
 
+            2883115123, 1647391059, 706024767,  134480908,  2512897874, 1176707941, 2646852446, 806885416,  932615841,
 
+            168101135,  798661301,  235341577,  605164086,  461406363,  3756188221, 3454790438, 1311188841, 2142417613,
 
+            3933566367, 302582043,  495158174,  1479289972, 874125870,  907746093,  3698224818, 3025820398, 1537253627,
 
+            2756858614, 1983593293, 3084310113, 2108928974, 1378429307, 3722699582, 1580150641, 327451799,  2790478837,
 
+            3117535592, 0,          3253595436, 1075847264, 3825007647, 2041688520, 3059440621, 3563743934, 2378943302,
 
+            1740553945, 1916352843, 2487896798, 2555137236, 2958579944, 2244988746, 3151024235, 3320835882, 1336584933,
 
+            3992714006, 2252555205, 2588757463, 1714631509, 293963156,  2319795663, 3925473552, 67240454,   4269768577,
 
+            2689618160, 2017213508, 631218106,  1269344483, 2723238387, 1571005438, 2151694528, 93294474,   1066570413,
 
+            563977660,  1882732616, 4059428100, 1673313503, 2008463041, 2950355573, 1109467491, 537923632,  3858759450,
 
+            4260623118, 3218264685, 2177748300, 403442708,  638784309,  3287084079, 3193921505, 899127202,  2286175436,
 
+            773265209,  2479146071, 1437050866, 4236148354, 2050833735, 3362022572, 3126681063, 840505643,  3866325909,
 
+            3227541664, 427917720,  2655997905, 2749160575, 1143087718, 1412049534, 999329963,  193497219,  2353415882,
 
+            3354324521, 1807268051, 672404540,  2816401017, 3160301282, 369822493,  2916866934, 3688947771, 1681011286,
 
+            1949973070, 336202270,  2454276571, 201721354,  1210328172, 3093060836, 2680341085, 3184776046, 1135389935,
 
+            3294782118, 965841320,  831886756,  3554993207, 4068047243, 3588745010, 2345191491, 1849112409, 3664604599,
 
+            26054028,   2983581028, 2622377682, 1235855840, 3630984372, 2891339514, 4092916743, 3488279077, 3395642799,
 
+            4101667470, 1202630377, 268961816,  1874508501, 4034427016, 1243948399, 1546530418, 941366308,  1470539505,
 
+            1941222599, 2546386513, 3421038627, 2715671932, 3899946140, 1042226977, 2521517021, 1639824860, 227249030,
 
+            260737669,  3765465232, 2084453954, 1907733956, 3429263018, 2420656344, 100860677,  4160157185, 470683154,
 
+            3261161891, 1781871967, 2924959737, 1773779408, 394692241,  2579611992, 974986535,  664706745,  3655459128,
 
+            3958962195, 731420851,  571543859,  3530123707, 2849626480, 126783113,  865375399,  765172662,  1008606754,
 
+            361203602,  3387549984, 2278477385, 2857719295, 1344809080, 2782912378, 59542671,   1503764984, 160008576,
 
+            437062935,  1707065306, 3622233649, 2218934982, 3496503480, 2185314755, 697932208,  1512910199, 504303377,
 
+            2075177163, 2824099068, 1841019862, 739644986};
 
+u32 T2[] = {2781242211, 2230877308, 2582542199, 2381740923, 234877682,  3184946027, 2984144751, 1418839493, 1348481072,
 
+            50462977,   2848876391, 2102799147, 434634494,  1656084439, 3863849899, 2599188086, 1167051466, 2636087938,
 
+            1082771913, 2281340285, 368048890,  3954334041, 3381544775, 201060592,  3963727277, 1739838676, 4250903202,
 
+            3930435503, 3206782108, 4149453988, 2531553906, 1536934080, 3262494647, 484572669,  2923271059, 1783375398,
 
+            1517041206, 1098792767, 49674231,   1334037708, 1550332980, 4098991525, 886171109,  150598129,  2481090929,
 
+            1940642008, 1398944049, 1059722517, 201851908,  1385547719, 1699095331, 1587397571, 674240536,  2704774806,
 
+            252314885,  3039795866, 151914247,  908333586,  2602270848, 1038082786, 651029483,  1766729511, 3447698098,
 
+            2682942837, 454166793,  2652734339, 1951935532, 775166490,  758520603,  3000790638, 4004797018, 4217086112,
 
+            4137964114, 1299594043, 1639438038, 3464344499, 2068982057, 1054729187, 1901997871, 2534638724, 4121318227,
 
+            1757008337, 0,          750906861,  1614815264, 535035132,  3363418545, 3988151131, 3201591914, 1183697867,
 
+            3647454910, 1265776953, 3734260298, 3566750796, 3903871064, 1250283471, 1807470800, 717615087,  3847203498,
 
+            384695291,  3313910595, 3617213773, 1432761139, 2484176261, 3481945413, 283769337,  100925954,  2180939647,
 
+            4037038160, 1148730428, 3123027871, 3813386408, 4087501137, 4267549603, 3229630528, 2315620239, 2906624658,
 
+            3156319645, 1215313976, 82966005,   3747855548, 3245848246, 1974459098, 1665278241, 807407632,  451280895,
 
+            251524083,  1841287890, 1283575245, 337120268,  891687699,  801369324,  3787349855, 2721421207, 3431482436,
 
+            959321879,  1469301956, 4065699751, 2197585534, 1199193405, 2898814052, 3887750493, 724703513,  2514908019,
 
+            2696962144, 2551808385, 3516813135, 2141445340, 1715741218, 2119445034, 2872807568, 2198571144, 3398190662,
 
+            700968686,  3547052216, 1009259540, 2041044702, 3803995742, 487983883,  1991105499, 1004265696, 1449407026,
 
+            1316239930, 504629770,  3683797321, 168560134,  1816667172, 3837287516, 1570751170, 1857934291, 4014189740,
 
+            2797888098, 2822345105, 2754712981, 936633572,  2347923833, 852879335,  1133234376, 1500395319, 3084545389,
 
+            2348912013, 1689376213, 3533459022, 3762923945, 3034082412, 4205598294, 133428468,  634383082,  2949277029,
 
+            2398386810, 3913789102, 403703816,  3580869306, 2297460856, 1867130149, 1918643758, 607656988,  4049053350,
 
+            3346248884, 1368901318, 600565992,  2090982877, 2632479860, 557719327,  3717614411, 3697393085, 2249034635,
 
+            2232388234, 2430627952, 1115438654, 3295786421, 2865522278, 3633334344, 84280067,   33027830,   303828494,
 
+            2747425121, 1600795957, 4188952407, 3496589753, 2434238086, 1486471617, 658119965,  3106381470, 953803233,
 
+            334231800,  3005978776, 857870609,  3151128937, 1890179545, 2298973838, 2805175444, 3056442267, 574365214,
 
+            2450884487, 550103529,  1233637070, 4289353045, 2018519080, 2057691103, 2399374476, 4166623649, 2148108681,
 
+            387583245,  3664101311, 836232934,  3330556482, 3100665960, 3280093505, 2955516313, 2002398509, 287182607,
 
+            3413881008, 4238890068, 3597515707, 975967766};
 
+u32 T3[] = {1671808611, 2089089148, 2006576759, 2072901243, 4061003762, 1807603307, 1873927791, 3310653893, 810573872,
 
+            16974337,   1739181671, 729634347,  4263110654, 3613570519, 2883997099, 1989864566, 3393556426, 2191335298,
 
+            3376449993, 2106063485, 4195741690, 1508618841, 1204391495, 4027317232, 2917941677, 3563566036, 2734514082,
 
+            2951366063, 2629772188, 2767672228, 1922491506, 3227229120, 3082974647, 4246528509, 2477669779, 644500518,
 
+            911895606,  1061256767, 4144166391, 3427763148, 878471220,  2784252325, 3845444069, 4043897329, 1905517169,
 
+            3631459288, 827548209,  356461077,  67897348,   3344078279, 593839651,  3277757891, 405286936,  2527147926,
 
+            84871685,   2595565466, 118033927,  305538066,  2157648768, 3795705826, 3945188843, 661212711,  2999812018,
 
+            1973414517, 152769033,  2208177539, 745822252,  439235610,  455947803,  1857215598, 1525593178, 2700827552,
 
+            1391895634, 994932283,  3596728278, 3016654259, 695947817,  3812548067, 795958831,  2224493444, 1408607827,
 
+            3513301457, 0,          3979133421, 543178784,  4229948412, 2982705585, 1542305371, 1790891114, 3410398667,
 
+            3201918910, 961245753,  1256100938, 1289001036, 1491644504, 3477767631, 3496721360, 4012557807, 2867154858,
 
+            4212583931, 1137018435, 1305975373, 861234739,  2241073541, 1171229253, 4178635257, 33948674,   2139225727,
 
+            1357946960, 1011120188, 2679776671, 2833468328, 1374921297, 2751356323, 1086357568, 2408187279, 2460827538,
 
+            2646352285, 944271416,  4110742005, 3168756668, 3066132406, 3665145818, 560153121,  271589392,  4279952895,
 
+            4077846003, 3530407890, 3444343245, 202643468,  322250259,  3962553324, 1608629855, 2543990167, 1154254916,
 
+            389623319,  3294073796, 2817676711, 2122513534, 1028094525, 1689045092, 1575467613, 422261273,  1939203699,
 
+            1621147744, 2174228865, 1339137615, 3699352540, 577127458,  712922154,  2427141008, 2290289544, 1187679302,
 
+            3995715566, 3100863416, 339486740,  3732514782, 1591917662, 186455563,  3681988059, 3762019296, 844522546,
 
+            978220090,  169743370,  1239126601, 101321734,  611076132,  1558493276, 3260915650, 3547250131, 2901361580,
 
+            1655096418, 2443721105, 2510565781, 3828863972, 2039214713, 3878868455, 3359869896, 928607799,  1840765549,
 
+            2374762893, 3580146133, 1322425422, 2850048425, 1823791212, 1459268694, 4094161908, 3928346602, 1706019429,
 
+            2056189050, 2934523822, 135794696,  3134549946, 2022240376, 628050469,  779246638,  472135708,  2800834470,
 
+            3032970164, 3327236038, 3894660072, 3715932637, 1956440180, 522272287,  1272813131, 3185336765, 2340818315,
 
+            2323976074, 1888542832, 1044544574, 3049550261, 1722469478, 1222152264, 50660867,   4127324150, 236067854,
 
+            1638122081, 895445557,  1475980887, 3117443513, 2257655686, 3243809217, 489110045,  2662934430, 3778599393,
 
+            4162055160, 2561878936, 288563729,  1773916777, 3648039385, 2391345038, 2493985684, 2612407707, 505560094,
 
+            2274497927, 3911240169, 3460925390, 1442818645, 678973480,  3749357023, 2358182796, 2717407649, 2306869641,
 
+            219617805,  3218761151, 3862026214, 1120306242, 1756942440, 1103331905, 2578459033, 762796589,  252780047,
 
+            2966125488, 1425844308, 3151392187, 372911126};
 
+u32 T4[] = {1667474886, 2088535288, 2004326894, 2071694838, 4075949567, 1802223062, 1869591006, 3318043793, 808472672,
 
+            16843522,   1734846926, 724270422,  4278065639, 3621216949, 2880169549, 1987484396, 3402253711, 2189597983,
 
+            3385409673, 2105378810, 4210693615, 1499065266, 1195886990, 4042263547, 2913856577, 3570689971, 2728590687,
 
+            2947541573, 2627518243, 2762274643, 1920112356, 3233831835, 3082273397, 4261223649, 2475929149, 640051788,
 
+            909531756,  1061110142, 4160160501, 3435941763, 875846760,  2779116625, 3857003729, 4059105529, 1903268834,
 
+            3638064043, 825316194,  353713962,  67374088,   3351728789, 589522246,  3284360861, 404236336,  2526454071,
 
+            84217610,   2593830191, 117901582,  303183396,  2155911963, 3806477791, 3958056653, 656894286,  2998062463,
 
+            1970642922, 151591698,  2206440989, 741110872,  437923380,  454765878,  1852748508, 1515908788, 2694904667,
 
+            1381168804, 993742198,  3604373943, 3014905469, 690584402,  3823320797, 791638366,  2223281939, 1398011302,
 
+            3520161977, 0,          3991743681, 538992704,  4244381667, 2981218425, 1532751286, 1785380564, 3419096717,
 
+            3200178535, 960056178,  1246420628, 1280103576, 1482221744, 3486468741, 3503319995, 4025428677, 2863326543,
 
+            4227536621, 1128514950, 1296947098, 859002214,  2240123921, 1162203018, 4193849577, 33687044,   2139062782,
 
+            1347481760, 1010582648, 2678045221, 2829640523, 1364325282, 2745433693, 1077985408, 2408548869, 2459086143,
 
+            2644360225, 943212656,  4126475505, 3166494563, 3065430391, 3671750063, 555836226,  269496352,  4294908645,
 
+            4092792573, 3537006015, 3452783745, 202118168,  320025894,  3974901699, 1600119230, 2543297077, 1145359496,
 
+            387397934,  3301201811, 2812801621, 2122220284, 1027426170, 1684319432, 1566435258, 421079858,  1936954854,
 
+            1616945344, 2172753945, 1330631070, 3705438115, 572679748,  707427924,  2425400123, 2290647819, 1179044492,
 
+            4008585671, 3099120491, 336870440,  3739122087, 1583276732, 185277718,  3688593069, 3772791771, 842159716,
 
+            976899700,  168435220,  1229577106, 101059084,  606366792,  1549591736, 3267517855, 3553849021, 2897014595,
 
+            1650632388, 2442242105, 2509612081, 3840161747, 2038008818, 3890688725, 3368567691, 926374254,  1835907034,
 
+            2374863873, 3587531953, 1313788572, 2846482505, 1819063512, 1448540844, 4109633523, 3941213647, 1701162954,
 
+            2054852340, 2930698567, 134748176,  3132806511, 2021165296, 623210314,  774795868,  471606328,  2795958615,
 
+            3031746419, 3334885783, 3907527627, 3722280097, 1953799400, 522133822,  1263263126, 3183336545, 2341176845,
 
+            2324333839, 1886425312, 1044267644, 3048588401, 1718004428, 1212733584, 50529542,   4143317495, 235803164,
 
+            1633788866, 892690282,  1465383342, 3115962473, 2256965911, 3250673817, 488449850,  2661202215, 3789633753,
 
+            4177007595, 2560144171, 286339874,  1768537042, 3654906025, 2391705863, 2492770099, 2610673197, 505291324,
 
+            2273808917, 3924369609, 3469625735, 1431699370, 673740880,  3755965093, 2358021891, 2711746649, 2307489801,
 
+            218961690,  3217021541, 3873845719, 1111672452, 1751693520, 1094828930, 2576986153, 757954394,  252645662,
 
+            2964376443, 1414855848, 3149649517, 370555436};
 
 
 
-uint32_t **aes_init_key(uint8_t *key) {
 
-    uint32_t **k_e = new uint32_t *[15];
 
+u32 **aes_init_key(u8 *key) {
 
+    u32 **k_e = new u32 *[15];
 
     for(int i = 0; i < 15; i++) {
 
-        k_e[i] = new uint32_t[8];
 
+        k_e[i] = new u32[8];
 
         for(int j = 0; j < 8; j++) {
 
             k_e[i][j] = 0;
 
         }
 
     }
 
 
 
-    uint32_t tk[8];
 
+    u32 tk[8];
 
     for(int i = 0; i < 8; i++) {
 
         tk[i] = (key[i * 4] << 24) | (key[i * 4 + 1] << 16) | (key[i * 4 + 2] << 8) | (key[i * 4 + 3]);
 
     }
 
 
 
-    uint8_t t = 0;
 
-    uint8_t j = 0;
 
+    u8 t = 0;
 
+    u8 j = 0;
 
     while(j < 8 && t < 120) {
 
         k_e[t / 8][t % 8] = tk[j];
 
         j++;
 
         t++;
 
     }
 
 
 
-    uint8_t r_con_index = 0;
 
+    u8 r_con_index = 0;
 
     while(t < 120) {
 
-        uint32_t tt = tk[7];
 
+        u32 tt = tk[7];
 
         tk[0] = tk[0] ^ (S[(tt >> 16) & 0xFF] << 24) ^ (S[(tt >> 8) & 0xFF] << 16) ^ (S[tt & 0xFF] << 8) ^
 
                 (S[(tt >> 24) & 0xFF]) ^ (r_con[r_con_index] << 24);
 
         r_con_index++;
@@ -196,16 +191,16 @@ uint32_t **aes_init_key(uint8_t *key) {
 
     return k_e;
 
 }
 
 
 
-void aes_free_key(uint32_t **key) {
 
+void aes_free_key(u32 **key) {
 
     for(int i = 0; i < 15; i++) {
 
         delete key[i];
 
     }
 
     delete key;
 
 }
 
 
 
-void aes_encrypt_block(uint8_t *in, uint8_t *out, uint32_t **k_e) {
 
-    uint32_t a[8];
 
-    uint32_t b[8];
 
+void aes_encrypt_block(u8 *in, u8 *out, u32 **k_e) {
 
+    u32 a[8];
 
+    u32 b[8];
 
     for(int i = 0; i < 8; i++) {
 
         b[i] = (in[i * 4] << 24 | in[i * 4 + 1] << 16 | in[i * 4 + 2] << 8 | in[i * 4 + 3]) ^ k_e[0][i];
 
     }
@@ -222,7 +217,7 @@ void aes_encrypt_block(uint8_t *in, uint8_t *out, uint32_t **k_e) {
 
     }
 
 
 
     for(int i = 0; i < 8; i++) {
 
-        uint32_t tt = k_e[14][i];
 
+        u32 tt = k_e[14][i];
 
         out[i * 4 + 0] = (S[(b[(i + 0) % 8] >> 24) & 0xFF] ^ (tt >> 24)) & 0xFF;
 
         out[i * 4 + 1] = (S[(b[(i + 1) % 8] >> 16) & 0xFF] ^ (tt >> 16)) & 0xFF;
 
         out[i * 4 + 2] = (S[(b[(i + 3) % 8] >> 8) & 0xFF] ^ (tt >> 8)) & 0xFF;
@@ -230,20 +225,20 @@ void aes_encrypt_block(uint8_t *in, uint8_t *out, uint32_t **k_e) {
 
     }
 
 }
 
 
 
-uint8_t *encrypt(const uint8_t *iv, uint8_t *msg, size_t s_msg, size_t *s_out) {
 
+u8 *encrypt(const u8 *iv, u8 *msg, size_t s_msg, size_t *s_out) {
 
     auto key_str = UString::format("osu!-scoreburgr---------%d", OSU_VERSION_DATEONLY);
 
-    uint32_t **key = aes_init_key((uint8_t *)key_str.toUtf8());
 
+    u32 **key = aes_init_key((u8 *)key_str.toUtf8());
 
 
 
     int bytes_encrypted = 0;
 
     int bytes_to_encrypt = s_msg;
 
-    uint8_t padding = (32 - (bytes_to_encrypt % 32));
 
+    u8 padding = (32 - (bytes_to_encrypt % 32));
 
 
 
     *s_out = bytes_to_encrypt + padding;
 
-    uint8_t *out = new uint8_t[*s_out];
 
+    u8 *out = new u8[*s_out];
 
 
 
     int keep_going = 1;
 
     while(keep_going) {
 
-        uint8_t block[32] = {0};
 
+        u8 block[32] = {0};
 
 
 
         int nb = bytes_to_encrypt > 32 ? 32 : bytes_to_encrypt;
 
         memcpy(block, msg, nb);
--- a/src/App/Osu/BanchoAes.h
+++ b/src/App/Osu/BanchoAes.h
@@ -1,4 +1,4 @@
 
 #pragma once
 
 #include <stdint.h>
 
 
 
-uint8_t *encrypt(const uint8_t *iv, uint8_t *msg, size_t s_msg, size_t *s_out);
 
+u8 *encrypt(const u8 *iv, u8 *msg, size_t s_msg, size_t *s_out);
--- a/src/App/Osu/BanchoLeaderboard.cpp
+++ b/src/App/Osu/BanchoLeaderboard.cpp
@@ -10,13 +10,13 @@
 
 #include "BanchoNetworking.h"
 
 #include "BanchoUsers.h"
 
 #include "ConVar.h"
 
+#include "Database.h"
 
 #include "Engine.h"
 
-#include "OsuDatabase.h"
 
-#include "OsuModSelector.h"
 
-#include "OsuSongBrowser.h"
 
+#include "ModSelector.h"
 
+#include "SongBrowser.h"
 
 
 
-Score parse_score(char *score_line) {
 
-    Score score;
 
+FinishedScore parse_score(char *score_line) {
 
+    FinishedScore score;
 
     score.server = bancho.endpoint.toUtf8();
 
     score.isLegacyScore = true;
 
     score.isImportedLegacyScore = true;
@@ -94,7 +94,7 @@ Score parse_score(char *score_line) {
 
     return score;
 
 }
 
 
 
-void fetch_online_scores(OsuDatabaseBeatmap *beatmap) {
 
+void fetch_online_scores(DatabaseBeatmap *beatmap) {
 
     UString path = "/web/osu-osz2-getscores.php?s=0&vv=4&v=1";
 
     path.append(UString::format("&c=%s", beatmap->getMD5Hash().hash));
 
 
@@ -127,7 +127,7 @@ void fetch_online_scores(OsuDatabaseBeatmap *beatmap) {
 
     request.type = GET_MAP_LEADERBOARD;
 
     request.path = path;
 
     request.mime = NULL;
 
-    request.extra = (uint8_t *)strdup(beatmap->getMD5Hash().hash);
 
+    request.extra = (u8 *)strdup(beatmap->getMD5Hash().hash);
 
 
 
     send_api_request(request);
 
 }
@@ -155,7 +155,7 @@ void process_leaderboard_response(Packet response) {
 
     //       you actually received the data if you plan on using it.
 
     OnlineMapInfo info = {0};
 
     MD5Hash beatmap_hash = (char *)response.extra;
 
-    std::vector<Score> scores;
 
+    std::vector<FinishedScore> scores;
 
     char *body = (char *)response.memory;
 
 
 
     char *ranked_status = strtok_x('|', &body);
@@ -194,7 +194,7 @@ void process_leaderboard_response(Packet response) {
 
 
 
     char *score_line = NULL;
 
     while((score_line = strtok_x('\n', &body))[0] != '\0') {
 
-        Score score = parse_score(score_line);
 
+        FinishedScore score = parse_score(score_line);
 
         score.md5hash = beatmap_hash;
 
         scores.push_back(score);
 
     }
--- a/src/App/Osu/BanchoLeaderboard.h
+++ b/src/App/Osu/BanchoLeaderboard.h
@@ -1,15 +1,15 @@
 
 #pragma once
 
 #include "BanchoProtocol.h"
 
-#include "OsuDatabaseBeatmap.h"
 
+#include "DatabaseBeatmap.h"
 
 
 
 struct OnlineMapInfo {
 
     long ranked_status;
 
     bool server_has_osz2;
 
-    uint32_t beatmap_id;
 
-    uint32_t beatmap_set_id;
 
+    u32 beatmap_id;
 
+    u32 beatmap_set_id;
 
     int nb_scores;
 
 };
 
 
 
 void process_leaderboard_response(Packet response);
 
 
 
-void fetch_online_scores(OsuDatabaseBeatmap *beatmap);
 
+void fetch_online_scores(DatabaseBeatmap *beatmap);
--- a/src/App/Osu/BanchoNetworking.cpp
+++ b/src/App/Osu/BanchoNetworking.cpp
@@ -8,21 +8,21 @@
 
 #include "BanchoLeaderboard.h"
 
 #include "BanchoProtocol.h"
 
 #include "BanchoUsers.h"
 
+#include "Beatmap.h"
 
 #include "CBaseUICheckbox.h"
 
+#include "Chat.h"
 
 #include "ConVar.h"
 
+#include "Database.h"
 
 #include "Downloader.h"
 
 #include "Engine.h"
 
 #include "File.h"
 
-#include "OsuBeatmap.h"
 
-#include "OsuChat.h"
 
-#include "OsuDatabase.h"
 
-#include "OsuLobby.h"
 
-#include "OsuOptionsMenu.h"
 
-#include "OsuRoom.h"
 
-#include "OsuSongBrowser.h"
 
-#include "OsuUIAvatar.h"
 
-#include "OsuUIButton.h"
 
+#include "Lobby.h"
 
+#include "OptionsMenu.h"
 
 #include "ResourceManager.h"
 
+#include "RoomScreen.h"
 
+#include "SongBrowser.h"
 
+#include "UIAvatar.h"
 
+#include "UIButton.h"
 
 #include "miniz.h"
 
 
 
 // Bancho protocol
@@ -51,9 +51,9 @@ void disconnect() {
 
     // This is a blocking call, but we *do* want this to block when quitting the game.
 
     if(bancho.is_online()) {
 
         Packet packet;
 
-        write_short(&packet, LOGOUT);
 
-        write_byte(&packet, 0);
 
-        write_int32(&packet, 0);
 
+        write_u16(&packet, LOGOUT);
 
+        write_u8(&packet, 0);
 
+        write_u32(&packet, 0);
 
 
 
         CURL *curl = curl_easy_init();
 
         auto version_header = UString::format("x-mcosu-ver: %s", bancho.neosu_version.toUtf8());
@@ -136,7 +136,7 @@ void reconnect() {
 
     }
 
 
 
     const char *pw = cv_password.toUtf8();  // cv_password needs to stay in scope!
 
-    bancho.pw_md5 = md5((uint8_t *)pw, strlen(pw));
 
+    bancho.pw_md5 = md5((u8 *)pw, strlen(pw));
 
 
 
     bancho.username = convar->getConVarByName("name")->getString();
 
     bancho.endpoint = convar->getConVarByName("mp_server")->getString();
@@ -155,7 +155,7 @@ size_t curl_write(void *contents, size_t size, size_t nmemb, void *userp) {
 
     size_t realsize = size * nmemb;
 
     Packet *mem = (Packet *)userp;
 
 
 
-    uint8_t *ptr = (uint8_t *)realloc(mem->memory, mem->size + realsize + 1);
 
+    u8 *ptr = (u8 *)realloc(mem->memory, mem->size + realsize + 1);
 
     if(!ptr) {
 
         /* out of memory! */
 
         debugLog("not enough memory (realloc returned NULL)\n");
@@ -177,7 +177,7 @@ static void send_api_request(CURL *curl, APIRequest api_out) {
 
     response.id = api_out.type;
 
     response.extra = api_out.extra;
 
     response.extra_int = api_out.extra_int;
 
-    response.memory = (uint8_t *)malloc(2048);
 
+    response.memory = (u8 *)malloc(2048);
 
 
 
     struct curl_slist *chunk = NULL;
 
     auto query_url = UString::format("https://osu.%s%s", bancho.endpoint.toUtf8(), api_out.path.toUtf8());
@@ -213,7 +213,7 @@ static void send_api_request(CURL *curl, APIRequest api_out) {
 
 
 
 static void send_bancho_packet(CURL *curl, Packet outgoing) {
 
     Packet response;
 
-    response.memory = (uint8_t *)malloc(2048);
 
+    response.memory = (u8 *)malloc(2048);
 
 
 
     struct curl_slist *chunk = NULL;
 
     auto version_header = UString::format("x-mcosu-ver: %s", bancho.neosu_version.toUtf8());
@@ -259,11 +259,9 @@ static void send_bancho_packet(CURL *curl, Packet outgoing) {
 
     if(hres == CURLHE_OK) {
 
         if(strstr(header->value, "submit=0") != NULL) {
 
             bancho.score_submission_policy = ServerPolicy::NO;
 
-            bancho.osu->m_optionsMenu->updateLayout();
 
             debugLog("Server doesn't want score submission. :(\n");
 
         } else if(strstr(header->value, "submit=1") != NULL) {
 
             bancho.score_submission_policy = ServerPolicy::YES;
 
-            bancho.osu->m_optionsMenu->updateLayout();
 
             debugLog("Server wants score submission! :D\n");
 
         }
 
 
@@ -276,9 +274,9 @@ static void send_bancho_packet(CURL *curl, Packet outgoing) {
 
     }
 
 
 
     while(response.pos < response.size) {
 
-        uint16_t packet_id = read_short(&response);
 
+        u16 packet_id = read<u16>(&response);
 
         response.pos++;
 
-        uint32_t packet_len = read_int32(&response);
 
+        u32 packet_len = read<u32>(&response);
 
         if(packet_len > 10485760) {
 
             debugLog("Received a packet over 10Mb! Dropping response.\n");
 
             goto end;
@@ -286,7 +284,7 @@ static void send_bancho_packet(CURL *curl, Packet outgoing) {
 
 
 
         Packet incoming = {
 
             .id = packet_id,
 
-            .memory = (uint8_t *)malloc(packet_len),
 
+            .memory = (u8 *)malloc(packet_len),
 
             .size = packet_len,
 
             .pos = 0,
 
         };
@@ -345,9 +343,9 @@ static void *do_networking(void *data) {
 
             free(login.memory);
 
             pthread_mutex_lock(&outgoing_mutex);
 
         } else if(should_ping && outgoing.pos == 0) {
 
-            write_short(&outgoing, PING);
 
-            write_byte(&outgoing, 0);
 
-            write_int32(&outgoing, 0);
 
+            write_u16(&outgoing, PING);
 
+            write_u8(&outgoing, 0);
 
+            write_u32(&outgoing, 0);
 
 
 
             // Polling gets slower over time, but resets when we receive new data
 
             if(seconds_between_pings < 30.0) {
@@ -362,9 +360,9 @@ static void *do_networking(void *data) {
 
 
 
             // DEBUG: If we're not sending the right amount of bytes, bancho.py just
 
             // chugs along! To try to detect it faster, we'll send two packets per request.
 
-            write_short(&out, PING);
 
-            write_byte(&out, 0);
 
-            write_int32(&out, 0);
 
+            write_u16(&out, PING);
 
+            write_u8(&out, 0);
 
+            write_u32(&out, 0);
 
 
 
             send_bancho_packet(curl, out);
 
             free(out.memory);
@@ -383,7 +381,7 @@ static void *do_networking(void *data) {
 
 static void handle_api_response(Packet packet) {
 
     switch(packet.id) {
 
         case GET_BEATMAPSET_INFO: {
 
-            OsuRoom::process_beatmapset_info_response(packet);
 
+            RoomScreen::process_beatmapset_info_response(packet);
 
             break;
 
         }
 
 
@@ -399,7 +397,7 @@ static void handle_api_response(Packet packet) {
 
                 break;
 
             }
 
 
 
-            Score *score = (Score *)packet.extra;
 
+            FinishedScore *score = (FinishedScore *)packet.extra;
 
             std::stringstream replay_path;
 
             replay_path << MCENGINE_DATA_DIR "replays/" << score->server << "/" << score->unixTimestamp
 
                         << ".replay.lzma";
@@ -414,7 +412,7 @@ static void handle_api_response(Packet packet) {
 
 
 
             fwrite(packet.memory, packet.size, 1, replay_file);
 
             fclose(replay_file);
 
-            OsuReplay::load_and_watch(*score);
 
+            Replay::load_and_watch(*score);
 
             break;
 
         }
 
 
@@ -497,9 +495,9 @@ void send_packet(Packet &packet) {
 
 
 
     // We're not sending it immediately, instead we just add it to the pile of
 
     // packets to send
 
-    write_short(&outgoing, packet.id);
 
-    write_byte(&outgoing, 0);
 
-    write_int32(&outgoing, packet.pos);
 
+    write_u16(&outgoing, packet.id);
 
+    write_u8(&outgoing, 0);
 
+    write_u32(&outgoing, packet.pos);
 
     write_bytes(&outgoing, packet.memory, packet.pos);
 
 
 
     pthread_mutex_unlock(&outgoing_mutex);
--- a/src/App/Osu/BanchoNetworking.h
+++ b/src/App/Osu/BanchoNetworking.h
@@ -29,15 +29,15 @@ struct APIRequest {
 
     APIRequestType type;
 
     UString path = "";
 
     curl_mime *mime = NULL;
 
-    uint8_t *extra = nullptr;
 
-    uint32_t extra_int = 0;  // lazy
 
+    u8 *extra = nullptr;
 
+    u32 extra_int = 0;  // lazy
 
 };
 
 
 
 struct ReplayExtraInfo {
 
     MD5Hash diff2_md5;
 
-    int32_t mod_flags;
 
+    i32 mod_flags;
 
     UString username;
 
-    int32_t player_id;
 
+    i32 player_id;
 
 };
 
 
 
 void disconnect();
--- a/src/App/Osu/BanchoProtocol.cpp
+++ b/src/App/Osu/BanchoProtocol.cpp
@@ -5,18 +5,21 @@
 
 
 
 #include "Bancho.h"
 
 
 
+// Null array for returning empty structures when trying to read more data out of a Packet than expected.
 
+u8 NULL_ARRAY[NULL_ARRAY_SIZE] = {0};
 
+
 
 Room::Room() {
 
     // 0-initialized room means we're not in multiplayer at the moment
 
 }
 
 
 
 Room::Room(Packet *packet) {
 
-    id = read_short(packet);
 
-    in_progress = read_byte(packet);
 
-    match_type = read_byte(packet);
 
-    mods = read_int32(packet);
 
+    id = read<u16>(packet);
 
+    in_progress = read<u8>(packet);
 
+    match_type = read<u8>(packet);
 
+    mods = read<u32>(packet);
 
     name = read_string(packet);
 
 
 
-    has_password = read_byte(packet) > 0;
 
+    has_password = read<u8>(packet) > 0;
 
     if(has_password) {
 
         // Discard password. It should be an empty string, but just in case, read it properly.
 
         packet->pos--;
@@ -24,17 +27,17 @@ Room::Room(Packet *packet) {
 
     }
 
 
 
     map_name = read_string(packet);
 
-    map_id = read_int32(packet);
 
+    map_id = read<u32>(packet);
 
 
 
     auto hash_str = read_string(packet);
 
     map_md5 = hash_str.toUtf8();
 
 
 
     nb_players = 0;
 
     for(int i = 0; i < 16; i++) {
 
-        slots[i].status = read_byte(packet);
 
+        slots[i].status = read<u8>(packet);
 
     }
 
     for(int i = 0; i < 16; i++) {
 
-        slots[i].team = read_byte(packet);
 
+        slots[i].team = read<u8>(packet);
 
     }
 
     for(int s = 0; s < 16; s++) {
 
         if(!slots[s].is_locked()) {
@@ -42,103 +45,79 @@ Room::Room(Packet *packet) {
 
         }
 
 
 
         if(slots[s].has_player()) {
 
-            slots[s].player_id = read_int32(packet);
 
+            slots[s].player_id = read<u32>(packet);
 
             nb_players++;
 
         }
 
     }
 
 
 
-    host_id = read_int32(packet);
 
-    mode = read_byte(packet);
 
-    win_condition = read_byte(packet);
 
-    team_type = read_byte(packet);
 
-    freemods = read_byte(packet);
 
+    host_id = read<u32>(packet);
 
+    mode = read<u8>(packet);
 
+    win_condition = read<u8>(packet);
 
+    team_type = read<u8>(packet);
 
+    freemods = read<u8>(packet);
 
     if(freemods) {
 
         for(int i = 0; i < 16; i++) {
 
-            slots[i].mods = read_int32(packet);
 
+            slots[i].mods = read<u32>(packet);
 
         }
 
     }
 
 
 
-    seed = read_int32(packet);
 
+    seed = read<u32>(packet);
 
 }
 
 
 
 void Room::pack(Packet *packet) {
 
-    write_short(packet, id);
 
-    write_byte(packet, in_progress);
 
-    write_byte(packet, match_type);
 
-    write_int32(packet, mods);
 
+    write_u16(packet, id);
 
+    write_u8(packet, in_progress);
 
+    write_u8(packet, match_type);
 
+    write_u32(packet, mods);
 
     write_string(packet, name.toUtf8());
 
     write_string(packet, password.toUtf8());
 
     write_string(packet, map_name.toUtf8());
 
-    write_int32(packet, map_id);
 
+    write_u32(packet, map_id);
 
     write_string(packet, map_md5.toUtf8());
 
     for(int i = 0; i < 16; i++) {
 
-        write_byte(packet, slots[i].status);
 
+        write_u8(packet, slots[i].status);
 
     }
 
     for(int i = 0; i < 16; i++) {
 
-        write_byte(packet, slots[i].team);
 
+        write_u8(packet, slots[i].team);
 
     }
 
     for(int s = 0; s < 16; s++) {
 
         if(slots[s].has_player()) {
 
-            write_int32(packet, slots[s].player_id);
 
+            write_u32(packet, slots[s].player_id);
 
         }
 
     }
 
 
 
-    write_int32(packet, host_id);
 
-    write_byte(packet, mode);
 
-    write_byte(packet, win_condition);
 
-    write_byte(packet, team_type);
 
-    write_byte(packet, freemods);
 
+    write_u32(packet, host_id);
 
+    write_u8(packet, mode);
 
+    write_u8(packet, win_condition);
 
+    write_u8(packet, team_type);
 
+    write_u8(packet, freemods);
 
     if(freemods) {
 
         for(int i = 0; i < 16; i++) {
 
-            write_int32(packet, slots[i].mods);
 
+            write_u32(packet, slots[i].mods);
 
         }
 
     }
 
 
 
-    write_int32(packet, seed);
 
+    write_u32(packet, seed);
 
 }
 
 
 
 bool Room::is_host() { return host_id == bancho.user_id; }
 
 
 
-void read_bytes(Packet *packet, uint8_t *bytes, size_t n) {
 
+void read_bytes(Packet *packet, u8 *bytes, size_t n) {
 
     if(packet->pos + n > packet->size) {
 
         packet->pos = packet->size + 1;
 
-        return;
 
+    } else {
 
+        memcpy(bytes, packet->memory + packet->pos, n);
 
+        packet->pos += n;
 
     }
 
-    memcpy(bytes, packet->memory + packet->pos, n);
 
-    packet->pos += n;
 
-}
 
-
 
-uint8_t read_byte(Packet *packet) {
 
-    uint8_t byte = 0;
 
-    read_bytes(packet, &byte, 1);
 
-    return byte;
 
-}
 
-
 
-uint16_t read_short(Packet *packet) {
 
-    uint16_t s = 0;
 
-    read_bytes(packet, (uint8_t *)&s, 2);
 
-    return s;
 
 }
 
 
 
-uint32_t read_int32(Packet *packet) {
 
-    uint32_t i = 0;
 
-    read_bytes(packet, (uint8_t *)&i, 4);
 
-    return i;
 
-}
 
-
 
-uint64_t read_int64(Packet *packet) {
 
-    uint64_t i = 0;
 
-    read_bytes(packet, (uint8_t *)&i, 8);
 
-    return i;
 
-}
 
-
 
-uint32_t read_uleb128(Packet *packet) {
 
-    uint32_t result = 0;
 
-    uint32_t shift = 0;
 
-    uint8_t byte = 0;
 
+u32 read_uleb128(Packet *packet) {
 
+    u32 result = 0;
 
+    u32 shift = 0;
 
+    u8 byte = 0;
 
 
 
     do {
 
-        byte = read_byte(packet);
 
+        byte = read<u8>(packet);
 
         result |= (byte & 0x7f) << shift;
 
         shift += 7;
 
     } while(byte & 0x80);
@@ -146,24 +125,12 @@ uint32_t read_uleb128(Packet *packet) {
 
     return result;
 
 }
 
 
 
-float read_float32(Packet *packet) {
 
-    float f = 0;
 
-    read_bytes(packet, (uint8_t *)&f, 4);
 
-    return f;
 
-}
 
-
 
-double read_float64(Packet *packet) {
 
-    double f = 0;
 
-    read_bytes(packet, (uint8_t *)&f, 8);
 
-    return f;
 
-}
 
-
 
 UString read_string(Packet *packet) {
 
-    uint8_t empty_check = read_byte(packet);
 
+    u8 empty_check = read<u8>(packet);
 
     if(empty_check == 0) return UString("");
 
 
 
-    uint32_t len = read_uleb128(packet);
 
-    uint8_t *str = new uint8_t[len + 1];
 
+    u32 len = read_uleb128(packet);
 
+    u8 *str = new u8[len + 1];
 
     read_bytes(packet, str, len);
 
     str[len] = '\0';
 
 
@@ -174,11 +141,11 @@ UString read_string(Packet *packet) {
 
 }
 
 
 
 std::string read_stdstring(Packet *packet) {
 
-    uint8_t empty_check = read_byte(packet);
 
+    u8 empty_check = read<u8>(packet);
 
     if(empty_check == 0) return std::string();
 
 
 
-    uint32_t len = read_uleb128(packet);
 
-    uint8_t *str = new uint8_t[len + 1];
 
+    u32 len = read_uleb128(packet);
 
+    u8 *str = new u8[len + 1];
 
     read_bytes(packet, str, len);
 
 
 
     std::string str_out((const char *)str, len);
@@ -190,30 +157,30 @@ std::string read_stdstring(Packet *packet) {
 
 MD5Hash read_hash(Packet *packet) {
 
     MD5Hash hash;
 
 
 
-    uint8_t empty_check = read_byte(packet);
 
+    u8 empty_check = read<u8>(packet);
 
     if(empty_check == 0) return hash;
 
 
 
-    uint32_t len = read_uleb128(packet);
 
+    u32 len = read_uleb128(packet);
 
     if(len > 32) {
 
         len = 32;
 
     }
 
 
 
-    read_bytes(packet, (uint8_t *)hash.hash, len);
 
+    read_bytes(packet, (u8 *)hash.hash, len);
 
     hash.hash[len] = '\0';
 
     return hash;
 
 }
 
 
 
 void skip_string(Packet *packet) {
 
-    uint8_t empty_check = read_byte(packet);
 
+    u8 empty_check = read<u8>(packet);
 
     if(empty_check == 0) {
 
         return;
 
     }
 
 
 
-    uint32_t len = read_uleb128(packet);
 
+    u32 len = read_uleb128(packet);
 
     packet->pos += len;
 
 }
 
 
 
-void write_bytes(Packet *packet, uint8_t *bytes, size_t n) {
 
+void write_bytes(Packet *packet, u8 *bytes, size_t n) {
 
     if(packet->pos + n > packet->size) {
 
         packet->memory = (unsigned char *)realloc(packet->memory, packet->size + n + 128);
 
         packet->size += n + 128;
@@ -224,46 +191,46 @@ void write_bytes(Packet *packet, uint8_t *bytes, size_t n) {
 
     packet->pos += n;
 
 }
 
 
 
-void write_byte(Packet *packet, uint8_t b) { write_bytes(packet, &b, 1); }
 
+void write_u8(Packet *packet, u8 b) { write_bytes(packet, &b, 1); }
 
 
 
-void write_short(Packet *packet, uint16_t s) { write_bytes(packet, (uint8_t *)&s, 2); }
 
+void write_u16(Packet *packet, u16 s) { write_bytes(packet, (u8 *)&s, 2); }
 
 
 
-void write_int32(Packet *packet, uint32_t i) { write_bytes(packet, (uint8_t *)&i, 4); }
 
+void write_u32(Packet *packet, u32 i) { write_bytes(packet, (u8 *)&i, 4); }
 
 
 
-void write_int64(Packet *packet, uint64_t i) { write_bytes(packet, (uint8_t *)&i, 8); }
 
+void write_u64(Packet *packet, u64 i) { write_bytes(packet, (u8 *)&i, 8); }
 
 
 
-void write_uleb128(Packet *packet, uint32_t num) {
 
+void write_uleb128(Packet *packet, u32 num) {
 
     if(num == 0) {
 
-        uint8_t zero = 0;
 
-        write_byte(packet, zero);
 
+        u8 zero = 0;
 
+        write_u8(packet, zero);
 
         return;
 
     }
 
 
 
     while(num != 0) {
 
-        uint8_t next = num & 0x7F;
 
+        u8 next = num & 0x7F;
 
         num >>= 7;
 
         if(num != 0) {
 
             next |= 0x80;
 
         }
 
-        write_byte(packet, next);
 
+        write_u8(packet, next);
 
     }
 
 }
 
 
 
-void write_float32(Packet *packet, float f) { write_bytes(packet, (uint8_t *)&f, 4); }
 
+void write_f32(Packet *packet, float f) { write_bytes(packet, (u8 *)&f, 4); }
 
 
 
-void write_float64(Packet *packet, double f) { write_bytes(packet, (uint8_t *)&f, 8); }
 
+void write_f64(Packet *packet, double f) { write_bytes(packet, (u8 *)&f, 8); }
 
 
 
 void write_string(Packet *packet, const char *str) {
 
     if(!str || str[0] == '\0') {
 
-        uint8_t zero = 0;
 
-        write_byte(packet, zero);
 
+        u8 zero = 0;
 
+        write_u8(packet, zero);
 
         return;
 
     }
 
 
 
-    uint8_t empty_check = 11;
 
-    write_byte(packet, empty_check);
 
+    u8 empty_check = 11;
 
+    write_u8(packet, empty_check);
 
 
 
-    uint32_t len = strlen(str);
 
+    u32 len = strlen(str);
 
     write_uleb128(packet, len);
 
-    write_bytes(packet, (uint8_t *)str, len);
 
+    write_bytes(packet, (u8 *)str, len);
 
 }
--- a/src/App/Osu/BanchoProtocol.h
+++ b/src/App/Osu/BanchoProtocol.h
@@ -1,8 +1,6 @@
 
 #pragma once
 
-#include <stddef.h>
 
-#include <stdint.h>
 
-
 
 #include "UString.h"
 
+#include "types.h"
 
 
 
 enum Action {
 
     IDLE = 0,
@@ -137,20 +135,20 @@ enum OutgoingPackets {
 
 };
 
 
 
 struct Packet {
 
-    uint16_t id = 0;
 
-    uint8_t *memory = nullptr;
 
+    u16 id = 0;
 
+    u8 *memory = nullptr;
 
     size_t size = 0;
 
     size_t pos = 0;
 
-    uint8_t *extra = nullptr;
 
-    uint32_t extra_int = 0;  // lazy
 
+    u8 *extra = nullptr;
 
+    u32 extra_int = 0;  // lazy
 
 };
 
 
 
 struct Slot {
 
     // From ROOM_CREATED, ROOM_UPDATED
 
-    uint8_t status = 0;  // bitfield of [quit, complete, playing, no_map, ready, not_ready, locked, open]
 
-    uint8_t team = 0;
 
-    uint32_t player_id = 0;
 
-    uint32_t mods = 0;
 
+    u8 status = 0;  // bitfield of [quit, complete, playing, no_map, ready, not_ready, locked, open]
 
+    u8 team = 0;
 
+    u32 player_id = 0;
 
+    u32 mods = 0;
 
 
 
     // From MATCH_PLAYER_SKIPPED
 
     bool skipped = false;
@@ -159,19 +157,19 @@ struct Slot {
 
     bool died = false;
 
 
 
     // From MATCH_SCORE_UPDATED
 
-    int32_t last_update_tms = 0;
 
-    uint16_t num300 = 0;
 
-    uint16_t num100 = 0;
 
-    uint16_t num50 = 0;
 
-    uint16_t num_geki = 0;
 
-    uint16_t num_katu = 0;
 
-    uint16_t num_miss = 0;
 
-    int32_t total_score = 0;
 
-    uint16_t current_combo = 0;
 
-    uint16_t max_combo = 0;
 
-    uint8_t is_perfect = 0;
 
-    uint8_t current_hp = 0;
 
-    uint8_t tag = 0;
 
+    i32 last_update_tms = 0;
 
+    u16 num300 = 0;
 
+    u16 num100 = 0;
 
+    u16 num50 = 0;
 
+    u16 num_geki = 0;
 
+    u16 num_katu = 0;
 
+    u16 num_miss = 0;
 
+    i32 total_score = 0;
 
+    u16 current_combo = 0;
 
+    u16 max_combo = 0;
 
+    u8 is_perfect = 0;
 
+    u8 current_hp = 0;
 
+    u8 tag = 0;
 
     double sv2_combo = 0.0;
 
     double sv2_bonus = 0.0;
 
 
@@ -203,11 +201,11 @@ class Room {
 
     Room();
 
     Room(Packet *packet);
 
 
 
-    uint16_t id = 0;
 
-    uint8_t in_progress = 0;
 
-    uint8_t match_type = 0;
 
-    uint32_t mods = 0;
 
-    uint32_t seed = 0;
 
+    u16 id = 0;
 
+    u8 in_progress = 0;
 
+    u8 match_type = 0;
 
+    u32 mods = 0;
 
+    u32 seed = 0;
 
     bool all_players_loaded = false;
 
     bool all_players_skipped = false;
 
     bool player_loaded = false;
@@ -218,16 +216,16 @@ class Room {
 
 
 
     UString map_name = "";
 
     MD5Hash map_md5;
 
-    int32_t map_id = 0;
 
+    i32 map_id = 0;
 
 
 
-    uint8_t mode = 0;
 
-    uint8_t win_condition = 0;
 
-    uint8_t team_type = 0;
 
-    uint8_t freemods = 0;
 
+    u8 mode = 0;
 
+    u8 win_condition = 0;
 
+    u8 team_type = 0;
 
+    u8 freemods = 0;
 
 
 
-    int32_t host_id = 0;
 
-    uint8_t nb_players = 0;
 
-    uint8_t nb_open_slots = 0;
 
+    i32 host_id = 0;
 
+    u8 nb_players = 0;
 
+    u8 nb_open_slots = 0;
 
     Slot slots[16];
 
 
 
     bool all_players_ready() {
@@ -243,25 +241,50 @@ class Room {
 
     void pack(Packet *packet);
 
 };
 
 
 
-void read_bytes(Packet *packet, uint8_t *bytes, size_t n);
 
-uint8_t read_byte(Packet *packet);
 
-uint16_t read_short(Packet *packet);
 
-uint32_t read_int32(Packet *packet);
 
-uint64_t read_int64(Packet *packet);
 
-uint32_t read_uleb128(Packet *packet);
 
-float read_float32(Packet *packet);
 
-double read_float64(Packet *packet);
 
+void read_bytes(Packet *packet, u8 *bytes, size_t n);
 
+u32 read_uleb128(Packet *packet);
 
 UString read_string(Packet *packet);
 
 std::string read_stdstring(Packet *packet);
 
 void skip_string(Packet *packet);
 
 MD5Hash read_hash(Packet *packet);
 
 
 
-void write_bytes(Packet *packet, uint8_t *bytes, size_t n);
 
-void write_byte(Packet *packet, uint8_t b);
 
-void write_short(Packet *packet, uint16_t s);
 
-void write_int32(Packet *packet, uint32_t i);
 
-void write_int64(Packet *packet, uint64_t i);
 
-void write_uleb128(Packet *packet, uint32_t num);
 
-void write_float32(Packet *packet, float f);
 
-void write_float64(Packet *packet, double f);
 
+// Null array for returning empty structures when trying to read more data out of a Packet than expected.
 
+// See the read<> template below.
 
+#define NULL_ARRAY_SIZE 128
 
+extern u8 NULL_ARRAY[NULL_ARRAY_SIZE];
 
+
 
+template <typename T>
 
+T read(Packet *packet) {
 
+    static_assert(sizeof(T) <= sizeof(NULL_ARRAY), "Please make NULL_ARRAY_SIZE bigger");
 
+
 
+    if(packet->pos + sizeof(T) > packet->size) {
 
+        packet->pos = packet->size + 1;
 
+        return *(T *)NULL_ARRAY;
 
+    } else {
 
+        T out = *(T *)(packet->memory + packet->pos);
 
+        packet->pos += sizeof(T);
 
+        return out;
 
+    }
 
+}
 
+
 
+void write_bytes(Packet *packet, u8 *bytes, size_t n);
 
+void write_u8(Packet *packet, u8 b);
 
+void write_u16(Packet *packet, u16 s);
 
+void write_u32(Packet *packet, u32 i);
 
+void write_u64(Packet *packet, u64 i);
 
+void write_f32(Packet *packet, f32 f);
 
+void write_f64(Packet *packet, f64 f);
 
+void write_uleb128(Packet *packet, u32 num);
 
 void write_string(Packet *packet, const char *str);
 
+
 
+template <typename T>
 
+void write(Packet *packet, T t) {
 
+    if(packet->pos + sizeof(T) > packet->size) {
 
+        packet->memory = (u8 *)realloc(packet->memory, packet->size + sizeof(T) + 128);
 
+        packet->size += sizeof(T) + 128;
 
+        if(!packet->memory) return;
 
+    }
 
+
 
+    *(packet->memory + packet->pos) = t;
 
+    packet->pos += sizeof(T);
 
+}
--- a/src/App/Osu/BanchoSubmitter.cpp
+++ b/src/App/Osu/BanchoSubmitter.cpp
@@ -10,11 +10,11 @@
 
 #include "BanchoAes.h"
 
 #include "BanchoNetworking.h"
 
 #include "BanchoSubmitter.h"
 
+#include "DatabaseBeatmap.h"
 
 #include "Engine.h"
 
-#include "OsuDatabaseBeatmap.h"
 
 #include "base64.h"
 
 
 
-void submit_score(Score score) {
 
+void submit_score(FinishedScore score) {
 
     debugLog("Submitting score...\n");
 
     const char *GRADES[] = {"XH", "SH", "X", "S", "A", "B", "C", "D", "F", "N"};
 
 
@@ -22,13 +22,13 @@ void submit_score(Score score) {
 
     if(!bancho.set_fposu_flag) score.modsLegacy &= ~ModFlags::FPoSu;
 
     if(!bancho.set_mirror_flag) score.modsLegacy &= ~ModFlags::Mirror;
 
 
 
-    uint8_t *compressed_data = NULL;
 
+    u8 *compressed_data = NULL;
 
 
 
     char score_time[80];
 
     struct tm *timeinfo = localtime((const time_t *)&score.unixTimestamp);
 
     strftime(score_time, sizeof(score_time), "%y%m%d%H%M%S", timeinfo);
 
 
 
-    uint8_t iv[32];
 
+    u8 iv[32];
 
 #ifdef _WIN32
 
     HCRYPTPROV hCryptProv;
 
     CryptAcquireContext(&hCryptProv, NULL, NULL, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT);
@@ -108,8 +108,8 @@ void submit_score(Score score) {
 
     }
 
     {
 
         size_t s_client_hashes_encrypted = 0;
 
-        uint8_t *client_hashes_encrypted = encrypt(iv, (uint8_t *)bancho.client_hashes.toUtf8(),
 
-                                                   bancho.client_hashes.lengthUtf8(), &s_client_hashes_encrypted);
 
+        u8 *client_hashes_encrypted = encrypt(iv, (u8 *)bancho.client_hashes.toUtf8(),
 
+                                              bancho.client_hashes.lengthUtf8(), &s_client_hashes_encrypted);
 
         const char *client_hashes_b64 =
 
             (const char *)base64_encode(client_hashes_encrypted, s_client_hashes_encrypted, NULL);
 
         part = curl_mime_addpart(request.mime);
@@ -133,7 +133,7 @@ void submit_score(Score score) {
 
             idiot_check.append(UString::format("0%d%s", OSU_VERSION_DATEONLY, score_time));
 
             idiot_check.append(bancho.client_hashes);
 
 
 
-            auto idiot_hash = md5((uint8_t *)idiot_check.toUtf8(), idiot_check.lengthUtf8());
 
+            auto idiot_hash = md5((u8 *)idiot_check.toUtf8(), idiot_check.lengthUtf8());
 
             score_data.append(":");
 
             score_data.append(idiot_hash.hash);
 
         }
@@ -154,8 +154,8 @@ void submit_score(Score score) {
 
         score_data.append(":mcosu");  // anticheat flags
 
 
 
         size_t s_score_data_encrypted = 0;
 
-        uint8_t *score_data_encrypted =
 
-            encrypt(iv, (uint8_t *)score_data.toUtf8(), score_data.lengthUtf8(), &s_score_data_encrypted);
 
+        u8 *score_data_encrypted =
 
+            encrypt(iv, (u8 *)score_data.toUtf8(), score_data.lengthUtf8(), &s_score_data_encrypted);
 
         const char *score_data_b64 = (const char *)base64_encode(score_data_encrypted, s_score_data_encrypted, NULL);
 
 
 
         part = curl_mime_addpart(request.mime);
@@ -165,7 +165,7 @@ void submit_score(Score score) {
 
     }
 
     {
 
         size_t s_compressed_data = 0;
 
-        OsuReplay::compress_frames(score.replay, &compressed_data, &s_compressed_data);
 
+        Replay::compress_frames(score.replay, &compressed_data, &s_compressed_data);
 
         if(s_compressed_data <= 24) {
 
             debugLog("Replay too small to submit! Compressed size: %d bytes\n", s_compressed_data);
 
             goto err;
--- a/src/App/Osu/BanchoSubmitter.h
+++ b/src/App/Osu/BanchoSubmitter.h
@@ -1,4 +1,4 @@
 
 #pragma once
 
-#include "OsuDatabase.h"
 
+#include "Database.h"
 
 
 
-void submit_score(Score score);
 
+void submit_score(FinishedScore score);
--- a/src/App/Osu/BanchoUsers.cpp
+++ b/src/App/Osu/BanchoUsers.cpp
@@ -1,9 +1,9 @@
 
 #include "BanchoUsers.h"
 
 
 
-std::unordered_map<uint32_t, UserInfo*> online_users;
 
-std::vector<uint32_t> friends;
 
+std::unordered_map<u32, UserInfo*> online_users;
 
+std::vector<u32> friends;
 
 
 
-UserInfo* get_user_info(uint32_t user_id, bool fetch) {
 
+UserInfo* get_user_info(u32 user_id, bool fetch) {
 
     auto it = online_users.find(user_id);
 
     if(it != online_users.end()) {
 
         return it->second;
--- a/src/App/Osu/BanchoUsers.h
+++ b/src/App/Osu/BanchoUsers.h
@@ -5,34 +5,34 @@
 
 #include "UString.h"
 
 
 
 struct UserInfo {
 
-    uint32_t user_id = 0;
 
+    u32 user_id = 0;
 
 
 
     // Presence (via USER_PRESENCE_REQUEST or USER_PRESENCE_REQUEST_ALL)
 
     UString name;
 
-    uint8_t utc_offset = 0;
 
-    uint8_t country = 0;
 
-    uint8_t privileges = 0;
 
+    u8 utc_offset = 0;
 
+    u8 country = 0;
 
+    u8 privileges = 0;
 
     float longitude = 0.f;
 
     float latitude = 0.f;
 
-    int32_t global_rank = 0;
 
+    i32 global_rank = 0;
 
 
 
     // Stats (via USER_STATS_REQUEST)
 
     Action action = UNKNOWN;
 
     GameMode mode = STANDARD;
 
     UString info_text = UString("Loading...");
 
     UString map_md5;
 
-    int32_t map_id = 0;
 
-    uint32_t mods = 0;
 
-    int64_t total_score = 0;
 
-    int64_t ranked_score = 0;
 
-    int32_t plays = 0;
 
-    uint16_t pp = 0.f;
 
+    i32 map_id = 0;
 
+    u32 mods = 0;
 
+    i64 total_score = 0;
 
+    i64 ranked_score = 0;
 
+    i32 plays = 0;
 
+    u16 pp = 0.f;
 
     float accuracy = 0.f;
 
 
 
     bool is_friend();
 
 };
 
 
 
-extern std::unordered_map<uint32_t, UserInfo*> online_users;
 
-extern std::vector<uint32_t> friends;
 
+extern std::unordered_map<u32, UserInfo*> online_users;
 
+extern std::vector<u32> friends;
 
 
 
-UserInfo* get_user_info(uint32_t user_id, bool fetch = false);
 
+UserInfo* get_user_info(u32 user_id, bool fetch = false);
--- a/src/App/Osu/Beatmap.cpp
+++ b/src/App/Osu/Beatmap.cpp
--- a/src/App/Osu/OsuBeatmap.h
+++ b/src/App/Osu/OsuBeatmap.h
@@ -1,42 +1,42 @@
 
 #pragma once
 
-#include "OsuDatabaseBeatmap.h"
 
-#include "OsuReplay.h"
 
-#include "OsuScore.h"
 
+#include "DatabaseBeatmap.h"
 
+#include "Replay.h"
 
 #include "Timer.h"
 
 #include "UString.h"
 
 #include "cbase.h"
 
+#include "score.h"
 
 
 
 class Sound;
 
 class ConVar;
 
 
 
 class Osu;
 
-class OsuSkin;
 
-class OsuHitObject;
 
+class Skin;
 
+class HitObject;
 
 
 
-class OsuDatabaseBeatmap;
 
+class DatabaseBeatmap;
 
 
 
-class OsuBackgroundStarCacheLoader;
 
-class OsuBackgroundStarCalcHandler;
 
+class BackgroundStarCacheLoader;
 
+class BackgroundStarCalcHandler;
 
 
 
 struct Click {
 
     long tms;
 
     Vector2 pos;
 
 };
 
 
 
-class OsuBeatmap {
 
+class Beatmap {
 
    public:
 
-    friend class OsuBackgroundStarCacheLoader;
 
-    friend class OsuBackgroundStarCalcHandler;
 
+    friend class BackgroundStarCacheLoader;
 
+    friend class BackgroundStarCalcHandler;
 
 
 
-    OsuBeatmap(Osu *osu);
 
-    ~OsuBeatmap();
 
+    Beatmap(Osu *osu);
 
+    ~Beatmap();
 
 
 
     void draw(Graphics *g);
 
     void drawDebug(Graphics *g);
 
     void drawBackground(Graphics *g);
 
 
 
     void update();
 
-    void update2();  // Used to be OsuBeatmap::update()
 
+    void update2();  // Used to be Beatmap::update()
 
 
 
     void onKeyDown(KeyboardEvent &e);
 
 
@@ -58,7 +58,7 @@ class OsuBeatmap {
 
         Vector2 coords) const;  // hitobjects should use this one (includes lots of special behaviour)
 
     Vector2 osuCoords2RawPixels(
 
         Vector2 coords) const;  // raw transform from osu!pixels to absolute screen pixels (without any mods whatsoever)
 
-    Vector3 osuCoordsTo3D(Vector2 coords, const OsuHitObject *hitObject) const;
 
+    Vector3 osuCoordsTo3D(Vector2 coords, const HitObject *hitObject) const;
 
     Vector3 osuCoordsToRaw3D(Vector2 coords) const;  // (without any mods whatsoever)
 
     Vector2 osuCoords2LegacyPixels(
 
         Vector2 coords) const;  // only applies vanilla osu mods and static mods to the coordinates (used for generating
@@ -107,9 +107,9 @@ class OsuBeatmap {
 
     // songbrowser & player logic
 
     void select();  // loads the music of the currently selected diff and starts playing from the previewTime (e.g.
 
                     // clicking on a beatmap)
 
-    void selectDifficulty2(OsuDatabaseBeatmap *difficulty2);
 
+    void selectDifficulty2(DatabaseBeatmap *difficulty2);
 
     void deselect();  // stops + unloads the currently loaded music and deletes all hitobjects
 
-    bool watch(Score score, double start_percent);
 
+    bool watch(FinishedScore score, double start_percent);
 
     bool play();
 
     void restart(bool quick = false);
 
     void pause(bool quitIfWaiting = true);
@@ -185,22 +185,22 @@ class OsuBeatmap {
 
 
 
     // replay recording
 
     void write_frame();
 
-    std::vector<OsuReplay::Frame> live_replay;
 
+    std::vector<Replay::Frame> live_replay;
 
     double last_event_time = 0.0;
 
     long last_event_ms = 0;
 
-    uint8_t current_keys = 0;
 
-    uint8_t last_keys = 0;
 
+    u8 current_keys = 0;
 
+    u8 last_keys = 0;
 
 
 
     // replay replaying
 
     // current_keys, last_keys also reused
 
-    std::vector<OsuReplay::Frame> spectated_replay;
 
+    std::vector<Replay::Frame> spectated_replay;
 
     Vector2 m_interpolatedMousePos;
 
     bool m_bIsWatchingReplay = false;
 
     long current_frame_idx = 0;
 
 
 
-    // used by OsuHitObject children and OsuModSelector
 
+    // used by HitObject children and ModSelector
 
     inline Osu *getOsu() const { return m_osu; }
 
-    OsuSkin *getSkin() const;  // maybe use this for beatmap skins, maybe
 
+    Skin *getSkin() const;  // maybe use this for beatmap skins, maybe
 
     inline int getRandomSeed() const { return m_iRandomSeed; }
 
 
 
     inline long getCurMusicPos() const { return m_iCurMusicPos; }
@@ -220,7 +220,7 @@ class OsuBeatmap {
 
     inline double getHPMultiplierComboEnd() const { return m_fHpMultiplierComboEnd; }
 
 
 
     // database (legacy)
 
-    inline OsuDatabaseBeatmap *getSelectedDifficulty2() const { return m_selectedDifficulty2; }
 
+    inline DatabaseBeatmap *getSelectedDifficulty2() const { return m_selectedDifficulty2; }
 
 
 
     // generic state
 
     inline bool isPlaying() const { return m_bIsPlaying; }
@@ -241,21 +241,21 @@ class OsuBeatmap {
 
     std::string getTitle() const;
 
     std::string getArtist() const;
 
 
 
-    inline const std::vector<OsuDatabaseBeatmap::BREAK> &getBreaks() const { return m_breaks; }
 
+    inline const std::vector<DatabaseBeatmap::BREAK> &getBreaks() const { return m_breaks; }
 
     unsigned long getBreakDurationTotal() const;
 
-    OsuDatabaseBeatmap::BREAK getBreakForTimeRange(long startMS, long positionMS, long endMS) const;
 
+    DatabaseBeatmap::BREAK getBreakForTimeRange(long startMS, long positionMS, long endMS) const;
 
 
 
-    // OsuHitObject and other helper functions
 
-    OsuScore::HIT addHitResult(OsuHitObject *hitObject, OsuScore::HIT hit, long delta, bool isEndOfCombo = false,
 
-                               bool ignoreOnHitErrorBar = false, bool hitErrorBarOnly = false, bool ignoreCombo = false,
 
-                               bool ignoreScore = false, bool ignoreHealth = false);
 
+    // HitObject and other helper functions
 
+    LiveScore::HIT addHitResult(HitObject *hitObject, LiveScore::HIT hit, long delta, bool isEndOfCombo = false,
 
+                                bool ignoreOnHitErrorBar = false, bool hitErrorBarOnly = false,
 
+                                bool ignoreCombo = false, bool ignoreScore = false, bool ignoreHealth = false);
 
     void addSliderBreak();
 
     void addScorePoints(int points, bool isSpinner = false);
 
     void addHealth(double percent, bool isFromHitResult);
 
     void updateTimingPoints(long curPos);
 
 
 
     // ILLEGAL:
 
-    inline const std::vector<OsuHitObject *> &getHitObjectsPointer() const { return m_hitobjects; }
 
+    inline const std::vector<HitObject *> &getHitObjectsPointer() const { return m_hitobjects; }
 
     inline float getBreakBackgroundFadeAnim() const { return m_fBreakBackgroundFade; }
 
 
 
    protected:
@@ -292,7 +292,7 @@ class OsuBeatmap {
 
     float m_fWaitTime;
 
 
 
     // database
 
-    OsuDatabaseBeatmap *m_selectedDifficulty2;
 
+    DatabaseBeatmap *m_selectedDifficulty2;
 
 
 
     // sound
 
     Sound *m_music;
@@ -320,10 +320,10 @@ class OsuBeatmap {
 
     double m_fHpMultiplierComboEnd;
 
 
 
     // breaks
 
-    std::vector<OsuDatabaseBeatmap::BREAK> m_breaks;
 
+    std::vector<DatabaseBeatmap::BREAK> m_breaks;
 
     float m_fBreakBackgroundFade;
 
     bool m_bInBreak;
 
-    OsuHitObject *m_currentHitObject;
 
+    HitObject *m_currentHitObject;
 
     long m_iNextHitObjectTime;
 
     long m_iPreviousHitObjectTime;
 
     long m_iPreviousSectionPassFailTime;
@@ -337,9 +337,9 @@ class OsuBeatmap {
 
     std::vector<Click> m_clicks;
 
 
 
     // hitobjects
 
-    std::vector<OsuHitObject *> m_hitobjects;
 
-    std::vector<OsuHitObject *> m_hitobjectsSortedByEndTime;
 
-    std::vector<OsuHitObject *> m_misaimObjects;
 
+    std::vector<HitObject *> m_hitobjects;
 
+    std::vector<HitObject *> m_hitobjectsSortedByEndTime;
 
+    std::vector<HitObject *> m_misaimObjects;
 
     int m_iRandomSeed;
 
 
 
     // statistics
@@ -454,7 +454,7 @@ class OsuBeatmap {
 
     float m_fAimSliderFactor;
 
     float m_fSpeedStars;
 
     float m_fSpeedNotes;
 
-    OsuBackgroundStarCacheLoader *m_starCacheLoader;
 
+    BackgroundStarCacheLoader *m_starCacheLoader;
 
     float m_fStarCacheTime;
 
 
 
     // dynamic slider vertex buffer and other recalculation checks (for live mod switching)
@@ -482,7 +482,7 @@ class OsuBeatmap {
 
     int m_iMafhamPrevHitObjectIndex;
 
     int m_iMafhamActiveRenderHitObjectIndex;
 
     int m_iMafhamFinishedRenderHitObjectIndex;
 
-    bool m_bInMafhamRenderChunk;  // used by OsuSlider to not animate the reverse arrow, and by OsuCircle to not animate
 
+    bool m_bInMafhamRenderChunk;  // used by Slider to not animate the reverse arrow, and by Circle to not animate
 
                                   // note blocking shaking, while being rendered into the scene buffer
 
 
 
     int m_iMandalaIndex;
--- a/src/App/Osu/OsuChangelog.cpp
+++ b/src/App/Osu/OsuChangelog.cpp
@@ -5,7 +5,7 @@
 
 // $NoKeywords: $osulog
 
 //===============================================================================//
 
 
 
-#include "OsuChangelog.h"
 
+#include "Changelog.h"
 
 
 
 #include "CBaseUIButton.h"
 
 #include "CBaseUIContainer.h"
@@ -13,15 +13,15 @@
 
 #include "CBaseUIScrollView.h"
 
 #include "ConVar.h"
 
 #include "Engine.h"
 
+#include "HUD.h"
 
 #include "Mouse.h"
 
+#include "OptionsMenu.h"
 
 #include "Osu.h"
 
-#include "OsuHUD.h"
 
-#include "OsuOptionsMenu.h"
 
-#include "OsuSkin.h"
 
 #include "ResourceManager.h"
 
+#include "Skin.h"
 
 #include "SoundEngine.h"
 
 
 
-OsuChangelog::OsuChangelog(Osu *osu) : OsuScreenBackable(osu) {
 
+Changelog::Changelog(Osu *osu) : ScreenBackable(osu) {
 
     setPos(-1, -1);
 
     m_scrollView = new CBaseUIScrollView(-1, -1, 0, 0, "");
 
     m_scrollView->setVerticalScrolling(true);
@@ -46,7 +46,7 @@ OsuChangelog::OsuChangelog(Osu *osu) : OsuScreenBackable(osu) {
 
     latest.changes.push_back("- Changed default instant replay key to F2 to avoid conflicts with mod selector");
 
     latest.changes.push_back("- Disabled score submission when mods are toggled mid-game");
 
     latest.changes.push_back("- Forced exclusive mode when using WASAPI output");
 
-    latest.changes.push_back("- Optimized beatmap list loading speed");
 
+    latest.changes.push_back("- Optimized beatmap list loading speed (a lot)");
 
     latest.changes.push_back("- Optimized collection processing speed");
 
     latest.changes.push_back("- Removed support for the Nintendo Switch");
 
     latest.changes.push_back("- Updated protocol version");
@@ -218,7 +218,7 @@ OsuChangelog::OsuChangelog(Osu *osu) : OsuScreenBackable(osu) {
 
             };
 
 
 
             CBaseUIButton *change = new CustomCBaseUILabel(changelogs[i].changes[c]);
 
-            change->setClickCallback(fastdelegate::MakeDelegate(this, &OsuChangelog::onChangeClicked));
 
+            change->setClickCallback(fastdelegate::MakeDelegate(this, &Changelog::onChangeClicked));
 
 
 
             if(i > 0) change->setTextColor(0xff888888);
 
 
@@ -235,23 +235,23 @@ OsuChangelog::OsuChangelog(Osu *osu) : OsuScreenBackable(osu) {
 
     }
 
 }
 
 
 
-OsuChangelog::~OsuChangelog() { m_changelogs.clear(); }
 
+Changelog::~Changelog() { m_changelogs.clear(); }
 
 
 
-void OsuChangelog::mouse_update(bool *propagate_clicks) {
 
+void Changelog::mouse_update(bool *propagate_clicks) {
 
     if(!m_bVisible) return;
 
-    OsuScreenBackable::mouse_update(propagate_clicks);
 
+    ScreenBackable::mouse_update(propagate_clicks);
 
 }
 
 
 
-CBaseUIContainer *OsuChangelog::setVisible(bool visible) {
 
-    OsuScreenBackable::setVisible(visible);
 
+CBaseUIContainer *Changelog::setVisible(bool visible) {
 
+    ScreenBackable::setVisible(visible);
 
 
 
     if(m_bVisible) updateLayout();
 
 
 
     return this;
 
 }
 
 
 
-void OsuChangelog::updateLayout() {
 
-    OsuScreenBackable::updateLayout();
 
+void Changelog::updateLayout() {
 
+    ScreenBackable::updateLayout();
 
 
 
     const float dpiScale = Osu::getUIScale(m_osu);
 
 
@@ -282,13 +282,13 @@ void OsuChangelog::updateLayout() {
 
     m_scrollView->setScrollSizeToContent(15 * dpiScale);
 
 }
 
 
 
-void OsuChangelog::onBack() {
 
+void Changelog::onBack() {
 
     engine->getSound()->play(m_osu->getSkin()->getMenuClick());
 
 
 
     m_osu->toggleChangelog();
 
 }
 
 
 
-void OsuChangelog::onChangeClicked(CBaseUIButton *button) {
 
+void Changelog::onChangeClicked(CBaseUIButton *button) {
 
     const UString changeTextMaybeContainingClickableURL = button->getText();
 
 
 
     const int maybeURLBeginIndex = changeTextMaybeContainingClickableURL.find("http");
--- a/src/App/Osu/OsuChangelog.h
+++ b/src/App/Osu/OsuChangelog.h
@@ -8,17 +8,17 @@
 
 #ifndef OSUCHANGELOG_H
 
 #define OSUCHANGELOG_H
 
 
 
-#include "OsuScreenBackable.h"
 
+#include "ScreenBackable.h"
 
 
 
 class CBaseUIContainer;
 
 class CBaseUIScrollView;
 
 class CBaseUIImage;
 
 class CBaseUILabel;
 
 
 
-class OsuChangelog : public OsuScreenBackable {
 
+class Changelog : public ScreenBackable {
 
    public:
 
-    OsuChangelog(Osu *osu);
 
-    virtual ~OsuChangelog();
 
+    Changelog(Osu *osu);
 
+    virtual ~Changelog();
 
 
 
     virtual void mouse_update(bool *propagate_clicks);
 
 
--- a/src/App/Osu/OsuChat.cpp
+++ b/src/App/Osu/OsuChat.cpp
@@ -1,31 +1,31 @@
 
-#include "OsuChat.h"
 
+#include "Chat.h"
 
 
 
 #include "AnimationHandler.h"
 
 #include "Bancho.h"
 
 #include "BanchoNetworking.h"
 
+#include "Beatmap.h"
 
 #include "CBaseUIButton.h"
 
 #include "CBaseUIContainer.h"
 
 #include "CBaseUILabel.h"
 
 #include "Engine.h"
 
 #include "Font.h"
 
 #include "Keyboard.h"
 
+#include "Lobby.h"
 
+#include "ModSelector.h"
 
+#include "OptionsMenu.h"
 
 #include "Osu.h"
 
-#include "OsuBeatmap.h"
 
-#include "OsuLobby.h"
 
-#include "OsuModSelector.h"
 
-#include "OsuOptionsMenu.h"
 
-#include "OsuPauseMenu.h"
 
-#include "OsuPromptScreen.h"
 
-#include "OsuRoom.h"
 
-#include "OsuSkin.h"
 
-#include "OsuSongBrowser.h"
 
-#include "OsuUIButton.h"
 
-#include "OsuUIUserContextMenu.h"
 
+#include "PauseMenu.h"
 
+#include "PromptScreen.h"
 
 #include "RenderTarget.h"
 
 #include "ResourceManager.h"
 
+#include "RoomScreen.h"
 
+#include "Skin.h"
 
+#include "SongBrowser.h"
 
 #include "SoundEngine.h"
 
+#include "UIButton.h"
 
+#include "UIUserContextMenu.h"
 
 
 
-OsuChatChannel::OsuChatChannel(OsuChat *chat, UString name_arg) {
 
+ChatChannel::ChatChannel(Chat *chat, UString name_arg) {
 
     m_chat = chat;
 
     name = name_arg;
 
 
@@ -37,21 +37,21 @@ OsuChatChannel::OsuChatChannel(OsuChat *chat, UString name_arg) {
 
     ui->setDrawScrollbars(true);
 
     ui->sticky = true;
 
 
 
-    btn = new OsuUIButton(bancho.osu, 0, 0, 0, 0, "button", name);
 
+    btn = new UIButton(bancho.osu, 0, 0, 0, 0, "button", name);
 
     btn->grabs_clicks = true;
 
     btn->setUseDefaultSkin();
 
-    btn->setClickCallback(fastdelegate::MakeDelegate(this, &OsuChatChannel::onChannelButtonClick));
 
+    btn->setClickCallback(fastdelegate::MakeDelegate(this, &ChatChannel::onChannelButtonClick));
 
     m_chat->m_button_container->addBaseUIElement(btn);
 
 }
 
 
 
-OsuChatChannel::~OsuChatChannel() {
 
+ChatChannel::~ChatChannel() {
 
     delete ui;
 
     m_chat->m_button_container->deleteBaseUIElement(btn);
 
 }
 
 
 
-void OsuChatChannel::onChannelButtonClick(CBaseUIButton *btn) { m_chat->switchToChannel(this); }
 
+void ChatChannel::onChannelButtonClick(CBaseUIButton *btn) { m_chat->switchToChannel(this); }
 
 
 
-void OsuChatChannel::add_message(ChatMessage msg) {
 
+void ChatChannel::add_message(ChatMessage msg) {
 
     const float line_height = 20;
 
     const Color system_color = 0xffffff00;
 
 
@@ -71,7 +71,7 @@ void OsuChatChannel::add_message(ChatMessage msg) {
 
     if(!is_system_message) {
 
         float name_width = m_chat->font->getStringWidth(msg.author_name);
 
 
 
-        auto user_box = new OsuUIUserLabel(m_chat->m_osu, msg.author_id, msg.author_name);
 
+        auto user_box = new UIUserLabel(m_chat->m_osu, msg.author_id, msg.author_name);
 
         user_box->setTextColor(0xff2596be);
 
         user_box->setPos(x, y_total);
 
         user_box->setSize(name_width, line_height);
@@ -118,7 +118,7 @@ void OsuChatChannel::add_message(ChatMessage msg) {
 
     ui->setScrollSizeToContent();
 
 }
 
 
 
-void OsuChatChannel::updateLayout(Vector2 pos, Vector2 size) {
 
+void ChatChannel::updateLayout(Vector2 pos, Vector2 size) {
 
     ui->clear();
 
     ui->setPos(pos);
 
     ui->setSize(size);
@@ -131,16 +131,16 @@ void OsuChatChannel::updateLayout(Vector2 pos, Vector2 size) {
 
     ui->setScrollSizeToContent();
 
 }
 
 
 
-OsuChat::OsuChat(Osu *osu) : OsuScreen(osu) {
 
+Chat::Chat(Osu *osu) : OsuScreen(osu) {
 
     font = engine->getResourceManager()->getFont("FONT_DEFAULT");
 
 
 
     m_button_container = new CBaseUIContainer(0, 0, 0, 0, "");
 
 
 
-    join_channel_btn = new OsuUIButton(osu, 0, 0, 0, 0, "button", "+");
 
+    join_channel_btn = new UIButton(osu, 0, 0, 0, 0, "button", "+");
 
     join_channel_btn->setUseDefaultSkin();
 
     join_channel_btn->setColor(0xffffff55);
 
     join_channel_btn->setSize(button_height + 2, button_height + 2);
 
-    join_channel_btn->setClickCallback(fastdelegate::MakeDelegate(this, &OsuChat::askWhatChannelToJoin));
 
+    join_channel_btn->setClickCallback(fastdelegate::MakeDelegate(this, &Chat::askWhatChannelToJoin));
 
     m_button_container->addBaseUIElement(join_channel_btn);
 
 
 
     m_input_box = new CBaseUITextbox(0, 0, 0, 0, "");
@@ -152,7 +152,7 @@ OsuChat::OsuChat(Osu *osu) : OsuScreen(osu) {
 
     updateLayout(m_osu->getScreenSize());
 
 }
 
 
 
-void OsuChat::draw(Graphics *g) {
 
+void Chat::draw(Graphics *g) {
 
     const bool isAnimating = anim->isAnimating(&m_fAnimation);
 
     if(!m_bVisible && !isAnimating) return;
 
 
@@ -204,7 +204,7 @@ void OsuChat::draw(Graphics *g) {
 
     }
 
 }
 
 
 
-void OsuChat::mouse_update(bool *propagate_clicks) {
 
+void Chat::mouse_update(bool *propagate_clicks) {
 
     if(!m_bVisible) return;
 
     OsuScreen::mouse_update(propagate_clicks);
 
     m_button_container->mouse_update(propagate_clicks);
@@ -216,7 +216,7 @@ void OsuChat::mouse_update(bool *propagate_clicks) {
 
     m_input_box->focus(false);
 
 }
 
 
 
-void OsuChat::onKeyDown(KeyboardEvent &key) {
 
+void Chat::onKeyDown(KeyboardEvent &key) {
 
     if(!m_bVisible) return;
 
 
 
     // Escape: close chat
@@ -243,7 +243,7 @@ void OsuChat::onKeyDown(KeyboardEvent &key) {
 
             write_string(&packet, (char *)bancho.username.toUtf8());
 
             write_string(&packet, (char *)m_input_box->getText().toUtf8());
 
             write_string(&packet, (char *)m_selected_channel->name.toUtf8());
 
-            write_int32(&packet, bancho.user_id);
 
+            write_u32(&packet, bancho.user_id);
 
             send_packet(packet);
 
 
 
             // Server doesn't echo the message back
@@ -301,21 +301,21 @@ void OsuChat::onKeyDown(KeyboardEvent &key) {
 
     }
 
 }
 
 
 
-void OsuChat::onKeyUp(KeyboardEvent &key) {
 
+void Chat::onKeyUp(KeyboardEvent &key) {
 
     if(!m_bVisible || key.isConsumed()) return;
 
 
 
     m_input_box->onKeyUp(key);
 
     key.consume();
 
 }
 
 
 
-void OsuChat::onChar(KeyboardEvent &key) {
 
+void Chat::onChar(KeyboardEvent &key) {
 
     if(!m_bVisible || key.isConsumed()) return;
 
 
 
     m_input_box->onChar(key);
 
     key.consume();
 
 }
 
 
 
-void OsuChat::mark_as_read(OsuChatChannel *chan) {
 
+void Chat::mark_as_read(ChatChannel *chan) {
 
     if(!m_bVisible) return;
 
 
 
     // XXX: Only mark as read after 500ms
@@ -323,7 +323,7 @@ void OsuChat::mark_as_read(OsuChatChannel *chan) {
 
 
 
     CURL *curl = curl_easy_init();
 
     if(!curl) {
 
-        debugLog("Failed to initialize cURL in OsuChat::mark_as_read()!\n");
 
+        debugLog("Failed to initialize cURL in Chat::mark_as_read()!\n");
 
         return;
 
     }
 
     char *channel_urlencoded = curl_easy_escape(curl, chan->name.toUtf8(), 0);
@@ -345,7 +345,7 @@ void OsuChat::mark_as_read(OsuChatChannel *chan) {
 
     curl_easy_cleanup(curl);
 
 }
 
 
 
-void OsuChat::switchToChannel(OsuChatChannel *chan) {
 
+void Chat::switchToChannel(ChatChannel *chan) {
 
     m_selected_channel = chan;
 
     if(!chan->read) {
 
         mark_as_read(m_selected_channel);
@@ -355,7 +355,7 @@ void OsuChat::switchToChannel(OsuChatChannel *chan) {
 
     updateButtonLayout(getSize());
 
 }
 
 
 
-void OsuChat::addChannel(UString channel_name, bool switch_to) {
 
+void Chat::addChannel(UString channel_name, bool switch_to) {
 
     for(auto chan : m_channels) {
 
         if(chan->name == channel_name) {
 
             if(switch_to) {
@@ -365,7 +365,7 @@ void OsuChat::addChannel(UString channel_name, bool switch_to) {
 
         }
 
     }
 
 
 
-    OsuChatChannel *chan = new OsuChatChannel(this, channel_name);
 
+    ChatChannel *chan = new ChatChannel(this, channel_name);
 
     m_channels.push_back(chan);
 
 
 
     if(m_selected_channel == nullptr && m_channels.size() == 1) {
@@ -379,7 +379,7 @@ void OsuChat::addChannel(UString channel_name, bool switch_to) {
 
     updateLayout(m_osu->getScreenSize());
 
 }
 
 
 
-void OsuChat::addMessage(UString channel_name, ChatMessage msg) {
 
+void Chat::addMessage(UString channel_name, ChatMessage msg) {
 
     if(msg.author_id > 0 && channel_name[0] != '#' && msg.author_name != bancho.username) {
 
         // If it's a PM, the channel title should be the one who sent the message
 
         channel_name = msg.author_name;
@@ -403,8 +403,8 @@ void OsuChat::addMessage(UString channel_name, ChatMessage msg) {
 
     }
 
 }
 
 
 
-void OsuChat::removeChannel(UString channel_name) {
 
-    OsuChatChannel *chan = nullptr;
 
+void Chat::removeChannel(UString channel_name) {
 
+    ChatChannel *chan = nullptr;
 
     for(auto c : m_channels) {
 
         if(c->name == channel_name) {
 
             chan = c;
@@ -427,7 +427,7 @@ void OsuChat::removeChannel(UString channel_name) {
 
     updateButtonLayout(getSize());
 
 }
 
 
 
-void OsuChat::updateLayout(Vector2 newResolution) {
 
+void Chat::updateLayout(Vector2 newResolution) {
 
     // We don't want to update while the chat is hidden, to avoid lagspikes during gameplay
 
     if(!m_bVisible) {
 
         layout_update_scheduled = true;
@@ -462,18 +462,17 @@ void OsuChat::updateLayout(Vector2 newResolution) {
 
     layout_update_scheduled = false;
 
 }
 
 
 
-void OsuChat::updateButtonLayout(Vector2 screen) {
 
+void Chat::updateButtonLayout(Vector2 screen) {
 
     const float initial_x = 2;
 
     float total_x = initial_x;
 
 
 
-    std::sort(m_channels.begin(), m_channels.end(),
 
-              [](OsuChatChannel *a, OsuChatChannel *b) { return a->name < b->name; });
 
+    std::sort(m_channels.begin(), m_channels.end(), [](ChatChannel *a, ChatChannel *b) { return a->name < b->name; });
 
 
 
     // Look, I really tried. But for some reason setRelPos() doesn't work until we change
 
     // the screen resolution once. So I'll just compute absolute position manually.
 
     float button_container_height = button_height + 2;
 
     for(auto chan : m_channels) {
 
-        OsuUIButton *btn = chan->btn;
 
+        UIButton *btn = chan->btn;
 
         float button_width = font->getStringWidth(btn->getText()) + 20;
 
 
 
         // Wrap channel buttons
@@ -489,7 +488,7 @@ void OsuChat::updateButtonLayout(Vector2 screen) {
 
     float total_y = 0.f;
 
     total_x = initial_x;
 
     for(auto chan : m_channels) {
 
-        OsuUIButton *btn = chan->btn;
 
+        UIButton *btn = chan->btn;
 
         float button_width = font->getStringWidth(btn->getText()) + 20;
 
 
 
         // Wrap channel buttons
@@ -520,7 +519,7 @@ void OsuChat::updateButtonLayout(Vector2 screen) {
 
     m_button_container->setSize(screen.x, button_container_height);
 
 }
 
 
 
-void OsuChat::join(UString channel_name) {
 
+void Chat::join(UString channel_name) {
 
     // XXX: Open the channel immediately, without letting the user send messages in it.
 
     //      Would require a way to signal if a channel is joined or not.
 
     //      Would allow to keep open the tabs of the channels we got kicked out of.
@@ -530,7 +529,7 @@ void OsuChat::join(UString channel_name) {
 
     send_packet(packet);
 
 }
 
 
 
-void OsuChat::leave(UString channel_name) {
 
+void Chat::leave(UString channel_name) {
 
     bool send_leave_packet = channel_name[0] == '#';
 
     if(channel_name == UString("#lobby")) send_leave_packet = false;
 
     if(channel_name == UString("#multiplayer")) send_leave_packet = false;
@@ -545,7 +544,7 @@ void OsuChat::leave(UString channel_name) {
 
     removeChannel(channel_name);
 
 }
 
 
 
-void OsuChat::onDisconnect() {
 
+void Chat::onDisconnect() {
 
     for(auto chan : m_channels) {
 
         delete chan;
 
     }
@@ -562,9 +561,9 @@ void OsuChat::onDisconnect() {
 
     updateVisibility();
 
 }
 
 
 
-void OsuChat::onResolutionChange(Vector2 newResolution) { updateLayout(newResolution); }
 
+void Chat::onResolutionChange(Vector2 newResolution) { updateLayout(newResolution); }
 
 
 
-bool OsuChat::isVisibilityForced() {
 
+bool Chat::isVisibilityForced() {
 
     if(m_osu->m_room == nullptr || m_osu->m_lobby == nullptr || m_osu->m_songBrowser2 == nullptr) return false;
 
     bool sitting_in_room =
 
         m_osu->m_room->isVisible() && !m_osu->m_songBrowser2->isVisible() && !bancho.is_playing_a_multi_map();
@@ -579,7 +578,7 @@ bool OsuChat::isVisibilityForced() {
 
     return is_forced;
 
 }
 
 
 
-void OsuChat::updateVisibility() {
 
+void Chat::updateVisibility() {
 
     auto selected_beatmap = m_osu->getSelectedBeatmap();
 
     bool can_skip = (selected_beatmap != nullptr) && (selected_beatmap->isInSkippableSection());
 
     bool is_spectating = m_osu->m_bModAuto || (m_osu->m_bModAutopilot && m_osu->m_bModRelax) ||
@@ -600,7 +599,7 @@ void OsuChat::updateVisibility() {
 
     }
 
 }
 
 
 
-CBaseUIContainer *OsuChat::setVisible(bool visible) {
 
+CBaseUIContainer *Chat::setVisible(bool visible) {
 
     if(visible == m_bVisible) return this;
 
 
 
     if(visible && bancho.user_id <= 0) {
@@ -627,14 +626,14 @@ CBaseUIContainer *OsuChat::setVisible(bool visible) {
 
     return this;
 
 }
 
 
 
-bool OsuChat::isMouseInChat() {
 
+bool Chat::isMouseInChat() {
 
     if(!isVisible()) return false;
 
     if(m_selected_channel == nullptr) return false;
 
     return m_input_box->isMouseInside() || m_selected_channel->ui->isMouseInside();
 
 }
 
 
 
-void OsuChat::askWhatChannelToJoin(CBaseUIButton *btn) {
 
+void Chat::askWhatChannelToJoin(CBaseUIButton *btn) {
 
     // XXX: Could display nicer UI with full channel list (chat_channels in Bancho.cpp)
 
     m_osu->m_prompt->prompt("Type in the channel you want to join (e.g. '#osu'):",
 
-                            fastdelegate::MakeDelegate(this, &OsuChat::join));
 
+                            fastdelegate::MakeDelegate(this, &Chat::join));
 
 }
--- a/src/App/Osu/OsuChat.h
+++ b/src/App/Osu/OsuChat.h
@@ -6,23 +6,23 @@
 
 
 
 class CBaseUIButton;
 
 class McFont;
 
-class OsuChat;
 
-class OsuUIButton;
 
+class Chat;
 
+class UIButton;
 
 
 
 struct ChatMessage {
 
     time_t tms;
 
-    int32_t author_id;
 
+    i32 author_id;
 
     UString author_name;
 
     UString text;
 
 };
 
 
 
-struct OsuChatChannel {
 
-    OsuChatChannel(OsuChat *chat, UString name_arg);
 
-    ~OsuChatChannel();
 
+struct ChatChannel {
 
+    ChatChannel(Chat *chat, UString name_arg);
 
+    ~ChatChannel();
 
 
 
-    OsuChat *m_chat;
 
+    Chat *m_chat;
 
     CBaseUIScrollView *ui;
 
-    OsuUIButton *btn;
 
+    UIButton *btn;
 
     UString name;
 
     std::vector<ChatMessage> messages;
 
     float y_total;
@@ -33,9 +33,9 @@ struct OsuChatChannel {
 
     void onChannelButtonClick(CBaseUIButton *btn);
 
 };
 
 
 
-class OsuChat : public OsuScreen {
 
+class Chat : public OsuScreen {
 
    public:
 
-    OsuChat(Osu *osu);
 
+    Chat(Osu *osu);
 
 
 
     virtual void draw(Graphics *g);
 
     virtual void mouse_update(bool *propagate_clicks);
@@ -44,8 +44,8 @@ class OsuChat : public OsuScreen {
 
     virtual void onChar(KeyboardEvent &e);
 
     virtual void onResolutionChange(Vector2 newResolution);
 
 
 
-    void mark_as_read(OsuChatChannel *chan);
 
-    void switchToChannel(OsuChatChannel *chan);
 
+    void mark_as_read(ChatChannel *chan);
 
+    void switchToChannel(ChatChannel *chan);
 
     void addChannel(UString channel_name, bool switch_to = false);
 
     void addMessage(UString channel_name, ChatMessage msg);
 
     void removeChannel(UString channel_name);
@@ -62,10 +62,10 @@ class OsuChat : public OsuScreen {
 
     bool isMouseInChat();
 
 
 
     void askWhatChannelToJoin(CBaseUIButton *btn);
 
-    OsuUIButton *join_channel_btn;
 
+    UIButton *join_channel_btn;
 
 
 
-    OsuChatChannel *m_selected_channel = nullptr;
 
-    std::vector<OsuChatChannel *> m_channels;
 
+    ChatChannel *m_selected_channel = nullptr;
 
+    std::vector<ChatChannel *> m_channels;
 
     CBaseUIContainer *m_button_container;
 
     CBaseUITextbox *m_input_box;
 
 
--- a/src/App/Osu/OsuCircle.cpp
+++ b/src/App/Osu/OsuCircle.cpp
@@ -5,23 +5,23 @@
 
 // $NoKeywords: $circle
 
 //===============================================================================//
 
 
 
-#include "OsuCircle.h"
 
+#include "Circle.h"
 
 
 
 #include "AnimationHandler.h"
 
+#include "Beatmap.h"
 
 #include "Camera.h"
 
 #include "ConVar.h"
 
 #include "Engine.h"
 
+#include "GameRules.h"
 
+#include "ModFPoSu.h"
 
 #include "OpenGL3Interface.h"
 
 #include "OpenGLES2Interface.h"
 
 #include "OpenGLHeaders.h"
 
 #include "OpenGLLegacyInterface.h"
 
 #include "Osu.h"
 
-#include "OsuBeatmap.h"
 
-#include "OsuGameRules.h"
 
-#include "OsuModFPoSu.h"
 
-#include "OsuSkin.h"
 
-#include "OsuSkinImage.h"
 
 #include "ResourceManager.h"
 
+#include "Skin.h"
 
+#include "SkinImage.h"
 
 #include "SoundEngine.h"
 
 
 
 ConVar osu_bug_flicker_log("osu_bug_flicker_log", false, FCVAR_NONE);
@@ -39,12 +39,12 @@ ConVar osu_draw_approach_circles("osu_draw_approach_circles", true, FCVAR_NONE);
 
 
 
 ConVar osu_slider_draw_endcircle("osu_slider_draw_endcircle", true, FCVAR_NONE);
 
 
 
-int OsuCircle::rainbowNumber = 0;
 
-int OsuCircle::rainbowColorCounter = 0;
 
+int Circle::rainbowNumber = 0;
 
+int Circle::rainbowColorCounter = 0;
 
 
 
-void OsuCircle::drawApproachCircle(Graphics *g, OsuBeatmap *beatmap, Vector2 rawPos, int number, int colorCounter,
 
-                                   int colorOffset, float colorRGBMultiplier, float approachScale, float alpha,
 
-                                   bool overrideHDApproachCircle) {
 
+void Circle::drawApproachCircle(Graphics *g, Beatmap *beatmap, Vector2 rawPos, int number, int colorCounter,
 
+                                int colorOffset, float colorRGBMultiplier, float approachScale, float alpha,
 
+                                bool overrideHDApproachCircle) {
 
     rainbowNumber = number;
 
     rainbowColorCounter = colorCounter;
 
 
@@ -59,18 +59,18 @@ void OsuCircle::drawApproachCircle(Graphics *g, OsuBeatmap *beatmap, Vector2 raw
 
                        overrideHDApproachCircle);
 
 }
 
 
 
-void OsuCircle::drawCircle(Graphics *g, OsuBeatmap *beatmap, Vector2 rawPos, int number, int colorCounter,
 
-                           int colorOffset, float colorRGBMultiplier, float approachScale, float alpha,
 
-                           float numberAlpha, bool drawNumber, bool overrideHDApproachCircle) {
 
+void Circle::drawCircle(Graphics *g, Beatmap *beatmap, Vector2 rawPos, int number, int colorCounter, int colorOffset,
 
+                        float colorRGBMultiplier, float approachScale, float alpha, float numberAlpha, bool drawNumber,
 
+                        bool overrideHDApproachCircle) {
 
     drawCircle(g, beatmap->getSkin(), beatmap->osuCoords2Pixels(rawPos), beatmap->getHitcircleDiameter(),
 
                beatmap->getNumberScale(), beatmap->getHitcircleOverlapScale(), number, colorCounter, colorOffset,
 
                colorRGBMultiplier, approachScale, alpha, numberAlpha, drawNumber, overrideHDApproachCircle);
 
 }
 
 
 
-void OsuCircle::drawCircle(Graphics *g, OsuSkin *skin, Vector2 pos, float hitcircleDiameter, float numberScale,
 
-                           float overlapScale, int number, int colorCounter, int colorOffset, float colorRGBMultiplier,
 
-                           float approachScale, float alpha, float numberAlpha, bool drawNumber,
 
-                           bool overrideHDApproachCircle) {
 
+void Circle::drawCircle(Graphics *g, Skin *skin, Vector2 pos, float hitcircleDiameter, float numberScale,
 
+                        float overlapScale, int number, int colorCounter, int colorOffset, float colorRGBMultiplier,
 
+                        float approachScale, float alpha, float numberAlpha, bool drawNumber,
 
+                        bool overrideHDApproachCircle) {
 
     if(alpha <= 0.0f || !osu_draw_circles.getBool()) return;
 
 
 
     rainbowNumber = number;
@@ -104,7 +104,7 @@ void OsuCircle::drawCircle(Graphics *g, OsuSkin *skin, Vector2 pos, float hitcir
 
         drawHitCircleOverlay(g, skin->getHitCircleOverlay2(), pos, circleOverlayImageScale, alpha, colorRGBMultiplier);
 
 }
 
 
 
-void OsuCircle::drawCircle(Graphics *g, OsuSkin *skin, Vector2 pos, float hitcircleDiameter, Color color, float alpha) {
 
+void Circle::drawCircle(Graphics *g, Skin *skin, Vector2 pos, float hitcircleDiameter, Color color, float alpha) {
 
     // this function is only used by the target practice heatmap
 
 
 
     // circle
@@ -116,19 +116,19 @@ void OsuCircle::drawCircle(Graphics *g, OsuSkin *skin, Vector2 pos, float hitcir
 
     drawHitCircleOverlay(g, skin->getHitCircleOverlay2(), pos, circleOverlayImageScale, alpha, 1.0f);
 
 }
 
 
 
-void OsuCircle::drawSliderStartCircle(Graphics *g, OsuBeatmap *beatmap, Vector2 rawPos, int number, int colorCounter,
 
-                                      int colorOffset, float colorRGBMultiplier, float approachScale, float alpha,
 
-                                      float numberAlpha, bool drawNumber, bool overrideHDApproachCircle) {
 
+void Circle::drawSliderStartCircle(Graphics *g, Beatmap *beatmap, Vector2 rawPos, int number, int colorCounter,
 
+                                   int colorOffset, float colorRGBMultiplier, float approachScale, float alpha,
 
+                                   float numberAlpha, bool drawNumber, bool overrideHDApproachCircle) {
 
     drawSliderStartCircle(g, beatmap->getSkin(), beatmap->osuCoords2Pixels(rawPos), beatmap->getHitcircleDiameter(),
 
                           beatmap->getNumberScale(), beatmap->getHitcircleOverlapScale(), number, colorCounter,
 
                           colorOffset, colorRGBMultiplier, approachScale, alpha, numberAlpha, drawNumber,
 
                           overrideHDApproachCircle);
 
 }
 
 
 
-void OsuCircle::drawSliderStartCircle(Graphics *g, OsuSkin *skin, Vector2 pos, float hitcircleDiameter,
 
-                                      float numberScale, float hitcircleOverlapScale, int number, int colorCounter,
 
-                                      int colorOffset, float colorRGBMultiplier, float approachScale, float alpha,
 
-                                      float numberAlpha, bool drawNumber, bool overrideHDApproachCircle) {
 
+void Circle::drawSliderStartCircle(Graphics *g, Skin *skin, Vector2 pos, float hitcircleDiameter, float numberScale,
 
+                                   float hitcircleOverlapScale, int number, int colorCounter, int colorOffset,
 
+                                   float colorRGBMultiplier, float approachScale, float alpha, float numberAlpha,
 
+                                   bool drawNumber, bool overrideHDApproachCircle) {
 
     if(alpha <= 0.0f || !osu_draw_circles.getBool()) return;
 
 
 
     // if no sliderstartcircle image is preset, fallback to default circle
@@ -176,19 +176,19 @@ void OsuCircle::drawSliderStartCircle(Graphics *g, OsuSkin *skin, Vector2 pos, f
 
     }
 
 }
 
 
 
-void OsuCircle::drawSliderEndCircle(Graphics *g, OsuBeatmap *beatmap, Vector2 rawPos, int number, int colorCounter,
 
-                                    int colorOffset, float colorRGBMultiplier, float approachScale, float alpha,
 
-                                    float numberAlpha, bool drawNumber, bool overrideHDApproachCircle) {
 
+void Circle::drawSliderEndCircle(Graphics *g, Beatmap *beatmap, Vector2 rawPos, int number, int colorCounter,
 
+                                 int colorOffset, float colorRGBMultiplier, float approachScale, float alpha,
 
+                                 float numberAlpha, bool drawNumber, bool overrideHDApproachCircle) {
 
     drawSliderEndCircle(g, beatmap->getSkin(), beatmap->osuCoords2Pixels(rawPos), beatmap->getHitcircleDiameter(),
 
                         beatmap->getNumberScale(), beatmap->getHitcircleOverlapScale(), number, colorCounter,
 
                         colorOffset, colorRGBMultiplier, approachScale, alpha, numberAlpha, drawNumber,
 
                         overrideHDApproachCircle);
 
 }
 
 
 
-void OsuCircle::drawSliderEndCircle(Graphics *g, OsuSkin *skin, Vector2 pos, float hitcircleDiameter, float numberScale,
 
-                                    float overlapScale, int number, int colorCounter, int colorOffset,
 
-                                    float colorRGBMultiplier, float approachScale, float alpha, float numberAlpha,
 
-                                    bool drawNumber, bool overrideHDApproachCircle) {
 
+void Circle::drawSliderEndCircle(Graphics *g, Skin *skin, Vector2 pos, float hitcircleDiameter, float numberScale,
 
+                                 float overlapScale, int number, int colorCounter, int colorOffset,
 
+                                 float colorRGBMultiplier, float approachScale, float alpha, float numberAlpha,
 
+                                 bool drawNumber, bool overrideHDApproachCircle) {
 
     if(alpha <= 0.0f || !osu_slider_draw_endcircle.getBool() || !osu_draw_circles.getBool()) return;
 
 
 
     // if no sliderendcircle image is preset, fallback to default circle
@@ -220,10 +220,10 @@ void OsuCircle::drawSliderEndCircle(Graphics *g, OsuSkin *skin, Vector2 pos, flo
 
     }
 
 }
 
 
 
-void OsuCircle::drawApproachCircle(Graphics *g, OsuSkin *skin, Vector2 pos, Color comboColor, float hitcircleDiameter,
 
-                                   float approachScale, float alpha, bool modHD, bool overrideHDApproachCircle) {
 
+void Circle::drawApproachCircle(Graphics *g, Skin *skin, Vector2 pos, Color comboColor, float hitcircleDiameter,
 
+                                float approachScale, float alpha, bool modHD, bool overrideHDApproachCircle) {
 
     if((!modHD || overrideHDApproachCircle) && osu_draw_approach_circles.getBool() &&
 
-       !OsuGameRules::osu_mod_mafham.getBool()) {
 
+       !GameRules::osu_mod_mafham.getBool()) {
 
         if(approachScale > 1.0f) {
 
             const float approachCircleImageScale =
 
                 hitcircleDiameter / (128.0f * (skin->isApproachCircle2x() ? 2.0f : 1.0f));
@@ -254,15 +254,15 @@ void OsuCircle::drawApproachCircle(Graphics *g, OsuSkin *skin, Vector2 pos, Colo
 
     }
 
 }
 
 
 
-void OsuCircle::drawHitCircleOverlay(Graphics *g, OsuSkinImage *hitCircleOverlayImage, Vector2 pos,
 
-                                     float circleOverlayImageScale, float alpha, float colorRGBMultiplier) {
 
+void Circle::drawHitCircleOverlay(Graphics *g, SkinImage *hitCircleOverlayImage, Vector2 pos,
 
+                                  float circleOverlayImageScale, float alpha, float colorRGBMultiplier) {
 
     g->setColor(COLORf(1.0f, colorRGBMultiplier, colorRGBMultiplier, colorRGBMultiplier));
 
     g->setAlpha(alpha);
 
     hitCircleOverlayImage->drawRaw(g, pos, circleOverlayImageScale);
 
 }
 
 
 
-void OsuCircle::drawHitCircle(Graphics *g, Image *hitCircleImage, Vector2 pos, Color comboColor, float circleImageScale,
 
-                              float alpha) {
 
+void Circle::drawHitCircle(Graphics *g, Image *hitCircleImage, Vector2 pos, Color comboColor, float circleImageScale,
 
+                           float alpha) {
 
     g->setColor(comboColor);
 
 
 
     if(osu_circle_rainbow.getBool()) {
@@ -287,13 +287,13 @@ void OsuCircle::drawHitCircle(Graphics *g, Image *hitCircleImage, Vector2 pos, C
 
     g->popTransform();
 
 }
 
 
 
-void OsuCircle::drawHitCircleNumber(Graphics *g, OsuSkin *skin, float numberScale, float overlapScale, Vector2 pos,
 
-                                    int number, float numberAlpha, float colorRGBMultiplier) {
 
+void Circle::drawHitCircleNumber(Graphics *g, Skin *skin, float numberScale, float overlapScale, Vector2 pos,
 
+                                 int number, float numberAlpha, float colorRGBMultiplier) {
 
     if(!osu_draw_numbers.getBool()) return;
 
 
 
     class DigitWidth {
 
        public:
 
-        static float getWidth(OsuSkin *skin, int digit) {
 
+        static float getWidth(Skin *skin, int digit) {
 
             switch(digit) {
 
                 case 0:
 
                     return skin->getDefault0()->getWidth();
@@ -416,9 +416,9 @@ void OsuCircle::drawHitCircleNumber(Graphics *g, OsuSkin *skin, float numberScal
 
     g->popTransform();
 
 }
 
 
 
-OsuCircle::OsuCircle(int x, int y, long time, int sampleType, int comboNumber, bool isEndOfCombo, int colorCounter,
 
-                     int colorOffset, OsuBeatmap *beatmap)
 
-    : OsuHitObject(time, sampleType, comboNumber, isEndOfCombo, colorCounter, colorOffset, beatmap) {
 
+Circle::Circle(int x, int y, long time, int sampleType, int comboNumber, bool isEndOfCombo, int colorCounter,
 
+               int colorOffset, Beatmap *beatmap)
 
+    : HitObject(time, sampleType, comboNumber, isEndOfCombo, colorCounter, colorOffset, beatmap) {
 
     m_vOriginalRawPos = Vector2(x, y);
 
     m_vRawPos = m_vOriginalRawPos;
 
 
@@ -429,11 +429,11 @@ OsuCircle::OsuCircle(int x, int y, long time, int sampleType, int comboNumber, b
 
     m_fShakeAnimation = 0.0f;
 
 }
 
 
 
-OsuCircle::~OsuCircle() { onReset(0); }
 
+Circle::~Circle() { onReset(0); }
 
 
 
-void OsuCircle::draw(Graphics *g) {
 
-    OsuHitObject::draw(g);
 
-    OsuSkin *skin = m_beatmap->getOsu()->getSkin();
 
+void Circle::draw(Graphics *g) {
 
+    HitObject::draw(g);
 
+    Skin *skin = m_beatmap->getOsu()->getSkin();
 
 
 
     // draw hit animation
 
     if(m_fHitAnimation > 0.0f && m_fHitAnimation != 1.0f && !m_beatmap->getOsu()->getModHD()) {
@@ -443,7 +443,7 @@ void OsuCircle::draw(Graphics *g) {
 
         scale = -scale * (scale - 2.0f);  // quad out scale
 
 
 
         const bool drawNumber = skin->getVersion() > 1.0f ? false : true;
 
-        const float foscale = OsuGameRules::osu_circle_fade_out_scale.getFloat();
 
+        const float foscale = GameRules::osu_circle_fade_out_scale.getFloat();
 
 
 
         g->pushTransform();
 
         {
@@ -488,8 +488,8 @@ void OsuCircle::draw(Graphics *g) {
 
                m_bOverrideHDApproachCircle);
 
 }
 
 
 
-void OsuCircle::draw2(Graphics *g) {
 
-    OsuHitObject::draw2(g);
 
+void Circle::draw2(Graphics *g) {
 
+    HitObject::draw2(g);
 
     if(m_bFinished || (!m_bVisible && !m_bWaiting))
 
         return;  // special case needed for when we are past this objects time, but still within not-miss range, because
 
                  // we still need to draw the object
@@ -510,13 +510,13 @@ void OsuCircle::draw2(Graphics *g) {
 
                        m_bWaiting && !hd ? 1.0f : m_fAlphaForApproachCircle, m_bOverrideHDApproachCircle);
 
 }
 
 
 
-void OsuCircle::update(long curPos) {
 
-    OsuHitObject::update(curPos);
 
+void Circle::update(long curPos) {
 
+    HitObject::update(curPos);
 
 
 
     // if we have not been clicked yet, check if we are in the timeframe of a miss, also handle auto and relax
 
     if(!m_bFinished) {
 
         if(m_beatmap->getOsu()->getModAuto()) {
 
-            if(curPos >= m_iTime) onHit(OsuScore::HIT::HIT_300, 0);
 
+            if(curPos >= m_iTime) onHit(LiveScore::HIT::HIT_300, 0);
 
         } else {
 
             const long delta = curPos - m_iTime;
 
 
@@ -526,9 +526,9 @@ void OsuCircle::update(long curPos) {
 
                     const Vector2 pos = m_beatmap->osuCoords2Pixels(m_vRawPos);
 
                     const float cursorDelta = (m_beatmap->getCursorPos() - pos).length();
 
                     if((cursorDelta < m_beatmap->getHitcircleDiameter() / 2.0f && m_beatmap->getOsu()->getModRelax())) {
 
-                        OsuScore::HIT result = OsuGameRules::getHitResult(delta, m_beatmap);
 
+                        LiveScore::HIT result = GameRules::getHitResult(delta, m_beatmap);
 
 
 
-                        if(result != OsuScore::HIT::HIT_NULL) {
 
+                        if(result != LiveScore::HIT::HIT_NULL) {
 
                             const float targetDelta = cursorDelta / (m_beatmap->getHitcircleDiameter() / 2.0f);
 
                             const float targetAngle = rad2deg(
 
                                 atan2(m_beatmap->getCursorPos().y - pos.y, m_beatmap->getCursorPos().x - pos.x));
@@ -543,27 +543,27 @@ void OsuCircle::update(long curPos) {
 
                 m_bWaiting = true;
 
 
 
                 // if this is a miss after waiting
 
-                if(delta > (long)OsuGameRules::getHitWindow50(m_beatmap)) onHit(OsuScore::HIT::HIT_MISS, delta);
 
+                if(delta > (long)GameRules::getHitWindow50(m_beatmap)) onHit(LiveScore::HIT::HIT_MISS, delta);
 
             } else
 
                 m_bWaiting = false;
 
         }
 
     }
 
 }
 
 
 
-void OsuCircle::updateStackPosition(float stackOffset) {
 
+void Circle::updateStackPosition(float stackOffset) {
 
     m_vRawPos = m_vOriginalRawPos - Vector2(m_iStack * stackOffset,
 
                                             m_iStack * stackOffset * (m_beatmap->getOsu()->getModHR() ? -1.0f : 1.0f));
 
 }
 
 
 
-void OsuCircle::miss(long curPos) {
 
+void Circle::miss(long curPos) {
 
     if(m_bFinished) return;
 
 
 
     const long delta = curPos - m_iTime;
 
 
 
-    onHit(OsuScore::HIT::HIT_MISS, delta);
 
+    onHit(LiveScore::HIT::HIT_MISS, delta);
 
 }
 
 
 
-void OsuCircle::onClickEvent(std::vector<Click> &clicks) {
 
+void Circle::onClickEvent(std::vector<Click> &clicks) {
 
     if(m_bFinished) return;
 
 
 
     const Vector2 cursorPos = clicks[0].pos;
@@ -579,8 +579,8 @@ void OsuCircle::onClickEvent(std::vector<Click> &clicks) {
 
 
 
         const long delta = clicks[0].tms - (long)m_iTime;
 
 
 
-        OsuScore::HIT result = OsuGameRules::getHitResult(delta, m_beatmap);
 
-        if(result != OsuScore::HIT::HIT_NULL) {
 
+        LiveScore::HIT result = GameRules::getHitResult(delta, m_beatmap);
 
+        if(result != LiveScore::HIT::HIT_NULL) {
 
             const float targetDelta = cursorDelta / (m_beatmap->getHitcircleDiameter() / 2.0f);
 
             const float targetAngle = rad2deg(atan2(cursorPos.y - pos.y, cursorPos.x - pos.x));
 
 
@@ -590,17 +590,17 @@ void OsuCircle::onClickEvent(std::vector<Click> &clicks) {
 
     }
 
 }
 
 
 
-void OsuCircle::onHit(OsuScore::HIT result, long delta, float targetDelta, float targetAngle) {
 
+void Circle::onHit(LiveScore::HIT result, long delta, float targetDelta, float targetAngle) {
 
     // sound and hit animation
 
-    if(result != OsuScore::HIT::HIT_MISS) {
 
+    if(result != LiveScore::HIT::HIT_MISS) {
 
         if(m_osu_timingpoints_force->getBool()) m_beatmap->updateTimingPoints(m_iTime);
 
 
 
         const Vector2 osuCoords = m_beatmap->pixels2OsuCoords(m_beatmap->osuCoords2Pixels(m_vRawPos));
 
 
 
-        m_beatmap->getSkin()->playHitCircleSound(m_iSampleType, OsuGameRules::osuCoords2Pan(osuCoords.x));
 
+        m_beatmap->getSkin()->playHitCircleSound(m_iSampleType, GameRules::osuCoords2Pan(osuCoords.x));
 
 
 
         m_fHitAnimation = 0.001f;  // quickfix for 1 frame missing images
 
-        anim->moveQuadOut(&m_fHitAnimation, 1.0f, OsuGameRules::getFadeOutTime(m_beatmap), true);
 
+        anim->moveQuadOut(&m_fHitAnimation, 1.0f, GameRules::getFadeOutTime(m_beatmap), true);
 
     }
 
 
 
     // add it, and we are finished
@@ -608,8 +608,8 @@ void OsuCircle::onHit(OsuScore::HIT result, long delta, float targetDelta, float
 
     m_bFinished = true;
 
 }
 
 
 
-void OsuCircle::onReset(long curPos) {
 
-    OsuHitObject::onReset(curPos);
 
+void Circle::onReset(long curPos) {
 
+    HitObject::onReset(curPos);
 
 
 
     m_bWaiting = false;
 
     m_fShakeAnimation = 0.0f;
@@ -625,4 +625,4 @@ void OsuCircle::onReset(long curPos) {
 
     }
 
 }
 
 
 
-Vector2 OsuCircle::getAutoCursorPos(long curPos) { return m_beatmap->osuCoords2Pixels(m_vRawPos); }
 
+Vector2 Circle::getAutoCursorPos(long curPos) { return m_beatmap->osuCoords2Pixels(m_vRawPos); }
--- a/src/App/Osu/OsuCircle.h
+++ b/src/App/Osu/OsuCircle.h
@@ -8,57 +8,57 @@
 
 #ifndef OSUCIRCLE_H
 
 #define OSUCIRCLE_H
 
 
 
-#include "OsuHitObject.h"
 
+#include "HitObject.h"
 
 
 
-class OsuModFPoSu;
 
-class OsuSkinImage;
 
+class ModFPoSu;
 
+class SkinImage;
 
 
 
-class OsuCircle : public OsuHitObject {
 
+class Circle : public HitObject {
 
    public:
 
     // main
 
-    static void drawApproachCircle(Graphics *g, OsuBeatmap *beatmap, Vector2 rawPos, int number, int colorCounter,
 
+    static void drawApproachCircle(Graphics *g, Beatmap *beatmap, Vector2 rawPos, int number, int colorCounter,
 
                                    int colorOffset, float colorRGBMultiplier, float approachScale, float alpha,
 
                                    bool overrideHDApproachCircle = false);
 
-    static void drawCircle(Graphics *g, OsuBeatmap *beatmap, Vector2 rawPos, int number, int colorCounter,
 
-                           int colorOffset, float colorRGBMultiplier, float approachScale, float alpha,
 
-                           float numberAlpha, bool drawNumber = true, bool overrideHDApproachCircle = false);
 
-    static void drawCircle(Graphics *g, OsuSkin *skin, Vector2 pos, float hitcircleDiameter, float numberScale,
 
+    static void drawCircle(Graphics *g, Beatmap *beatmap, Vector2 rawPos, int number, int colorCounter, int colorOffset,
 
+                           float colorRGBMultiplier, float approachScale, float alpha, float numberAlpha,
 
+                           bool drawNumber = true, bool overrideHDApproachCircle = false);
 
+    static void drawCircle(Graphics *g, Skin *skin, Vector2 pos, float hitcircleDiameter, float numberScale,
 
                            float overlapScale, int number, int colorCounter, int colorOffset, float colorRGBMultiplier,
 
                            float approachScale, float alpha, float numberAlpha, bool drawNumber = true,
 
                            bool overrideHDApproachCircle = false);
 
-    static void drawCircle(Graphics *g, OsuSkin *skin, Vector2 pos, float hitcircleDiameter, Color color,
 
+    static void drawCircle(Graphics *g, Skin *skin, Vector2 pos, float hitcircleDiameter, Color color,
 
                            float alpha = 1.0f);
 
-    static void drawSliderStartCircle(Graphics *g, OsuBeatmap *beatmap, Vector2 rawPos, int number, int colorCounter,
 
+    static void drawSliderStartCircle(Graphics *g, Beatmap *beatmap, Vector2 rawPos, int number, int colorCounter,
 
                                       int colorOffset, float colorRGBMultiplier, float approachScale, float alpha,
 
                                       float numberAlpha, bool drawNumber = true, bool overrideHDApproachCircle = false);
 
-    static void drawSliderStartCircle(Graphics *g, OsuSkin *skin, Vector2 pos, float hitcircleDiameter,
 
-                                      float numberScale, float hitcircleOverlapScale, int number, int colorCounter = 0,
 
+    static void drawSliderStartCircle(Graphics *g, Skin *skin, Vector2 pos, float hitcircleDiameter, float numberScale,
 
+                                      float hitcircleOverlapScale, int number, int colorCounter = 0,
 
                                       int colorOffset = 0, float colorRGBMultiplier = 1.0f, float approachScale = 1.0f,
 
                                       float alpha = 1.0f, float numberAlpha = 1.0f, bool drawNumber = true,
 
                                       bool overrideHDApproachCircle = false);
 
-    static void drawSliderEndCircle(Graphics *g, OsuBeatmap *beatmap, Vector2 rawPos, int number, int colorCounter,
 
+    static void drawSliderEndCircle(Graphics *g, Beatmap *beatmap, Vector2 rawPos, int number, int colorCounter,
 
                                     int colorOffset, float colorRGBMultiplier, float approachScale, float alpha,
 
                                     float numberAlpha, bool drawNumber = true, bool overrideHDApproachCircle = false);
 
-    static void drawSliderEndCircle(Graphics *g, OsuSkin *skin, Vector2 pos, float hitcircleDiameter, float numberScale,
 
+    static void drawSliderEndCircle(Graphics *g, Skin *skin, Vector2 pos, float hitcircleDiameter, float numberScale,
 
                                     float overlapScale, int number = 0, int colorCounter = 0, int colorOffset = 0,
 
                                     float colorRGBMultiplier = 1.0f, float approachScale = 1.0f, float alpha = 1.0f,
 
                                     float numberAlpha = 1.0f, bool drawNumber = true,
 
                                     bool overrideHDApproachCircle = false);
 
 
 
     // split helper functions
 
-    static void drawApproachCircle(Graphics *g, OsuSkin *skin, Vector2 pos, Color comboColor, float hitcircleDiameter,
 
+    static void drawApproachCircle(Graphics *g, Skin *skin, Vector2 pos, Color comboColor, float hitcircleDiameter,
 
                                    float approachScale, float alpha, bool modHD, bool overrideHDApproachCircle);
 
-    static void drawHitCircleOverlay(Graphics *g, OsuSkinImage *hitCircleOverlayImage, Vector2 pos,
 
+    static void drawHitCircleOverlay(Graphics *g, SkinImage *hitCircleOverlayImage, Vector2 pos,
 
                                      float circleOverlayImageScale, float alpha, float colorRGBMultiplier);
 
     static void drawHitCircle(Graphics *g, Image *hitCircleImage, Vector2 pos, Color comboColor, float circleImageScale,
 
                               float alpha);
 
-    static void drawHitCircleNumber(Graphics *g, OsuSkin *skin, float numberScale, float overlapScale, Vector2 pos,
 
+    static void drawHitCircleNumber(Graphics *g, Skin *skin, float numberScale, float overlapScale, Vector2 pos,
 
                                     int number, float numberAlpha, float colorRGBMultiplier);
 
 
 
    public:
 
-    OsuCircle(int x, int y, long time, int sampleType, int comboNumber, bool isEndOfCombo, int colorCounter,
 
-              int colorOffset, OsuBeatmap *beatmap);
 
-    virtual ~OsuCircle();
 
+    Circle(int x, int y, long time, int sampleType, int comboNumber, bool isEndOfCombo, int colorCounter,
 
+           int colorOffset, Beatmap *beatmap);
 
+    virtual ~Circle();
 
 
 
     virtual void draw(Graphics *g);
 
     virtual void draw2(Graphics *g);
@@ -81,9 +81,9 @@ class OsuCircle : public OsuHitObject {
 
     static int rainbowNumber;
 
     static int rainbowColorCounter;
 
 
 
-    void onHit(OsuScore::HIT result, long delta, float targetDelta = 0.0f, float targetAngle = 0.0f);
 
+    void onHit(LiveScore::HIT result, long delta, float targetDelta = 0.0f, float targetAngle = 0.0f);
 
 
 
-    OsuBeatmap *m_beatmap;
 
+    Beatmap *m_beatmap;
 
 
 
     Vector2 m_vRawPos;
 
     Vector2 m_vOriginalRawPos;  // for live mod changing
--- a/src/App/Osu/Collections.cpp
+++ b/src/App/Osu/Collections.cpp
@@ -2,8 +2,8 @@
 
 
 
 #include "BanchoProtocol.h"
 
 #include "ConVar.h"
 
+#include "Database.h"
 
 #include "Engine.h"
 
-#include "OsuDatabase.h"
 
 
 
 bool collections_loaded = false;
 
 std::vector<Collection*> collections;
@@ -100,8 +100,8 @@ bool load_collections() {
 
     peppy_collections_path.append("collection.db");
 
     Packet peppy_collections = load_db(peppy_collections_path);
 
     if(peppy_collections.size > 0) {
 
-        uint32_t version = read_int32(&peppy_collections);
 
-        uint32_t nb_collections = read_int32(&peppy_collections);
 
+        u32 version = read<u32>(&peppy_collections);
 
+        u32 nb_collections = read<u32>(&peppy_collections);
 
 
 
         if(version > osu_database_version) {
 
             debugLog("osu!stable collection.db version more recent than neosu, loading might fail.\n");
@@ -109,7 +109,7 @@ bool load_collections() {
 
 
 
         for(int c = 0; c < nb_collections; c++) {
 
             auto name = read_stdstring(&peppy_collections);
 
-            uint32_t nb_maps = read_int32(&peppy_collections);
 
+            u32 nb_maps = read<u32>(&peppy_collections);
 
 
 
             auto collection = get_or_create_collection(name);
 
             collection->maps.reserve(nb_maps);
@@ -126,8 +126,8 @@ bool load_collections() {
 
 
 
     auto neosu_collections = load_db("collections.db");
 
     if(neosu_collections.size > 0) {
 
-        uint32_t version = read_int32(&neosu_collections);
 
-        uint32_t nb_collections = read_int32(&neosu_collections);
 
+        u32 version = read<u32>(&neosu_collections);
 
+        u32 nb_collections = read<u32>(&neosu_collections);
 
 
 
         if(version > COLLECTIONS_DB_VERSION) {
 
             debugLog("neosu collections.db version is too recent! Cannot load it without stuff breaking.\n");
@@ -140,9 +140,9 @@ bool load_collections() {
 
             auto name = read_stdstring(&neosu_collections);
 
             auto collection = get_or_create_collection(name);
 
 
 
-            uint32_t nb_deleted_maps = 0;
 
+            u32 nb_deleted_maps = 0;
 
             if(version >= 20240429) {
 
-                nb_deleted_maps = read_int32(&neosu_collections);
 
+                nb_deleted_maps = read<u32>(&neosu_collections);
 
             }
 
 
 
             collection->deleted_maps.reserve(nb_deleted_maps);
@@ -157,7 +157,7 @@ bool load_collections() {
 
                 collection->deleted_maps.push_back(map_hash);
 
             }
 
 
 
-            uint32_t nb_maps = read_int32(&neosu_collections);
 
+            u32 nb_maps = read<u32>(&neosu_collections);
 
             collection->maps.reserve(collection->maps.size() + nb_maps);
 
             collection->neosu_maps.reserve(nb_maps);
 
 
@@ -175,7 +175,17 @@ bool load_collections() {
 
     }
 
     free(neosu_collections.memory);
 
 
 
-    debugLog("collections.db: loading took %f seconds\n", (engine->getTimeReal() - startTime));
 
+    u32 nb_peppy = 0;
 
+    u32 nb_neosu = 0;
 
+    u32 nb_total = 0;
 
+    for(auto collection : collections) {
 
+        nb_peppy += collection->peppy_maps.size();
 
+        nb_neosu += collection->neosu_maps.size();
 
+        nb_total += collection->maps.size();
 
+    }
 
+
 
+    debugLog("peppy+neosu collections: loading took %f seconds (%d peppy, %d neosu, %d maps total)\n",
 
+             (engine->getTimeReal() - startTime), nb_peppy, nb_neosu, nb_total);
 
     collections_loaded = true;
 
     return true;
 
 }
@@ -198,22 +208,22 @@ bool save_collections() {
 
     const double startTime = engine->getTimeReal();
 
 
 
     Packet db;
 
-    write_int32(&db, COLLECTIONS_DB_VERSION);
 
+    write_u32(&db, COLLECTIONS_DB_VERSION);
 
 
 
-    uint32_t nb_collections = collections.size();
 
-    write_int32(&db, nb_collections);
 
+    u32 nb_collections = collections.size();
 
+    write_u32(&db, nb_collections);
 
 
 
     for(auto collection : collections) {
 
         write_string(&db, collection->name.c_str());
 
 
 
-        uint32_t nb_deleted = collection->deleted_maps.size();
 
-        write_int32(&db, nb_deleted);
 
+        u32 nb_deleted = collection->deleted_maps.size();
 
+        write_u32(&db, nb_deleted);
 
         for(auto map : collection->deleted_maps) {
 
             write_string(&db, map.hash);
 
         }
 
 
 
-        uint32_t nb_neosu = collection->neosu_maps.size();
 
-        write_int32(&db, nb_neosu);
 
+        u32 nb_neosu = collection->neosu_maps.size();
 
+        write_u32(&db, nb_neosu);
 
         for(auto map : collection->neosu_maps) {
 
             write_string(&db, map.hash);
 
         }
--- a/src/App/Osu/Database.cpp
+++ b/src/App/Osu/Database.cpp
--- a/src/App/Osu/OsuDatabase.h
+++ b/src/App/Osu/OsuDatabase.h
@@ -1,30 +1,33 @@
 
 #pragma once
 
 #include "BanchoProtocol.h"  // Packet
 
-#include "OsuReplay.h"
 
-#include "OsuScore.h"
 
-#include "Score.h"
 
+#include "Replay.h"
 
 #include "UString.h"
 
 #include "cbase.h"
 
+#include "score.h"
 
 
 
 class Timer;
 
 class ConVar;
 
 
 
 class Osu;
 
 class OsuFile;
 
-class OsuDatabaseBeatmap;
 
-class OsuDatabaseLoader;
 
+class DatabaseBeatmap;
 
+class DatabaseLoader;
 
 
 
+#define STARS_CACHE_VERSION 20240430
 
+
 
+// Field ordering matters here
 
+#pragma pack(push, 1)
 
 struct TIMINGPOINT {
 
     double msPerBeat;
 
     double offset;
 
     bool timingChange;
 
 };
 
-TIMINGPOINT read_timing_point(Packet *packet);
 
+#pragma pack(pop)
 
 
 
 Packet load_db(std::string path);
 
 bool save_db(Packet *db, std::string path);
 
 
 
-class OsuDatabase {
 
+class Database {
 
    public:
 
     struct PlayerStats {
 
         UString name;
@@ -37,13 +40,13 @@ class OsuDatabase {
 
     };
 
 
 
     struct PlayerPPScores {
 
-        std::vector<Score *> ppScores;
 
+        std::vector<FinishedScore *> ppScores;
 
         unsigned long long totalScore;
 
     };
 
 
 
     struct SCORE_SORTING_COMPARATOR {
 
         virtual ~SCORE_SORTING_COMPARATOR() { ; }
 
-        virtual bool operator()(Score const &a, Score const &b) const = 0;
 
+        virtual bool operator()(FinishedScore const &a, FinishedScore const &b) const = 0;
 
     };
 
 
 
     struct SCORE_SORTING_METHOD {
@@ -52,8 +55,8 @@ class OsuDatabase {
 
     };
 
 
 
    public:
 
-    OsuDatabase(Osu *osu);
 
-    ~OsuDatabase();
 
+    Database(Osu *osu);
 
+    ~Database();
 
 
 
     void update();
 
 
@@ -61,10 +64,10 @@ class OsuDatabase {
 
     void cancel();
 
     void save();
 
 
 
-    OsuDatabaseBeatmap *addBeatmap(std::string beatmapFolderPath);
 
+    DatabaseBeatmap *addBeatmap(std::string beatmapFolderPath);
 
 
 
-    int addScore(MD5Hash beatmapMD5Hash, Score score);
 
-    void deleteScore(MD5Hash beatmapMD5Hash, uint64_t scoreUnixTimestamp);
 
+    int addScore(MD5Hash beatmapMD5Hash, FinishedScore score);
 
+    void deleteScore(MD5Hash beatmapMD5Hash, u64 scoreUnixTimestamp);
 
     void sortScores(MD5Hash beatmapMD5Hash);
 
     void forceScoreUpdateOnNextCalculatePlayerStats() { m_bDidScoresChangeForStats = true; }
 
     void forceScoresSaveOnNextShutdown() { m_bDidScoresChangeForSave = true; }
@@ -82,31 +85,41 @@ class OsuDatabase {
 
     inline bool isFinished() const { return (getProgress() >= 1.0f); }
 
     inline bool foundChanges() const { return m_bFoundChanges; }
 
 
 
-    inline const std::vector<OsuDatabaseBeatmap *> getDatabaseBeatmaps() const { return m_databaseBeatmaps; }
 
-    OsuDatabaseBeatmap *getBeatmap(const MD5Hash &md5hash);
 
-    OsuDatabaseBeatmap *getBeatmapDifficulty(const MD5Hash &md5hash);
 
+    inline const std::vector<DatabaseBeatmap *> getDatabaseBeatmaps() const { return m_databaseBeatmaps; }
 
+    DatabaseBeatmap *getBeatmap(const MD5Hash &md5hash);
 
+    DatabaseBeatmap *getBeatmapDifficulty(const MD5Hash &md5hash);
 
 
 
-    inline std::unordered_map<MD5Hash, std::vector<Score>> *getScores() { return &m_scores; }
 
+    inline std::unordered_map<MD5Hash, std::vector<FinishedScore>> *getScores() { return &m_scores; }
 
     inline const std::vector<SCORE_SORTING_METHOD> &getScoreSortingMethods() const { return m_scoreSortingMethods; }
 
 
 
     inline unsigned long long getAndIncrementScoreSortHackCounter() { return m_iSortHackCounter++; }
 
 
 
-    std::unordered_map<MD5Hash, std::vector<Score>> m_online_scores;
 
+    std::unordered_map<MD5Hash, std::vector<FinishedScore>> m_online_scores;
 
     std::string getOsuSongsFolder();
 
 
 
-    OsuDatabaseBeatmap *loadRawBeatmap(std::string beatmapPath);  // only used for raw loading without db
 
+    DatabaseBeatmap *loadRawBeatmap(std::string beatmapPath);  // only used for raw loading without db
 
+
 
+    void loadDB(Packet *db, bool &fallbackToRawLoad);
 
+
 
+    // stars.cache
 
+    struct STARS_CACHE_ENTRY {
 
+        float starsNomod = -1;
 
+        i32 min_bpm = -1;
 
+        i32 max_bpm = -1;
 
+        i32 common_bpm = -1;
 
+    };
 
+    std::unordered_map<MD5Hash, STARS_CACHE_ENTRY> m_starsCache;
 
 
 
    private:
 
-    friend class OsuDatabaseLoader;
 
+    friend class DatabaseLoader;
 
 
 
     static ConVar *m_name_ref;
 
     static ConVar *m_osu_songbrowser_scores_sortingtype_ref;
 
 
 
-    void addScoreRaw(const MD5Hash &beatmapMD5Hash, const Score &score);
 
+    void addScoreRaw(const MD5Hash &beatmapMD5Hash, const FinishedScore &score);
 
 
 
     std::string parseLegacyCfgBeatmapDirectoryParameter();
 
     void scheduleLoadRaw();
 
-    void loadDB(Packet *db, bool &fallbackToRawLoad);
 
 
 
     void loadStars();
 
     void saveStars();
@@ -126,7 +139,7 @@ class OsuDatabase {
 
     int m_iNumBeatmapsToLoad;
 
     std::atomic<float> m_fLoadingProgress;
 
     std::atomic<bool> m_bInterruptLoad;
 
-    std::vector<OsuDatabaseBeatmap *> m_databaseBeatmaps;
 
+    std::vector<DatabaseBeatmap *> m_databaseBeatmaps;
 
 
 
     // osu!.db
 
     int m_iVersion;
@@ -134,7 +147,7 @@ class OsuDatabase {
 
 
 
     // scores.db (legacy and custom)
 
     bool m_bScoresLoaded;
 
-    std::unordered_map<MD5Hash, std::vector<Score>> m_scores;
 
+    std::unordered_map<MD5Hash, std::vector<FinishedScore>> m_scores;
 
     bool m_bDidScoresChangeForSave;
 
     bool m_bDidScoresChangeForStats;
 
     unsigned long long m_iSortHackCounter;
@@ -147,12 +160,4 @@ class OsuDatabase {
 
     std::string m_sRawBeatmapLoadOsuSongFolder;
 
     std::vector<std::string> m_rawBeatmapFolders;
 
     std::vector<std::string> m_rawLoadBeatmapFolders;
 
-    std::unordered_map<MD5Hash, OsuDatabaseBeatmap *> m_rawHashToDiff2;
 
-    std::unordered_map<MD5Hash, OsuDatabaseBeatmap *> m_rawHashToBeatmap;
 
-
 
-    // stars.cache
 
-    struct STARS_CACHE_ENTRY {
 
-        float starsNomod;
 
-    };
 
-    std::unordered_map<MD5Hash, STARS_CACHE_ENTRY> m_starsCache;
 
 };
--- a/src/App/Osu/OsuDatabaseBeatmap.cpp
+++ b/src/App/Osu/OsuDatabaseBeatmap.cpp
@@ -5,25 +5,27 @@
 
 // $NoKeywords: $osudiff
 
 //===============================================================================//
 
 
 
-#include "OsuDatabaseBeatmap.h"
 
+#include "DatabaseBeatmap.h"
 
 
 
 #include <iostream>
 
 #include <sstream>
 
 
 
 #include "Bancho.h"  // md5
 
+#include "Beatmap.h"
 
+#include "Circle.h"
 
 #include "ConVar.h"
 
+#include "Database.h"
 
 #include "Engine.h"
 
 #include "File.h"
 
+#include "GameRules.h"
 
+#include "HitObject.h"
 
+#include "NotificationOverlay.h"
 
 #include "Osu.h"
 
-#include "OsuBeatmap.h"
 
-#include "OsuCircle.h"
 
-#include "OsuGameRules.h"
 
-#include "OsuHitObject.h"
 
-#include "OsuNotificationOverlay.h"
 
-#include "OsuSkin.h"
 
-#include "OsuSlider.h"
 
-#include "OsuSliderCurves.h"
 
-#include "OsuSpinner.h"
 
+#include "Skin.h"
 
+#include "Slider.h"
 
+#include "SliderCurves.h"
 
+#include "SongBrowser.h"
 
+#include "Spinner.h"
 
 
 
 ConVar osu_mod_random("osu_mod_random", false, FCVAR_NONVANILLA);
 
 ConVar osu_mod_random_seed(
@@ -73,16 +75,16 @@ ConVar osu_beatmap_max_num_slider_scoringtimes("osu_beatmap_max_num_slider_scori
 
                                                "maximum number of slider score increase events allowed per slider "
 
                                                "(prevent crashing on deliberate game-breaking beatmaps)");
 
 
 
-unsigned long long OsuDatabaseBeatmap::sortHackCounter = 0;
 
+unsigned long long DatabaseBeatmap::sortHackCounter = 0;
 
 
 
-ConVar *OsuDatabaseBeatmap::m_osu_slider_curve_max_length_ref = NULL;
 
-ConVar *OsuDatabaseBeatmap::m_osu_stars_xexxar_angles_sliders_ref = NULL;
 
-ConVar *OsuDatabaseBeatmap::m_osu_stars_stacking_ref = NULL;
 
-ConVar *OsuDatabaseBeatmap::m_osu_debug_pp_ref = NULL;
 
-ConVar *OsuDatabaseBeatmap::m_osu_slider_end_inside_check_offset_ref = NULL;
 
+ConVar *DatabaseBeatmap::m_osu_slider_curve_max_length_ref = NULL;
 
+ConVar *DatabaseBeatmap::m_osu_stars_xexxar_angles_sliders_ref = NULL;
 
+ConVar *DatabaseBeatmap::m_osu_stars_stacking_ref = NULL;
 
+ConVar *DatabaseBeatmap::m_osu_debug_pp_ref = NULL;
 
+ConVar *DatabaseBeatmap::m_osu_slider_end_inside_check_offset_ref = NULL;
 
 
 
-OsuDatabaseBeatmap::OsuDatabaseBeatmap(Osu *osu, std::string filePath, std::string folder,
 
-                                       bool filePathIsInMemoryBeatmap) {
 
+DatabaseBeatmap::DatabaseBeatmap(Osu *osu, std::string filePath, std::string folder, bool filePathIsInMemoryBeatmap) {
 
+    m_difficulties = new std::vector<DatabaseBeatmap *>();
 
     m_osu = osu;
 
 
 
     m_sFilePath = filePath;
@@ -142,27 +144,28 @@ OsuDatabaseBeatmap::OsuDatabaseBeatmap(Osu *osu, std::string filePath, std::stri
 
     m_iOnlineOffset = 0;
 
 }
 
 
 
-OsuDatabaseBeatmap::OsuDatabaseBeatmap(Osu *osu, std::vector<OsuDatabaseBeatmap *> &difficulties)
 
-    : OsuDatabaseBeatmap(osu, "", "") {
 
+DatabaseBeatmap::DatabaseBeatmap(Osu *osu, std::vector<DatabaseBeatmap *> *difficulties)
 
+    : DatabaseBeatmap(osu, "", "") {
 
     setDifficulties(difficulties);
 
 }
 
 
 
-OsuDatabaseBeatmap::~OsuDatabaseBeatmap() {
 
-    for(size_t i = 0; i < m_difficulties.size(); i++) {
 
-        delete m_difficulties[i];
 
+DatabaseBeatmap::~DatabaseBeatmap() {
 
+    for(size_t i = 0; i < m_difficulties->size(); i++) {
 
+        delete(*m_difficulties)[i];
 
     }
 
+    SAFE_DELETE(m_difficulties);
 
 }
 
 
 
-OsuDatabaseBeatmap::PRIMITIVE_CONTAINER OsuDatabaseBeatmap::loadPrimitiveObjects(const std::string &osuFilePath,
 
-                                                                                 bool filePathIsInMemoryBeatmap) {
 
+DatabaseBeatmap::PRIMITIVE_CONTAINER DatabaseBeatmap::loadPrimitiveObjects(const std::string &osuFilePath,
 
+                                                                           bool filePathIsInMemoryBeatmap) {
 
     std::atomic<bool> dead;
 
     dead = false;
 
     return loadPrimitiveObjects(osuFilePath, filePathIsInMemoryBeatmap, dead);
 
 }
 
 
 
-OsuDatabaseBeatmap::PRIMITIVE_CONTAINER OsuDatabaseBeatmap::loadPrimitiveObjects(const std::string &osuFilePath,
 
-                                                                                 bool filePathIsInMemoryBeatmap,
 
-                                                                                 const std::atomic<bool> &dead) {
 
+DatabaseBeatmap::PRIMITIVE_CONTAINER DatabaseBeatmap::loadPrimitiveObjects(const std::string &osuFilePath,
 
+                                                                           bool filePathIsInMemoryBeatmap,
 
+                                                                           const std::atomic<bool> &dead) {
 
     PRIMITIVE_CONTAINER c;
 
     {
 
         c.errorCode = 0;
@@ -513,8 +516,8 @@ OsuDatabaseBeatmap::PRIMITIVE_CONTAINER OsuDatabaseBeatmap::loadPrimitiveObjects
 
     return c;
 
 }
 
 
 
-OsuDatabaseBeatmap::CALCULATE_SLIDER_TIMES_CLICKS_TICKS_RESULT OsuDatabaseBeatmap::calculateSliderTimesClicksTicks(
 
-    int beatmapVersion, std::vector<SLIDER> &sliders, std::vector<TIMINGPOINT> &timingpoints, float sliderMultiplier,
 
+DatabaseBeatmap::CALCULATE_SLIDER_TIMES_CLICKS_TICKS_RESULT DatabaseBeatmap::calculateSliderTimesClicksTicks(
 
+    int beatmapVersion, std::vector<SLIDER> &sliders, zarray<TIMINGPOINT> &timingpoints, float sliderMultiplier,
 
     float sliderTickRate) {
 
     std::atomic<bool> dead;
 
     dead = false;
@@ -522,8 +525,8 @@ OsuDatabaseBeatmap::CALCULATE_SLIDER_TIMES_CLICKS_TICKS_RESULT OsuDatabaseBeatma
 
                                            false);
 
 }
 
 
 
-OsuDatabaseBeatmap::CALCULATE_SLIDER_TIMES_CLICKS_TICKS_RESULT OsuDatabaseBeatmap::calculateSliderTimesClicksTicks(
 
-    int beatmapVersion, std::vector<SLIDER> &sliders, std::vector<TIMINGPOINT> &timingpoints, float sliderMultiplier,
 
+DatabaseBeatmap::CALCULATE_SLIDER_TIMES_CLICKS_TICKS_RESULT DatabaseBeatmap::calculateSliderTimesClicksTicks(
 
+    int beatmapVersion, std::vector<SLIDER> &sliders, zarray<TIMINGPOINT> &timingpoints, float sliderMultiplier,
 
     float sliderTickRate, const std::atomic<bool> &dead) {
 
     CALCULATE_SLIDER_TIMES_CLICKS_TICKS_RESULT r;
 
     { r.errorCode = 0; }
@@ -630,7 +633,7 @@ OsuDatabaseBeatmap::CALCULATE_SLIDER_TIMES_CLICKS_TICKS_RESULT OsuDatabaseBeatma
 
 
 
             // 2) add repeat times (either at slider begin or end)
 
             for(int i = 0; i < (s.repeat - 1); i++) {
 
-                const long time = s.time + (long)(s.sliderTimeWithoutRepeats * (i + 1));  // see OsuSlider.cpp
 
+                const long time = s.time + (long)(s.sliderTimeWithoutRepeats * (i + 1));  // see Slider.cpp
 
                 s.scoringTimesForStarCalc.push_back(OsuDifficultyHitObject::SLIDER_SCORING_TIME{
 
                     .type = OsuDifficultyHitObject::SLIDER_SCORING_TIME::TYPE::REPEAT,
 
                     .time = time,
@@ -642,10 +645,10 @@ OsuDatabaseBeatmap::CALCULATE_SLIDER_TIMES_CLICKS_TICKS_RESULT OsuDatabaseBeatma
 
             for(int i = 0; i < s.repeat; i++) {
 
                 for(int t = 0; t < s.ticks.size(); t++) {
 
                     const float tickPercentRelativeToRepeatFromStartAbs =
 
-                        (((i + 1) % 2) != 0 ? s.ticks[t] : 1.0f - s.ticks[t]);  // see OsuSlider.cpp
 
-                    const long time = s.time + (long)(s.sliderTimeWithoutRepeats * i) +
 
-                                      (long)(tickPercentRelativeToRepeatFromStartAbs *
 
-                                             s.sliderTimeWithoutRepeats);  // see OsuSlider.cpp
 
+                        (((i + 1) % 2) != 0 ? s.ticks[t] : 1.0f - s.ticks[t]);  // see Slider.cpp
 
+                    const long time =
 
+                        s.time + (long)(s.sliderTimeWithoutRepeats * i) +
 
+                        (long)(tickPercentRelativeToRepeatFromStartAbs * s.sliderTimeWithoutRepeats);  // see Slider.cpp
 
                     s.scoringTimesForStarCalc.push_back(OsuDifficultyHitObject::SLIDER_SCORING_TIME{
 
                         .type = OsuDifficultyHitObject::SLIDER_SCORING_TIME::TYPE::TICK,
 
                         .time = time,
@@ -673,20 +676,18 @@ OsuDatabaseBeatmap::CALCULATE_SLIDER_TIMES_CLICKS_TICKS_RESULT OsuDatabaseBeatma
 
     return r;
 
 }
 
 
 
-OsuDatabaseBeatmap::LOAD_DIFFOBJ_RESULT OsuDatabaseBeatmap::loadDifficultyHitObjects(const std::string &osuFilePath,
 
-                                                                                     float AR, float CS,
 
-                                                                                     float speedMultiplier,
 
-                                                                                     bool calculateStarsInaccurately) {
 
+DatabaseBeatmap::LOAD_DIFFOBJ_RESULT DatabaseBeatmap::loadDifficultyHitObjects(const std::string &osuFilePath, float AR,
 
+                                                                               float CS, float speedMultiplier,
 
+                                                                               bool calculateStarsInaccurately) {
 
     std::atomic<bool> dead;
 
     dead = false;
 
     return loadDifficultyHitObjects(osuFilePath, AR, CS, speedMultiplier, calculateStarsInaccurately, dead);
 
 }
 
 
 
-OsuDatabaseBeatmap::LOAD_DIFFOBJ_RESULT OsuDatabaseBeatmap::loadDifficultyHitObjects(const std::string &osuFilePath,
 
-                                                                                     float AR, float CS,
 
-                                                                                     float speedMultiplier,
 
-                                                                                     bool calculateStarsInaccurately,
 
-                                                                                     const std::atomic<bool> &dead) {
 
+DatabaseBeatmap::LOAD_DIFFOBJ_RESULT DatabaseBeatmap::loadDifficultyHitObjects(const std::string &osuFilePath, float AR,
 
+                                                                               float CS, float speedMultiplier,
 
+                                                                               bool calculateStarsInaccurately,
 
+                                                                               const std::atomic<bool> &dead) {
 
     LOAD_DIFFOBJ_RESULT result = LOAD_DIFFOBJ_RESULT();
 
 
 
     // build generalized OsuDifficultyHitObjects from the vectors (hitcircles, sliders, spinners)
@@ -777,7 +778,7 @@ OsuDatabaseBeatmap::LOAD_DIFFOBJ_RESULT OsuDatabaseBeatmap::loadDifficultyHitObj
 
     std::sort(result.diffobjects.begin(), result.diffobjects.end(), DiffHitObjectSortComparator());
 
 
 
     // calculate stacks
 
-    // see OsuBeatmap.cpp
 
+    // see Beatmap.cpp
 
     // NOTE: this must be done before the speed multiplier is applied!
 
     // HACKHACK: code duplication ffs
 
     if(m_osu_stars_stacking_ref->getBool() &&
@@ -785,11 +786,11 @@ OsuDatabaseBeatmap::LOAD_DIFFOBJ_RESULT OsuDatabaseBeatmap::loadDifficultyHitObj
 
     {
 
         const float finalAR = AR;
 
         const float finalCS = CS;
 
-        const float rawHitCircleDiameter = OsuGameRules::getRawHitCircleDiameter(finalCS);
 
+        const float rawHitCircleDiameter = GameRules::getRawHitCircleDiameter(finalCS);
 
 
 
         const float STACK_LENIENCE = 3.0f;
 
 
 
-        const float approachTime = OsuGameRules::getApproachTimeForStacking(finalAR);
 
+        const float approachTime = GameRules::getApproachTimeForStacking(finalAR);
 
 
 
         if(c.version > 5) {
 
             // peppy's algorithm
@@ -863,7 +864,7 @@ OsuDatabaseBeatmap::LOAD_DIFFOBJ_RESULT OsuDatabaseBeatmap::loadDifficultyHitObj
 
         } else  // version < 6
 
         {
 
             // old stacking algorithm for old beatmaps
 
-            // https://github.com/ppy/osu/blob/master/osu.Game.Rulesets.Osu/Beatmaps/OsuBeatmapProcessor.cs
 
+            // https://github.com/ppy/osu/blob/master/osu.Game.Rulesets.Osu/Beatmaps/BeatmapProcessor.cs
 
 
 
             for(int i = 0; i < result.diffobjects.size(); i++) {
 
                 OsuDifficultyHitObject *currHitObject = &result.diffobjects[i];
@@ -903,7 +904,7 @@ OsuDatabaseBeatmap::LOAD_DIFFOBJ_RESULT OsuDatabaseBeatmap::loadDifficultyHitObj
 
         }
 
 
 
         // update hitobject positions
 
-        float stackOffset = rawHitCircleDiameter / 128.0f / OsuGameRules::broken_gamefield_rounding_allowance * 6.4f;
 
+        float stackOffset = rawHitCircleDiameter / 128.0f / GameRules::broken_gamefield_rounding_allowance * 6.4f;
 
         for(int i = 0; i < result.diffobjects.size(); i++) {
 
             if(dead.load()) {
 
                 result.errorCode = 6;
@@ -940,21 +941,20 @@ OsuDatabaseBeatmap::LOAD_DIFFOBJ_RESULT OsuDatabaseBeatmap::loadDifficultyHitObj
 
     return result;
 
 }
 
 
 
-bool OsuDatabaseBeatmap::loadMetadata(OsuDatabaseBeatmap *databaseBeatmap) {
 
+bool DatabaseBeatmap::loadMetadata(DatabaseBeatmap *databaseBeatmap) {
 
     if(databaseBeatmap == NULL) return false;
 
-    if(databaseBeatmap->m_difficulties.size() > 0) return false;  // we are just a container
 
+    if(!databaseBeatmap->m_difficulties->empty()) return false;  // we are just a container
 
 
 
     // reset
 
-    databaseBeatmap->m_timingpoints = std::vector<TIMINGPOINT>();
 
+    databaseBeatmap->m_timingpoints.clear();
 
 
 
-    if(Osu::debug->getBool())
 
-        debugLog("OsuDatabaseBeatmap::loadMetadata() : %s\n", databaseBeatmap->m_sFilePath.c_str());
 
+    if(Osu::debug->getBool()) debugLog("DatabaseBeatmap::loadMetadata() : %s\n", databaseBeatmap->m_sFilePath.c_str());
 
 
 
     // generate MD5 hash (loads entire file, very slow)
 
     {
 
         File file(!databaseBeatmap->m_bFilePathIsInMemoryBeatmap ? databaseBeatmap->m_sFilePath : "");
 
 
 
-        const uint8_t *beatmapFile = NULL;
 
+        const u8 *beatmapFile = NULL;
 
         size_t beatmapFileSize = 0;
 
         {
 
             if(!databaseBeatmap->m_bFilePathIsInMemoryBeatmap) {
@@ -963,13 +963,13 @@ bool OsuDatabaseBeatmap::loadMetadata(OsuDatabaseBeatmap *databaseBeatmap) {
 
                     beatmapFileSize = file.getFileSize();
 
                 }
 
             } else {
 
-                beatmapFile = (uint8_t *)databaseBeatmap->m_sFilePath.c_str();
 
+                beatmapFile = (u8 *)databaseBeatmap->m_sFilePath.c_str();
 
                 beatmapFileSize = databaseBeatmap->m_sFilePath.size();
 
             }
 
         }
 
 
 
         if(beatmapFile != NULL) {
 
-            auto hash = md5((uint8_t *)beatmapFile, beatmapFileSize);
 
+            auto hash = md5((u8 *)beatmapFile, beatmapFileSize);
 
             databaseBeatmap->m_sMD5Hash = MD5Hash(hash.toUtf8());
 
         }
 
     }
@@ -1168,7 +1168,7 @@ bool OsuDatabaseBeatmap::loadMetadata(OsuDatabaseBeatmap *databaseBeatmap) {
 
 
 
     // general sanity checks
 
     if((databaseBeatmap->m_timingpoints.size() < 1)) {
 
-        if(Osu::debug->getBool()) debugLog("OsuDatabaseBeatmap::loadMetadata() : no timingpoints in beatmap!\n");
 
+        if(Osu::debug->getBool()) debugLog("DatabaseBeatmap::loadMetadata() : no timingpoints in beatmap!\n");
 
 
 
         return false;  // nothing more to do here
 
     }
@@ -1179,128 +1179,34 @@ bool OsuDatabaseBeatmap::loadMetadata(OsuDatabaseBeatmap *databaseBeatmap) {
 
 
 
     // sort timingpoints and calculate BPM range
 
     if(databaseBeatmap->m_timingpoints.size() > 0) {
 
-        if(Osu::debug->getBool()) debugLog("OsuDatabaseBeatmap::loadMetadata() : calculating BPM range ...\n");
 
+        if(Osu::debug->getBool()) debugLog("DatabaseBeatmap::loadMetadata() : calculating BPM range ...\n");
 
 
 
         // sort timingpoints by time
 
         std::sort(databaseBeatmap->m_timingpoints.begin(), databaseBeatmap->m_timingpoints.end(),
 
                   TimingPointSortComparator());
 
 
 
-        // calculate bpm range
 
-        float tempMinBPM = 0.0f;
 
-        float tempMaxBPM = std::numeric_limits<float>::max();
 
-        std::vector<TIMINGPOINT> uninheritedTimingpoints;
 
-        for(int i = 0; i < databaseBeatmap->m_timingpoints.size(); i++) {
 
-            const TIMINGPOINT &t = databaseBeatmap->m_timingpoints[i];
 
-
 
-            if(t.msPerBeat >= 0.0f)  // NOT inherited
 
-            {
 
-                uninheritedTimingpoints.push_back(t);
 
-
 
-                if(t.msPerBeat > tempMinBPM) tempMinBPM = t.msPerBeat;
 
-                if(t.msPerBeat < tempMaxBPM) tempMaxBPM = t.msPerBeat;
 
+        // NOTE: if we have our own stars/bpm cached then use that
 
+        bool bpm_was_cached = false;
 
+        auto db = bancho.osu->getSongBrowser()->getDatabase();
 
+        const auto result = db->m_starsCache.find(databaseBeatmap->getMD5Hash());
 
+        if(result != db->m_starsCache.end()) {
 
+            if(result->second.starsNomod >= 0.f) {
 
+                databaseBeatmap->m_fStarsNomod = result->second.starsNomod;
 
+            }
 
+            if(result->second.min_bpm >= 0) {
 
+                databaseBeatmap->m_iMinBPM = result->second.min_bpm;
 
+                databaseBeatmap->m_iMaxBPM = result->second.max_bpm;
 
+                databaseBeatmap->m_iMostCommonBPM = result->second.common_bpm;
 
+                bpm_was_cached = true;
 
             }
 
         }
 
 
 
-        // convert from msPerBeat to BPM
 
-        const float msPerMinute = 1.0f * 60.0f * 1000.0f;
 
-        if(tempMinBPM != 0.0f) tempMinBPM = msPerMinute / tempMinBPM;
 
-        if(tempMaxBPM != 0.0f) tempMaxBPM = msPerMinute / tempMaxBPM;
 
-
 
-        databaseBeatmap->m_iMinBPM = (int)std::round(tempMinBPM);
 
-        databaseBeatmap->m_iMaxBPM = (int)std::round(tempMaxBPM);
 
-
 
-        struct MostCommonBPMHelper {
 
-            static int calculateMostCommonBPM(
 
-                const std::vector<OsuDatabaseBeatmap::TIMINGPOINT> &uninheritedTimingpoints, long lastTime) {
 
-                if(uninheritedTimingpoints.size() < 1) return 0;
 
-
 
-                struct Tuple {
 
-                    float beatLength;
 
-                    long duration;
 
-
 
-                    size_t sortHack;
 
-                };
 
-
 
-                // "Construct a set of (beatLength, duration) tuples for each individual timing point."
 
-                std::vector<Tuple> tuples;
 
-                tuples.reserve(uninheritedTimingpoints.size());
 
-                for(size_t i = 0; i < uninheritedTimingpoints.size(); i++) {
 
-                    const OsuDatabaseBeatmap::TIMINGPOINT &t = uninheritedTimingpoints[i];
 
-
 
-                    Tuple tuple;
 
-                    {
 
-                        if(t.offset > lastTime) {
 
-                            tuple.beatLength = std::round(t.msPerBeat * 1000.0f) / 1000.0f;
 
-                            tuple.duration = 0;
 
-                        } else {
 
-                            // "osu-stable forced the first control point to start at 0."
 
-                            // "This is reproduced here to maintain compatibility around osu!mania scroll speed and song
 
-                            // select display."
 
-                            const long currentTime = (i == 0 ? 0 : t.offset);
 
-                            const long nextTime =
 
-                                (i >= uninheritedTimingpoints.size() - 1 ? lastTime
 
-                                                                         : uninheritedTimingpoints[i + 1].offset);
 
-
 
-                            tuple.beatLength = std::round(t.msPerBeat * 1000.0f) / 1000.0f;
 
-                            tuple.duration = std::max(nextTime - currentTime, (long)0);
 
-                        }
 
-
 
-                        tuple.sortHack = i;
 
-                    }
 
-                    tuples.push_back(tuple);
 
-                }
 
-
 
-                // "Aggregate durations into a set of (beatLength, duration) tuples for each beat length"
 
-                std::vector<Tuple> aggregations;
 
-                aggregations.reserve(tuples.size());
 
-                for(size_t i = 0; i < tuples.size(); i++) {
 
-                    const Tuple &t = tuples[i];
 
-
 
-                    bool foundExistingAggregation = false;
 
-                    size_t aggregationIndex = 0;
 
-                    for(size_t j = 0; j < aggregations.size(); j++) {
 
-                        if(aggregations[j].beatLength == t.beatLength) {
 
-                            foundExistingAggregation = true;
 
-                            aggregationIndex = j;
 
-                            break;
 
-                        }
 
-                    }
 
-
 
-                    if(!foundExistingAggregation)
 
-                        aggregations.push_back(t);
 
-                    else
 
-                        aggregations[aggregationIndex].duration += t.duration;
 
-                }
 
-
 
-                // "Get the most common one, or 0 as a suitable default"
 
-                struct SortByDuration {
 
-                    bool operator()(Tuple const &a, Tuple const &b) const {
 
-                        // first condition: duration
 
-                        // second condition: if duration is the same, higher BPM goes before lower BPM
 
-
 
-                        // strict weak ordering!
 
-                        if(a.duration == b.duration && a.beatLength == b.beatLength)
 
-                            return a.sortHack > b.sortHack;
 
-                        else if(a.duration == b.duration)
 
-                            return (a.beatLength < b.beatLength);
 
-                        else
 
-                            return (a.duration > b.duration);
 
-                    }
 
-                };
 
-                std::sort(aggregations.begin(), aggregations.end(), SortByDuration());
 
-
 
-                float mostCommonBPM = aggregations[0].beatLength;
 
-                {
 
-                    // convert from msPerBeat to BPM
 
-                    const float msPerMinute = 1.0f * 60.0f * 1000.0f;
 
-                    if(mostCommonBPM != 0.0f) mostCommonBPM = msPerMinute / mostCommonBPM;
 
-                }
 
-                return (int)std::round(mostCommonBPM);
 
-            }
 
-        };
 
-        databaseBeatmap->m_iMostCommonBPM = MostCommonBPMHelper::calculateMostCommonBPM(
 
-            uninheritedTimingpoints,
 
-            databaseBeatmap->m_timingpoints[databaseBeatmap->m_timingpoints.size() - 1].offset);
 
+        if(!bpm_was_cached) {
 
+            auto bpm = getBPM(databaseBeatmap->m_timingpoints);
 
+            databaseBeatmap->m_iMinBPM = bpm.min;
 
+            databaseBeatmap->m_iMaxBPM = bpm.max;
 
+            databaseBeatmap->m_iMostCommonBPM = bpm.most_common;
 
+        }
 
     }
 
 
 
     // special case: old beatmaps have AR = OD, there is no ApproachRate stored
@@ -1309,8 +1215,8 @@ bool OsuDatabaseBeatmap::loadMetadata(OsuDatabaseBeatmap *databaseBeatmap) {
 
     return true;
 
 }
 
 
 
-OsuDatabaseBeatmap::LOAD_GAMEPLAY_RESULT OsuDatabaseBeatmap::loadGameplay(OsuDatabaseBeatmap *databaseBeatmap,
 
-                                                                          OsuBeatmap *beatmap) {
 
+DatabaseBeatmap::LOAD_GAMEPLAY_RESULT DatabaseBeatmap::loadGameplay(DatabaseBeatmap *databaseBeatmap,
 
+                                                                    Beatmap *beatmap) {
 
     LOAD_GAMEPLAY_RESULT result = LOAD_GAMEPLAY_RESULT();
 
 
 
     // NOTE: reload metadata (force ensures that all necessary data is ready for creating hitobjects and playing etc.,
@@ -1368,9 +1274,9 @@ OsuDatabaseBeatmap::LOAD_GAMEPLAY_RESULT OsuDatabaseBeatmap::loadGameplay(OsuDat
 
     // build hitobjects from the primitive data we loaded from the osu file
 
     {
 
         struct Helper {
 
-            static inline uint32_t pcgHash(uint32_t input) {
 
-                const uint32_t state = input * 747796405u + 2891336453u;
 
-                const uint32_t word = ((state >> ((state >> 28u) + 4u)) ^ state) * 277803737u;
 
+            static inline u32 pcgHash(u32 input) {
 
+                const u32 state = input * 747796405u + 2891336453u;
 
+                const u32 word = ((state >> ((state >> 28u) + 4u)) ^ state) * 277803737u;
 
                 return (word >> 22u) ^ word;
 
             }
 
         };
@@ -1385,17 +1291,17 @@ OsuDatabaseBeatmap::LOAD_GAMEPLAY_RESULT OsuDatabaseBeatmap::loadGameplay(OsuDat
 
 
 
             if(osu_mod_random.getBool()) {
 
                 h.x = clamp<int>(
 
-                    h.x - (int)(((Helper::pcgHash(result.randomSeed + h.x) % OsuGameRules::OSU_COORD_WIDTH) / 8.0f) *
 
+                    h.x - (int)(((Helper::pcgHash(result.randomSeed + h.x) % GameRules::OSU_COORD_WIDTH) / 8.0f) *
 
                                 osu_mod_random_circle_offset_x_percent.getFloat()),
 
-                    0, OsuGameRules::OSU_COORD_WIDTH);
 
+                    0, GameRules::OSU_COORD_WIDTH);
 
                 h.y = clamp<int>(
 
-                    h.y - (int)(((Helper::pcgHash(result.randomSeed + h.y) % OsuGameRules::OSU_COORD_HEIGHT) / 8.0f) *
 
+                    h.y - (int)(((Helper::pcgHash(result.randomSeed + h.y) % GameRules::OSU_COORD_HEIGHT) / 8.0f) *
 
                                 osu_mod_random_circle_offset_y_percent.getFloat()),
 
-                    0, OsuGameRules::OSU_COORD_HEIGHT);
 
+                    0, GameRules::OSU_COORD_HEIGHT);
 
             }
 
 
 
             result.hitobjects.push_back(
 
-                new OsuCircle(h.x, h.y, h.time, h.sampleType, h.number, false, h.colorCounter, h.colorOffset, beatmap));
 
+                new Circle(h.x, h.y, h.time, h.sampleType, h.number, false, h.colorCounter, h.colorOffset, beatmap));
 
         }
 
         maxPossibleCombo += c.hitcircles.size();
 
 
@@ -1407,26 +1313,26 @@ OsuDatabaseBeatmap::LOAD_GAMEPLAY_RESULT OsuDatabaseBeatmap::loadGameplay(OsuDat
 
 
 
             if(osu_mod_random.getBool()) {
 
                 for(int p = 0; p < s.points.size(); p++) {
 
-                    s.points[p].x =
 
-                        clamp<int>(s.points[p].x - (int)(((Helper::pcgHash(result.randomSeed + s.points[p].x) %
 
-                                                           OsuGameRules::OSU_COORD_WIDTH) /
 
-                                                          3.0f) *
 
-                                                         osu_mod_random_slider_offset_x_percent.getFloat()),
 
-                                   0, OsuGameRules::OSU_COORD_WIDTH);
 
-                    s.points[p].y =
 
-                        clamp<int>(s.points[p].y - (int)(((Helper::pcgHash(result.randomSeed + s.points[p].y) %
 
-                                                           OsuGameRules::OSU_COORD_HEIGHT) /
 
-                                                          3.0f) *
 
-                                                         osu_mod_random_slider_offset_y_percent.getFloat()),
 
-                                   0, OsuGameRules::OSU_COORD_HEIGHT);
 
+                    s.points[p].x = clamp<int>(
 
+                        s.points[p].x -
 
+                            (int)(((Helper::pcgHash(result.randomSeed + s.points[p].x) % GameRules::OSU_COORD_WIDTH) /
 
+                                   3.0f) *
 
+                                  osu_mod_random_slider_offset_x_percent.getFloat()),
 
+                        0, GameRules::OSU_COORD_WIDTH);
 
+                    s.points[p].y = clamp<int>(
 
+                        s.points[p].y -
 
+                            (int)(((Helper::pcgHash(result.randomSeed + s.points[p].y) % GameRules::OSU_COORD_HEIGHT) /
 
+                                   3.0f) *
 
+                                  osu_mod_random_slider_offset_y_percent.getFloat()),
 
+                        0, GameRules::OSU_COORD_HEIGHT);
 
                 }
 
             }
 
 
 
             if(osu_mod_reverse_sliders.getBool()) std::reverse(s.points.begin(), s.points.end());
 
 
 
-            result.hitobjects.push_back(new OsuSlider(s.type, s.repeat, s.pixelLength, s.points, s.hitSounds, s.ticks,
 
-                                                      s.sliderTime, s.sliderTimeWithoutRepeats, s.time, s.sampleType,
 
-                                                      s.number, false, s.colorCounter, s.colorOffset, beatmap));
 
+            result.hitobjects.push_back(new Slider(s.type, s.repeat, s.pixelLength, s.points, s.hitSounds, s.ticks,
 
+                                                   s.sliderTime, s.sliderTimeWithoutRepeats, s.time, s.sampleType,
 
+                                                   s.number, false, s.colorCounter, s.colorOffset, beatmap));
 
 
 
             const int repeats = std::max((s.repeat - 1), 0);
 
             maxPossibleCombo += 2 + repeats + (repeats + 1) * s.ticks.size();  // start/end + repeat arrow + ticks
@@ -1437,18 +1343,18 @@ OsuDatabaseBeatmap::LOAD_GAMEPLAY_RESULT OsuDatabaseBeatmap::loadGameplay(OsuDat
 
 
 
             if(osu_mod_random.getBool()) {
 
                 s.x = clamp<int>(
 
-                    s.x - (int)(((Helper::pcgHash(result.randomSeed + s.x) % OsuGameRules::OSU_COORD_WIDTH) / 1.25f) *
 
+                    s.x - (int)(((Helper::pcgHash(result.randomSeed + s.x) % GameRules::OSU_COORD_WIDTH) / 1.25f) *
 
                                 (Helper::pcgHash(result.randomSeed + s.x) % 2 == 0 ? 1.0f : -1.0f) *
 
                                 osu_mod_random_spinner_offset_x_percent.getFloat()),
 
-                    0, OsuGameRules::OSU_COORD_WIDTH);
 
+                    0, GameRules::OSU_COORD_WIDTH);
 
                 s.y = clamp<int>(
 
-                    s.y - (int)(((Helper::pcgHash(result.randomSeed + s.y) % OsuGameRules::OSU_COORD_HEIGHT) / 1.25f) *
 
+                    s.y - (int)(((Helper::pcgHash(result.randomSeed + s.y) % GameRules::OSU_COORD_HEIGHT) / 1.25f) *
 
                                 (Helper::pcgHash(result.randomSeed + s.y) % 2 == 0 ? 1.0f : -1.0f) *
 
                                 osu_mod_random_spinner_offset_y_percent.getFloat()),
 
-                    0, OsuGameRules::OSU_COORD_HEIGHT);
 
+                    0, GameRules::OSU_COORD_HEIGHT);
 
             }
 
 
 
-            result.hitobjects.push_back(new OsuSpinner(s.x, s.y, s.time, s.sampleType, false, s.endTime, beatmap));
 
+            result.hitobjects.push_back(new Spinner(s.x, s.y, s.time, s.sampleType, false, s.endTime, beatmap));
 
         }
 
         maxPossibleCombo += c.spinners.size();
 
 
@@ -1466,16 +1372,16 @@ OsuDatabaseBeatmap::LOAD_GAMEPLAY_RESULT OsuDatabaseBeatmap::loadGameplay(OsuDat
 
             const bool touchDevice = databaseBeatmap->m_osu->getModTD();
 
 
 
             LOAD_DIFFOBJ_RESULT diffres =
 
-                OsuDatabaseBeatmap::loadDifficultyHitObjects(osuFilePath, AR, CS, speedMultiplier);
 
+                DatabaseBeatmap::loadDifficultyHitObjects(osuFilePath, AR, CS, speedMultiplier);
 
 
 
             double aim = 0.0;
 
             double aimSliderFactor = 0.0;
 
             double speed = 0.0;
 
             double speedNotes = 0.0;
 
-            double stars = OsuDifficultyCalculator::calculateStarDiffForHitObjects(
 
+            double stars = DifficultyCalculator::calculateStarDiffForHitObjects(
 
                 diffres.diffobjects, CS, OD, speedMultiplier, relax, touchDevice, &aim, &aimSliderFactor, &speed,
 
                 &speedNotes);
 
-            double pp = OsuDifficultyCalculator::calculatePPv2(
 
+            double pp = DifficultyCalculator::calculatePPv2(
 
                 beatmap->getOsu(), beatmap, aim, aimSliderFactor, speed, speedNotes, databaseBeatmap->m_iNumObjects,
 
                 databaseBeatmap->m_iNumCircles, databaseBeatmap->m_iNumSliders, databaseBeatmap->m_iNumSpinners,
 
                 maxPossibleCombo);
@@ -1491,7 +1397,7 @@ OsuDatabaseBeatmap::LOAD_GAMEPLAY_RESULT OsuDatabaseBeatmap::loadGameplay(OsuDat
 
 
 
     // sort hitobjects by starttime
 
     struct HitObjectSortComparator {
 
-        bool operator()(OsuHitObject const *a, OsuHitObject const *b) const {
 
+        bool operator()(HitObject const *a, HitObject const *b) const {
 
             // strict weak ordering!
 
             if(a->getTime() == b->getTime())
 
                 return a->getSortHack() < b->getSortHack();
@@ -1514,12 +1420,12 @@ OsuDatabaseBeatmap::LOAD_GAMEPLAY_RESULT OsuDatabaseBeatmap::loadGameplay(OsuDat
 
 
 
         int combo = 0;
 
         for(size_t i = 0; i < result.hitobjects.size(); i++) {
 
-            OsuHitObject *currentHitObject = result.hitobjects[i];
 
-            const OsuHitObject *nextHitObject = (i + 1 < result.hitobjects.size() ? result.hitobjects[i + 1] : NULL);
 
+            HitObject *currentHitObject = result.hitobjects[i];
 
+            const HitObject *nextHitObject = (i + 1 < result.hitobjects.size() ? result.hitobjects[i + 1] : NULL);
 
 
 
-            const OsuCircle *circlePointer = dynamic_cast<OsuCircle *>(currentHitObject);
 
-            const OsuSlider *sliderPointer = dynamic_cast<OsuSlider *>(currentHitObject);
 
-            const OsuSpinner *spinnerPointer = dynamic_cast<OsuSpinner *>(currentHitObject);
 
+            const Circle *circlePointer = dynamic_cast<Circle *>(currentHitObject);
 
+            const Slider *sliderPointer = dynamic_cast<Slider *>(currentHitObject);
 
+            const Spinner *spinnerPointer = dynamic_cast<Spinner *>(currentHitObject);
 
 
 
             int scoreComboMultiplier = std::max(combo - 1, 0);
 
 
@@ -1551,9 +1457,9 @@ OsuDatabaseBeatmap::LOAD_GAMEPLAY_RESULT OsuDatabaseBeatmap::loadGameplay(OsuDat
 
             // NOTE: spinners don't increment the combo number
 
             int comboNumber = 1;
 
             for(size_t i = 0; i < result.hitobjects.size(); i++) {
 
-                OsuHitObject *currentHitObject = result.hitobjects[i];
 
+                HitObject *currentHitObject = result.hitobjects[i];
 
 
 
-                const OsuSpinner *spinnerPointer = dynamic_cast<OsuSpinner *>(currentHitObject);
 
+                const Spinner *spinnerPointer = dynamic_cast<Spinner *>(currentHitObject);
 
 
 
                 if(spinnerPointer == NULL) {
 
                     currentHitObject->setComboNumber(comboNumber);
@@ -1565,7 +1471,7 @@ OsuDatabaseBeatmap::LOAD_GAMEPLAY_RESULT OsuDatabaseBeatmap::loadGameplay(OsuDat
 
         const int numberMax = osu_number_max.getInt();
 
         if(numberMax > 0) {
 
             for(size_t i = 0; i < result.hitobjects.size(); i++) {
 
-                OsuHitObject *currentHitObject = result.hitobjects[i];
 
+                HitObject *currentHitObject = result.hitobjects[i];
 
 
 
                 const int currentComboNumber = currentHitObject->getComboNumber();
 
                 const int newComboNumber = (currentComboNumber % numberMax);
@@ -1575,57 +1481,56 @@ OsuDatabaseBeatmap::LOAD_GAMEPLAY_RESULT OsuDatabaseBeatmap::loadGameplay(OsuDat
 
         }
 
     }
 
 
 
-    debugLog("OsuDatabaseBeatmap::load() loaded %i hitobjects\n", result.hitobjects.size());
 
+    debugLog("DatabaseBeatmap::load() loaded %i hitobjects\n", result.hitobjects.size());
 
 
 
     return result;
 
 }
 
 
 
-void OsuDatabaseBeatmap::setDifficulties(std::vector<OsuDatabaseBeatmap *> &difficulties) {
 
-    m_difficulties = difficulties;
 
-
 
-    if(m_difficulties.size() > 0) {
 
-        // set representative values for this container (i.e. use values from first difficulty)
 
-        m_sTitle = m_difficulties[0]->m_sTitle;
 
-        m_sArtist = m_difficulties[0]->m_sArtist;
 
-        m_sCreator = m_difficulties[0]->m_sCreator;
 
-        m_sBackgroundImageFileName = m_difficulties[0]->m_sBackgroundImageFileName;
 
-
 
-        // also precalculate some largest representative values
 
-        m_iLengthMS = 0;
 
-        m_fCS = 0.0f;
 
-        m_fAR = 0.0f;
 
-        m_fOD = 0.0f;
 
-        m_fHP = 0.0f;
 
-        m_fStarsNomod = 0.0f;
 
-        m_iMinBPM = std::numeric_limits<int>::max();
 
-        m_iMaxBPM = 0;
 
-        m_iMostCommonBPM = 0;
 
-        last_modification_time = 0;
 
-        for(size_t i = 0; i < m_difficulties.size(); i++) {
 
-            if(m_difficulties[i]->getLengthMS() > m_iLengthMS) m_iLengthMS = m_difficulties[i]->getLengthMS();
 
-            if(m_difficulties[i]->getCS() > m_fCS) m_fCS = m_difficulties[i]->getCS();
 
-            if(m_difficulties[i]->getAR() > m_fAR) m_fAR = m_difficulties[i]->getAR();
 
-            if(m_difficulties[i]->getHP() > m_fHP) m_fHP = m_difficulties[i]->getHP();
 
-            if(m_difficulties[i]->getOD() > m_fOD) m_fOD = m_difficulties[i]->getOD();
 
-            if(m_difficulties[i]->getStarsNomod() > m_fStarsNomod) m_fStarsNomod = m_difficulties[i]->getStarsNomod();
 
-            if(m_difficulties[i]->getMinBPM() < m_iMinBPM) m_iMinBPM = m_difficulties[i]->getMinBPM();
 
-            if(m_difficulties[i]->getMaxBPM() > m_iMaxBPM) m_iMaxBPM = m_difficulties[i]->getMaxBPM();
 
-            if(m_difficulties[i]->getMostCommonBPM() > m_iMostCommonBPM)
 
-                m_iMostCommonBPM = m_difficulties[i]->getMostCommonBPM();
 
-            if(m_difficulties[i]->last_modification_time > last_modification_time)
 
-                last_modification_time = m_difficulties[i]->last_modification_time;
 
-        }
 
+void DatabaseBeatmap::setDifficulties(std::vector<DatabaseBeatmap *> *difficulties) {
 
+    if(m_difficulties != difficulties) {
 
+        delete m_difficulties;
 
+        m_difficulties = difficulties;
 
     }
 
-}
 
 
 
-void OsuDatabaseBeatmap::updateSetHeuristics() { setDifficulties(m_difficulties); }
 
+    if(m_difficulties->empty()) return;
 
+
 
+    // set representative values for this container (i.e. use values from first difficulty)
 
+    m_sTitle = (*m_difficulties)[0]->m_sTitle;
 
+    m_sArtist = (*m_difficulties)[0]->m_sArtist;
 
+    m_sCreator = (*m_difficulties)[0]->m_sCreator;
 
+    m_sBackgroundImageFileName = (*m_difficulties)[0]->m_sBackgroundImageFileName;
 
+
 
+    // also precalculate some largest representative values
 
+    m_iLengthMS = 0;
 
+    m_fCS = 0.0f;
 
+    m_fAR = 0.0f;
 
+    m_fOD = 0.0f;
 
+    m_fHP = 0.0f;
 
+    m_fStarsNomod = 0.0f;
 
+    m_iMinBPM = std::numeric_limits<int>::max();
 
+    m_iMaxBPM = 0;
 
+    m_iMostCommonBPM = 0;
 
+    last_modification_time = 0;
 
+    for(auto diff : (*m_difficulties)) {
 
+        if(diff->getLengthMS() > m_iLengthMS) m_iLengthMS = diff->getLengthMS();
 
+        if(diff->getCS() > m_fCS) m_fCS = diff->getCS();
 
+        if(diff->getAR() > m_fAR) m_fAR = diff->getAR();
 
+        if(diff->getHP() > m_fHP) m_fHP = diff->getHP();
 
+        if(diff->getOD() > m_fOD) m_fOD = diff->getOD();
 
+        if(diff->getStarsNomod() > m_fStarsNomod) m_fStarsNomod = diff->getStarsNomod();
 
+        if(diff->getMinBPM() < m_iMinBPM) m_iMinBPM = diff->getMinBPM();
 
+        if(diff->getMaxBPM() > m_iMaxBPM) m_iMaxBPM = diff->getMaxBPM();
 
+        if(diff->getMostCommonBPM() > m_iMostCommonBPM) m_iMostCommonBPM = diff->getMostCommonBPM();
 
+        if(diff->last_modification_time > last_modification_time) last_modification_time = diff->last_modification_time;
 
+    }
 
+}
 
 
 
-OsuDatabaseBeatmap::TIMING_INFO OsuDatabaseBeatmap::getTimingInfoForTime(unsigned long positionMS) {
 
+DatabaseBeatmap::TIMING_INFO DatabaseBeatmap::getTimingInfoForTime(unsigned long positionMS) {
 
     return getTimingInfoForTimeAndTimingPoints(positionMS, m_timingpoints);
 
 }
 
 
 
-OsuDatabaseBeatmap::TIMING_INFO OsuDatabaseBeatmap::getTimingInfoForTimeAndTimingPoints(
 
-    unsigned long positionMS, std::vector<TIMINGPOINT> &timingpoints) {
 
+DatabaseBeatmap::TIMING_INFO DatabaseBeatmap::getTimingInfoForTimeAndTimingPoints(
 
+    unsigned long positionMS, const zarray<TIMINGPOINT> &timingpoints) {
 
     TIMING_INFO ti;
 
     ti.offset = 0;
 
     ti.beatLengthBase = 1;
@@ -1683,65 +1588,20 @@ OsuDatabaseBeatmap::TIMING_INFO OsuDatabaseBeatmap::getTimingInfoForTimeAndTimin
 
         ti.sampleSet = timingpoints[audioPoint].sampleSet;
 
     }
 
 
 
-    // old (McKay's algorithm)
 
-    // (doesn't work for all aspire maps, e.g. XNOR)
 
-    /*
 
-    // initial timing values (get first non-inherited timingpoint as base)
 
-    for (int i=0; i<timingpoints.size(); i++)
 
-    {
 
-            TIMINGPOINT *t = &timingpoints[i];
 
-            if (t->msPerBeat >= 0)
 
-            {
 
-                    ti.beatLength = t->msPerBeat;
 
-                    ti.beatLengthBase = ti.beatLength;
 
-                    ti.offset = t->offset;
 
-                    break;
 
-            }
 
-    }
 
-
 
-    // go through all timingpoints before positionMS
 
-    for (int i=0; i<timingpoints.size(); i++)
 
-    {
 
-            TIMINGPOINT *t = &timingpoints[i];
 
-            if (t->offset > (long)positionMS)
 
-                    break;
 
-
 
-            //debugLog("timingpoint %i msperbeat = %f\n", i, t->msPerBeat);
 
-
 
-            if (t->msPerBeat >= 0) // NOT inherited
 
-            {
 
-                    ti.beatLengthBase = t->msPerBeat;
 
-                    ti.beatLength = ti.beatLengthBase;
 
-                    ti.offset = t->offset;
 
-            }
 
-            else // inherited
 
-            {
 
-                    // note how msPerBeat is clamped
 
-                    ti.isNaN = std::isnan(t->msPerBeat);
 
-                    ti.beatLength = ti.beatLengthBase * (clamp<float>(!ti.isNaN ? std::abs(t->msPerBeat) : 1000, 10,
 
-    1000) / 100.0f); // sliderMultiplier of a timingpoint = (t->velocity / -100.0f)
 
-            }
 
-
 
-            ti.volume = t->volume;
 
-            ti.sampleType = t->sampleType;
 
-            ti.sampleSet = t->sampleSet;
 
-    }
 
-    */
 
-
 
     return ti;
 
 }
 
 
 
-OsuDatabaseBeatmapBackgroundImagePathLoader::OsuDatabaseBeatmapBackgroundImagePathLoader(const std::string &filePath)
 
+DatabaseBeatmapBackgroundImagePathLoader::DatabaseBeatmapBackgroundImagePathLoader(const std::string &filePath)
 
     : Resource() {
 
     m_sFilePath = filePath;
 
 }
 
 
 
-void OsuDatabaseBeatmapBackgroundImagePathLoader::init() {
 
+void DatabaseBeatmapBackgroundImagePathLoader::init() {
 
     // (nothing)
 
     m_bReady = true;
 
 }
 
 
 
-void OsuDatabaseBeatmapBackgroundImagePathLoader::initAsync() {
 
+void DatabaseBeatmapBackgroundImagePathLoader::initAsync() {
 
     File file(m_sFilePath);
 
     if(!file.canRead()) return;
 
 
@@ -1780,7 +1640,7 @@ void OsuDatabaseBeatmapBackgroundImagePathLoader::initAsync() {
 
     m_bReady = true;  // NOTE: on purpose. there is nothing to do in init(), so finish 1 frame early
 
 }
 
 
 
-OsuDatabaseBeatmapStarCalculator::OsuDatabaseBeatmapStarCalculator() : Resource() {
 
+DatabaseBeatmapStarCalculator::DatabaseBeatmapStarCalculator() : Resource() {
 
     m_bDead = true;  // NOTE: start dead! need to revive() before use
 
 
 
     m_diff2 = NULL;
@@ -1809,20 +1669,20 @@ OsuDatabaseBeatmapStarCalculator::OsuDatabaseBeatmapStarCalculator() : Resource(
 
     m_iMaxPossibleCombo = 0;
 
 }
 
 
 
-void OsuDatabaseBeatmapStarCalculator::init() {
 
+void DatabaseBeatmapStarCalculator::init() {
 
     // NOTE: this accesses runtime mods, so must be run sync (not async)
 
     // technically the getSelectedBeatmap() call here is a bit unsafe, since the beatmap could have changed already
 
     // between async and sync, but in that case we recalculate immediately after anyways
 
     if(!m_bDead.load() && m_iErrorCode == 0)
 
-        m_pp = OsuDifficultyCalculator::calculatePPv2(m_diff2->m_osu, m_diff2->m_osu->getSelectedBeatmap(),
 
-                                                      m_aimStars.load(), m_aimSliderFactor.load(), m_speedStars.load(),
 
-                                                      m_speedNotes.load(), m_iNumObjects.load(), m_iNumCircles.load(),
 
-                                                      m_iNumSliders.load(), m_iNumSpinners.load(), m_iMaxPossibleCombo);
 
+        m_pp = DifficultyCalculator::calculatePPv2(m_diff2->m_osu, m_diff2->m_osu->getSelectedBeatmap(),
 
+                                                   m_aimStars.load(), m_aimSliderFactor.load(), m_speedStars.load(),
 
+                                                   m_speedNotes.load(), m_iNumObjects.load(), m_iNumCircles.load(),
 
+                                                   m_iNumSliders.load(), m_iNumSpinners.load(), m_iMaxPossibleCombo);
 
 
 
     m_bReady = true;
 
 }
 
 
 
-void OsuDatabaseBeatmapStarCalculator::initAsync() {
 
+void DatabaseBeatmapStarCalculator::initAsync() {
 
     // sanity reset
 
     m_totalStars = 0.0;
 
     m_aimStars = 0.0;
@@ -1833,8 +1693,8 @@ void OsuDatabaseBeatmapStarCalculator::initAsync() {
 
 
 
     m_iLengthMS = 0;
 
 
 
-    OsuDatabaseBeatmap::LOAD_DIFFOBJ_RESULT diffres =
 
-        OsuDatabaseBeatmap::loadDifficultyHitObjects(m_sFilePath, m_fAR, m_fCS, m_fSpeedMultiplier, false, m_bDead);
 
+    DatabaseBeatmap::LOAD_DIFFOBJ_RESULT diffres =
 
+        DatabaseBeatmap::loadDifficultyHitObjects(m_sFilePath, m_fAR, m_fCS, m_fSpeedMultiplier, false, m_bDead);
 
     m_iErrorCode = diffres.errorCode;
 
 
 
     if(m_iErrorCode == 0) {
@@ -1855,7 +1715,7 @@ void OsuDatabaseBeatmapStarCalculator::initAsync() {
 
         double aimSliderFactor = 0.0;
 
         double speedStars = 0.0;
 
         double speedNotes = 0.0;
 
-        m_totalStars = OsuDifficultyCalculator::calculateStarDiffForHitObjects(
 
+        m_totalStars = DifficultyCalculator::calculateStarDiffForHitObjects(
 
             diffres.diffobjects, m_fCS, m_fOD, m_fSpeedMultiplier, m_bRelax, m_bTouchDevice, &aimStars,
 
             &aimSliderFactor, &speedStars, &speedNotes, -1, &m_aimStrains, &m_speedStrains, m_bDead);
 
         m_aimStars = aimStars;
@@ -1875,8 +1735,8 @@ void OsuDatabaseBeatmapStarCalculator::initAsync() {
 
     m_bAsyncReady = true;
 
 }
 
 
 
-void OsuDatabaseBeatmapStarCalculator::setBeatmapDifficulty(OsuDatabaseBeatmap *diff2, float AR, float CS, float OD,
 
-                                                            float speedMultiplier, bool relax, bool touchDevice) {
 
+void DatabaseBeatmapStarCalculator::setBeatmapDifficulty(DatabaseBeatmap *diff2, float AR, float CS, float OD,
 
+                                                         float speedMultiplier, bool relax, bool touchDevice) {
 
     m_diff2 = diff2;
 
 
 
     m_sFilePath = diff2->getFilePath();
@@ -1889,7 +1749,7 @@ void OsuDatabaseBeatmapStarCalculator::setBeatmapDifficulty(OsuDatabaseBeatmap *
 
     m_bTouchDevice = touchDevice;
 
 }
 
 
 
-std::string OsuDatabaseBeatmap::getFullSoundFilePath() {
 
+std::string DatabaseBeatmap::getFullSoundFilePath() {
 
     // On linux, paths are case sensitive, so we retry different variations
 
     if(env->getOS() != Environment::OS::OS_LINUX || env->fileExists(m_sFullSoundFilePath)) {
 
         return m_sFullSoundFilePath;
--- a/src/App/Osu/OsuDatabaseBeatmap.h
+++ b/src/App/Osu/OsuDatabaseBeatmap.h
@@ -1,32 +1,23 @@
 
-//================ Copyright (c) 2020, PG, All rights reserved. =================//
 
-//
 
-// Purpose:		loader + container for raw beatmap files/data (v2 rewrite)
 
-//
 
-// $NoKeywords: $osudiff
 
-//===============================================================================//
 
-
 
-#ifndef OSUDATABASEBEATMAP_H
 
-#define OSUDATABASEBEATMAP_H
 
-
 
+#pragma once
 
+#include "DifficultyCalculator.h"
 
 #include "Osu.h"
 
-#include "OsuDifficultyCalculator.h"
 
 #include "Resource.h"
 
 
 
 class Osu;
 
-class OsuBeatmap;
 
-class OsuHitObject;
 
+class Beatmap;
 
+class HitObject;
 
 
 
-class OsuDatabase;
 
+class Database;
 
 
 
-class OsuBackgroundImageHandler;
 
+class BackgroundImageHandler;
 
 
 
 // purpose:
 
 // 1) contain all infos which are ALWAYS kept in memory for beatmaps
 
-// 2) be the data source for OsuBeatmap when starting a difficulty
 
+// 2) be the data source for Beatmap when starting a difficulty
 
 // 3) allow async calculations/loaders to work on the contained data (e.g. background image loader)
 
-// 4) be a container for difficulties (all top level OsuDatabaseBeatmap objects are containers)
 
+// 4) be a container for difficulties (all top level DatabaseBeatmap objects are containers)
 
 
 
-class OsuDatabaseBeatmap {
 
+class DatabaseBeatmap {
 
    public:
 
     // raw structs
 
 
@@ -69,7 +60,7 @@ class OsuDatabaseBeatmap {
 
     struct LOAD_GAMEPLAY_RESULT {
 
         int errorCode;
 
 
 
-        std::vector<OsuHitObject *> hitobjects;
 
+        std::vector<HitObject *> hitobjects;
 
         std::vector<BREAK> breaks;
 
         std::vector<Color> combocolors;
 
 
@@ -95,19 +86,19 @@ class OsuDatabaseBeatmap {
 
         bool isNaN;
 
     };
 
 
 
-    OsuDatabaseBeatmap(Osu *osu, std::string filePath, std::string folder, bool filePathIsInMemoryBeatmap = false);
 
-    OsuDatabaseBeatmap(Osu *osu, std::vector<OsuDatabaseBeatmap *> &difficulties);
 
-    ~OsuDatabaseBeatmap();
 
+    DatabaseBeatmap(Osu *osu, std::string filePath, std::string folder, bool filePathIsInMemoryBeatmap = false);
 
+    DatabaseBeatmap(Osu *osu, std::vector<DatabaseBeatmap *> *difficulties);
 
+    ~DatabaseBeatmap();
 
 
 
     static LOAD_DIFFOBJ_RESULT loadDifficultyHitObjects(const std::string &osuFilePath, float AR, float CS,
 
                                                         float speedMultiplier, bool calculateStarsInaccurately = false);
 
     static LOAD_DIFFOBJ_RESULT loadDifficultyHitObjects(const std::string &osuFilePath, float AR, float CS,
 
                                                         float speedMultiplier, bool calculateStarsInaccurately,
 
                                                         const std::atomic<bool> &dead);
 
-    static bool loadMetadata(OsuDatabaseBeatmap *databaseBeatmap);
 
-    static LOAD_GAMEPLAY_RESULT loadGameplay(OsuDatabaseBeatmap *databaseBeatmap, OsuBeatmap *beatmap);
 
+    static bool loadMetadata(DatabaseBeatmap *databaseBeatmap);
 
+    static LOAD_GAMEPLAY_RESULT loadGameplay(DatabaseBeatmap *databaseBeatmap, Beatmap *beatmap);
 
 
 
-    void setDifficulties(std::vector<OsuDatabaseBeatmap *> &difficulties);
 
+    void setDifficulties(std::vector<DatabaseBeatmap *> *difficulties);
 
 
 
     void setLengthMS(unsigned long lengthMS) { m_iLengthMS = lengthMS; }
 
 
@@ -120,8 +111,6 @@ class OsuDatabaseBeatmap {
 
 
 
     void setLocalOffset(long localOffset) { m_iLocalOffset = localOffset; }
 
 
 
-    void updateSetHeuristics();
 
-
 
     inline Osu *getOsu() const { return m_osu; }
 
 
 
     inline std::string getFolder() const { return m_sFolder; }
@@ -129,13 +118,13 @@ class OsuDatabaseBeatmap {
 
 
 
     inline unsigned long long getSortHack() const { return m_iSortHack; }
 
 
 
-    inline const std::vector<OsuDatabaseBeatmap *> &getDifficulties() const { return m_difficulties; }
 
+    inline const std::vector<DatabaseBeatmap *> &getDifficulties() const { return *m_difficulties; }
 
 
 
     inline const MD5Hash &getMD5Hash() const { return m_sMD5Hash; }
 
 
 
     TIMING_INFO getTimingInfoForTime(unsigned long positionMS);
 
     static TIMING_INFO getTimingInfoForTimeAndTimingPoints(unsigned long positionMS,
 
-                                                           std::vector<TIMINGPOINT> &timingpoints);
 
+                                                           const zarray<TIMINGPOINT> &timingpoints);
 
 
 
     // raw metadata
 
 
@@ -165,7 +154,7 @@ class OsuDatabaseBeatmap {
 
     inline float getSliderTickRate() const { return m_fSliderTickRate; }
 
     inline float getSliderMultiplier() const { return m_fSliderMultiplier; }
 
 
 
-    inline const std::vector<TIMINGPOINT> &getTimingpoints() const { return m_timingpoints; }
 
+    inline const zarray<TIMINGPOINT> &getTimingpoints() const { return m_timingpoints; }
 
 
 
     std::string getFullSoundFilePath();
 
 
@@ -223,7 +212,7 @@ class OsuDatabaseBeatmap {
 
     float m_fSliderTickRate;
 
     float m_fSliderMultiplier;
 
 
 
-    std::vector<TIMINGPOINT> m_timingpoints;  // necessary for main menu anim
 
+    zarray<TIMINGPOINT> m_timingpoints;  // necessary for main menu anim
 
 
 
     // redundant data (technically contained in metadata, but precomputed anyway)
 
 
@@ -234,9 +223,9 @@ class OsuDatabaseBeatmap {
 
 
 
     float m_fStarsNomod;
 
 
 
-    int m_iMinBPM;
 
-    int m_iMaxBPM;
 
-    int m_iMostCommonBPM;
 
+    int m_iMinBPM = 0;
 
+    int m_iMaxBPM = 0;
 
+    int m_iMostCommonBPM = 0;
 
 
 
     int m_iNumObjects;
 
     int m_iNumCircles;
@@ -295,7 +284,7 @@ class OsuDatabaseBeatmap {
 
         std::vector<SPINNER> spinners;
 
         std::vector<BREAK> breaks;
 
 
 
-        std::vector<TIMINGPOINT> timingpoints;
 
+        zarray<TIMINGPOINT> timingpoints;
 
         std::vector<Color> combocolors;
 
 
 
         float stackLeniency;
@@ -312,9 +301,9 @@ class OsuDatabaseBeatmap {
 
 
 
     // class internal data (custom)
 
 
 
-    friend class OsuDatabase;
 
-    friend class OsuBackgroundImageHandler;
 
-    friend class OsuDatabaseBeatmapStarCalculator;
 
+    friend class Database;
 
+    friend class BackgroundImageHandler;
 
+    friend class DatabaseBeatmapStarCalculator;
 
 
 
     static unsigned long long sortHackCounter;
 
 
@@ -328,12 +317,14 @@ class OsuDatabaseBeatmap {
 
                                                     bool filePathIsInMemoryBeatmap = false);
 
     static PRIMITIVE_CONTAINER loadPrimitiveObjects(const std::string &osuFilePath, bool filePathIsInMemoryBeatmap,
 
                                                     const std::atomic<bool> &dead);
 
+    static CALCULATE_SLIDER_TIMES_CLICKS_TICKS_RESULT calculateSliderTimesClicksTicks(int beatmapVersion,
 
+                                                                                      std::vector<SLIDER> &sliders,
 
+                                                                                      zarray<TIMINGPOINT> &timingpoints,
 
+                                                                                      float sliderMultiplier,
 
+                                                                                      float sliderTickRate);
 
     static CALCULATE_SLIDER_TIMES_CLICKS_TICKS_RESULT calculateSliderTimesClicksTicks(
 
-        int beatmapVersion, std::vector<SLIDER> &sliders, std::vector<TIMINGPOINT> &timingpoints,
 
-        float sliderMultiplier, float sliderTickRate);
 
-    static CALCULATE_SLIDER_TIMES_CLICKS_TICKS_RESULT calculateSliderTimesClicksTicks(
 
-        int beatmapVersion, std::vector<SLIDER> &sliders, std::vector<TIMINGPOINT> &timingpoints,
 
-        float sliderMultiplier, float sliderTickRate, const std::atomic<bool> &dead);
 
+        int beatmapVersion, std::vector<SLIDER> &sliders, zarray<TIMINGPOINT> &timingpoints, float sliderMultiplier,
 
+        float sliderTickRate, const std::atomic<bool> &dead);
 
 
 
     Osu *m_osu;
 
 
@@ -343,14 +334,14 @@ class OsuDatabaseBeatmap {
 
 
 
     unsigned long long m_iSortHack;
 
 
 
-    std::vector<OsuDatabaseBeatmap *> m_difficulties;
 
+    std::vector<DatabaseBeatmap *> *m_difficulties = nullptr;
 
 
 
     MD5Hash m_sMD5Hash;
 
 
 
     // helper functions
 
 
 
     struct TimingPointSortComparator {
 
-        bool operator()(OsuDatabaseBeatmap::TIMINGPOINT const &a, OsuDatabaseBeatmap::TIMINGPOINT const &b) const {
 
+        bool operator()(DatabaseBeatmap::TIMINGPOINT const &a, DatabaseBeatmap::TIMINGPOINT const &b) const {
 
             // first condition: offset
 
             // second condition: if offset is the same, non-inherited timingpoints go before inherited timingpoints
 
 
@@ -363,9 +354,9 @@ class OsuDatabaseBeatmap {
 
     };
 
 };
 
 
 
-class OsuDatabaseBeatmapBackgroundImagePathLoader : public Resource {
 
+class DatabaseBeatmapBackgroundImagePathLoader : public Resource {
 
    public:
 
-    OsuDatabaseBeatmapBackgroundImagePathLoader(const std::string &filePath);
 
+    DatabaseBeatmapBackgroundImagePathLoader(const std::string &filePath);
 
 
 
     inline const std::string &getLoadedBackgroundImageFileName() const { return m_sLoadedBackgroundImageFileName; }
 
 
@@ -378,18 +369,18 @@ class OsuDatabaseBeatmapBackgroundImagePathLoader : public Resource {
 
     std::string m_sLoadedBackgroundImageFileName;
 
 };
 
 
 
-class OsuDatabaseBeatmapStarCalculator : public Resource {
 
+class DatabaseBeatmapStarCalculator : public Resource {
 
    public:
 
-    OsuDatabaseBeatmapStarCalculator();
 
+    DatabaseBeatmapStarCalculator();
 
 
 
     bool isDead() const { return m_bDead.load(); }
 
     void kill() { m_bDead = true; }
 
     void revive() { m_bDead = false; }
 
 
 
-    void setBeatmapDifficulty(OsuDatabaseBeatmap *diff2, float AR, float CS, float OD, float speedMultiplier,
 
-                              bool relax, bool touchDevice);
 
+    void setBeatmapDifficulty(DatabaseBeatmap *diff2, float AR, float CS, float OD, float speedMultiplier, bool relax,
 
+                              bool touchDevice);
 
 
 
-    inline OsuDatabaseBeatmap *getBeatmapDifficulty() const { return m_diff2; }
 
+    inline DatabaseBeatmap *getBeatmapDifficulty() const { return m_diff2; }
 
 
 
     inline double getTotalStars() const { return m_totalStars.load(); }
 
     inline double getAimStars() const { return m_aimStars.load(); }
@@ -412,7 +403,7 @@ class OsuDatabaseBeatmapStarCalculator : public Resource {
 
 
 
     std::atomic<bool> m_bDead;
 
 
 
-    OsuDatabaseBeatmap *m_diff2;
 
+    DatabaseBeatmap *m_diff2;
 
 
 
     float m_fAR;
 
     float m_fCS;
@@ -442,4 +433,79 @@ class OsuDatabaseBeatmapStarCalculator : public Resource {
 
     int m_iMaxPossibleCombo;
 
 };
 
 
 
-#endif
 
+struct BPMInfo {
 
+    i32 min;
 
+    i32 max;
 
+    i32 most_common;
 
+};
 
+
 
+template <typename T>
 
+struct BPMInfo getBPM(const zarray<T> &timing_points) {
 
+    if(timing_points.empty()) {
 
+        return BPMInfo{
 
+            .min = 0,
 
+            .max = 0,
 
+            .most_common = 0,
 
+        };
 
+    }
 
+
 
+    struct Tuple {
 
+        i32 bpm;
 
+        i32 duration;
 
+    };
 
+
 
+    zarray<Tuple> bpms;
 
+    bpms.reserve(timing_points.size());
 
+
 
+    long lastTime = timing_points[timing_points.size() - 1].offset;
 
+    for(size_t i = 0; i < timing_points.size(); i++) {
 
+        const T &t = timing_points[i];
 
+        if(t.offset > lastTime) continue;
 
+        if(t.msPerBeat < 0) continue;
 
+
 
+        // "osu-stable forced the first control point to start at 0."
 
+        // "This is reproduced here to maintain compatibility around osu!mania scroll speed and song
 
+        // select display."
 
+        const long currentTime = (i == 0 ? 0 : t.offset);
 
+        const long nextTime = (i == timing_points.size() - 1 ? lastTime : timing_points[i + 1].offset);
 
+
 
+        i32 bpm = t.msPerBeat / 60000;
 
+        i32 duration = std::max(nextTime - currentTime, (long)0);
 
+
 
+        bool found = false;
 
+        for(auto tuple : bpms) {
 
+            if(tuple.bpm == bpm) {
 
+                tuple.duration += duration;
 
+                found = true;
 
+                break;
 
+            }
 
+        }
 
+
 
+        if(!found) {
 
+            bpms.push_back(Tuple{
 
+                .bpm = bpm,
 
+                .duration = duration,
 
+            });
 
+        }
 
+    }
 
+
 
+    i32 min = 9001;
 
+    i32 max = 0;
 
+    i32 mostCommonBPM = 0;
 
+    i32 longestDuration = 0;
 
+    for(auto tuple : bpms) {
 
+        if(tuple.bpm > max) max = tuple.bpm;
 
+        if(tuple.bpm < min) min = tuple.bpm;
 
+
 
+        if(tuple.duration > longestDuration) {
 
+            longestDuration = tuple.duration;
 
+            mostCommonBPM = tuple.bpm;
 
+        }
 
+    }
 
+
 
+    return BPMInfo{
 
+        .min = min,
 
+        .max = max,
 
+        .most_common = mostCommonBPM,
 
+    };
 
+}
--- a/src/App/Osu/OsuDifficultyCalculator.cpp
+++ b/src/App/Osu/OsuDifficultyCalculator.cpp
@@ -5,15 +5,15 @@
 
 // $NoKeywords: $tomstarspp
 
 //==============================================================================================//
 
 
 
-#include "OsuDifficultyCalculator.h"
 
+#include "DifficultyCalculator.h"
 
 
 
+#include "Beatmap.h"
 
 #include "ConVar.h"
 
 #include "Engine.h"
 
+#include "GameRules.h"
 
 #include "Osu.h"
 
-#include "OsuBeatmap.h"
 
-#include "OsuGameRules.h"
 
-#include "OsuReplay.h"
 
-#include "OsuSliderCurves.h"
 
+#include "Replay.h"
 
+#include "SliderCurves.h"
 
 
 
 ConVar osu_stars_xexxar_angles_sliders("osu_stars_xexxar_angles_sliders", true, FCVAR_NONE,
 
                                        "completely enables/disables the new star/pp calc algorithm");
@@ -76,8 +76,8 @@ OsuDifficultyHitObject::OsuDifficultyHitObject(TYPE type, Vector2 pos, long time
 
             // 5208 sliders @ MillhioreF - haitai but every hai adds another haitai in the background (Chewy-san)
 
             // [Weriko Rank the dream (nerf) but loli].osu
 
 
 
-            this->curve = OsuSliderCurve::createCurve(this->osuSliderCurveType, controlPoints, this->pixelLength,
 
-                                                      osu_stars_slider_curve_points_separation.getFloat());
 
+            this->curve = SliderCurve::createCurve(this->osuSliderCurveType, controlPoints, this->pixelLength,
 
+                                                   osu_stars_slider_curve_points_separation.getFloat());
 
         } else {
 
             // new: delay curve creation to when it's needed, and also immediately delete afterwards (at the cost of
 
             // having to store a copy of the control points)
@@ -171,7 +171,7 @@ Vector2 OsuDifficultyHitObject::getOriginalRawPosAt(long pos) {
 
         {
 
                 // delay curve creation to when it's needed (1)
 
                 if (curve == NULL && scheduledCurveAlloc)
 
-                        curve = OsuSliderCurve::createCurve(osuSliderCurveType, scheduledCurveAllocControlPoints,
 
+                        curve = SliderCurve::createCurve(osuSliderCurveType, scheduledCurveAllocControlPoints,
 
         pixelLength, osu_stars_slider_curve_points_separation.getFloat());
 
         }
 
         */
@@ -219,14 +219,14 @@ float OsuDifficultyHitObject::getT(long pos, bool raw) {
 
     }
 
 }
 
 
 
-ConVar *OsuDifficultyCalculator::m_osu_slider_scorev2_ref = NULL;
 
+ConVar *DifficultyCalculator::m_osu_slider_scorev2_ref = NULL;
 
 
 
-double OsuDifficultyCalculator::calculateStarDiffForHitObjects(std::vector<OsuDifficultyHitObject> &sortedHitObjects,
 
-                                                               float CS, float OD, float speedMultiplier, bool relax,
 
-                                                               bool touchDevice, double *aim, double *aimSliderFactor,
 
-                                                               double *speed, double *speedNotes, int upToObjectIndex,
 
-                                                               std::vector<double> *outAimStrains,
 
-                                                               std::vector<double> *outSpeedStrains) {
 
+double DifficultyCalculator::calculateStarDiffForHitObjects(std::vector<OsuDifficultyHitObject> &sortedHitObjects,
 
+                                                            float CS, float OD, float speedMultiplier, bool relax,
 
+                                                            bool touchDevice, double *aim, double *aimSliderFactor,
 
+                                                            double *speed, double *speedNotes, int upToObjectIndex,
 
+                                                            std::vector<double> *outAimStrains,
 
+                                                            std::vector<double> *outSpeedStrains) {
 
     std::atomic<bool> dead;
 
     dead = false;
 
     return calculateStarDiffForHitObjects(sortedHitObjects, CS, OD, speedMultiplier, relax, touchDevice, aim,
@@ -234,7 +234,7 @@ double OsuDifficultyCalculator::calculateStarDiffForHitObjects(std::vector<OsuDi
 
                                           outSpeedStrains, dead);
 
 }
 
 
 
-double OsuDifficultyCalculator::calculateStarDiffForHitObjects(
 
+double DifficultyCalculator::calculateStarDiffForHitObjects(
 
     std::vector<OsuDifficultyHitObject> &sortedHitObjects, float CS, float OD, float speedMultiplier, bool relax,
 
     bool touchDevice, double *aim, double *aimSliderFactor, double *speed, double *speedNotes, int upToObjectIndex,
 
     std::vector<double> *outAimStrains, std::vector<double> *outSpeedStrains, const std::atomic<bool> &dead) {
@@ -253,9 +253,9 @@ double OsuDifficultyCalculator::calculateStarDiffForHitObjects(
 
         false;  // NOTE: un-compensate because lazer doesn't use this (and lazer code is used for calculating global
 
                 // online ranking pp/stars now)
 
     float circleRadiusInOsuPixels =
 
-        OsuGameRules::getRawHitCircleDiameter(clamp<float>(CS, 0.0f, 12.142f), applyBrokenGamefieldRoundingAllowance) /
 
+        GameRules::getRawHitCircleDiameter(clamp<float>(CS, 0.0f, 12.142f), applyBrokenGamefieldRoundingAllowance) /
 
         2.0f;  // NOTE: clamped CS because neosu allows CS > ~12.1429 (at which point the diameter becomes negative)
 
-    const float hitWindow300 = 2.0f * OsuGameRules::getRawHitWindow300(OD) / speedMultiplier;
 
+    const float hitWindow300 = 2.0f * GameRules::getRawHitWindow300(OD) / speedMultiplier;
 
 
 
     // ******************************************************************************************************************************************
 
     // //
@@ -978,7 +978,7 @@ double OsuDifficultyCalculator::calculateStarDiffForHitObjects(
 
                 {
 
                     // delay curve creation to when it's needed (1)
 
                     if(prev1.ho->scheduledCurveAlloc && prev1.ho->curve == NULL) {
 
-                        prev1.ho->curve = OsuSliderCurve::createCurve(
 
+                        prev1.ho->curve = SliderCurve::createCurve(
 
                             prev1.ho->osuSliderCurveType, prev1.ho->scheduledCurveAllocControlPoints,
 
                             prev1.ho->pixelLength, starsSliderCurvePointsSeparation);
 
                         prev1.ho->updateCurveStackPosition(
@@ -1085,10 +1085,10 @@ double OsuDifficultyCalculator::calculateStarDiffForHitObjects(
 
     return calculateTotalStarsFromSkills(*aim, *speed);
 
 }
 
 
 
-double OsuDifficultyCalculator::calculatePPv2(Osu *osu, OsuBeatmap *beatmap, double aim, double aimSliderFactor,
 
-                                              double speed, double speedNotes, int numHitObjects, int numCircles,
 
-                                              int numSliders, int numSpinners, int maxPossibleCombo, int combo,
 
-                                              int misses, int c300, int c100, int c50) {
 
+double DifficultyCalculator::calculatePPv2(Osu *osu, Beatmap *beatmap, double aim, double aimSliderFactor, double speed,
 
+                                           double speedNotes, int numHitObjects, int numCircles, int numSliders,
 
+                                           int numSpinners, int maxPossibleCombo, int combo, int misses, int c300,
 
+                                           int c100, int c50) {
 
     // NOTE: depends on active mods + OD + AR
 
 
 
     if(m_osu_slider_scorev2_ref == NULL) m_osu_slider_scorev2_ref = convar->getConVarByName("osu_slider_scorev2");
@@ -1105,11 +1105,10 @@ double OsuDifficultyCalculator::calculatePPv2(Osu *osu, OsuBeatmap *beatmap, dou
 
                          maxPossibleCombo, combo, misses, c300, c100, c50);
 
 }
 
 
 
-double OsuDifficultyCalculator::calculatePPv2(int modsLegacy, double timescale, double ar, double od, double aim,
 
-                                              double aimSliderFactor, double speed, double speedNotes,
 
-                                              int numHitObjects, int numCircles, int numSliders, int numSpinners,
 
-                                              int maxPossibleCombo, int combo, int misses, int c300, int c100,
 
-                                              int c50) {
 
+double DifficultyCalculator::calculatePPv2(int modsLegacy, double timescale, double ar, double od, double aim,
 
+                                           double aimSliderFactor, double speed, double speedNotes, int numHitObjects,
 
+                                           int numCircles, int numSliders, int numSpinners, int maxPossibleCombo,
 
+                                           int combo, int misses, int c300, int c100, int c50) {
 
     // NOTE: depends on active mods + OD + AR
 
 
 
     // apply "timescale" aka speed multiplier to ar/od
@@ -1119,8 +1118,8 @@ double OsuDifficultyCalculator::calculatePPv2(int modsLegacy, double timescale,
 
     // that it will have the locked value AFTER applying the speed multiplier here) (all UI elements which display ar/od
 
     // from stored scores, like the ranking screen or score buttons, also do this calculation before displaying the
 
     // values to the user. of course the mod selection screen does too.)
 
-    od = OsuGameRules::getRawOverallDifficultyForSpeedMultiplier(OsuGameRules::getRawHitWindow300(od), timescale);
 
-    ar = OsuGameRules::getRawApproachRateForSpeedMultiplier(OsuGameRules::getRawApproachTime(ar), timescale);
 
+    od = GameRules::getRawOverallDifficultyForSpeedMultiplier(GameRules::getRawHitWindow300(od), timescale);
 
+    ar = GameRules::getRawApproachRateForSpeedMultiplier(GameRules::getRawApproachTime(ar), timescale);
 
 
 
     if(c300 < 0) c300 = numHitObjects - c100 - c50 - misses;
 
 
@@ -1199,7 +1198,7 @@ double OsuDifficultyCalculator::calculatePPv2(int modsLegacy, double timescale,
 
     return totalValue;
 
 }
 
 
 
-double OsuDifficultyCalculator::calculateTotalStarsFromSkills(double aim, double speed) {
 
+double DifficultyCalculator::calculateTotalStarsFromSkills(double aim, double speed) {
 
     double baseAimPerformance = std::pow(5.0 * std::max(1.0, aim / 0.0675) - 4.0, 3.0) / 100000.0;
 
     double baseSpeedPerformance = std::pow(5.0 * std::max(1.0, speed / 0.0675) - 4.0, 3.0) / 100000.0;
 
     double basePerformance =
@@ -1210,12 +1209,11 @@ double OsuDifficultyCalculator::calculateTotalStarsFromSkills(double aim, double
 
                : 0.0;
 
 }
 
 
 
-// https://github.com/ppy/osu-performance/blob/master/src/performance/osu/OsuScore.cpp
 
+// https://github.com/ppy/osu-performance/blob/master/src/performance/osu/Score.cpp
 
 // https://github.com/ppy/osu/blob/master/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
 
 
 
-double OsuDifficultyCalculator::computeAimValue(const ScoreData &score,
 
-                                                const OsuDifficultyCalculator::Attributes &attributes,
 
-                                                double effectiveMissCount) {
 
+double DifficultyCalculator::computeAimValue(const ScoreData &score, const DifficultyCalculator::Attributes &attributes,
 
+                                             double effectiveMissCount) {
 
     double rawAim = attributes.AimStrain;
 
 
 
     double aimValue = std::pow(5.0 * std::max(1.0, rawAim / 0.0675) - 4.0, 3.0) / 100000.0;
@@ -1283,8 +1281,8 @@ double OsuDifficultyCalculator::computeAimValue(const ScoreData &score,
 
     return aimValue;
 
 }
 
 
 
-double OsuDifficultyCalculator::computeSpeedValue(const ScoreData &score, const Attributes &attributes,
 
-                                                  double effectiveMissCount) {
 
+double DifficultyCalculator::computeSpeedValue(const ScoreData &score, const Attributes &attributes,
 
+                                               double effectiveMissCount) {
 
     if((score.modsLegacy & ModFlags::Relax) && !osu_stars_and_pp_lazer_relax_autopilot_nerf_disabled.getBool())
 
         return 0.0;
 
 
@@ -1345,7 +1343,7 @@ double OsuDifficultyCalculator::computeSpeedValue(const ScoreData &score, const
 
     return speedValue;
 
 }
 
 
 
-double OsuDifficultyCalculator::computeAccuracyValue(const ScoreData &score, const Attributes &attributes) {
 
+double DifficultyCalculator::computeAccuracyValue(const ScoreData &score, const Attributes &attributes) {
 
     double betterAccuracyPercentage;
 
     if(score.amountHitObjectsWithAccuracy > 0)
 
         betterAccuracyPercentage =
--- a/src/App/Osu/OsuDifficultyCalculator.h
+++ b/src/App/Osu/OsuDifficultyCalculator.h
@@ -11,9 +11,9 @@
 
 #include "cbase.h"
 
 
 
 class Osu;
 
-class OsuBeatmap;
 
+class Beatmap;
 
 
 
-class OsuSliderCurve;
 
+class SliderCurve;
 
 
 
 class ConVar;
 
 
@@ -88,7 +88,7 @@ class OsuDifficultyHitObject {
 
     int repeats;
 
 
 
     // custom
 
-    OsuSliderCurve *curve;
 
+    SliderCurve *curve;
 
     bool scheduledCurveAlloc;
 
     std::vector<Vector2> scheduledCurveAllocControlPoints;
 
     float scheduledCurveAllocStackOffset;
@@ -102,7 +102,7 @@ class OsuDifficultyHitObject {
 
     static unsigned long long sortHackCounter;
 
 };
 
 
 
-class OsuDifficultyCalculator {
 
+class DifficultyCalculator {
 
    public:
 
     static constexpr const int PP_ALGORITHM_VERSION = 20220902;
 
 
@@ -122,7 +122,7 @@ class OsuDifficultyCalculator {
 
                                                  std::vector<double> *outSpeedStrains, const std::atomic<bool> &dead);
 
 
 
     // pp, use runtime mods (convenience)
 
-    static double calculatePPv2(Osu *osu, OsuBeatmap *beatmap, double aim, double aimSliderFactor, double speed,
 
+    static double calculatePPv2(Osu *osu, Beatmap *beatmap, double aim, double aimSliderFactor, double speed,
 
                                 double speedNotes, int numHitObjects, int numCircles, int numSliders, int numSpinners,
 
                                 int maxPossibleCombo, int combo = -1, int misses = 0, int c300 = -1, int c100 = 0,
 
                                 int c50 = 0);
--- a/src/App/Osu/Downloader.cpp
+++ b/src/App/Osu/Downloader.cpp
@@ -14,7 +14,7 @@
 
 
 
 struct DownloadResult {
 
     std::string url;
 
-    std::vector<uint8_t> data;
 
+    std::vector<u8> data;
 
     float progress = 0.f;
 
     int response_code = 0;
 
 };
@@ -103,7 +103,7 @@ void* do_downloads(void* arg) {
 
             pthread_mutex_lock(&threads_mtx);
 
             result->progress = 1.f;
 
             result->response_code = response_code;
 
-            result->data = std::vector<uint8_t>(response.memory, response.memory + response.size);
 
+            result->data = std::vector<u8>(response.memory, response.memory + response.size);
 
             pthread_mutex_unlock(&threads_mtx);
 
         } else {
 
             debugLog("Failed to download %s: %s\n", url.c_str(), curl_easy_strerror(res));
@@ -113,7 +113,7 @@ void* do_downloads(void* arg) {
 
             if(response_code == 429) {
 
                 result->progress = 0.f;
 
             } else {
 
-                result->data = std::vector<uint8_t>(response.memory, response.memory + response.size);
 
+                result->data = std::vector<u8>(response.memory, response.memory + response.size);
 
                 result->progress = -1.f;
 
             }
 
             pthread_mutex_unlock(&threads_mtx);
@@ -146,7 +146,7 @@ end_thread:
 
     return NULL;
 
 }
 
 
 
-void download(const char* url, float* progress, std::vector<uint8_t>& out, int* response_code) {
 
+void download(const char* url, float* progress, std::vector<u8>& out, int* response_code) {
 
     char* hostname = NULL;
 
     bool download_found = false;
 
     DownloadThread* matching_thread = nullptr;
@@ -218,7 +218,7 @@ end:
 
     curl_url_cleanup(urlu);
 
 }
 
 
 
-void download_beatmapset(uint32_t set_id, float* progress) {
 
+void download_beatmapset(u32 set_id, float* progress) {
 
     // Check if we already have downloaded it
 
     std::stringstream ss;
 
     ss << MCENGINE_DATA_DIR "maps/" << std::to_string(set_id) << "/";
@@ -228,7 +228,7 @@ void download_beatmapset(uint32_t set_id, float* progress) {
 
         return;
 
     }
 
 
 
-    std::vector<uint8_t> data;
 
+    std::vector<u8> data;
 
     auto mirror = convar->getConVarByName("beatmap_mirror")->getString();
 
     mirror.append(UString::format("%d", set_id));
 
     int response_code = 0;
--- a/src/App/Osu/Downloader.h
+++ b/src/App/Osu/Downloader.h
@@ -6,8 +6,8 @@ void abort_downloads();
 
 // Downloads `url` and stores downloaded file data into `out`
 
 // When file is fully downloaded, `progress` is 1 and `out` is not NULL
 
 // When download fails, `progress` is -1
 
-void download(const char *url, float *progress, std::vector<uint8_t> &out, int *response_code);
 
+void download(const char *url, float *progress, std::vector<u8> &out, int *response_code);
 
 
 
 // Downloads and extracts given beatmapset
 
 // When download/extraction fails, `progress` is -1
 
-void download_beatmapset(uint32_t set_id, float *progress);
 
+void download_beatmapset(u32 set_id, float *progress);
--- a/src/App/Osu/GameRules.cpp
+++ b/src/App/Osu/GameRules.cpp
@@ -0,0 +1,83 @@
 
+//================ Copyright (c) 2016, PG, All rights reserved. =================//
 
+//
 
+// Purpose:		difficulty & playfield behaviour
 
+//
 
+// $NoKeywords: $osugr
 
+//===============================================================================//
 
+
 
+#include "GameRules.h"
 
+
 
+ConVar GameRules::osu_playfield_border_top_percent("osu_playfield_border_top_percent", 0.117f, FCVAR_NONE);
 
+ConVar GameRules::osu_playfield_border_bottom_percent("osu_playfield_border_bottom_percent", 0.0834f, FCVAR_NONE);
 
+
 
+ConVar GameRules::osu_hitobject_hittable_dim(
 
+    "osu_hitobject_hittable_dim", true, FCVAR_NONE,
 
+    "whether to dim objects not yet within the miss-range (when they can't even be missed yet)");
 
+ConVar GameRules::osu_hitobject_hittable_dim_start_percent(
 
+    "osu_hitobject_hittable_dim_start_percent", 0.7647f, FCVAR_NONE,
 
+    "dimmed objects start at this brightness value before becoming fullbright (only RGB, this does not affect "
 
+    "alpha/transparency)");
 
+ConVar GameRules::osu_hitobject_hittable_dim_duration("osu_hitobject_hittable_dim_duration", 100, FCVAR_NONE,
 
+                                                      "in milliseconds (!)");
 
+
 
+ConVar GameRules::osu_hitobject_fade_in_time("osu_hitobject_fade_in_time", 400, FCVAR_CHEAT, "in milliseconds (!)");
 
+ConVar GameRules::osu_hitobject_fade_out_time("osu_hitobject_fade_out_time", 0.293f, FCVAR_CHEAT, "in seconds (!)");
 
+ConVar GameRules::osu_hitobject_fade_out_time_speed_multiplier_min(
 
+    "osu_hitobject_fade_out_time_speed_multiplier_min", 0.5f, FCVAR_CHEAT,
 
+    "The minimum multiplication factor allowed for the speed multiplier influencing the fadeout duration");
 
+
 
+ConVar GameRules::osu_circle_fade_out_scale("osu_circle_fade_out_scale", 0.4f, FCVAR_CHEAT);
 
+
 
+ConVar GameRules::osu_slider_followcircle_fadein_fade_time("osu_slider_followcircle_fadein_fade_time", 0.06f,
 
+                                                           FCVAR_NONE);
 
+ConVar GameRules::osu_slider_followcircle_fadeout_fade_time("osu_slider_followcircle_fadeout_fade_time", 0.25f,
 
+                                                            FCVAR_NONE);
 
+ConVar GameRules::osu_slider_followcircle_fadein_scale("osu_slider_followcircle_fadein_scale", 0.5f, FCVAR_NONE);
 
+ConVar GameRules::osu_slider_followcircle_fadein_scale_time("osu_slider_followcircle_fadein_scale_time", 0.18f,
 
+                                                            FCVAR_NONE);
 
+ConVar GameRules::osu_slider_followcircle_fadeout_scale("osu_slider_followcircle_fadeout_scale", 0.8f, FCVAR_NONE);
 
+ConVar GameRules::osu_slider_followcircle_fadeout_scale_time("osu_slider_followcircle_fadeout_scale_time", 0.25f,
 
+                                                             FCVAR_NONE);
 
+ConVar GameRules::osu_slider_followcircle_tick_pulse_time("osu_slider_followcircle_tick_pulse_time", 0.2f, FCVAR_NONE);
 
+ConVar GameRules::osu_slider_followcircle_tick_pulse_scale("osu_slider_followcircle_tick_pulse_scale", 0.1f,
 
+                                                           FCVAR_NONE);
 
+
 
+ConVar GameRules::osu_spinner_fade_out_time_multiplier("osu_spinner_fade_out_time_multiplier", 0.7f, FCVAR_CHEAT);
 
+
 
+ConVar GameRules::osu_slider_followcircle_size_multiplier("osu_slider_followcircle_size_multiplier", 2.4f, FCVAR_CHEAT);
 
+
 
+ConVar GameRules::osu_mod_fps("osu_mod_fps", false, FCVAR_NONVANILLA);
 
+ConVar GameRules::osu_mod_no50s("osu_mod_no50s", false, FCVAR_NONVANILLA);
 
+ConVar GameRules::osu_mod_no100s("osu_mod_no100s", false, FCVAR_NONVANILLA);
 
+ConVar GameRules::osu_mod_ming3012("osu_mod_ming3012", false, FCVAR_NONVANILLA);
 
+ConVar GameRules::osu_mod_millhioref("osu_mod_millhioref", false, FCVAR_NONVANILLA);
 
+ConVar GameRules::osu_mod_millhioref_multiplier("osu_mod_millhioref_multiplier", 2.0f, FCVAR_CHEAT);
 
+ConVar GameRules::osu_mod_mafham("osu_mod_mafham", false, FCVAR_NONVANILLA);
 
+ConVar GameRules::osu_mod_mafham_render_livesize(
 
+    "osu_mod_mafham_render_livesize", 25, FCVAR_NONE,
 
+    "render this many hitobjects without any scene buffering, higher = more lag but more up-to-date scene");
 
+ConVar GameRules::osu_stacking_ar_override("osu_stacking_ar_override", -1, FCVAR_CHEAT,
 
+                                           "allows overriding the approach time used for the stacking calculations. "
 
+                                           "behaves as if disabled if the value is less than 0.");
 
+ConVar GameRules::osu_mod_halfwindow("osu_mod_halfwindow", false, FCVAR_NONVANILLA);
 
+ConVar GameRules::osu_mod_halfwindow_allow_300s("osu_mod_halfwindow_allow_300s", true, FCVAR_NONE,
 
+                                                "should positive hit deltas be allowed within 300 range");
 
+
 
+// all values here are in milliseconds
 
+ConVar GameRules::osu_approachtime_min("osu_approachtime_min", 1800, FCVAR_CHEAT);
 
+ConVar GameRules::osu_approachtime_mid("osu_approachtime_mid", 1200, FCVAR_CHEAT);
 
+ConVar GameRules::osu_approachtime_max("osu_approachtime_max", 450, FCVAR_CHEAT);
 
+
 
+ConVar GameRules::osu_hitwindow_300_min("osu_hitwindow_300_min", 80, FCVAR_CHEAT);
 
+ConVar GameRules::osu_hitwindow_300_mid("osu_hitwindow_300_mid", 50, FCVAR_CHEAT);
 
+ConVar GameRules::osu_hitwindow_300_max("osu_hitwindow_300_max", 20, FCVAR_CHEAT);
 
+
 
+ConVar GameRules::osu_hitwindow_100_min("osu_hitwindow_100_min", 140, FCVAR_CHEAT);
 
+ConVar GameRules::osu_hitwindow_100_mid("osu_hitwindow_100_mid", 100, FCVAR_CHEAT);
 
+ConVar GameRules::osu_hitwindow_100_max("osu_hitwindow_100_max", 60, FCVAR_CHEAT);
 
+
 
+ConVar GameRules::osu_hitwindow_50_min("osu_hitwindow_50_min", 200, FCVAR_CHEAT);
 
+ConVar GameRules::osu_hitwindow_50_mid("osu_hitwindow_50_mid", 150, FCVAR_CHEAT);
 
+ConVar GameRules::osu_hitwindow_50_max("osu_hitwindow_50_max", 100, FCVAR_CHEAT);
 
+
 
+ConVar GameRules::osu_hitwindow_miss("osu_hitwindow_miss", 400, FCVAR_CHEAT);
--- a/src/App/Osu/OsuGameRules.h
+++ b/src/App/Osu/OsuGameRules.h
@@ -8,17 +8,17 @@
 
 #ifndef OSUGAMERULES_H
 
 #define OSUGAMERULES_H
 
 
 
+#include "Beatmap.h"
 
 #include "ConVar.h"
 
 #include "Osu.h"
 
-#include "OsuBeatmap.h"
 
 
 
-class OsuGameRules {
 
+class GameRules {
 
    public:
 
     //********************//
 
     //  Positional Audio  //
 
     //********************//
 
 
 
-    static float osuCoords2Pan(float x) { return (x / (float)OsuGameRules::OSU_COORD_WIDTH - 0.5f) * 0.8f; }
 
+    static float osuCoords2Pan(float x) { return (x / (float)GameRules::OSU_COORD_WIDTH - 0.5f) * 0.8f; }
 
 
 
     //************************//
 
     //	Hitobject Animations  //
@@ -46,8 +46,7 @@ class OsuGameRules {
 
 
 
     static ConVar osu_spinner_fade_out_time_multiplier;
 
 
 
-    static float getFadeOutTime(
 
-        OsuBeatmap *beatmap)  // this scales the fadeout duration with the current speed multiplier
 
+    static float getFadeOutTime(Beatmap *beatmap)  // this scales the fadeout duration with the current speed multiplier
 
     {
 
         const float fade_out_time = osu_hitobject_fade_out_time.getFloat();
 
         const float multiplier_min = osu_hitobject_fade_out_time_speed_multiplier_min.getFloat();
@@ -157,22 +156,22 @@ class OsuGameRules {
 
         return mapDifficultyRangeInv(approachTime * (1.0f / speedMultiplier), getRawMinApproachTime(),
 
                                      getRawMidApproachTime(), getRawMaxApproachTime());
 
     }
 
-    static float getApproachRateForSpeedMultiplier(OsuBeatmap *beatmap, float speedMultiplier) {
 
+    static float getApproachRateForSpeedMultiplier(Beatmap *beatmap, float speedMultiplier) {
 
         return mapDifficultyRangeInv((float)getApproachTime(beatmap) * (1.0f / speedMultiplier), getMinApproachTime(),
 
                                      getMidApproachTime(), getMaxApproachTime());
 
     }
 
-    static float getApproachRateForSpeedMultiplier(OsuBeatmap *beatmap)  // respect all mods and overrides
 
+    static float getApproachRateForSpeedMultiplier(Beatmap *beatmap)  // respect all mods and overrides
 
     {
 
         return getApproachRateForSpeedMultiplier(beatmap, beatmap->getOsu()->getSpeedMultiplier());
 
     }
 
-    static float getRawApproachRateForSpeedMultiplier(OsuBeatmap *beatmap)  // ignore AR override
 
+    static float getRawApproachRateForSpeedMultiplier(Beatmap *beatmap)  // ignore AR override
 
     {
 
         return mapDifficultyRangeInv(
 
             (float)getRawApproachTime(beatmap) * (1.0f / beatmap->getOsu()->getSpeedMultiplier()), getMinApproachTime(),
 
             getMidApproachTime(), getMaxApproachTime());
 
     }
 
     static float getConstantApproachRateForSpeedMultiplier(
 
-        OsuBeatmap *beatmap)  // ignore AR override, keep AR consistent through speed changes
 
+        Beatmap *beatmap)  // ignore AR override, keep AR consistent through speed changes
 
     {
 
         return mapDifficultyRangeInv((float)getRawApproachTime(beatmap) * beatmap->getOsu()->getSpeedMultiplier(),
 
                                      getMinApproachTime(), getMidApproachTime(), getMaxApproachTime());
@@ -192,24 +191,24 @@ class OsuGameRules {
 
         return mapDifficultyRangeInv(hitWindow300 * (1.0f / speedMultiplier), getMinHitWindow300(),
 
                                      getMidHitWindow300(), getMaxHitWindow300());
 
     }
 
-    static float getOverallDifficultyForSpeedMultiplier(OsuBeatmap *beatmap,
 
+    static float getOverallDifficultyForSpeedMultiplier(Beatmap *beatmap,
 
                                                         float speedMultiplier)  // respect all mods and overrides
 
     {
 
         return mapDifficultyRangeInv((float)getHitWindow300(beatmap) * (1.0f / speedMultiplier), getMinHitWindow300(),
 
                                      getMidHitWindow300(), getMaxHitWindow300());
 
     }
 
-    static float getOverallDifficultyForSpeedMultiplier(OsuBeatmap *beatmap)  // respect all mods and overrides
 
+    static float getOverallDifficultyForSpeedMultiplier(Beatmap *beatmap)  // respect all mods and overrides
 
     {
 
         return getOverallDifficultyForSpeedMultiplier(beatmap, beatmap->getOsu()->getSpeedMultiplier());
 
     }
 
-    static float getRawOverallDifficultyForSpeedMultiplier(OsuBeatmap *beatmap)  // ignore OD override
 
+    static float getRawOverallDifficultyForSpeedMultiplier(Beatmap *beatmap)  // ignore OD override
 
     {
 
         return mapDifficultyRangeInv(
 
             (float)getRawHitWindow300(beatmap) * (1.0f / beatmap->getOsu()->getSpeedMultiplier()), getMinHitWindow300(),
 
             getMidHitWindow300(), getMaxHitWindow300());
 
     }
 
     static float getConstantOverallDifficultyForSpeedMultiplier(
 
-        OsuBeatmap *beatmap)  // ignore OD override, keep OD consistent through speed changes
 
+        Beatmap *beatmap)  // ignore OD override, keep OD consistent through speed changes
 
     {
 
         return mapDifficultyRangeInv((float)getRawHitWindow300(beatmap) * beatmap->getOsu()->getSpeedMultiplier(),
 
                                      getMinHitWindow300(), getMidHitWindow300(), getMaxHitWindow300());
@@ -226,12 +225,12 @@ class OsuGameRules {
 
     {
 
         return mapDifficultyRange(AR, getRawMinApproachTime(), getRawMidApproachTime(), getRawMaxApproachTime());
 
     }
 
-    static float getApproachTime(OsuBeatmap *beatmap) {
 
+    static float getApproachTime(Beatmap *beatmap) {
 
         return osu_mod_mafham.getBool() ? beatmap->getLength() * 2
 
                                         : mapDifficultyRange(beatmap->getAR(), getMinApproachTime(),
 
                                                              getMidApproachTime(), getMaxApproachTime());
 
     }
 
-    static float getRawApproachTime(OsuBeatmap *beatmap)  // ignore AR override
 
+    static float getRawApproachTime(Beatmap *beatmap)  // ignore AR override
 
     {
 
         return osu_mod_mafham.getBool() ? beatmap->getLength() * 2
 
                                         : mapDifficultyRange(beatmap->getRawAR(), getMinApproachTime(),
@@ -241,7 +240,7 @@ class OsuGameRules {
 
         return mapDifficultyRange(osu_stacking_ar_override.getFloat() < 0.0f ? AR : osu_stacking_ar_override.getFloat(),
 
                                   getMinApproachTime(), getMidApproachTime(), getMaxApproachTime());
 
     }
 
-    static float getApproachTimeForStacking(OsuBeatmap *beatmap) {
 
+    static float getApproachTimeForStacking(Beatmap *beatmap) {
 
         return mapDifficultyRange(
 
             osu_stacking_ar_override.getFloat() < 0.0f ? beatmap->getAR() : osu_stacking_ar_override.getFloat(),
 
             getMinApproachTime(), getMidApproachTime(), getMaxApproachTime());
@@ -251,85 +250,84 @@ class OsuGameRules {
 
     {
 
         return mapDifficultyRange(OD, getMinHitWindow300(), getMidHitWindow300(), getMaxHitWindow300());
 
     }
 
-    static float getHitWindow300(OsuBeatmap *beatmap) {
 
+    static float getHitWindow300(Beatmap *beatmap) {
 
         return mapDifficultyRange(beatmap->getOD(), getMinHitWindow300(), getMidHitWindow300(), getMaxHitWindow300());
 
     }
 
-    static float getRawHitWindow300(OsuBeatmap *beatmap)  // ignore OD override
 
+    static float getRawHitWindow300(Beatmap *beatmap)  // ignore OD override
 
     {
 
         return mapDifficultyRange(beatmap->getRawOD(), getMinHitWindow300(), getMidHitWindow300(),
 
                                   getMaxHitWindow300());
 
     }
 
 
 
-    static float getHitWindow100(OsuBeatmap *beatmap) {
 
+    static float getHitWindow100(Beatmap *beatmap) {
 
         return mapDifficultyRange(beatmap->getOD(), getMinHitWindow100(), getMidHitWindow100(), getMaxHitWindow100());
 
     }
 
 
 
-    static float getHitWindow50(OsuBeatmap *beatmap) {
 
+    static float getHitWindow50(Beatmap *beatmap) {
 
         return mapDifficultyRange(beatmap->getOD(), getMinHitWindow50(), getMidHitWindow50(), getMaxHitWindow50());
 
     }
 
 
 
-    static inline float getHitWindowMiss(OsuBeatmap *beatmap) {
 
+    static inline float getHitWindowMiss(Beatmap *beatmap) {
 
         return osu_hitwindow_miss.getFloat();  // opsu is using this here: (500.0f - (beatmap->getOD() * 10.0f)), while
 
                                                // osu is just using 400 absolute ms hardcoded, not sure why
 
     }
 
 
 
-    static float getSpinnerSpinsPerSecond(OsuBeatmap *beatmap)  // raw spins required per second
 
+    static float getSpinnerSpinsPerSecond(Beatmap *beatmap)  // raw spins required per second
 
     {
 
         return mapDifficultyRange(beatmap->getOD(), 3.0f, 5.0f, 7.5f);
 
     }
 
-    static float getSpinnerRotationsForSpeedMultiplier(OsuBeatmap *beatmap, long spinnerDuration,
 
-                                                       float speedMultiplier) {
 
+    static float getSpinnerRotationsForSpeedMultiplier(Beatmap *beatmap, long spinnerDuration, float speedMultiplier) {
 
         /// return (int)((float)spinnerDuration / 1000.0f * getSpinnerSpinsPerSecond(beatmap)); // actual
 
         return (int)((((float)spinnerDuration / 1000.0f * getSpinnerSpinsPerSecond(beatmap)) * 0.5f) *
 
                      (std::min(1.0f / speedMultiplier, 1.0f)));  // Mc
 
     }
 
     static float getSpinnerRotationsForSpeedMultiplier(
 
-        OsuBeatmap *beatmap,
 
+        Beatmap *beatmap,
 
         long spinnerDuration)  // spinner length compensated rotations // respect all mods and overrides
 
     {
 
         return getSpinnerRotationsForSpeedMultiplier(beatmap, spinnerDuration, beatmap->getOsu()->getSpeedMultiplier());
 
     }
 
 
 
-    static OsuScore::HIT getHitResult(long delta, OsuBeatmap *beatmap) {
 
+    static LiveScore::HIT getHitResult(long delta, Beatmap *beatmap) {
 
         if(osu_mod_halfwindow.getBool() && delta > 0 && delta <= (long)getHitWindowMiss(beatmap)) {
 
             if(!osu_mod_halfwindow_allow_300s.getBool())
 
-                return OsuScore::HIT::HIT_MISS;
 
+                return LiveScore::HIT::HIT_MISS;
 
             else if(delta > (long)getHitWindow300(beatmap))
 
-                return OsuScore::HIT::HIT_MISS;
 
+                return LiveScore::HIT::HIT_MISS;
 
         }
 
 
 
         delta = std::abs(delta);
 
 
 
-        OsuScore::HIT result = OsuScore::HIT::HIT_NULL;
 
+        LiveScore::HIT result = LiveScore::HIT::HIT_NULL;
 
 
 
         if(!osu_mod_ming3012.getBool() && !osu_mod_no100s.getBool() && !osu_mod_no50s.getBool()) {
 
             if(delta <= (long)getHitWindow300(beatmap))
 
-                result = OsuScore::HIT::HIT_300;
 
+                result = LiveScore::HIT::HIT_300;
 
             else if(delta <= (long)getHitWindow100(beatmap))
 
-                result = OsuScore::HIT::HIT_100;
 
+                result = LiveScore::HIT::HIT_100;
 
             else if(delta <= (long)getHitWindow50(beatmap))
 
-                result = OsuScore::HIT::HIT_50;
 
+                result = LiveScore::HIT::HIT_50;
 
             else if(delta <= (long)getHitWindowMiss(beatmap))
 
-                result = OsuScore::HIT::HIT_MISS;
 
+                result = LiveScore::HIT::HIT_MISS;
 
         } else if(osu_mod_ming3012.getBool()) {
 
             if(delta <= (long)getHitWindow300(beatmap))
 
-                result = OsuScore::HIT::HIT_300;
 
+                result = LiveScore::HIT::HIT_300;
 
             else if(delta <= (long)getHitWindow50(beatmap))
 
-                result = OsuScore::HIT::HIT_50;
 
+                result = LiveScore::HIT::HIT_50;
 
             else if(delta <= (long)getHitWindowMiss(beatmap))
 
-                result = OsuScore::HIT::HIT_MISS;
 
+                result = LiveScore::HIT::HIT_MISS;
 
         } else if(osu_mod_no100s.getBool()) {
 
             if(delta <= (long)getHitWindow300(beatmap))
 
-                result = OsuScore::HIT::HIT_300;
 
+                result = LiveScore::HIT::HIT_300;
 
             else if(delta <= (long)getHitWindowMiss(beatmap))
 
-                result = OsuScore::HIT::HIT_MISS;
 
+                result = LiveScore::HIT::HIT_MISS;
 
         } else if(osu_mod_no50s.getBool()) {
 
             if(delta <= (long)getHitWindow300(beatmap))
 
-                result = OsuScore::HIT::HIT_300;
 
+                result = LiveScore::HIT::HIT_300;
 
             else if(delta <= (long)getHitWindow100(beatmap))
 
-                result = OsuScore::HIT::HIT_100;
 
+                result = LiveScore::HIT::HIT_100;
 
             else if(delta <= (long)getHitWindowMiss(beatmap))
 
-                result = OsuScore::HIT::HIT_MISS;
 
+                result = LiveScore::HIT::HIT_MISS;
 
         }
 
 
 
         return result;
@@ -358,7 +356,7 @@ class OsuGameRules {
 
         return getPlayfieldSize(osu).x / OSU_COORD_WIDTH;  // scales osu!pixels to the actual playfield size
 
     }
 
 
 
-    static float getHitCircleDiameter(OsuBeatmap *beatmap) {
 
+    static float getHitCircleDiameter(Beatmap *beatmap) {
 
         return getRawHitCircleDiameter(beatmap->getCS()) * getHitCircleXMultiplier(beatmap->getOsu());
 
     }
 
 
--- a/src/App/Osu/OsuHUD.cpp
+++ b/src/App/Osu/OsuHUD.cpp
@@ -5,37 +5,36 @@
 
 // $NoKeywords: $osuhud
 
 //===============================================================================//
 
 
 
-#include "OsuHUD.h"
 
+#include "HUD.h"
 
 
 
 #include "AnimationHandler.h"
 
 #include "Bancho.h"
 
 #include "BanchoUsers.h"
 
+#include "Beatmap.h"
 
 #include "CBaseUIContainer.h"
 
+#include "Circle.h"
 
 #include "ConVar.h"
 
+#include "Database.h"
 
+#include "DatabaseBeatmap.h"
 
 #include "Engine.h"
 
 #include "Environment.h"
 
+#include "GameRules.h"
 
+#include "HitObject.h"
 
+#include "Lobby.h"
 
+#include "ModFPoSu.h"
 
 #include "Mouse.h"
 
 #include "OpenGLES2Interface.h"
 
 #include "Osu.h"
 
-#include "OsuBeatmap.h"
 
-#include "OsuCircle.h"
 
-#include "OsuDatabase.h"
 
-#include "OsuDatabaseBeatmap.h"
 
-#include "OsuGameRules.h"
 
-#include "OsuHitObject.h"
 
-#include "OsuLobby.h"
 
-#include "OsuModFPoSu.h"
 
-#include "OsuRankingScreen.h"
 
-#include "OsuRoom.h"
 
-#include "OsuScore.h"
 
-#include "OsuScoreboardSlot.h"
 
-#include "OsuSkin.h"
 
-#include "OsuSkinImage.h"
 
-#include "OsuSongBrowser.h"
 
-#include "OsuUIAvatar.h"
 
+#include "RankingScreen.h"
 
 #include "ResourceManager.h"
 
+#include "ScoreboardSlot.h"
 
 #include "Shader.h"
 
+#include "Skin.h"
 
+#include "SkinImage.h"
 
+#include "SongBrowser.h"
 
+#include "UIAvatar.h"
 
 #include "VertexArrayObject.h"
 
+#include "score.h"
 
 
 
 ConVar osu_automatic_cursor_size("osu_automatic_cursor_size", false, FCVAR_NONE);
 
 
@@ -247,7 +246,7 @@ ConVar osu_combo_anim1_size("osu_combo_anim1_size", 0.15f, FCVAR_NONE);
 
 ConVar osu_combo_anim2_duration("osu_combo_anim2_duration", 0.4f, FCVAR_NONE);
 
 ConVar osu_combo_anim2_size("osu_combo_anim2_size", 0.5f, FCVAR_NONE);
 
 
 
-OsuHUD::OsuHUD(Osu *osu) : OsuScreen(osu) {
 
+HUD::HUD(Osu *osu) : OsuScreen(osu) {
 
     m_osu = osu;
 
 
 
     // convar refs
@@ -299,10 +298,10 @@ OsuHUD::OsuHUD(Osu *osu) : OsuScreen(osu) {
 
     m_fKiScaleAnim = 0.8f;
 
 }
 
 
 
-OsuHUD::~OsuHUD() {}
 
+HUD::~HUD() {}
 
 
 
-void OsuHUD::draw(Graphics *g) {
 
-    OsuBeatmap *beatmap = m_osu->getSelectedBeatmap();
 
+void HUD::draw(Graphics *g) {
 
+    Beatmap *beatmap = m_osu->getSelectedBeatmap();
 
     if(beatmap == NULL) return;  // sanity check
 
 
 
     if(osu_draw_hud.getBool()) {
@@ -324,21 +323,20 @@ void OsuHUD::draw(Graphics *g) {
 
             const int hitObjectIndexForCurrentTime =
 
                 (beatmap->getHitObjectIndexForCurrentTime() < 1 ? -1 : beatmap->getHitObjectIndexForCurrentTime());
 
 
 
-            drawStatistics(g, m_osu->getScore()->getNumMisses(), m_osu->getScore()->getNumSliderBreaks(),
 
-                           beatmap->getMaxPossibleCombo(),
 
-                           OsuDifficultyCalculator::calculateTotalStarsFromSkills(
 
-                               beatmap->getAimStarsForUpToHitObjectIndex(hitObjectIndexForCurrentTime),
 
-                               beatmap->getSpeedStarsForUpToHitObjectIndex(hitObjectIndexForCurrentTime)),
 
-                           m_osu->getSongBrowser()->getDynamicStarCalculator()->getTotalStars(),
 
-                           beatmap->getMostCommonBPM(),
 
-                           OsuGameRules::getApproachRateForSpeedMultiplier(beatmap, beatmap->getSpeedMultiplier()),
 
-                           beatmap->getCS(),
 
-                           OsuGameRules::getOverallDifficultyForSpeedMultiplier(beatmap, beatmap->getSpeedMultiplier()),
 
-                           beatmap->getHP(), beatmap->getNPS(), beatmap->getND(), m_osu->getScore()->getUnstableRate(),
 
-                           m_osu->getScore()->getPPv2(), m_osu->getSongBrowser()->getDynamicStarCalculator()->getPPv2(),
 
-                           ((int)OsuGameRules::getHitWindow300(beatmap) - 0.5f) *
 
-                               (1.0f / m_osu->getSpeedMultiplier()),  // see OsuUISongBrowserInfoLabel::update()
 
-                           m_osu->getScore()->getHitErrorAvgCustomMin(), m_osu->getScore()->getHitErrorAvgCustomMax());
 
+            drawStatistics(
 
+                g, m_osu->getScore()->getNumMisses(), m_osu->getScore()->getNumSliderBreaks(),
 
+                beatmap->getMaxPossibleCombo(),
 
+                DifficultyCalculator::calculateTotalStarsFromSkills(
 
+                    beatmap->getAimStarsForUpToHitObjectIndex(hitObjectIndexForCurrentTime),
 
+                    beatmap->getSpeedStarsForUpToHitObjectIndex(hitObjectIndexForCurrentTime)),
 
+                m_osu->getSongBrowser()->getDynamicStarCalculator()->getTotalStars(), beatmap->getMostCommonBPM(),
 
+                GameRules::getApproachRateForSpeedMultiplier(beatmap, beatmap->getSpeedMultiplier()), beatmap->getCS(),
 
+                GameRules::getOverallDifficultyForSpeedMultiplier(beatmap, beatmap->getSpeedMultiplier()),
 
+                beatmap->getHP(), beatmap->getNPS(), beatmap->getND(), m_osu->getScore()->getUnstableRate(),
 
+                m_osu->getScore()->getPPv2(), m_osu->getSongBrowser()->getDynamicStarCalculator()->getPPv2(),
 
+                ((int)GameRules::getHitWindow300(beatmap) - 0.5f) *
 
+                    (1.0f / m_osu->getSpeedMultiplier()),  // see UISongBrowserInfoLabel::update()
 
+                m_osu->getScore()->getHitErrorAvgCustomMin(), m_osu->getScore()->getHitErrorAvgCustomMax());
 
         }
 
         g->popTransform();
 
 
@@ -356,14 +354,14 @@ void OsuHUD::draw(Graphics *g) {
 
                 osu_hud_scorebar_hide_during_breaks.getBool() ? (1.0f - beatmap->getBreakBackgroundFadeAnim()) : 1.0f,
 
                 m_fScoreBarBreakAnim);
 
 
 
-        // NOTE: moved to draw behind hitobjects in OsuBeatmap::draw()
 
+        // NOTE: moved to draw behind hitobjects in Beatmap::draw()
 
         if(m_osu_mod_fposu_ref->getBool()) {
 
             if(osu_draw_hiterrorbar.getBool() &&
 
                (beatmap == NULL ||
 
                 (!beatmap->isSpinnerActive() || !osu_hud_hiterrorbar_hide_during_spinner.getBool())) &&
 
                !beatmap->isLoading()) {
 
-                drawHitErrorBar(g, OsuGameRules::getHitWindow300(beatmap), OsuGameRules::getHitWindow100(beatmap),
 
-                                OsuGameRules::getHitWindow50(beatmap), OsuGameRules::getHitWindowMiss(beatmap),
 
+                drawHitErrorBar(g, GameRules::getHitWindow300(beatmap), GameRules::getHitWindow100(beatmap),
 
+                                GameRules::getHitWindow50(beatmap), GameRules::getHitWindowMiss(beatmap),
 
                                 m_osu->getScore()->getUnstableRate());
 
             }
 
         }
@@ -387,14 +385,14 @@ void OsuHUD::draw(Graphics *g) {
 
                                  m_osu->getScore()->getKeyCount(3), m_osu->getScore()->getKeyCount(4));
 
         }
 
 
 
-        // NOTE: moved to draw behind hitobjects in OsuBeatmap::draw()
 
+        // NOTE: moved to draw behind hitobjects in Beatmap::draw()
 
         if(m_osu_mod_fposu_ref->getBool()) {
 
             if(osu_draw_hiterrorbar.getBool() &&
 
                (beatmap == NULL ||
 
                 (!beatmap->isSpinnerActive() || !osu_hud_hiterrorbar_hide_during_spinner.getBool())) &&
 
                !beatmap->isLoading()) {
 
-                drawHitErrorBar(g, OsuGameRules::getHitWindow300(beatmap), OsuGameRules::getHitWindow100(beatmap),
 
-                                OsuGameRules::getHitWindow50(beatmap), OsuGameRules::getHitWindowMiss(beatmap),
 
+                drawHitErrorBar(g, GameRules::getHitWindow300(beatmap), GameRules::getHitWindow100(beatmap),
 
+                                GameRules::getHitWindow50(beatmap), GameRules::getHitWindowMiss(beatmap),
 
                                 m_osu->getScore()->getUnstableRate());
 
             }
 
         }
@@ -417,12 +415,12 @@ void OsuHUD::draw(Graphics *g) {
 
             const unsigned long startTimePlayableMS = beatmap->getStartTimePlayable();
 
             const unsigned long endTimePlayableMS = startTimePlayableMS + lengthPlayableMS;
 
 
 
-            const std::vector<OsuDatabaseBeatmap::BREAK> &beatmapBreaks = beatmap->getBreaks();
 
+            const std::vector<DatabaseBeatmap::BREAK> &beatmapBreaks = beatmap->getBreaks();
 
 
 
             breaks.reserve(beatmapBreaks.size());
 
 
 
             for(int i = 0; i < beatmapBreaks.size(); i++) {
 
-                const OsuDatabaseBeatmap::BREAK &bk = beatmapBreaks[i];
 
+                const DatabaseBeatmap::BREAK &bk = beatmapBreaks[i];
 
 
 
                 // ignore breaks after last hitobject
 
                 if(/*bk.endTime <= (int)startTimePlayableMS ||*/ bk.startTime >=
@@ -450,8 +448,8 @@ void OsuHUD::draw(Graphics *g) {
 
         drawSkip(g);
 
 }
 
 
 
-void OsuHUD::mouse_update(bool *propagate_clicks) {
 
-    OsuBeatmap *beatmap = m_osu->getSelectedBeatmap();
 
+void HUD::mouse_update(bool *propagate_clicks) {
 
+    Beatmap *beatmap = m_osu->getSelectedBeatmap();
 
 
 
     if(beatmap != NULL) {
 
         // health anim
@@ -501,8 +499,8 @@ void OsuHUD::mouse_update(bool *propagate_clicks) {
 
     }
 
 }
 
 
 
-void OsuHUD::drawDummy(Graphics *g) {
 
-    drawPlayfieldBorder(g, OsuGameRules::getPlayfieldCenter(m_osu), OsuGameRules::getPlayfieldSize(m_osu), 0);
 
+void HUD::drawDummy(Graphics *g) {
 
+    drawPlayfieldBorder(g, GameRules::getPlayfieldCenter(m_osu), GameRules::getPlayfieldSize(m_osu), 0);
 
 
 
     if(osu_draw_scorebarbg.getBool()) drawScorebarBg(g, 1.0f, 0.0f);
 
 
@@ -541,7 +539,7 @@ void OsuHUD::drawDummy(Graphics *g) {
 
     if(osu_draw_hiterrorbar.getBool()) drawHitErrorBar(g, 50, 100, 150, 400, 70);
 
 }
 
 
 
-void OsuHUD::drawCursor(Graphics *g, Vector2 pos, float alphaMultiplier, bool secondTrail, bool updateAndDrawTrail) {
 
+void HUD::drawCursor(Graphics *g, Vector2 pos, float alphaMultiplier, bool secondTrail, bool updateAndDrawTrail) {
 
     if(osu_draw_cursor_ripples.getBool() && (!m_osu_mod_fposu_ref->getBool() || !m_osu->isInPlayMode()))
 
         drawCursorRipples(g);
 
 
@@ -550,7 +548,7 @@ void OsuHUD::drawCursor(Graphics *g, Vector2 pos, float alphaMultiplier, bool se
 
                   false, updateAndDrawTrail);
 
 }
 
 
 
-void OsuHUD::drawCursorTrail(Graphics *g, Vector2 pos, float alphaMultiplier, bool secondTrail) {
 
+void HUD::drawCursorTrail(Graphics *g, Vector2 pos, float alphaMultiplier, bool secondTrail) {
 
     const bool fposuTrailJumpFix = (m_osu_mod_fposu_ref->getBool() && m_osu->isInPlayMode() &&
 
                                     !m_osu->getFPoSu()->isCrosshairIntersectingScreen());
 
 
@@ -559,15 +557,15 @@ void OsuHUD::drawCursorTrail(Graphics *g, Vector2 pos, float alphaMultiplier, bo
 
                        fposuTrailJumpFix);
 
 }
 
 
 
-void OsuHUD::drawCursorInt(Graphics *g, Shader *trailShader, std::vector<CURSORTRAIL> &trail, Matrix4 &mvp, Vector2 pos,
 
-                           float alphaMultiplier, bool emptyTrailFrame, bool updateAndDrawTrail) {
 
+void HUD::drawCursorInt(Graphics *g, Shader *trailShader, std::vector<CURSORTRAIL> &trail, Matrix4 &mvp, Vector2 pos,
 
+                        float alphaMultiplier, bool emptyTrailFrame, bool updateAndDrawTrail) {
 
     if(updateAndDrawTrail) drawCursorTrailInt(g, trailShader, trail, mvp, pos, alphaMultiplier, emptyTrailFrame);
 
 
 
     drawCursorRaw(g, pos, alphaMultiplier);
 
 }
 
 
 
-void OsuHUD::drawCursorTrailInt(Graphics *g, Shader *trailShader, std::vector<CURSORTRAIL> &trail, Matrix4 &mvp,
 
-                                Vector2 pos, float alphaMultiplier, bool emptyTrailFrame) {
 
+void HUD::drawCursorTrailInt(Graphics *g, Shader *trailShader, std::vector<CURSORTRAIL> &trail, Matrix4 &mvp,
 
+                             Vector2 pos, float alphaMultiplier, bool emptyTrailFrame) {
 
     Image *trailImage = m_osu->getSkin()->getCursorTrail();
 
 
 
     if(osu_draw_cursor_trail.getBool() && trailImage->isReady()) {
@@ -663,7 +661,7 @@ void OsuHUD::drawCursorTrailInt(Graphics *g, Shader *trailShader, std::vector<CU
 
     }
 
 }
 
 
 
-void OsuHUD::drawCursorRaw(Graphics *g, Vector2 pos, float alphaMultiplier) {
 
+void HUD::drawCursorRaw(Graphics *g, Vector2 pos, float alphaMultiplier) {
 
     Image *cursor = m_osu->getSkin()->getCursor();
 
     const float scale = getCursorScaleFactor() * (m_osu->getSkin()->isCursor2x() ? 0.5f : 1.0f);
 
     const float animatedScale = scale * (m_osu->getSkin()->getCursorExpand() ? m_fCursorExpandAnim : 1.0f);
@@ -706,7 +704,7 @@ void OsuHUD::drawCursorRaw(Graphics *g, Vector2 pos, float alphaMultiplier) {
 
     }
 
 }
 
 
 
-void OsuHUD::drawCursorTrailRaw(Graphics *g, float alpha, Vector2 pos) {
 
+void HUD::drawCursorTrailRaw(Graphics *g, float alpha, Vector2 pos) {
 
     Image *trailImage = m_osu->getSkin()->getCursorTrail();
 
     const float scale = getCursorTrailScaleFactor();
 
     const float animatedScale =
@@ -725,7 +723,7 @@ void OsuHUD::drawCursorTrailRaw(Graphics *g, float alpha, Vector2 pos) {
 
     g->popTransform();
 
 }
 
 
 
-void OsuHUD::drawCursorRipples(Graphics *g) {
 
+void HUD::drawCursorRipples(Graphics *g) {
 
     if(m_osu->getSkin()->getCursorRipple() == m_osu->getSkin()->getMissingTexture()) return;
 
 
 
     // allow overscale/underscale as usual
@@ -768,7 +766,7 @@ void OsuHUD::drawCursorRipples(Graphics *g) {
 
     if(osu_cursor_ripple_additive.getBool()) g->setBlendMode(Graphics::BLEND_MODE::BLEND_MODE_ALPHA);
 
 }
 
 
 
-void OsuHUD::drawFps(Graphics *g, McFont *font, float fps) {
 
+void HUD::drawFps(Graphics *g, McFont *font, float fps) {
 
     fps = std::round(fps);
 
     const UString fpsString = UString::format("%i fps", (int)(fps));
 
     const UString msString = UString::format("%.1f ms", (1.0f / fps) * 1000.0f);
@@ -821,12 +819,12 @@ void OsuHUD::drawFps(Graphics *g, McFont *font, float fps) {
 
     g->popTransform();
 
 }
 
 
 
-void OsuHUD::drawPlayfieldBorder(Graphics *g, Vector2 playfieldCenter, Vector2 playfieldSize, float hitcircleDiameter) {
 
+void HUD::drawPlayfieldBorder(Graphics *g, Vector2 playfieldCenter, Vector2 playfieldSize, float hitcircleDiameter) {
 
     drawPlayfieldBorder(g, playfieldCenter, playfieldSize, hitcircleDiameter, osu_hud_playfield_border_size.getInt());
 
 }
 
 
 
-void OsuHUD::drawPlayfieldBorder(Graphics *g, Vector2 playfieldCenter, Vector2 playfieldSize, float hitcircleDiameter,
 
-                                 float borderSize) {
 
+void HUD::drawPlayfieldBorder(Graphics *g, Vector2 playfieldCenter, Vector2 playfieldSize, float hitcircleDiameter,
 
+                              float borderSize) {
 
     if(borderSize <= 0.0f) return;
 
 
 
     // respect playfield stretching
@@ -921,7 +919,7 @@ void OsuHUD::drawPlayfieldBorder(Graphics *g, Vector2 playfieldCenter, Vector2 p
 
     g->popTransform();
 
 }
 
 
 
-void OsuHUD::drawLoadingSmall(Graphics *g) {
 
+void HUD::drawLoadingSmall(Graphics *g) {
 
     const float scale = Osu::getImageScale(m_osu, m_osu->getSkin()->getLoadingSpinner(), 29);
 
 
 
     g->setColor(0xffffffff);
@@ -935,7 +933,7 @@ void OsuHUD::drawLoadingSmall(Graphics *g) {
 
     g->popTransform();
 
 }
 
 
 
-void OsuHUD::drawBeatmapImportSpinner(Graphics *g) {
 
+void HUD::drawBeatmapImportSpinner(Graphics *g) {
 
     const float scale = Osu::getImageScale(m_osu, m_osu->getSkin()->getBeatmapImportSpinner(), 100);
 
 
 
     g->setColor(0xffffffff);
@@ -949,7 +947,7 @@ void OsuHUD::drawBeatmapImportSpinner(Graphics *g) {
 
     g->popTransform();
 
 }
 
 
 
-void OsuHUD::drawScoreNumber(Graphics *g, unsigned long long number, float scale, bool drawLeadingZeroes) {
 
+void HUD::drawScoreNumber(Graphics *g, unsigned long long number, float scale, bool drawLeadingZeroes) {
 
     // get digits
 
     static std::vector<int> digits;
 
     digits.clear();
@@ -1026,7 +1024,7 @@ void OsuHUD::drawScoreNumber(Graphics *g, unsigned long long number, float scale
 
     }
 
 }
 
 
 
-void OsuHUD::drawComboNumber(Graphics *g, unsigned long long number, float scale, bool drawLeadingZeroes) {
 
+void HUD::drawComboNumber(Graphics *g, unsigned long long number, float scale, bool drawLeadingZeroes) {
 
     // get digits
 
     static std::vector<int> digits;
 
     digits.clear();
@@ -1103,7 +1101,7 @@ void OsuHUD::drawComboNumber(Graphics *g, unsigned long long number, float scale
 
     }
 
 }
 
 
 
-void OsuHUD::drawComboSimple(Graphics *g, int combo, float scale) {
 
+void HUD::drawComboSimple(Graphics *g, int combo, float scale) {
 
     g->pushTransform();
 
     {
 
         drawComboNumber(g, combo, scale);
@@ -1117,7 +1115,7 @@ void OsuHUD::drawComboSimple(Graphics *g, int combo, float scale) {
 
     g->popTransform();
 
 }
 
 
 
-void OsuHUD::drawCombo(Graphics *g, int combo) {
 
+void HUD::drawCombo(Graphics *g, int combo) {
 
     g->setColor(0xffffffff);
 
 
 
     const int offset = 5;
@@ -1166,7 +1164,7 @@ void OsuHUD::drawCombo(Graphics *g, int combo) {
 
     g->popTransform();
 
 }
 
 
 
-void OsuHUD::drawScore(Graphics *g, unsigned long long score) {
 
+void HUD::drawScore(Graphics *g, unsigned long long score) {
 
     g->setColor(0xffffffff);
 
 
 
     int numDigits = 1;
@@ -1189,7 +1187,7 @@ void OsuHUD::drawScore(Graphics *g, unsigned long long score) {
 
     g->popTransform();
 
 }
 
 
 
-void OsuHUD::drawScorebarBg(Graphics *g, float alpha, float breakAnim) {
 
+void HUD::drawScorebarBg(Graphics *g, float alpha, float breakAnim) {
 
     if(m_osu->getSkin()->getScorebarBg()->isMissingTexture()) return;
 
 
 
     const float scale = osu_hud_scale.getFloat() * osu_hud_scorebar_scale.getFloat();
@@ -1202,7 +1200,7 @@ void OsuHUD::drawScorebarBg(Graphics *g, float alpha, float breakAnim) {
 
         g, (m_osu->getSkin()->getScorebarBg()->getSize() / 2.0f) * scale + (breakAnimOffset * scale), scale);
 
 }
 
 
 
-void OsuHUD::drawSectionPass(Graphics *g, float alpha) {
 
+void HUD::drawSectionPass(Graphics *g, float alpha) {
 
     if(!m_osu->getSkin()->getSectionPassImage()->isMissingTexture()) {
 
         g->setColor(0xffffffff);
 
         g->setAlpha(alpha);
@@ -1210,7 +1208,7 @@ void OsuHUD::drawSectionPass(Graphics *g, float alpha) {
 
     }
 
 }
 
 
 
-void OsuHUD::drawSectionFail(Graphics *g, float alpha) {
 
+void HUD::drawSectionFail(Graphics *g, float alpha) {
 
     if(!m_osu->getSkin()->getSectionFailImage()->isMissingTexture()) {
 
         g->setColor(0xffffffff);
 
         g->setAlpha(alpha);
@@ -1218,7 +1216,7 @@ void OsuHUD::drawSectionFail(Graphics *g, float alpha) {
 
     }
 
 }
 
 
 
-void OsuHUD::drawHPBar(Graphics *g, double health, float alpha, float breakAnim) {
 
+void HUD::drawHPBar(Graphics *g, double health, float alpha, float breakAnim) {
 
     const bool useNewDefault = !m_osu->getSkin()->getScorebarMarker()->isMissingTexture();
 
 
 
     const float scale = osu_hud_scale.getFloat() * osu_hud_scorebar_scale.getFloat();
@@ -1258,7 +1256,7 @@ void OsuHUD::drawHPBar(Graphics *g, double health, float alpha, float breakAnim)
 
 
 
     // draw ki
 
     {
 
-        OsuSkinImage *ki = NULL;
 
+        SkinImage *ki = NULL;
 
 
 
         if(useNewDefault)
 
             ki = m_osu->getSkin()->getScorebarMarker();
@@ -1280,7 +1278,7 @@ void OsuHUD::drawHPBar(Graphics *g, double health, float alpha, float breakAnim)
 
     }
 
 }
 
 
 
-void OsuHUD::drawAccuracySimple(Graphics *g, float accuracy, float scale) {
 
+void HUD::drawAccuracySimple(Graphics *g, float accuracy, float scale) {
 
     // get integer & fractional parts of the number
 
     const int accuracyInt = (int)accuracy;
 
     const int accuracyFrac = clamp<int>(((int)(std::round((accuracy - accuracyInt) * 100.0f))), 0, 99);  // round up
@@ -1311,7 +1309,7 @@ void OsuHUD::drawAccuracySimple(Graphics *g, float accuracy, float scale) {
 
     g->popTransform();
 
 }
 
 
 
-void OsuHUD::drawAccuracy(Graphics *g, float accuracy) {
 
+void HUD::drawAccuracy(Graphics *g, float accuracy) {
 
     g->setColor(0xffffffff);
 
 
 
     // get integer & fractional parts of the number
@@ -1367,7 +1365,7 @@ void OsuHUD::drawAccuracy(Graphics *g, float accuracy) {
 
     g->popTransform();
 
 }
 
 
 
-void OsuHUD::drawSkip(Graphics *g) {
 
+void HUD::drawSkip(Graphics *g) {
 
     const float scale = osu_hud_scale.getFloat();
 
 
 
     g->setColor(0xffffffff);
@@ -1375,7 +1373,7 @@ void OsuHUD::drawSkip(Graphics *g) {
 
         g, m_osu->getScreenSize() - (m_osu->getSkin()->getPlaySkip()->getSize() / 2) * scale, osu_hud_scale.getFloat());
 
 }
 
 
 
-void OsuHUD::drawWarningArrow(Graphics *g, Vector2 pos, bool flipVertically, bool originLeft) {
 
+void HUD::drawWarningArrow(Graphics *g, Vector2 pos, bool flipVertically, bool originLeft) {
 
     const float scale =
 
         osu_hud_scale.getFloat() * m_osu->getImageScale(m_osu, m_osu->getSkin()->getPlayWarningArrow(), 78);
 
 
@@ -1391,34 +1389,34 @@ void OsuHUD::drawWarningArrow(Graphics *g, Vector2 pos, bool flipVertically, boo
 
     g->popTransform();
 
 }
 
 
 
-void OsuHUD::drawWarningArrows(Graphics *g, float hitcircleDiameter) {
 
+void HUD::drawWarningArrows(Graphics *g, float hitcircleDiameter) {
 
     const float divider = 18.0f;
 
-    const float part = OsuGameRules::getPlayfieldSize(m_osu).y * (1.0f / divider);
 
+    const float part = GameRules::getPlayfieldSize(m_osu).y * (1.0f / divider);
 
 
 
     g->setColor(0xffffffff);
 
     drawWarningArrow(g,
 
-                     Vector2(m_osu->getUIScale(m_osu, 28), OsuGameRules::getPlayfieldCenter(m_osu).y -
 
-                                                               OsuGameRules::getPlayfieldSize(m_osu).y / 2 + part * 2),
 
+                     Vector2(m_osu->getUIScale(m_osu, 28), GameRules::getPlayfieldCenter(m_osu).y -
 
+                                                               GameRules::getPlayfieldSize(m_osu).y / 2 + part * 2),
 
                      false);
 
     drawWarningArrow(
 
         g,
 
-        Vector2(m_osu->getUIScale(m_osu, 28), OsuGameRules::getPlayfieldCenter(m_osu).y -
 
-                                                  OsuGameRules::getPlayfieldSize(m_osu).y / 2 + part * 2 + part * 13),
 
+        Vector2(m_osu->getUIScale(m_osu, 28), GameRules::getPlayfieldCenter(m_osu).y -
 
+                                                  GameRules::getPlayfieldSize(m_osu).y / 2 + part * 2 + part * 13),
 
         false);
 
 
 
     drawWarningArrow(
 
         g,
 
         Vector2(m_osu->getScreenWidth() - m_osu->getUIScale(m_osu, 28),
 
-                OsuGameRules::getPlayfieldCenter(m_osu).y - OsuGameRules::getPlayfieldSize(m_osu).y / 2 + part * 2),
 
+                GameRules::getPlayfieldCenter(m_osu).y - GameRules::getPlayfieldSize(m_osu).y / 2 + part * 2),
 
         true);
 
     drawWarningArrow(g,
 
                      Vector2(m_osu->getScreenWidth() - m_osu->getUIScale(m_osu, 28),
 
-                             OsuGameRules::getPlayfieldCenter(m_osu).y - OsuGameRules::getPlayfieldSize(m_osu).y / 2 +
 
+                             GameRules::getPlayfieldCenter(m_osu).y - GameRules::getPlayfieldSize(m_osu).y / 2 +
 
                                  part * 2 + part * 13),
 
                      true);
 
 }
 
 
 
-std::vector<SCORE_ENTRY> OsuHUD::getCurrentScores() {
 
+std::vector<SCORE_ENTRY> HUD::getCurrentScores() {
 
     static std::vector<SCORE_ENTRY> scores;
 
     scores.clear();
 
 
@@ -1433,12 +1431,12 @@ std::vector<SCORE_ENTRY> OsuHUD::getCurrentScores() {
 
             if(slot->player_id == bancho.user_id) {
 
                 // Update local player slot instantly
 
                 // (not including fields that won't be used for the HUD)
 
-                slot->num300 = (uint16_t)m_osu->getScore()->getNum300s();
 
-                slot->num100 = (uint16_t)m_osu->getScore()->getNum100s();
 
-                slot->num50 = (uint16_t)m_osu->getScore()->getNum50s();
 
-                slot->num_miss = (uint16_t)m_osu->getScore()->getNumMisses();
 
-                slot->current_combo = (uint16_t)m_osu->getScore()->getCombo();
 
-                slot->total_score = (int32_t)m_osu->getScore()->getScore();
 
+                slot->num300 = (u16)m_osu->getScore()->getNum300s();
 
+                slot->num100 = (u16)m_osu->getScore()->getNum100s();
 
+                slot->num50 = (u16)m_osu->getScore()->getNum50s();
 
+                slot->num_miss = (u16)m_osu->getScore()->getNumMisses();
 
+                slot->current_combo = (u16)m_osu->getScore()->getCombo();
 
+                slot->total_score = (i32)m_osu->getScore()->getScore();
 
                 slot->current_hp = beatmap->getHealth() * 200;
 
             }
 
 
@@ -1465,15 +1463,15 @@ std::vector<SCORE_ENTRY> OsuHUD::getCurrentScores() {
 
             }
 
 
 
             // hit_score != total_score: total_score also accounts for spinner bonus & mods
 
-            uint64_t hit_score = 300 * slot->num300 + 100 * slot->num100 + 50 * slot->num50;
 
-            uint64_t max_score = 300 * (slot->num300 + slot->num100 + slot->num50 + slot->num_miss);
 
+            u64 hit_score = 300 * slot->num300 + 100 * slot->num100 + 50 * slot->num50;
 
+            u64 max_score = 300 * (slot->num300 + slot->num100 + slot->num50 + slot->num_miss);
 
             scoreEntry.accuracy = max_score > 0 ? hit_score / max_score : 0.f;
 
 
 
             scores.push_back(std::move(scoreEntry));
 
         }
 
     } else {
 
         auto m_db = m_osu->getSongBrowser()->getDatabase();
 
-        std::vector<Score> *singleplayer_scores = &((*m_db->getScores())[beatmap_md5]);
 
+        std::vector<FinishedScore> *singleplayer_scores = &((*m_db->getScores())[beatmap_md5]);
 
         auto cv_sortingtype = convar->getConVarByName("osu_songbrowser_scores_sortingtype");
 
         bool is_online = cv_sortingtype->getString() == UString("Online Leaderboard");
 
         if(is_online) {
@@ -1493,7 +1491,7 @@ std::vector<SCORE_ENTRY> OsuHUD::getCurrentScores() {
 
             scoreEntry.combo = score.comboMax;
 
             scoreEntry.score = score.score;
 
             scoreEntry.accuracy =
 
-                OsuScore::calculateAccuracy(score.num300s, score.num100s, score.num50s, score.numMisses);
 
+                LiveScore::calculateAccuracy(score.num300s, score.num100s, score.num50s, score.numMisses);
 
             scoreEntry.dead = false;
 
             scoreEntry.highlight = false;
 
             scores.push_back(std::move(scoreEntry));
@@ -1536,10 +1534,10 @@ std::vector<SCORE_ENTRY> OsuHUD::getCurrentScores() {
 
     return scores;
 
 }
 
 
 
-void OsuHUD::resetScoreboard() {
 
-    OsuBeatmap *beatmap = m_osu->getSelectedBeatmap();
 
+void HUD::resetScoreboard() {
 
+    Beatmap *beatmap = m_osu->getSelectedBeatmap();
 
     if(beatmap == nullptr) return;
 
-    OsuDatabaseBeatmap *diff2 = beatmap->getSelectedDifficulty2();
 
+    DatabaseBeatmap *diff2 = beatmap->getSelectedDifficulty2();
 
     if(diff2 == nullptr) return;
 
 
 
     beatmap_md5 = diff2->getMD5Hash();
@@ -1553,7 +1551,7 @@ void OsuHUD::resetScoreboard() {
 
     auto scores = getCurrentScores();
 
     int i = 0;
 
     for(auto score : scores) {
 
-        auto slot = new OsuScoreboardSlot(score, i);
 
+        auto slot = new ScoreboardSlot(score, i);
 
         if(score.entry_id == player_entry_id) {
 
             player_slot = slot;
 
         }
@@ -1564,10 +1562,10 @@ void OsuHUD::resetScoreboard() {
 
     updateScoreboard(false);
 
 }
 
 
 
-void OsuHUD::updateScoreboard(bool animate) {
 
-    OsuBeatmap *beatmap = m_osu->getSelectedBeatmap();
 
+void HUD::updateScoreboard(bool animate) {
 
+    Beatmap *beatmap = m_osu->getSelectedBeatmap();
 
     if(beatmap == nullptr) return;
 
-    OsuDatabaseBeatmap *diff2 = beatmap->getSelectedDifficulty2();
 
+    DatabaseBeatmap *diff2 = beatmap->getSelectedDifficulty2();
 
     if(diff2 == nullptr) return;
 
 
 
     if(!convar->getConVarByName("scoreboard_animations")->getBool()) {
@@ -1598,13 +1596,13 @@ void OsuHUD::updateScoreboard(bool animate) {
 
     }
 
 }
 
 
 
-void OsuHUD::drawFancyScoreboard(Graphics *g) {
 
+void HUD::drawFancyScoreboard(Graphics *g) {
 
     for(auto slot : slots) {
 
         slot->draw(g);
 
     }
 
 }
 
 
 
-void OsuHUD::drawContinue(Graphics *g, Vector2 cursor, float hitcircleDiameter) {
 
+void HUD::drawContinue(Graphics *g, Vector2 cursor, float hitcircleDiameter) {
 
     Image *unpause = m_osu->getSkin()->getUnpause();
 
     const float unpauseScale = Osu::getImageScale(m_osu, unpause, 80);
 
 
@@ -1651,18 +1649,18 @@ void OsuHUD::drawContinue(Graphics *g, Vector2 cursor, float hitcircleDiameter)
 
     g->popTransform();
 
 }
 
 
 
-void OsuHUD::drawHitErrorBar(Graphics *g, OsuBeatmap *beatmap) {
 
+void HUD::drawHitErrorBar(Graphics *g, Beatmap *beatmap) {
 
     if(osu_draw_hud.getBool() || !osu_hud_shift_tab_toggles_everything.getBool()) {
 
         if(osu_draw_hiterrorbar.getBool() &&
 
            (!beatmap->isSpinnerActive() || !osu_hud_hiterrorbar_hide_during_spinner.getBool()) && !beatmap->isLoading())
 
-            drawHitErrorBar(g, OsuGameRules::getHitWindow300(beatmap), OsuGameRules::getHitWindow100(beatmap),
 
-                            OsuGameRules::getHitWindow50(beatmap), OsuGameRules::getHitWindowMiss(beatmap),
 
+            drawHitErrorBar(g, GameRules::getHitWindow300(beatmap), GameRules::getHitWindow100(beatmap),
 
+                            GameRules::getHitWindow50(beatmap), GameRules::getHitWindowMiss(beatmap),
 
                             m_osu->getScore()->getUnstableRate());
 
     }
 
 }
 
 
 
-void OsuHUD::drawHitErrorBar(Graphics *g, float hitWindow300, float hitWindow100, float hitWindow50,
 
-                             float hitWindowMiss, int ur) {
 
+void HUD::drawHitErrorBar(Graphics *g, float hitWindow300, float hitWindow100, float hitWindow50, float hitWindowMiss,
 
+                          int ur) {
 
     const Vector2 center =
 
         Vector2(m_osu->getScreenWidth() / 2.0f,
 
                 m_osu->getScreenHeight() -
@@ -1732,8 +1730,8 @@ void OsuHUD::drawHitErrorBar(Graphics *g, float hitWindow300, float hitWindow100
 
     }
 
 }
 
 
 
-void OsuHUD::drawHitErrorBarInt(Graphics *g, float hitWindow300, float hitWindow100, float hitWindow50,
 
-                                float hitWindowMiss) {
 
+void HUD::drawHitErrorBarInt(Graphics *g, float hitWindow300, float hitWindow100, float hitWindow50,
 
+                             float hitWindowMiss) {
 
     const float alpha = osu_hud_hiterrorbar_alpha.getFloat();
 
     if(alpha <= 0.0f) return;
 
 
@@ -1777,21 +1775,21 @@ void OsuHUD::drawHitErrorBarInt(Graphics *g, float hitWindow300, float hitWindow
 
 
 
     // draw background bar with color indicators for 300s, 100s and 50s (and the miss window)
 
     if(alphaBarInt > 0) {
 
-        const bool half = OsuGameRules::osu_mod_halfwindow.getBool();
 
-        const bool halfAllow300s = OsuGameRules::osu_mod_halfwindow_allow_300s.getBool();
 
+        const bool half = GameRules::osu_mod_halfwindow.getBool();
 
+        const bool halfAllow300s = GameRules::osu_mod_halfwindow_allow_300s.getBool();
 
 
 
         if(osu_hud_hiterrorbar_showmisswindow.getBool()) {
 
             g->setColor(colorMiss);
 
             g->fillRect(center.x - size.x / 2.0f, center.y - size.y / 2.0f, size.x, size.y);
 
         }
 
 
 
-        if(!OsuGameRules::osu_mod_no100s.getBool() && !OsuGameRules::osu_mod_no50s.getBool()) {
 
+        if(!GameRules::osu_mod_no100s.getBool() && !GameRules::osu_mod_no50s.getBool()) {
 
             g->setColor(color50);
 
             g->fillRect(center.x - size.x * percent50 / 2.0f, center.y - size.y / 2.0f,
 
                         size.x * percent50 * (half ? 0.5f : 1.0f), size.y);
 
         }
 
 
 
-        if(!OsuGameRules::osu_mod_ming3012.getBool() && !OsuGameRules::osu_mod_no100s.getBool()) {
 
+        if(!GameRules::osu_mod_ming3012.getBool() && !GameRules::osu_mod_no100s.getBool()) {
 
             g->setColor(color100);
 
             g->fillRect(center.x - size.x * percent100 / 2.0f, center.y - size.y / 2.0f,
 
                         size.x * percent100 * (half ? 0.5f : 1.0f), size.y);
@@ -1806,7 +1804,7 @@ void OsuHUD::drawHitErrorBarInt(Graphics *g, float hitWindow300, float hitWindow
 
     {
 
         if(osu_hud_hiterrorbar_entry_additive.getBool()) g->setBlendMode(Graphics::BLEND_MODE::BLEND_MODE_ADDITIVE);
 
 
 
-        const bool modMing3012 = OsuGameRules::osu_mod_ming3012.getBool();
 
+        const bool modMing3012 = GameRules::osu_mod_ming3012.getBool();
 
         const float hitFadeDuration = osu_hud_hiterrorbar_entry_hit_fade_time.getFloat();
 
         const float missFadeDuration = osu_hud_hiterrorbar_entry_miss_fade_time.getFloat();
 
         for(int i = m_hiterrors.size() - 1; i >= 0; i--) {
@@ -1861,7 +1859,7 @@ void OsuHUD::drawHitErrorBarInt(Graphics *g, float hitWindow300, float hitWindow
 
     }
 
 }
 
 
 
-void OsuHUD::drawHitErrorBarInt2(Graphics *g, Vector2 center, int ur) {
 
+void HUD::drawHitErrorBarInt2(Graphics *g, Vector2 center, int ur) {
 
     const float alpha = osu_hud_hiterrorbar_alpha.getFloat() * osu_hud_hiterrorbar_ur_alpha.getFloat();
 
     if(alpha <= 0.0f) return;
 
 
@@ -1907,7 +1905,7 @@ void OsuHUD::drawHitErrorBarInt2(Graphics *g, Vector2 center, int ur) {
 
     }
 
 }
 
 
 
-void OsuHUD::drawProgressBar(Graphics *g, float percent, bool waiting) {
 
+void HUD::drawProgressBar(Graphics *g, float percent, bool waiting) {
 
     if(!osu_draw_accuracy.getBool()) m_fAccuracyXOffset = m_osu->getScreenWidth();
 
 
 
     const float num_segments = 15 * 8;
@@ -1984,9 +1982,9 @@ void OsuHUD::drawProgressBar(Graphics *g, float percent, bool waiting) {
 
     g->popTransform();
 
 }
 
 
 
-void OsuHUD::drawStatistics(Graphics *g, int misses, int sliderbreaks, int maxPossibleCombo, float liveStars,
 
-                            float totalStars, int bpm, float ar, float cs, float od, float hp, int nps, int nd, int ur,
 
-                            float pp, float ppfc, float hitWindow300, int hitdeltaMin, int hitdeltaMax) {
 
+void HUD::drawStatistics(Graphics *g, int misses, int sliderbreaks, int maxPossibleCombo, float liveStars,
 
+                         float totalStars, int bpm, float ar, float cs, float od, float hp, int nps, int nd, int ur,
 
+                         float pp, float ppfc, float hitWindow300, int hitdeltaMin, int hitdeltaMax) {
 
     g->pushTransform();
 
     {
 
         const float offsetScale = Osu::getImageScale(m_osu, Vector2(1.0f, 1.0f), 1.0f);
@@ -2115,7 +2113,7 @@ void OsuHUD::drawStatistics(Graphics *g, int misses, int sliderbreaks, int maxPo
 
     g->popTransform();
 
 }
 
 
 
-void OsuHUD::drawStatisticText(Graphics *g, const UString text) {
 
+void HUD::drawStatisticText(Graphics *g, const UString text) {
 
     if(text.length() < 1) return;
 
 
 
     g->pushTransform();
@@ -2131,7 +2129,7 @@ void OsuHUD::drawStatisticText(Graphics *g, const UString text) {
 
     g->popTransform();
 
 }
 
 
 
-void OsuHUD::drawTargetHeatmap(Graphics *g, float hitcircleDiameter) {
 
+void HUD::drawTargetHeatmap(Graphics *g, float hitcircleDiameter) {
 
     const Vector2 center = Vector2((int)(hitcircleDiameter / 2.0f + 5.0f), (int)(hitcircleDiameter / 2.0f + 5.0f));
 
 
 
     const int brightnessSub = 0;
@@ -2140,7 +2138,7 @@ void OsuHUD::drawTargetHeatmap(Graphics *g, float hitcircleDiameter) {
 
     const Color color50 = COLOR(255, 255 - brightnessSub, 165 - brightnessSub, 0);
 
     const Color colorMiss = COLOR(255, 255 - brightnessSub, 0, 0);
 
 
 
-    OsuCircle::drawCircle(g, m_osu->getSkin(), center, hitcircleDiameter, COLOR(255, 50, 50, 50));
 
+    Circle::drawCircle(g, m_osu->getSkin(), center, hitcircleDiameter, COLOR(255, 50, 50, 50));
 
 
 
     const int size = hitcircleDiameter * 0.075f;
 
     for(int i = 0; i < m_targets.size(); i++) {
@@ -2200,9 +2198,9 @@ void OsuHUD::drawTargetHeatmap(Graphics *g, float hitcircleDiameter) {
 
     }
 
 }
 
 
 
-void OsuHUD::drawScrubbingTimeline(Graphics *g, unsigned long beatmapTime, unsigned long beatmapLength,
 
-                                   unsigned long beatmapLengthPlayable, unsigned long beatmapStartTimePlayable,
 
-                                   float beatmapPercentFinishedPlayable, const std::vector<BREAK> &breaks) {
 
+void HUD::drawScrubbingTimeline(Graphics *g, unsigned long beatmapTime, unsigned long beatmapLength,
 
+                                unsigned long beatmapLengthPlayable, unsigned long beatmapStartTimePlayable,
 
+                                float beatmapPercentFinishedPlayable, const std::vector<BREAK> &breaks) {
 
     static Vector2 last_cursor_pos = engine->getMouse()->getPos();
 
     static double last_cursor_movement = engine->getTime();
 
     Vector2 new_cursor_pos = engine->getMouse()->getPos();
@@ -2500,9 +2498,9 @@ void OsuHUD::drawScrubbingTimeline(Graphics *g, unsigned long beatmapTime, unsig
 
     g->popTransform();
 
 }
 
 
 
-void OsuHUD::drawInputOverlay(Graphics *g, int numK1, int numK2, int numM1, int numM2) {
 
-    OsuSkinImage *inputoverlayBackground = m_osu->getSkin()->getInputoverlayBackground();
 
-    OsuSkinImage *inputoverlayKey = m_osu->getSkin()->getInputoverlayKey();
 
+void HUD::drawInputOverlay(Graphics *g, int numK1, int numK2, int numM1, int numM2) {
 
+    SkinImage *inputoverlayBackground = m_osu->getSkin()->getInputoverlayBackground();
 
+    SkinImage *inputoverlayKey = m_osu->getSkin()->getInputoverlayKey();
 
 
 
     const float scale = osu_hud_scale.getFloat() * osu_hud_inputoverlay_scale.getFloat();  // global scaler
 
     const float oScale = inputoverlayBackground->getResolutionScale() *
@@ -2608,7 +2606,7 @@ void OsuHUD::drawInputOverlay(Graphics *g, int numK1, int numK2, int numM1, int
 
     }
 
 }
 
 
 
-float OsuHUD::getCursorScaleFactor() {
 
+float HUD::getCursorScaleFactor() {
 
     // FUCK OSU hardcoded piece of shit code
 
     const float spriteRes = 768.0f;
 
 
@@ -2619,16 +2617,16 @@ float OsuHUD::getCursorScaleFactor() {
 
     return ((float)m_osu->getScreenHeight() / spriteRes) * mapScale;
 
 }
 
 
 
-float OsuHUD::getCursorTrailScaleFactor() {
 
+float HUD::getCursorTrailScaleFactor() {
 
     return getCursorScaleFactor() * (m_osu->getSkin()->isCursorTrail2x() ? 0.5f : 1.0f);
 
 }
 
 
 
-float OsuHUD::getScoreScale() {
 
+float HUD::getScoreScale() {
 
     return m_osu->getImageScale(m_osu, m_osu->getSkin()->getScore0(), 13 * 1.5f) * osu_hud_scale.getFloat() *
 
            osu_hud_score_scale.getFloat();
 
 }
 
 
 
-void OsuHUD::animateCombo() {
 
+void HUD::animateCombo() {
 
     m_fComboAnim1 = 0.0f;
 
     m_fComboAnim2 = 1.0f;
 
 
@@ -2636,7 +2634,7 @@ void OsuHUD::animateCombo() {
 
     anim->moveQuadOut(&m_fComboAnim2, 0.0f, osu_combo_anim2_duration.getFloat(), 0.0f, true);
 
 }
 
 
 
-void OsuHUD::addHitError(long delta, bool miss, bool misaim) {
 
+void HUD::addHitError(long delta, bool miss, bool misaim) {
 
     // add entry
 
     {
 
         HITERROR h;
@@ -2661,7 +2659,7 @@ void OsuHUD::addHitError(long delta, bool miss, bool misaim) {
 
     if(m_hiterrors.size() > osu_hud_hiterrorbar_max_entries.getInt()) m_hiterrors.erase(m_hiterrors.begin());
 
 }
 
 
 
-void OsuHUD::addTarget(float delta, float angle) {
 
+void HUD::addTarget(float delta, float angle) {
 
     TARGET t;
 
     t.time = engine->getTime() + 3.5f;
 
     t.delta = delta;
@@ -2670,7 +2668,7 @@ void OsuHUD::addTarget(float delta, float angle) {
 
     m_targets.push_back(t);
 
 }
 
 
 
-void OsuHUD::animateInputoverlay(int key, bool down) {
 
+void HUD::animateInputoverlay(int key, bool down) {
 
     if(!osu_draw_inputoverlay.getBool() || (!osu_draw_hud.getBool() && osu_hud_shift_tab_toggles_everything.getBool()))
 
         return;
 
 
@@ -2720,7 +2718,7 @@ void OsuHUD::animateInputoverlay(int key, bool down) {
 
     }
 
 }
 
 
 
-void OsuHUD::addCursorRipple(Vector2 pos) {
 
+void HUD::addCursorRipple(Vector2 pos) {
 
     if(!osu_draw_cursor_ripples.getBool()) return;
 
 
 
     CURSORRIPPLE ripple;
@@ -2730,28 +2728,28 @@ void OsuHUD::addCursorRipple(Vector2 pos) {
 
     m_cursorRipples.push_back(ripple);
 
 }
 
 
 
-void OsuHUD::animateCursorExpand() {
 
+void HUD::animateCursorExpand() {
 
     m_fCursorExpandAnim = 1.0f;
 
     anim->moveQuadOut(&m_fCursorExpandAnim, osu_cursor_expand_scale_multiplier.getFloat(),
 
                       osu_cursor_expand_duration.getFloat(), 0.0f, true);
 
 }
 
 
 
-void OsuHUD::animateCursorShrink() {
 
+void HUD::animateCursorShrink() {
 
     anim->moveQuadOut(&m_fCursorExpandAnim, 1.0f, osu_cursor_expand_duration.getFloat(), 0.0f, true);
 
 }
 
 
 
-void OsuHUD::animateKiBulge() {
 
+void HUD::animateKiBulge() {
 
     m_fKiScaleAnim = 1.2f;
 
     anim->moveLinear(&m_fKiScaleAnim, 0.8f, 0.150f, true);
 
 }
 
 
 
-void OsuHUD::animateKiExplode() {
 
+void HUD::animateKiExplode() {
 
     // TODO: scale + fadeout of extra ki image additive, duration = 0.120, quad out:
 
     // if additive: fade from 0.5 alpha to 0, scale from 1.0 to 2.0
 
     // if not additive: fade from 1.0 alpha to 0, scale from 1.0 to 1.6
 
 }
 
 
 
-void OsuHUD::addCursorTrailPosition(std::vector<CURSORTRAIL> &trail, Vector2 pos, bool empty) {
 
+void HUD::addCursorTrailPosition(std::vector<CURSORTRAIL> &trail, Vector2 pos, bool empty) {
 
     if(empty) return;
 
     if(pos.x < -m_osu->getScreenWidth() || pos.x > m_osu->getScreenWidth() * 2 || pos.y < -m_osu->getScreenHeight() ||
 
        pos.y > m_osu->getScreenHeight() * 2)
@@ -2819,9 +2817,9 @@ void OsuHUD::addCursorTrailPosition(std::vector<CURSORTRAIL> &trail, Vector2 pos
 
     }
 
 }
 
 
 
-void OsuHUD::resetHitErrorBar() { m_hiterrors.clear(); }
 
+void HUD::resetHitErrorBar() { m_hiterrors.clear(); }
 
 
 
-McRect OsuHUD::getSkipClickRect() {
 
+McRect HUD::getSkipClickRect() {
 
     const float skipScale = osu_hud_scale.getFloat();
 
     return McRect(m_osu->getScreenWidth() - m_osu->getSkin()->getPlaySkip()->getSize().x * skipScale,
 
                   m_osu->getScreenHeight() - m_osu->getSkin()->getPlaySkip()->getSize().y * skipScale,
--- a/src/App/Osu/OsuHUD.h
+++ b/src/App/Osu/OsuHUD.h
@@ -11,10 +11,9 @@
 
 #include "OsuScreen.h"
 
 
 
 class Osu;
 
-class OsuUIAvatar;
 
-class OsuScore;
 
-class OsuBeatmap;
 
-struct OsuScoreboardSlot;
 
+class UIAvatar;
 
+class Beatmap;
 
+struct ScoreboardSlot;
 
 
 
 class McFont;
 
 class ConVar;
@@ -26,8 +25,8 @@ class CBaseUIContainer;
 
 
 
 struct SCORE_ENTRY {
 
     UString name;
 
-    int32_t entry_id = 0;
 
-    uint32_t player_id = 0;
 
+    i32 entry_id = 0;
 
+    u32 player_id = 0;
 
 
 
     int combo;
 
     unsigned long long score;
@@ -36,10 +35,10 @@ struct SCORE_ENTRY {
 
     bool highlight;
 
 };
 
 
 
-class OsuHUD : public OsuScreen {
 
+class HUD : public OsuScreen {
 
    public:
 
-    OsuHUD(Osu *osu);
 
-    virtual ~OsuHUD();
 
+    HUD(Osu *osu);
 
+    virtual ~HUD();
 
 
 
     virtual void draw(Graphics *g);
 
     virtual void mouse_update(bool *propagate_clicks);
@@ -53,7 +52,7 @@ class OsuHUD : public OsuScreen {
 
         bool secondTrail = false);  // NOTE: only use if drawCursor() with updateAndDrawTrail = false (FPoSu)
 
     void drawCursorRipples(Graphics *g);
 
     void drawFps(Graphics *g) { drawFps(g, m_tempFont, m_fCurFps); }
 
-    void drawHitErrorBar(Graphics *g, OsuBeatmap *beatmap);
 
+    void drawHitErrorBar(Graphics *g, Beatmap *beatmap);
 
     void drawPlayfieldBorder(Graphics *g, Vector2 playfieldCenter, Vector2 playfieldSize, float hitcircleDiameter);
 
     void drawPlayfieldBorder(Graphics *g, Vector2 playfieldCenter, Vector2 playfieldSize, float hitcircleDiameter,
 
                              float borderSize);
@@ -61,8 +60,8 @@ class OsuHUD : public OsuScreen {
 
     void drawBeatmapImportSpinner(Graphics *g);
 
     void drawScoreNumber(Graphics *g, unsigned long long number, float scale = 1.0f, bool drawLeadingZeroes = false);
 
     void drawComboNumber(Graphics *g, unsigned long long number, float scale = 1.0f, bool drawLeadingZeroes = false);
 
-    void drawComboSimple(Graphics *g, int combo, float scale = 1.0f);          // used by OsuRankingScreen
 
-    void drawAccuracySimple(Graphics *g, float accuracy, float scale = 1.0f);  // used by OsuRankingScreen
 
+    void drawComboSimple(Graphics *g, int combo, float scale = 1.0f);          // used by RankingScreen
 
+    void drawAccuracySimple(Graphics *g, float accuracy, float scale = 1.0f);  // used by RankingScreen
 
     void drawWarningArrow(Graphics *g, Vector2 pos, bool flipVertically, bool originLeft = true);
 
 
 
     std::vector<SCORE_ENTRY> getCurrentScores();
@@ -94,8 +93,8 @@ class OsuHUD : public OsuScreen {
 
     // ILLEGAL:
 
     inline float getScoreBarBreakAnim() const { return m_fScoreBarBreakAnim; }
 
 
 
-    OsuScoreboardSlot *player_slot = nullptr;
 
-    std::vector<OsuScoreboardSlot *> slots;
 
+    ScoreboardSlot *player_slot = nullptr;
 
+    std::vector<ScoreboardSlot *> slots;
 
     MD5Hash beatmap_md5;
 
 
 
    private:
@@ -222,7 +221,7 @@ class OsuHUD : public OsuScreen {
 
     // target heatmap
 
     std::vector<TARGET> m_targets;
 
 
 
-    std::vector<OsuUIAvatar *> m_avatars;
 
+    std::vector<UIAvatar *> m_avatars;
 
 
 
     // health
 
     double m_fHealth;
--- a/src/App/Osu/OsuHitObject.cpp
+++ b/src/App/Osu/OsuHitObject.cpp
@@ -5,18 +5,18 @@
 
 // $NoKeywords: $hitobj
 
 //===============================================================================//
 
 
 
-#include "OsuHitObject.h"
 
+#include "HitObject.h"
 
 
 
 #include "AnimationHandler.h"
 
+#include "Beatmap.h"
 
 #include "ConVar.h"
 
 #include "Engine.h"
 
+#include "GameRules.h"
 
+#include "HUD.h"
 
 #include "Osu.h"
 
-#include "OsuBeatmap.h"
 
-#include "OsuGameRules.h"
 
-#include "OsuHUD.h"
 
-#include "OsuSkin.h"
 
-#include "OsuSkinImage.h"
 
 #include "ResourceManager.h"
 
+#include "Skin.h"
 
+#include "SkinImage.h"
 
 
 
 ConVar osu_hitresult_draw_300s("osu_hitresult_draw_300s", false, FCVAR_NONE);
 
 
@@ -90,23 +90,22 @@ ConVar osu_relax_offset(
 
     "osu_relax_offset", 0, FCVAR_NONE,
 
     "osu!relax always hits -12 ms too early, so set this to -12 (note the negative) if you want it to be the same");
 
 
 
-ConVar *OsuHitObject::m_osu_approach_scale_multiplier_ref = &osu_approach_scale_multiplier;
 
-ConVar *OsuHitObject::m_osu_timingpoints_force = &osu_timingpoints_force;
 
-ConVar *OsuHitObject::m_osu_relax_offset_ref = &osu_relax_offset;
 
+ConVar *HitObject::m_osu_approach_scale_multiplier_ref = &osu_approach_scale_multiplier;
 
+ConVar *HitObject::m_osu_timingpoints_force = &osu_timingpoints_force;
 
+ConVar *HitObject::m_osu_relax_offset_ref = &osu_relax_offset;
 
 
 
-ConVar *OsuHitObject::m_osu_mod_mafham_ref = NULL;
 
+ConVar *HitObject::m_osu_mod_mafham_ref = NULL;
 
 
 
-unsigned long long OsuHitObject::sortHackCounter = 0;
 
+unsigned long long HitObject::sortHackCounter = 0;
 
 
 
-void OsuHitObject::drawHitResult(Graphics *g, OsuBeatmap *beatmap, Vector2 rawPos, OsuScore::HIT result,
 
-                                 float animPercentInv, float hitDeltaRangePercent) {
 
+void HitObject::drawHitResult(Graphics *g, Beatmap *beatmap, Vector2 rawPos, LiveScore::HIT result,
 
+                              float animPercentInv, float hitDeltaRangePercent) {
 
     drawHitResult(g, beatmap->getSkin(), beatmap->getHitcircleDiameter(), beatmap->getRawHitcircleDiameter(), rawPos,
 
                   result, animPercentInv, hitDeltaRangePercent);
 
 }
 
 
 
-void OsuHitObject::drawHitResult(Graphics *g, OsuSkin *skin, float hitcircleDiameter, float rawHitcircleDiameter,
 
-                                 Vector2 rawPos, OsuScore::HIT result, float animPercentInv,
 
-                                 float hitDeltaRangePercent) {
 
+void HitObject::drawHitResult(Graphics *g, Skin *skin, float hitcircleDiameter, float rawHitcircleDiameter,
 
+                              Vector2 rawPos, LiveScore::HIT result, float animPercentInv, float hitDeltaRangePercent) {
 
     if(animPercentInv <= 0.0f) return;
 
 
 
     const float animPercent = 1.0f - animPercentInv;
@@ -115,7 +114,7 @@ void OsuHitObject::drawHitResult(Graphics *g, OsuSkin *skin, float hitcircleDiam
 
 
 
     // determine color/transparency
 
     {
 
-        if(!osu_hitresult_delta_colorize.getBool() || result == OsuScore::HIT::HIT_MISS)
 
+        if(!osu_hitresult_delta_colorize.getBool() || result == LiveScore::HIT::HIT_MISS)
 
             g->setColor(0xffffffff);
 
         else {
 
             // NOTE: hitDeltaRangePercent is within -1.0f to 1.0f
@@ -168,46 +167,46 @@ void OsuHitObject::drawHitResult(Graphics *g, OsuSkin *skin, float hitcircleDiam
 
         bool hasParticle = true;
 
         float hitImageScale = 1.0f;
 
         switch(result) {
 
-            case OsuScore::HIT::HIT_MISS:
 
+            case LiveScore::HIT::HIT_MISS:
 
                 doScaleOrRotateAnim = skin->getHit0()->getNumImages() == 1;
 
                 hitImageScale = (rawHitcircleDiameter / skin->getHit0()->getSizeBaseRaw().x) * osuCoordScaleMultiplier;
 
                 break;
 
 
 
-            case OsuScore::HIT::HIT_50:
 
+            case LiveScore::HIT::HIT_50:
 
                 doScaleOrRotateAnim = skin->getHit50()->getNumImages() == 1;
 
                 hasParticle = skin->getParticle50() != skin->getMissingTexture();
 
                 hitImageScale = (rawHitcircleDiameter / skin->getHit50()->getSizeBaseRaw().x) * osuCoordScaleMultiplier;
 
                 break;
 
 
 
-            case OsuScore::HIT::HIT_100:
 
+            case LiveScore::HIT::HIT_100:
 
                 doScaleOrRotateAnim = skin->getHit100()->getNumImages() == 1;
 
                 hasParticle = skin->getParticle100() != skin->getMissingTexture();
 
                 hitImageScale =
 
                     (rawHitcircleDiameter / skin->getHit100()->getSizeBaseRaw().x) * osuCoordScaleMultiplier;
 
                 break;
 
 
 
-            case OsuScore::HIT::HIT_300:
 
+            case LiveScore::HIT::HIT_300:
 
                 doScaleOrRotateAnim = skin->getHit300()->getNumImages() == 1;
 
                 hasParticle = skin->getParticle300() != skin->getMissingTexture();
 
                 hitImageScale =
 
                     (rawHitcircleDiameter / skin->getHit300()->getSizeBaseRaw().x) * osuCoordScaleMultiplier;
 
                 break;
 
 
 
-            case OsuScore::HIT::HIT_100K:
 
+            case LiveScore::HIT::HIT_100K:
 
                 doScaleOrRotateAnim = skin->getHit100k()->getNumImages() == 1;
 
                 hasParticle = skin->getParticle100() != skin->getMissingTexture();
 
                 hitImageScale =
 
                     (rawHitcircleDiameter / skin->getHit100k()->getSizeBaseRaw().x) * osuCoordScaleMultiplier;
 
                 break;
 
 
 
-            case OsuScore::HIT::HIT_300K:
 
+            case LiveScore::HIT::HIT_300K:
 
                 doScaleOrRotateAnim = skin->getHit300k()->getNumImages() == 1;
 
                 hasParticle = skin->getParticle300() != skin->getMissingTexture();
 
                 hitImageScale =
 
                     (rawHitcircleDiameter / skin->getHit300k()->getSizeBaseRaw().x) * osuCoordScaleMultiplier;
 
                 break;
 
 
 
-            case OsuScore::HIT::HIT_300G:
 
+            case LiveScore::HIT::HIT_300G:
 
                 doScaleOrRotateAnim = skin->getHit300g()->getNumImages() == 1;
 
                 hasParticle = skin->getParticle300() != skin->getMissingTexture();
 
                 hitImageScale =
@@ -239,7 +238,7 @@ void OsuHitObject::drawHitResult(Graphics *g, OsuSkin *skin, float hitcircleDiam
 
         }
 
 
 
         switch(result) {
 
-            case OsuScore::HIT::HIT_MISS: {
 
+            case LiveScore::HIT::HIT_MISS: {
 
                 // special case: animated misses don't move down, and skins with version <= 1 also don't move down
 
                 Vector2 downAnim;
 
                 if(skin->getHit0()->getNumImages() < 2 && skin->getVersion() > 1.0f)
@@ -259,17 +258,17 @@ void OsuHitObject::drawHitResult(Graphics *g, OsuSkin *skin, float hitcircleDiam
 
                     (doScaleOrRotateAnim ? missScale : 1.0f) * hitImageScale * osu_hitresult_scale.getFloat());
 
             } break;
 
 
 
-            case OsuScore::HIT::HIT_50:
 
+            case LiveScore::HIT::HIT_50:
 
                 skin->getHit50()->drawRaw(
 
                     g, rawPos, (doScaleOrRotateAnim ? scale : 1.0f) * hitImageScale * osu_hitresult_scale.getFloat());
 
                 break;
 
 
 
-            case OsuScore::HIT::HIT_100:
 
+            case LiveScore::HIT::HIT_100:
 
                 skin->getHit100()->drawRaw(
 
                     g, rawPos, (doScaleOrRotateAnim ? scale : 1.0f) * hitImageScale * osu_hitresult_scale.getFloat());
 
                 break;
 
 
 
-            case OsuScore::HIT::HIT_300:
 
+            case LiveScore::HIT::HIT_300:
 
                 if(osu_hitresult_draw_300s.getBool()) {
 
                     skin->getHit300()->drawRaw(
 
                         g, rawPos,
@@ -277,12 +276,12 @@ void OsuHitObject::drawHitResult(Graphics *g, OsuSkin *skin, float hitcircleDiam
 
                 }
 
                 break;
 
 
 
-            case OsuScore::HIT::HIT_100K:
 
+            case LiveScore::HIT::HIT_100K:
 
                 skin->getHit100k()->drawRaw(
 
                     g, rawPos, (doScaleOrRotateAnim ? scale : 1.0f) * hitImageScale * osu_hitresult_scale.getFloat());
 
                 break;
 
 
 
-            case OsuScore::HIT::HIT_300K:
 
+            case LiveScore::HIT::HIT_300K:
 
                 if(osu_hitresult_draw_300s.getBool()) {
 
                     skin->getHit300k()->drawRaw(
 
                         g, rawPos,
@@ -290,7 +289,7 @@ void OsuHitObject::drawHitResult(Graphics *g, OsuSkin *skin, float hitcircleDiam
 
                 }
 
                 break;
 
 
 
-            case OsuScore::HIT::HIT_300G:
 
+            case LiveScore::HIT::HIT_300G:
 
                 if(osu_hitresult_draw_300s.getBool()) {
 
                     skin->getHit300g()->drawRaw(
 
                         g, rawPos,
@@ -302,8 +301,8 @@ void OsuHitObject::drawHitResult(Graphics *g, OsuSkin *skin, float hitcircleDiam
 
     g->popTransform();
 
 }
 
 
 
-OsuHitObject::OsuHitObject(long time, int sampleType, int comboNumber, bool isEndOfCombo, int colorCounter,
 
-                           int colorOffset, OsuBeatmap *beatmap) {
 
+HitObject::HitObject(long time, int sampleType, int comboNumber, bool isEndOfCombo, int colorCounter, int colorOffset,
 
+                     Beatmap *beatmap) {
 
     m_iTime = time;
 
     m_iSampleType = sampleType;
 
     m_iComboNumber = comboNumber;
@@ -341,18 +340,18 @@ OsuHitObject::OsuHitObject(long time, int sampleType, int comboNumber, bool isEn
 
     m_iSortHack = sortHackCounter++;
 
 }
 
 
 
-void OsuHitObject::draw2(Graphics *g) {
 
+void HitObject::draw2(Graphics *g) {
 
     drawHitResultAnim(g, m_hitresultanim1);
 
     drawHitResultAnim(g, m_hitresultanim2);
 
 }
 
 
 
-void OsuHitObject::drawHitResultAnim(Graphics *g, const HITRESULTANIM &hitresultanim) {
 
+void HitObject::drawHitResultAnim(Graphics *g, const HITRESULTANIM &hitresultanim) {
 
     if((hitresultanim.time - osu_hitresult_duration.getFloat()) <
 
            engine->getTime()  // NOTE: this is written like that on purpose, don't change it ("future" results can be
 
                               // scheduled with it, e.g. for slider end)
 
        && (hitresultanim.time + osu_hitresult_duration_max.getFloat() *
 
                                     (1.0f / m_beatmap->getOsu()->getAnimationSpeedMultiplier())) > engine->getTime()) {
 
-        OsuSkin *skin = m_beatmap->getSkin();
 
+        Skin *skin = m_beatmap->getSkin();
 
         {
 
             const long skinAnimationTimeStartOffset =
 
                 m_iTime + (hitresultanim.addObjectDurationToSkinAnimationTimeStartOffset ? m_iObjectDuration : 0) +
@@ -378,22 +377,22 @@ void OsuHitObject::drawHitResultAnim(Graphics *g, const HITRESULTANIM &hitresult
 
                 (((engine->getTime() - hitresultanim.time) * m_beatmap->getOsu()->getAnimationSpeedMultiplier()) /
 
                  osu_hitresult_duration.getFloat());
 
 
 
-            drawHitResult(
 
-                g, m_beatmap, m_beatmap->osuCoords2Pixels(hitresultanim.rawPos), hitresultanim.result, animPercentInv,
 
-                clamp<float>((float)hitresultanim.delta / OsuGameRules::getHitWindow50(m_beatmap), -1.0f, 1.0f));
 
+            drawHitResult(g, m_beatmap, m_beatmap->osuCoords2Pixels(hitresultanim.rawPos), hitresultanim.result,
 
+                          animPercentInv,
 
+                          clamp<float>((float)hitresultanim.delta / GameRules::getHitWindow50(m_beatmap), -1.0f, 1.0f));
 
         }
 
     }
 
 }
 
 
 
-void OsuHitObject::update(long curPos) {
 
+void HitObject::update(long curPos) {
 
     m_fAlphaForApproachCircle = 0.0f;
 
     m_fHittableDimRGBColorMultiplierPercent = 1.0f;
 
 
 
     double animationSpeedMultipler =
 
         m_beatmap->getOsu()->getSpeedMultiplier() / m_beatmap->getOsu()->getAnimationSpeedMultiplier();
 
-    m_iApproachTime = (m_bUseFadeInTimeAsApproachTime ? (OsuGameRules::getFadeInTime() * animationSpeedMultipler)
 
-                                                      : (long)OsuGameRules::getApproachTime(m_beatmap));
 
-    m_iFadeInTime = OsuGameRules::getFadeInTime() * animationSpeedMultipler;
 
+    m_iApproachTime = (m_bUseFadeInTimeAsApproachTime ? (GameRules::getFadeInTime() * animationSpeedMultipler)
 
+                                                      : (long)GameRules::getApproachTime(m_beatmap));
 
+    m_iFadeInTime = GameRules::getFadeInTime() * animationSpeedMultipler;
 
 
 
     m_iDelta = m_iTime - curPos;
 
 
@@ -496,16 +495,16 @@ void OsuHitObject::update(long curPos) {
 
             0.0f, 1.0f);
 
 
 
         // hittable dim, see https://github.com/ppy/osu/pull/20572
 
-        if(OsuGameRules::osu_hitobject_hittable_dim.getBool() &&
 
+        if(GameRules::osu_hitobject_hittable_dim.getBool() &&
 
            (!m_osu_mod_mafham_ref->getBool() || !osu_mod_mafham_ignore_hittable_dim.getBool())) {
 
-            const long hittableDimFadeStart = m_iTime - (long)OsuGameRules::getHitWindowMiss(m_beatmap);
 
+            const long hittableDimFadeStart = m_iTime - (long)GameRules::getHitWindowMiss(m_beatmap);
 
             const long hittableDimFadeEnd =
 
                 hittableDimFadeStart +
 
-                (long)OsuGameRules::osu_hitobject_hittable_dim_duration
 
+                (long)GameRules::osu_hitobject_hittable_dim_duration
 
                     .getInt();  // yes, this means the un-dim animation cuts into the already clickable range
 
 
 
             m_fHittableDimRGBColorMultiplierPercent =
 
-                lerp<float>(OsuGameRules::osu_hitobject_hittable_dim_start_percent.getFloat(), 1.0f,
 
+                lerp<float>(GameRules::osu_hitobject_hittable_dim_start_percent.getFloat(), 1.0f,
 
                             clamp<float>(1.0f - (float)(hittableDimFadeEnd - curPos) /
 
                                                     (float)(hittableDimFadeEnd - hittableDimFadeStart),
 
                                          0.0f, 1.0f));
@@ -518,32 +517,32 @@ void OsuHitObject::update(long curPos) {
 
     }
 
 }
 
 
 
-void OsuHitObject::addHitResult(OsuScore::HIT result, long delta, bool isEndOfCombo, Vector2 posRaw, float targetDelta,
 
-                                float targetAngle, bool ignoreOnHitErrorBar, bool ignoreCombo, bool ignoreHealth,
 
-                                bool addObjectDurationToSkinAnimationTimeStartOffset) {
 
-    if(m_beatmap->getOsu()->getModTarget() && result != OsuScore::HIT::HIT_MISS && targetDelta >= 0.0f) {
 
+void HitObject::addHitResult(LiveScore::HIT result, long delta, bool isEndOfCombo, Vector2 posRaw, float targetDelta,
 
+                             float targetAngle, bool ignoreOnHitErrorBar, bool ignoreCombo, bool ignoreHealth,
 
+                             bool addObjectDurationToSkinAnimationTimeStartOffset) {
 
+    if(m_beatmap->getOsu()->getModTarget() && result != LiveScore::HIT::HIT_MISS && targetDelta >= 0.0f) {
 
         const float p300 = osu_mod_target_300_percent.getFloat();
 
         const float p100 = osu_mod_target_100_percent.getFloat();
 
         const float p50 = osu_mod_target_50_percent.getFloat();
 
 
 
-        if(targetDelta < p300 && (result == OsuScore::HIT::HIT_300 || result == OsuScore::HIT::HIT_100))
 
-            result = OsuScore::HIT::HIT_300;
 
+        if(targetDelta < p300 && (result == LiveScore::HIT::HIT_300 || result == LiveScore::HIT::HIT_100))
 
+            result = LiveScore::HIT::HIT_300;
 
         else if(targetDelta < p100)
 
-            result = OsuScore::HIT::HIT_100;
 
+            result = LiveScore::HIT::HIT_100;
 
         else if(targetDelta < p50)
 
-            result = OsuScore::HIT::HIT_50;
 
+            result = LiveScore::HIT::HIT_50;
 
         else
 
-            result = OsuScore::HIT::HIT_MISS;
 
+            result = LiveScore::HIT::HIT_MISS;
 
 
 
         m_beatmap->getOsu()->getHUD()->addTarget(targetDelta, targetAngle);
 
     }
 
 
 
-    const OsuScore::HIT returnedHit = m_beatmap->addHitResult(this, result, delta, isEndOfCombo, ignoreOnHitErrorBar,
 
-                                                              false, ignoreCombo, false, ignoreHealth);
 
+    const LiveScore::HIT returnedHit = m_beatmap->addHitResult(this, result, delta, isEndOfCombo, ignoreOnHitErrorBar,
 
+                                                               false, ignoreCombo, false, ignoreHealth);
 
 
 
     HITRESULTANIM hitresultanim;
 
     {
 
-        hitresultanim.result = (returnedHit != OsuScore::HIT::HIT_MISS ? returnedHit : result);
 
+        hitresultanim.result = (returnedHit != LiveScore::HIT::HIT_MISS ? returnedHit : result);
 
         hitresultanim.rawPos = posRaw;
 
         hitresultanim.delta = delta;
 
         hitresultanim.time = engine->getTime();
@@ -558,7 +557,7 @@ void OsuHitObject::addHitResult(OsuScore::HIT result, long delta, bool isEndOfCo
 
         m_hitresultanim2 = hitresultanim;
 
 }
 
 
 
-void OsuHitObject::onReset(long curPos) {
 
+void HitObject::onReset(long curPos) {
 
     m_bMisAim = false;
 
     m_iAutopilotDelta = 0;
 
 
@@ -566,7 +565,7 @@ void OsuHitObject::onReset(long curPos) {
 
     m_hitresultanim2.time = -9999.0f;
 
 }
 
 
 
-float OsuHitObject::lerp3f(float a, float b, float c, float percent) {
 
+float HitObject::lerp3f(float a, float b, float c, float percent) {
 
     if(percent <= 0.5f)
 
         return lerp<float>(a, b, percent * 2.0f);
 
     else
--- a/src/App/Osu/OsuHitObject.h
+++ b/src/App/Osu/OsuHitObject.h
@@ -8,19 +8,19 @@
 
 #ifndef OSUHITOBJECT_H
 
 #define OSUHITOBJECT_H
 
 
 
-#include "OsuBeatmap.h"
 
+#include "Beatmap.h"
 
 
 
 class ConVar;
 
 
 
-class OsuModFPoSu;
 
-class OsuBeatmap;
 
+class ModFPoSu;
 
+class Beatmap;
 
 
 
-class OsuHitObject {
 
+class HitObject {
 
    public:
 
-    static void drawHitResult(Graphics *g, OsuBeatmap *beatmap, Vector2 rawPos, OsuScore::HIT result,
 
+    static void drawHitResult(Graphics *g, Beatmap *beatmap, Vector2 rawPos, LiveScore::HIT result,
 
                               float animPercentInv, float hitDeltaRangePercent);
 
-    static void drawHitResult(Graphics *g, OsuSkin *skin, float hitcircleDiameter, float rawHitcircleDiameter,
 
-                              Vector2 rawPos, OsuScore::HIT result, float animPercentInv, float hitDeltaRangePercent);
 
+    static void drawHitResult(Graphics *g, Skin *skin, float hitcircleDiameter, float rawHitcircleDiameter,
 
+                              Vector2 rawPos, LiveScore::HIT result, float animPercentInv, float hitDeltaRangePercent);
 
 
 
     static ConVar *m_osu_approach_scale_multiplier_ref;
 
     static ConVar *m_osu_timingpoints_force;
@@ -29,9 +29,9 @@ class OsuHitObject {
 
     static ConVar *m_osu_mod_mafham_ref;
 
 
 
    public:
 
-    OsuHitObject(long time, int sampleType, int comboNumber, bool isEndOfCombo, int colorCounter, int colorOffset,
 
-                 OsuBeatmap *beatmap);
 
-    virtual ~OsuHitObject() { ; }
 
+    HitObject(long time, int sampleType, int comboNumber, bool isEndOfCombo, int colorCounter, int colorOffset,
 
+              Beatmap *beatmap);
 
+    virtual ~HitObject() { ; }
 
 
 
     virtual void draw(Graphics *g) { ; }
 
     virtual void draw2(Graphics *g);
@@ -40,13 +40,13 @@ class OsuHitObject {
 
     virtual void updateStackPosition(float stackOffset) = 0;
 
     virtual void miss(long curPos) = 0;  // only used by notelock
 
 
 
-    inline OsuBeatmap *getBeatmap() const { return m_beatmap; }
 
+    inline Beatmap *getBeatmap() const { return m_beatmap; }
 
 
 
     virtual int getCombo() { return 1; }  // how much combo this hitobject is "worth"
 
     virtual bool isCircle() { return false; }
 
     virtual bool isSlider() { return false; }
 
     virtual bool isSpinner() { return false; }
 
-    void addHitResult(OsuScore::HIT result, long delta, bool isEndOfCombo, Vector2 posRaw, float targetDelta = 0.0f,
 
+    void addHitResult(LiveScore::HIT result, long delta, bool isEndOfCombo, Vector2 posRaw, float targetDelta = 0.0f,
 
                       float targetAngle = 0.0f, bool ignoreOnHitErrorBar = false, bool ignoreCombo = false,
 
                       bool ignoreHealth = false, bool addObjectDurationToSkinAnimationTimeStartOffset = true);
 
     void misAimed() { m_bMisAim = true; }
@@ -84,7 +84,7 @@ class OsuHitObject {
 
     virtual void onReset(long curPos);
 
 
 
    protected:
 
-    OsuBeatmap *m_beatmap;
 
+    Beatmap *m_beatmap;
 
 
 
     bool m_bVisible;
 
     bool m_bFinished;
@@ -124,7 +124,7 @@ class OsuHitObject {
 
     struct HITRESULTANIM {
 
         float time;
 
         Vector2 rawPos;
 
-        OsuScore::HIT result;
 
+        LiveScore::HIT result;
 
         long delta;
 
         bool addObjectDurationToSkinAnimationTimeStartOffset;
 
     };
--- a/src/App/Osu/Icons.cpp
+++ b/src/App/Osu/Icons.cpp
@@ -0,0 +1,37 @@
 
+//================ Copyright (c) 2018, PG, All rights reserved. =================//
 
+//
 
+// Purpose:		font awesome icon enum
 
+//
 
+// $NoKeywords: $
 
+//===============================================================================//
 
+
 
+#include "Icons.h"
 
+
 
+#include "Font.h"
 
+
 
+std::vector<wchar_t> Icons::icons;
 
+
 
+wchar_t Icons::Z_UNKNOWN_CHAR = Icons::addIcon(McFont::UNKNOWN_CHAR);
 
+wchar_t Icons::Z_SPACE = Icons::addIcon(0x20);
 
+
 
+wchar_t Icons::GEAR = Icons::addIcon(0xf013);
 
+wchar_t Icons::DESKTOP = Icons::addIcon(0xf108);
 
+wchar_t Icons::CIRCLE = Icons::addIcon(0xf10c);
 
+wchar_t Icons::CUBE = Icons::addIcon(0xf1b2);
 
+wchar_t Icons::VOLUME_UP = Icons::addIcon(0xf028);
 
+wchar_t Icons::VOLUME_DOWN = Icons::addIcon(0xf027);
 
+wchar_t Icons::VOLUME_OFF = Icons::addIcon(0xf026);
 
+wchar_t Icons::PAINTBRUSH = Icons::addIcon(0xf1fc);
 
+wchar_t Icons::GAMEPAD = Icons::addIcon(0xf11b);
 
+wchar_t Icons::WRENCH = Icons::addIcon(0xf0ad);
 
+wchar_t Icons::EYE = Icons::addIcon(0xf06e);
 
+wchar_t Icons::ARROW_CIRCLE_UP = Icons::addIcon(0xf01b);
 
+wchar_t Icons::TROPHY = Icons::addIcon(0xf091);
 
+wchar_t Icons::CARET_DOWN = Icons::addIcon(0xf0d7);
 
+wchar_t Icons::ARROW_DOWN = Icons::addIcon(0xf063);
 
+wchar_t Icons::GLOBE = Icons::addIcon(0xf0ac);
 
+wchar_t Icons::USER = Icons::addIcon(0xf2be);
 
+wchar_t Icons::UNDO = Icons::addIcon(0xf0e2);
 
+wchar_t Icons::KEYBOARD = Icons::addIcon(0xf11c);
 
+wchar_t Icons::LOCK = Icons::addIcon(0xf023);
 
+wchar_t Icons::UNLOCK = Icons::addIcon(0xf09c);
--- a/src/App/Osu/OsuIcons.h
+++ b/src/App/Osu/OsuIcons.h
@@ -10,7 +10,7 @@
 
 
 
 #include "cbase.h"
 
 
 
-class OsuIcons {
 
+class Icons {
 
    public:
 
     static std::vector<wchar_t> icons;
 
 
--- a/src/App/Osu/KeyBindings.cpp
+++ b/src/App/Osu/KeyBindings.cpp
@@ -0,0 +1,100 @@
 
+//================ Copyright (c) 2016, PG, All rights reserved. =================//
 
+//
 
+// Purpose:		key bindings container
 
+//
 
+// $NoKeywords: $osukey
 
+//===============================================================================//
 
+
 
+#include "KeyBindings.h"
 
+
 
+#include "Keyboard.h"
 
+
 
+ConVar KeyBindings::LEFT_CLICK("osu_key_left_click", (int)KEY_Z, FCVAR_NONE);
 
+ConVar KeyBindings::RIGHT_CLICK("osu_key_right_click", (int)KEY_X, FCVAR_NONE);
 
+ConVar KeyBindings::LEFT_CLICK_2("osu_key_left_click_2", 0, FCVAR_NONE);
 
+ConVar KeyBindings::RIGHT_CLICK_2("osu_key_right_click_2", 0, FCVAR_NONE);
 
+
 
+ConVar KeyBindings::FPOSU_ZOOM("osu_key_fposu_zoom", 0, FCVAR_NONE);
 
+
 
+ConVar KeyBindings::INCREASE_VOLUME("osu_key_increase_volume", (int)KEY_UP, FCVAR_NONE);
 
+ConVar KeyBindings::DECREASE_VOLUME("osu_key_decrease_volume", (int)KEY_DOWN, FCVAR_NONE);
 
+
 
+ConVar KeyBindings::INCREASE_LOCAL_OFFSET("osu_key_increase_local_offset", (int)KEY_ADD, FCVAR_NONE);
 
+ConVar KeyBindings::DECREASE_LOCAL_OFFSET("osu_key_decrease_local_offset", (int)KEY_SUBTRACT, FCVAR_NONE);
 
+
 
+ConVar KeyBindings::GAME_PAUSE("osu_key_game_pause", (int)KEY_ESCAPE, FCVAR_NONE);
 
+ConVar KeyBindings::SKIP_CUTSCENE("osu_key_skip_cutscene", (int)KEY_SPACE, FCVAR_NONE);
 
+ConVar KeyBindings::TOGGLE_SCOREBOARD("osu_key_toggle_scoreboard", (int)KEY_TAB, FCVAR_NONE);
 
+ConVar KeyBindings::SEEK_TIME("osu_key_seek_time", (int)KEY_SHIFT, FCVAR_NONE);
 
+ConVar KeyBindings::SEEK_TIME_BACKWARD("osu_key_seek_time_backward", (int)KEY_LEFT, FCVAR_NONE);
 
+ConVar KeyBindings::SEEK_TIME_FORWARD("osu_key_seek_time_forward", (int)KEY_RIGHT, FCVAR_NONE);
 
+ConVar KeyBindings::QUICK_RETRY("osu_key_quick_retry", (int)KEY_BACKSPACE, FCVAR_NONE);
 
+ConVar KeyBindings::QUICK_SAVE("osu_key_quick_save", (int)KEY_F6, FCVAR_NONE);
 
+ConVar KeyBindings::QUICK_LOAD("osu_key_quick_load", (int)KEY_F7, FCVAR_NONE);
 
+ConVar KeyBindings::INSTANT_REPLAY("osu_key_instant_replay", (int)KEY_F2, FCVAR_NONE);
 
+ConVar KeyBindings::TOGGLE_CHAT("osu_key_toggle_chat", (int)KEY_F8, FCVAR_NONE);
 
+ConVar KeyBindings::SAVE_SCREENSHOT("osu_key_save_screenshot", (int)KEY_F12, FCVAR_NONE);
 
+ConVar KeyBindings::DISABLE_MOUSE_BUTTONS("osu_key_disable_mouse_buttons", (int)KEY_F10, FCVAR_NONE);
 
+ConVar KeyBindings::BOSS_KEY("osu_key_boss", (int)KEY_INSERT, FCVAR_NONE);
 
+
 
+ConVar KeyBindings::TOGGLE_MODSELECT("osu_key_toggle_modselect", (int)KEY_F1, FCVAR_NONE);
 
+ConVar KeyBindings::RANDOM_BEATMAP("osu_key_random_beatmap", (int)KEY_F2, FCVAR_NONE);
 
+
 
+ConVar KeyBindings::MOD_EASY("osu_key_mod_easy", (int)KEY_Q, FCVAR_NONE);
 
+ConVar KeyBindings::MOD_NOFAIL("osu_key_mod_nofail", (int)KEY_W, FCVAR_NONE);
 
+ConVar KeyBindings::MOD_HALFTIME("osu_key_mod_halftime", (int)KEY_E, FCVAR_NONE);
 
+ConVar KeyBindings::MOD_HARDROCK("osu_key_mod_hardrock", (int)KEY_A, FCVAR_NONE);
 
+ConVar KeyBindings::MOD_SUDDENDEATH("osu_key_mod_suddendeath", (int)KEY_S, FCVAR_NONE);
 
+ConVar KeyBindings::MOD_DOUBLETIME("osu_key_mod_doubletime", (int)KEY_D, FCVAR_NONE);
 
+ConVar KeyBindings::MOD_HIDDEN("osu_key_mod_hidden", (int)KEY_F, FCVAR_NONE);
 
+ConVar KeyBindings::MOD_FLASHLIGHT("osu_key_mod_flashlight", (int)KEY_G, FCVAR_NONE);
 
+ConVar KeyBindings::MOD_RELAX("osu_key_mod_relax", (int)KEY_Z, FCVAR_NONE);
 
+ConVar KeyBindings::MOD_AUTOPILOT("osu_key_mod_autopilot", (int)KEY_X, FCVAR_NONE);
 
+ConVar KeyBindings::MOD_SPUNOUT("osu_key_mod_spunout", (int)KEY_C, FCVAR_NONE);
 
+ConVar KeyBindings::MOD_AUTO("osu_key_mod_auto", (int)KEY_V, FCVAR_NONE);
 
+ConVar KeyBindings::MOD_SCOREV2("osu_key_mod_scorev2", (int)KEY_B, FCVAR_NONE);
 
+
 
+std::vector<ConVar*> KeyBindings::ALL = {&KeyBindings::LEFT_CLICK,
 
+                                         &KeyBindings::RIGHT_CLICK,
 
+                                         &KeyBindings::LEFT_CLICK_2,
 
+                                         &KeyBindings::RIGHT_CLICK_2,
 
+
 
+                                         &KeyBindings::FPOSU_ZOOM,
 
+
 
+                                         &KeyBindings::INCREASE_VOLUME,
 
+                                         &KeyBindings::DECREASE_VOLUME,
 
+
 
+                                         &KeyBindings::INCREASE_LOCAL_OFFSET,
 
+                                         &KeyBindings::DECREASE_LOCAL_OFFSET,
 
+
 
+                                         &KeyBindings::GAME_PAUSE,
 
+                                         &KeyBindings::SKIP_CUTSCENE,
 
+                                         &KeyBindings::TOGGLE_SCOREBOARD,
 
+                                         &KeyBindings::SEEK_TIME,
 
+                                         &KeyBindings::SEEK_TIME_BACKWARD,
 
+                                         &KeyBindings::SEEK_TIME_FORWARD,
 
+                                         &KeyBindings::QUICK_RETRY,
 
+                                         &KeyBindings::QUICK_SAVE,
 
+                                         &KeyBindings::QUICK_LOAD,
 
+                                         &KeyBindings::INSTANT_REPLAY,
 
+                                         &KeyBindings::TOGGLE_CHAT,
 
+                                         &KeyBindings::SAVE_SCREENSHOT,
 
+                                         &KeyBindings::DISABLE_MOUSE_BUTTONS,
 
+                                         &KeyBindings::BOSS_KEY,
 
+
 
+                                         &KeyBindings::TOGGLE_MODSELECT,
 
+                                         &KeyBindings::RANDOM_BEATMAP,
 
+
 
+                                         &KeyBindings::MOD_EASY,
 
+                                         &KeyBindings::MOD_NOFAIL,
 
+                                         &KeyBindings::MOD_HALFTIME,
 
+                                         &KeyBindings::MOD_HARDROCK,
 
+                                         &KeyBindings::MOD_SUDDENDEATH,
 
+                                         &KeyBindings::MOD_DOUBLETIME,
 
+                                         &KeyBindings::MOD_HIDDEN,
 
+                                         &KeyBindings::MOD_FLASHLIGHT,
 
+                                         &KeyBindings::MOD_RELAX,
 
+                                         &KeyBindings::MOD_AUTOPILOT,
 
+                                         &KeyBindings::MOD_SPUNOUT,
 
+                                         &KeyBindings::MOD_AUTO,
 
+                                         &KeyBindings::MOD_SCOREV2};
--- a/src/App/Osu/OsuKeyBindings.h
+++ b/src/App/Osu/OsuKeyBindings.h
@@ -10,7 +10,7 @@
 
 
 
 #include "ConVar.h"
 
 
 
-class OsuKeyBindings {
 
+class KeyBindings {
 
    public:
 
     static ConVar LEFT_CLICK;
 
     static ConVar RIGHT_CLICK;
--- a/src/App/Osu/OsuLobby.cpp
+++ b/src/App/Osu/OsuLobby.cpp
@@ -1,4 +1,4 @@
 
-#include "OsuLobby.h"
 
+#include "Lobby.h"
 
 
 
 #include "Bancho.h"
 
 #include "BanchoNetworking.h"
@@ -6,18 +6,18 @@
 
 #include "CBaseUIButton.h"
 
 #include "CBaseUIContainer.h"
 
 #include "CBaseUILabel.h"
 
+#include "Chat.h"
 
 #include "Engine.h"
 
 #include "Keyboard.h"
 
+#include "MainMenu.h"
 
+#include "NotificationOverlay.h"
 
 #include "Osu.h"
 
-#include "OsuChat.h"
 
-#include "OsuMainMenu.h"
 
-#include "OsuNotificationOverlay.h"
 
-#include "OsuPromptScreen.h"
 
-#include "OsuRichPresence.h"
 
-#include "OsuUIButton.h"
 
+#include "PromptScreen.h"
 
 #include "ResourceManager.h"
 
+#include "RichPresence.h"
 
+#include "UIButton.h"
 
 
 
-RoomUIElement::RoomUIElement(OsuLobby* multi, Room* room, float x, float y, float width, float height)
 
+RoomUIElement::RoomUIElement(Lobby* multi, Room* room, float x, float y, float width, float height)
 
     : CBaseUIScrollView(x, y, width, height, "") {
 
     // NOTE: We can't store the room pointer, since it might expire later
 
     m_multi = multi;
@@ -41,7 +41,7 @@ RoomUIElement::RoomUIElement(OsuLobby* multi, Room* room, float x, float y, floa
 
     slots_ui->setDrawBackground(false);
 
     getContainer()->addBaseUIElement(slots_ui);
 
 
 
-    join_btn = new OsuUIButton(multi->m_osu, 10, 65, 120, 30, "", "Join room");
 
+    join_btn = new UIButton(multi->m_osu, 10, 65, 120, 30, "", "Join room");
 
     join_btn->setUseDefaultSkin();
 
     join_btn->setColor(0xff00ff00);
 
     join_btn->setClickCallback(fastdelegate::MakeDelegate(this, &RoomUIElement::onRoomJoinButtonClick));
@@ -59,13 +59,13 @@ void RoomUIElement::onRoomJoinButtonClick(CBaseUIButton* btn) {
 
     if(has_password) {
 
         m_multi->room_to_join = room_id;
 
         m_multi->m_osu->m_prompt->prompt("Room password:",
 
-                                         fastdelegate::MakeDelegate(m_multi, &OsuLobby::on_room_join_with_password));
 
+                                         fastdelegate::MakeDelegate(m_multi, &Lobby::on_room_join_with_password));
 
     } else {
 
         m_multi->joinRoom(room_id, "");
 
     }
 
 }
 
 
 
-OsuLobby::OsuLobby(Osu* osu) : OsuScreen(osu) {
 
+Lobby::Lobby(Osu* osu) : OsuScreen(osu) {
 
     font = engine->getResourceManager()->getFont("FONT_DEFAULT");
 
 
 
     auto heading = new CBaseUILabel(50, 30, 300, 40, "", "Multiplayer rooms");
@@ -75,10 +75,10 @@ OsuLobby::OsuLobby(Osu* osu) : OsuScreen(osu) {
 
     heading->setDrawBackground(false);
 
     addBaseUIElement(heading);
 
 
 
-    m_create_room_btn = new OsuUIButton(osu, 0, 0, 200, 50, "", "Create new room");
 
+    m_create_room_btn = new UIButton(osu, 0, 0, 200, 50, "", "Create new room");
 
     m_create_room_btn->setUseDefaultSkin();
 
     m_create_room_btn->setColor(0xff00ff00);
 
-    m_create_room_btn->setClickCallback(fastdelegate::MakeDelegate(this, &OsuLobby::on_create_room_clicked));
 
+    m_create_room_btn->setClickCallback(fastdelegate::MakeDelegate(this, &Lobby::on_create_room_clicked));
 
     addBaseUIElement(m_create_room_btn);
 
 
 
     m_list = new CBaseUIScrollView(0, 0, 0, 0, "");
@@ -91,7 +91,7 @@ OsuLobby::OsuLobby(Osu* osu) : OsuScreen(osu) {
 
     updateLayout(m_osu->getScreenSize());
 
 }
 
 
 
-void OsuLobby::onKeyDown(KeyboardEvent& key) {
 
+void Lobby::onKeyDown(KeyboardEvent& key) {
 
     if(!m_bVisible) return;
 
 
 
     if(key.getKeyCode() == KEY_ESCAPE) {
@@ -104,21 +104,21 @@ void OsuLobby::onKeyDown(KeyboardEvent& key) {
 
     // XXX: search bar
 
 }
 
 
 
-void OsuLobby::onKeyUp(KeyboardEvent& key) {
 
+void Lobby::onKeyUp(KeyboardEvent& key) {
 
     if(!m_bVisible) return;
 
 
 
     // XXX: search bar
 
 }
 
 
 
-void OsuLobby::onChar(KeyboardEvent& key) {
 
+void Lobby::onChar(KeyboardEvent& key) {
 
     if(!m_bVisible) return;
 
 
 
     // XXX: search bar
 
 }
 
 
 
-void OsuLobby::onResolutionChange(Vector2 newResolution) { updateLayout(newResolution); }
 
+void Lobby::onResolutionChange(Vector2 newResolution) { updateLayout(newResolution); }
 
 
 
-CBaseUIContainer* OsuLobby::setVisible(bool visible) {
 
+CBaseUIContainer* Lobby::setVisible(bool visible) {
 
     if(visible == m_bVisible) return this;
 
     m_bVisible = visible;
 
 
@@ -133,7 +133,7 @@ CBaseUIContainer* OsuLobby::setVisible(bool visible) {
 
         send_packet(packet);
 
 
 
         // LOBBY presence is broken so we send MULTIPLAYER
 
-        OsuRichPresence::setBanchoStatus(m_osu, "Looking to play", MULTIPLAYER);
 
+        RichPresence::setBanchoStatus(m_osu, "Looking to play", MULTIPLAYER);
 
 
 
         // XXX: Could call refreshBeatmaps() here so we load them if not already done so.
 
         //      Would need to edit it a bit to work outside of songBrowser2, + display loading progress.
@@ -158,7 +158,7 @@ CBaseUIContainer* OsuLobby::setVisible(bool visible) {
 
     return this;
 
 }
 
 
 
-void OsuLobby::updateLayout(Vector2 newResolution) {
 
+void Lobby::updateLayout(Vector2 newResolution) {
 
     setSize(newResolution);
 
 
 
     m_list->clear();
@@ -191,15 +191,15 @@ void OsuLobby::updateLayout(Vector2 newResolution) {
 
     m_list->setScrollSizeToContent();
 
 }
 
 
 
-void OsuLobby::addRoom(Room* room) {
 
+void Lobby::addRoom(Room* room) {
 
     rooms.push_back(room);
 
     updateLayout(getSize());
 
 }
 
 
 
-void OsuLobby::joinRoom(uint32_t id, UString password) {
 
+void Lobby::joinRoom(u32 id, UString password) {
 
     Packet packet;
 
     packet.id = JOIN_ROOM;
 
-    write_int32(&packet, id);
 
+    write_u32(&packet, id);
 
     write_string(&packet, password.toUtf8());
 
     send_packet(packet);
 
 
@@ -213,7 +213,7 @@ void OsuLobby::joinRoom(uint32_t id, UString password) {
 
     m_osu->getNotificationOverlay()->addNotification("Joining room...");
 
 }
 
 
 
-void OsuLobby::updateRoom(Room room) {
 
+void Lobby::updateRoom(Room room) {
 
     for(auto old_room : rooms) {
 
         if(old_room->id == room.id) {
 
             *old_room = room;
@@ -229,7 +229,7 @@ void OsuLobby::updateRoom(Room room) {
 
     addRoom(new_room);
 
 }
 
 
 
-void OsuLobby::removeRoom(uint32_t room_id) {
 
+void Lobby::removeRoom(u32 room_id) {
 
     for(auto room : rooms) {
 
         if(room->id == room_id) {
 
             auto it = std::find(rooms.begin(), rooms.end(), room);
@@ -242,7 +242,7 @@ void OsuLobby::removeRoom(uint32_t room_id) {
 
     updateLayout(getSize());
 
 }
 
 
 
-void OsuLobby::on_create_room_clicked() {
 
+void Lobby::on_create_room_clicked() {
 
     bancho.room = Room();
 
     bancho.room.name = "New room";  // XXX: doesn't work
 
     bancho.room.host_id = bancho.user_id;
@@ -260,9 +260,9 @@ void OsuLobby::on_create_room_clicked() {
 
     m_osu->getNotificationOverlay()->addNotification("Creating room...");
 
 }
 
 
 
-void OsuLobby::on_room_join_with_password(UString password) { joinRoom(room_to_join, password); }
 
+void Lobby::on_room_join_with_password(UString password) { joinRoom(room_to_join, password); }
 
 
 
-void OsuLobby::on_room_join_failed() {
 
+void Lobby::on_room_join_failed() {
 
     // Updating layout will reset is_loading to false
 
     updateLayout(getSize());
 
 }
--- a/src/App/Osu/OsuLobby.h
+++ b/src/App/Osu/OsuLobby.h
@@ -2,7 +2,7 @@
 
 
 
 // Important clarification: "Lobby" here refers to the place where you look
 
 // for rooms. This is the ppy naming; to remember it, think of the #lobby
 
-// channel the client joins when entering the lobby. See OsuRoom.h if you
 
+// channel the client joins when entering the lobby. See Room.h if you
 
 // were looking for the 16-player holder thing.
 
 
 
 #include "BanchoProtocol.h"
@@ -10,28 +10,28 @@
 
 #include "OsuScreen.h"
 
 
 
 class CBaseUIButton;
 
-class OsuLobby;
 
-class OsuUIButton;
 
+class Lobby;
 
+class UIButton;
 
 class Room;
 
 
 
 // NOTE: We make a CBaseUIScrollView but won't enable scrolling.
 
 //       It's just to draw the frame! ^_^
 
 struct RoomUIElement : CBaseUIScrollView {
 
-    RoomUIElement(OsuLobby* multi, Room* room, float x, float y, float width, float height);
 
+    RoomUIElement(Lobby* multi, Room* room, float x, float y, float width, float height);
 
 
 
-    OsuUIButton* join_btn;
 
+    UIButton* join_btn;
 
     CBaseUIScrollView* ui;
 
-    OsuLobby* m_multi;
 
-    int32_t room_id;
 
+    Lobby* m_multi;
 
+    i32 room_id;
 
     bool has_password;
 
 
 
     void updateLayout(Vector2 pos, Vector2 size);
 
     void onRoomJoinButtonClick(CBaseUIButton* btn);
 
 };
 
 
 
-class OsuLobby : public OsuScreen {
 
+class Lobby : public OsuScreen {
 
    public:
 
-    OsuLobby(Osu* osu);
 
+    Lobby(Osu* osu);
 
 
 
     virtual void onKeyDown(KeyboardEvent& e);
 
     virtual void onKeyUp(KeyboardEvent& e);
@@ -42,9 +42,9 @@ class OsuLobby : public OsuScreen {
 
     virtual CBaseUIContainer* setVisible(bool visible);
 
 
 
     void addRoom(Room* room);
 
-    void joinRoom(uint32_t id, UString password);
 
+    void joinRoom(u32 id, UString password);
 
     void updateRoom(Room room);
 
-    void removeRoom(uint32_t room_id);
 
+    void removeRoom(u32 room_id);
 
     void updateLayout(Vector2 newResolution);
 
 
 
     void on_create_room_clicked();
@@ -53,8 +53,8 @@ class OsuLobby : public OsuScreen {
 
     void on_room_join_failed();
 
 
 
     std::vector<Room*> rooms;
 
-    OsuUIButton* m_create_room_btn;
 
+    UIButton* m_create_room_btn;
 
     CBaseUIScrollView* m_list;
 
-    int32_t room_to_join;
 
+    i32 room_to_join;
 
     McFont* font;
 
 };
--- a/src/App/Osu/OsuMainMenu.cpp
+++ b/src/App/Osu/OsuMainMenu.cpp
@@ -5,67 +5,66 @@
 
 // $NoKeywords: $osumain
 
 //===============================================================================//
 
 
 
-#include "OsuMainMenu.h"
 
+#include "MainMenu.h"
 
 
 
 #include "AnimationHandler.h"
 
+#include "BackgroundImageHandler.h"
 
 #include "Bancho.h"
 
+#include "Beatmap.h"
 
 #include "CBaseUIButton.h"
 
 #include "CBaseUIContainer.h"
 
 #include "ConVar.h"
 
+#include "Database.h"
 
+#include "DatabaseBeatmap.h"
 
 #include "Downloader.h"
 
 #include "Engine.h"
 
 #include "File.h"
 
+#include "GameRules.h"
 
+#include "HUD.h"
 
 #include "Keyboard.h"
 
+#include "Lobby.h"
 
 #include "Mouse.h"
 
+#include "OptionsMenu.h"
 
 #include "Osu.h"
 
-#include "OsuBackgroundImageHandler.h"
 
-#include "OsuBeatmap.h"
 
-#include "OsuDatabase.h"
 
-#include "OsuDatabaseBeatmap.h"
 
-#include "OsuGameRules.h"
 
-#include "OsuHUD.h"
 
-#include "OsuLobby.h"
 
-#include "OsuOptionsMenu.h"
 
-#include "OsuRichPresence.h"
 
-#include "OsuSkin.h"
 
-#include "OsuSkinImage.h"
 
-#include "OsuSongBrowser.h"
 
-#include "OsuUIButton.h"
 
-#include "OsuUpdateHandler.h"
 
 #include "ResourceManager.h"
 
+#include "RichPresence.h"
 
+#include "Skin.h"
 
+#include "SkinImage.h"
 
+#include "SongBrowser.h"
 
 #include "SoundEngine.h"
 
+#include "UIButton.h"
 
+#include "UpdateHandler.h"
 
 #include "VertexArrayObject.h"
 
 
 
-UString OsuMainMenu::NEOSU_MAIN_BUTTON_TEXT = UString("neosu");
 
-UString OsuMainMenu::NEOSU_MAIN_BUTTON_SUBTEXT = UString("Multiplayer Client");
 
+UString MainMenu::NEOSU_MAIN_BUTTON_TEXT = UString("neosu");
 
+UString MainMenu::NEOSU_MAIN_BUTTON_SUBTEXT = UString("Multiplayer Client");
 
 
 
 #define NEOSU_NEWVERSION_NOTIFICATION_TRIGGER_FILE "version.txt"
 
 
 
-class OsuMainMenuCubeButton : public CBaseUIButton {
 
+class MainMenuCubeButton : public CBaseUIButton {
 
    public:
 
-    OsuMainMenuCubeButton(OsuMainMenu *mainMenu, float xPos, float yPos, float xSize, float ySize, UString name,
 
-                          UString text);
 
+    MainMenuCubeButton(MainMenu *mainMenu, float xPos, float yPos, float xSize, float ySize, UString name,
 
+                       UString text);
 
 
 
     virtual void draw(Graphics *g);
 
 
 
     void onMouseInside();
 
     void onMouseOutside();
 
 
 
-    OsuMainMenu *m_mainMenu;
 
+    MainMenu *m_mainMenu;
 
 };
 
 
 
-class OsuMainMenuButton : public CBaseUIButton {
 
+class MainMenuButton : public CBaseUIButton {
 
    public:
 
-    OsuMainMenuButton(OsuMainMenu *mainMenu, float xPos, float yPos, float xSize, float ySize, UString name,
 
-                      UString text);
 
+    MainMenuButton(MainMenu *mainMenu, float xPos, float yPos, float xSize, float ySize, UString name, UString text);
 
 
 
     void onMouseDownInside();
 
 
 
    private:
 
-    OsuMainMenu *m_mainMenu;
 
+    MainMenu *m_mainMenu;
 
 };
 
 
 
-void OsuMainMenuPauseButton::draw(Graphics *g) {
 
+void MainMenuPauseButton::draw(Graphics *g) {
 
     int third = m_vSize.x / 3;
 
 
 
     g->setColor(0xffffffff);
@@ -146,14 +145,14 @@ ConVar osu_main_menu_banner_ifupdatedfromoldversion_le3300_text(
 
 ConVar osu_main_menu_banner_ifupdatedfromoldversion_le3303_text(
 
     "osu_main_menu_banner_ifupdatedfromoldversion_le3303_text", "", FCVAR_NONE);
 
 
 
-ConVar *OsuMainMenu::m_osu_universal_offset_ref = NULL;
 
-ConVar *OsuMainMenu::m_osu_universal_offset_hardcoded_ref = NULL;
 
-ConVar *OsuMainMenu::m_osu_old_beatmap_offset_ref = NULL;
 
-ConVar *OsuMainMenu::m_osu_universal_offset_hardcoded_fallback_dsound_ref = NULL;
 
-ConVar *OsuMainMenu::m_osu_mod_random_ref = NULL;
 
-ConVar *OsuMainMenu::m_osu_songbrowser_background_fade_in_duration_ref = NULL;
 
+ConVar *MainMenu::m_osu_universal_offset_ref = NULL;
 
+ConVar *MainMenu::m_osu_universal_offset_hardcoded_ref = NULL;
 
+ConVar *MainMenu::m_osu_old_beatmap_offset_ref = NULL;
 
+ConVar *MainMenu::m_osu_universal_offset_hardcoded_fallback_dsound_ref = NULL;
 
+ConVar *MainMenu::m_osu_mod_random_ref = NULL;
 
+ConVar *MainMenu::m_osu_songbrowser_background_fade_in_duration_ref = NULL;
 
 
 
-OsuMainMenu::OsuMainMenu(Osu *osu) : OsuScreen(osu) {
 
+MainMenu::MainMenu(Osu *osu) : OsuScreen(osu) {
 
     if(m_osu_universal_offset_ref == NULL) m_osu_universal_offset_ref = convar->getConVarByName("osu_universal_offset");
 
     if(m_osu_universal_offset_hardcoded_ref == NULL)
 
         m_osu_universal_offset_hardcoded_ref = convar->getConVarByName("osu_universal_offset_hardcoded");
@@ -167,7 +166,7 @@ OsuMainMenu::OsuMainMenu(Osu *osu) : OsuScreen(osu) {
 
         m_osu_songbrowser_background_fade_in_duration_ref =
 
             convar->getConVarByName("osu_songbrowser_background_fade_in_duration");
 
 
 
-    osu_toggle_preview_music.setCallback(fastdelegate::MakeDelegate(this, &OsuMainMenu::onPausePressed));
 
+    osu_toggle_preview_music.setCallback(fastdelegate::MakeDelegate(this, &MainMenu::onPausePressed));
 
 
 
     // engine settings
 
     engine->getMouse()->addListener(this);
@@ -240,27 +239,27 @@ OsuMainMenu::OsuMainMenu(Osu *osu) : OsuScreen(osu) {
 
     setPos(-1, 0);
 
     setSize(m_osu->getScreenWidth(), m_osu->getScreenHeight());
 
 
 
-    m_cube = new OsuMainMenuCubeButton(this, 0, 0, 1, 1, "", "");
 
-    m_cube->setClickCallback(fastdelegate::MakeDelegate(this, &OsuMainMenu::onCubePressed));
 
+    m_cube = new MainMenuCubeButton(this, 0, 0, 1, 1, "", "");
 
+    m_cube->setClickCallback(fastdelegate::MakeDelegate(this, &MainMenu::onCubePressed));
 
     addBaseUIElement(m_cube);
 
 
 
     addMainMenuButton("Singleplayer")
 
-        ->setClickCallback(fastdelegate::MakeDelegate(this, &OsuMainMenu::onPlayButtonPressed));
 
+        ->setClickCallback(fastdelegate::MakeDelegate(this, &MainMenu::onPlayButtonPressed));
 
     addMainMenuButton("Multiplayer")
 
-        ->setClickCallback(fastdelegate::MakeDelegate(this, &OsuMainMenu::onMultiplayerButtonPressed));
 
+        ->setClickCallback(fastdelegate::MakeDelegate(this, &MainMenu::onMultiplayerButtonPressed));
 
     addMainMenuButton("Options (CTRL + O)")
 
-        ->setClickCallback(fastdelegate::MakeDelegate(this, &OsuMainMenu::onOptionsButtonPressed));
 
-    addMainMenuButton("Exit")->setClickCallback(fastdelegate::MakeDelegate(this, &OsuMainMenu::onExitButtonPressed));
 
+        ->setClickCallback(fastdelegate::MakeDelegate(this, &MainMenu::onOptionsButtonPressed));
 
+    addMainMenuButton("Exit")->setClickCallback(fastdelegate::MakeDelegate(this, &MainMenu::onExitButtonPressed));
 
 
 
-    m_pauseButton = new OsuMainMenuPauseButton(0, 0, 0, 0, "", "");
 
-    m_pauseButton->setClickCallback(fastdelegate::MakeDelegate(this, &OsuMainMenu::onPausePressed));
 
+    m_pauseButton = new MainMenuPauseButton(0, 0, 0, 0, "", "");
 
+    m_pauseButton->setClickCallback(fastdelegate::MakeDelegate(this, &MainMenu::onPausePressed));
 
     addBaseUIElement(m_pauseButton);
 
 
 
     m_updateAvailableButton =
 
-        new OsuUIButton(m_osu, 0, 0, 0, 0, "",
 
-                        Osu::debug->getBool() ? "Debug mode, update check disabled" : "Checking for updates ...");
 
+        new UIButton(m_osu, 0, 0, 0, 0, "",
 
+                     Osu::debug->getBool() ? "Debug mode, update check disabled" : "Checking for updates ...");
 
     m_updateAvailableButton->setUseDefaultSkin();
 
-    m_updateAvailableButton->setClickCallback(fastdelegate::MakeDelegate(this, &OsuMainMenu::onUpdatePressed));
 
+    m_updateAvailableButton->setClickCallback(fastdelegate::MakeDelegate(this, &MainMenu::onUpdatePressed));
 
     m_updateAvailableButton->setColor(0x2200ff00);
 
     m_updateAvailableButton->setTextColor(0x22ffffff);
 
 
@@ -269,11 +268,11 @@ OsuMainMenu::OsuMainMenu(Osu *osu) : OsuScreen(osu) {
 
     m_versionButton->setText(versionString);
 
     m_versionButton->setDrawBackground(false);
 
     m_versionButton->setDrawFrame(false);
 
-    m_versionButton->setClickCallback(fastdelegate::MakeDelegate(this, &OsuMainMenu::onVersionPressed));
 
+    m_versionButton->setClickCallback(fastdelegate::MakeDelegate(this, &MainMenu::onVersionPressed));
 
     addBaseUIElement(m_versionButton);
 
 }
 
 
 
-OsuMainMenu::~OsuMainMenu() {
 
+MainMenu::~MainMenu() {
 
     anim->deleteExistingAnimation(&m_fUpdateButtonAnim);
 
 
 
     anim->deleteExistingAnimation(&m_fMainMenuAnimFriendEyeFollowX);
@@ -294,7 +293,7 @@ OsuMainMenu::~OsuMainMenu() {
 
     if(m_bWasCleanShutdown) writeVersionFile();
 
 }
 
 
 
-void OsuMainMenu::draw(Graphics *g) {
 
+void MainMenu::draw(Graphics *g) {
 
     if(!m_bVisible) return;
 
 
 
     // load server icon
@@ -308,7 +307,7 @@ void OsuMainMenu::draw(Graphics *g) {
 
         icon_path.append("/server_icon");
 
 
 
         float progress = -1.f;
 
-        std::vector<uint8_t> data;
 
+        std::vector<u8> data;
 
         int response_code;
 
         download(bancho.server_icon_url.toUtf8(), &progress, data, &response_code);
 
         if(progress == -1.f) bancho.server_icon_url = "";
@@ -364,7 +363,7 @@ void OsuMainMenu::draw(Graphics *g) {
 
             alpha = 1.0f - (1.0f - alpha) * (1.0f - alpha);
 
         }
 
     }
 
-    OsuSongBrowser::drawSelectedBeatmapBackgroundImage(g, m_osu, alpha);
 
+    SongBrowser::drawSelectedBeatmapBackgroundImage(g, m_osu, alpha);
 
 
 
     // main button stuff
 
     bool haveTimingpoints = false;
@@ -383,7 +382,7 @@ void OsuMainMenu::draw(Graphics *g) {
 
                                       ? m_osu_old_beatmap_offset_ref->getInt()
 
                                       : 0);
 
 
 
-        OsuDatabaseBeatmap::TIMING_INFO t =
 
+        DatabaseBeatmap::TIMING_INFO t =
 
             m_osu->getSelectedBeatmap()->getSelectedDifficulty2()->getTimingInfoForTime(curMusicPos);
 
 
 
         if(t.beatLengthBase == 0.0f)  // bah
@@ -448,13 +447,13 @@ void OsuMainMenu::draw(Graphics *g) {
 
 
 
     // draw update check button
 
     {
 
-        if(m_osu->getUpdateHandler()->getStatus() == OsuUpdateHandler::STATUS::STATUS_SUCCESS_INSTALLATION) {
 
+        if(m_osu->getUpdateHandler()->getStatus() == UpdateHandler::STATUS::STATUS_SUCCESS_INSTALLATION) {
 
             g->push3DScene(McRect(m_updateAvailableButton->getPos().x, m_updateAvailableButton->getPos().y,
 
                                   m_updateAvailableButton->getSize().x, m_updateAvailableButton->getSize().y));
 
             g->rotate3DScene(m_fUpdateButtonAnim * 360.0f, 0, 0);
 
         }
 
         m_updateAvailableButton->draw(g);
 
-        if(m_osu->getUpdateHandler()->getStatus() == OsuUpdateHandler::STATUS::STATUS_SUCCESS_INSTALLATION)
 
+        if(m_osu->getUpdateHandler()->getStatus() == UpdateHandler::STATUS::STATUS_SUCCESS_INSTALLATION)
 
             g->pop3DScene();
 
     }
 
 
@@ -915,7 +914,7 @@ void OsuMainMenu::draw(Graphics *g) {
 
     }
 
 }
 
 
 
-void OsuMainMenu::mouse_update(bool *propagate_clicks) {
 
+void MainMenu::mouse_update(bool *propagate_clicks) {
 
     if(!m_bVisible) return;
 
 
 
     updateLayout();
@@ -1000,22 +999,22 @@ void OsuMainMenu::mouse_update(bool *propagate_clicks) {
 
 
 
     // handle update checker and status text
 
     switch(m_osu->getUpdateHandler()->getStatus()) {
 
-        case OsuUpdateHandler::STATUS::STATUS_UP_TO_DATE:
 
+        case UpdateHandler::STATUS::STATUS_UP_TO_DATE:
 
             if(m_updateAvailableButton->isVisible()) {
 
                 m_updateAvailableButton->setText("");
 
                 m_updateAvailableButton->setVisible(false);
 
             }
 
             break;
 
-        case OsuUpdateHandler::STATUS::STATUS_CHECKING_FOR_UPDATE:
 
+        case UpdateHandler::STATUS::STATUS_CHECKING_FOR_UPDATE:
 
             m_updateAvailableButton->setText("Checking for updates ...");
 
             break;
 
-        case OsuUpdateHandler::STATUS::STATUS_DOWNLOADING_UPDATE:
 
+        case UpdateHandler::STATUS::STATUS_DOWNLOADING_UPDATE:
 
             m_updateAvailableButton->setText("Downloading ...");
 
             break;
 
-        case OsuUpdateHandler::STATUS::STATUS_INSTALLING_UPDATE:
 
+        case UpdateHandler::STATUS::STATUS_INSTALLING_UPDATE:
 
             m_updateAvailableButton->setText("Installing ...");
 
             break;
 
-        case OsuUpdateHandler::STATUS::STATUS_SUCCESS_INSTALLATION:
 
+        case UpdateHandler::STATUS::STATUS_SUCCESS_INSTALLATION:
 
             if(engine->getTime() > m_fUpdateButtonTextTime && anim->isAnimating(&m_fUpdateButtonAnim) &&
 
                m_fUpdateButtonAnim > 0.175f) {
 
                 m_fUpdateButtonTextTime = m_fUpdateButtonAnimTime;
@@ -1029,12 +1028,12 @@ void OsuMainMenu::mouse_update(bool *propagate_clicks) {
 
                     m_updateAvailableButton->setText("A new version of neosu is ready!");
 
             }
 
             break;
 
-        case OsuUpdateHandler::STATUS::STATUS_ERROR:
 
+        case UpdateHandler::STATUS::STATUS_ERROR:
 
             m_updateAvailableButton->setText("Update Error! Click to retry ...");
 
             break;
 
     }
 
 
 
-    if(m_osu->getUpdateHandler()->getStatus() == OsuUpdateHandler::STATUS::STATUS_SUCCESS_INSTALLATION &&
 
+    if(m_osu->getUpdateHandler()->getStatus() == UpdateHandler::STATUS::STATUS_SUCCESS_INSTALLATION &&
 
        engine->getTime() > m_fUpdateButtonAnimTime) {
 
         m_fUpdateButtonAnimTime = engine->getTime() + 3.0f;
 
         m_fUpdateButtonAnim = 0.0f;
@@ -1060,7 +1059,7 @@ void OsuMainMenu::mouse_update(bool *propagate_clicks) {
 
     }
 
 }
 
 
 
-void OsuMainMenu::selectRandomBeatmap() {
 
+void MainMenu::selectRandomBeatmap() {
 
     auto sb = m_osu->getSongBrowser();
 
     if(sb->getDatabase()->isFinished() && !sb->m_beatmaps.empty()) {
 
         m_osu->getSongBrowser()->selectRandomBeatmap();
@@ -1102,7 +1101,7 @@ void OsuMainMenu::selectRandomBeatmap() {
 
     }
 
 }
 
 
 
-void OsuMainMenu::onKeyDown(KeyboardEvent &e) {
 
+void MainMenu::onKeyDown(KeyboardEvent &e) {
 
     OsuScreen::onKeyDown(e);  // only used for options menu
 
     if(!m_bVisible || e.isConsumed()) return;
 
 
@@ -1123,7 +1122,7 @@ void OsuMainMenu::onKeyDown(KeyboardEvent &e) {
 
     }
 
 }
 
 
 
-void OsuMainMenu::onMiddleChange(bool down) {
 
+void MainMenu::onMiddleChange(bool down) {
 
     if(!m_bVisible) return;
 
 
 
     // debug anims
@@ -1140,16 +1139,16 @@ void OsuMainMenu::onMiddleChange(bool down) {
 
     }
 
 }
 
 
 
-void OsuMainMenu::onResolutionChange(Vector2 newResolution) {
 
+void MainMenu::onResolutionChange(Vector2 newResolution) {
 
     updateLayout();
 
     setMenuElementsVisible(m_bMenuElementsVisible);
 
 }
 
 
 
-CBaseUIContainer *OsuMainMenu::setVisible(bool visible) {
 
+CBaseUIContainer *MainMenu::setVisible(bool visible) {
 
     m_bVisible = visible;
 
 
 
     if(visible) {
 
-        OsuRichPresence::onMainMenu(m_osu);
 
+        RichPresence::onMainMenu(m_osu);
 
 
 
         updateLayout();
 
 
@@ -1170,7 +1169,7 @@ CBaseUIContainer *OsuMainMenu::setVisible(bool visible) {
 
     return this;
 
 }
 
 
 
-void OsuMainMenu::updateLayout() {
 
+void MainMenu::updateLayout() {
 
     const float dpiScale = Osu::getUIScale(m_osu);
 
 
 
     m_vCenter = m_osu->getScreenSize() / 2.0f;
@@ -1221,7 +1220,7 @@ void OsuMainMenu::updateLayout() {
 
     update_pos();
 
 }
 
 
 
-void OsuMainMenu::animMainButton() {
 
+void MainMenu::animMainButton() {
 
     m_bInMainMenuRandomAnim = true;
 
 
 
     m_iMainMenuRandomAnimType = (rand() % 4) == 1 ? 1 : 0;
@@ -1261,7 +1260,7 @@ void OsuMainMenu::animMainButton() {
 
     }
 
 }
 
 
 
-void OsuMainMenu::animMainButtonBack() {
 
+void MainMenu::animMainButtonBack() {
 
     m_bInMainMenuRandomAnim = false;
 
 
 
     if(anim->isAnimating(&m_fMainMenuAnim)) {
@@ -1275,7 +1274,7 @@ void OsuMainMenu::animMainButtonBack() {
 
     }
 
 }
 
 
 
-void OsuMainMenu::setMenuElementsVisible(bool visible, bool animate) {
 
+void MainMenu::setMenuElementsVisible(bool visible, bool animate) {
 
     m_bMenuElementsVisible = visible;
 
 
 
     if(visible) {
@@ -1316,14 +1315,14 @@ void OsuMainMenu::setMenuElementsVisible(bool visible, bool animate) {
 
     }
 
 }
 
 
 
-void OsuMainMenu::writeVersionFile() {
 
+void MainMenu::writeVersionFile() {
 
     // remember, don't show the notification arrow until the version changes again
 
     std::ofstream versionFile(NEOSU_NEWVERSION_NOTIFICATION_TRIGGER_FILE, std::ios::out | std::ios::trunc);
 
     if(versionFile.good()) versionFile << Osu::version->getFloat();
 
 }
 
 
 
-OsuMainMenuButton *OsuMainMenu::addMainMenuButton(UString text) {
 
-    OsuMainMenuButton *button = new OsuMainMenuButton(this, m_vSize.x, 0, 1, 1, "", text);
 
+MainMenuButton *MainMenu::addMainMenuButton(UString text) {
 
+    MainMenuButton *button = new MainMenuButton(this, m_vSize.x, 0, 1, 1, "", text);
 
     button->setFont(m_osu->getSubTitleFont());
 
     button->setVisible(false);
 
 
@@ -1332,7 +1331,7 @@ OsuMainMenuButton *OsuMainMenu::addMainMenuButton(UString text) {
 
     return button;
 
 }
 
 
 
-void OsuMainMenu::onCubePressed() {
 
+void MainMenu::onCubePressed() {
 
     engine->getSound()->play(m_osu->getSkin()->getMenuHit());
 
 
 
     anim->moveQuadInOut(&m_fSizeAddAnim, 0.0f, 0.06f, 0.0f, false);
@@ -1376,7 +1375,7 @@ void OsuMainMenu::onCubePressed() {
 
     }
 
 }
 
 
 
-void OsuMainMenu::onPlayButtonPressed() {
 
+void MainMenu::onPlayButtonPressed() {
 
     m_bMainMenuAnimFriend = false;
 
     m_bMainMenuAnimFadeToFriendForNextAnim = false;
 
     m_bMainMenuAnimFriendScheduled = false;
@@ -1386,7 +1385,7 @@ void OsuMainMenu::onPlayButtonPressed() {
 
     m_osu->toggleSongBrowser();
 
 }
 
 
 
-void OsuMainMenu::onMultiplayerButtonPressed() {
 
+void MainMenu::onMultiplayerButtonPressed() {
 
     if(bancho.user_id <= 0) {
 
         m_osu->m_optionsMenu->askForLoginDetails();
 
         return;
@@ -1396,17 +1395,17 @@ void OsuMainMenu::onMultiplayerButtonPressed() {
 
     m_osu->m_lobby->setVisible(true);
 
 }
 
 
 
-void OsuMainMenu::onOptionsButtonPressed() {
 
+void MainMenu::onOptionsButtonPressed() {
 
     if(!m_osu->getOptionsMenu()->isVisible()) m_osu->toggleOptionsMenu();
 
 }
 
 
 
-void OsuMainMenu::onExitButtonPressed() {
 
+void MainMenu::onExitButtonPressed() {
 
     m_fShutdownScheduledTime = engine->getTime() + 0.3f;
 
     m_bWasCleanShutdown = true;
 
     setMenuElementsVisible(false);
 
 }
 
 
 
-void OsuMainMenu::onPausePressed() {
 
+void MainMenu::onPausePressed() {
 
     if(m_osu->getInstanceID() > 1) return;
 
 
 
     if(m_osu->getSelectedBeatmap()->isPreviewMusicPlaying()) {
@@ -1419,16 +1418,16 @@ void OsuMainMenu::onPausePressed() {
 
     }
 
 }
 
 
 
-void OsuMainMenu::onUpdatePressed() {
 
+void MainMenu::onUpdatePressed() {
 
     if(m_osu->getInstanceID() > 1) return;
 
 
 
-    if(m_osu->getUpdateHandler()->getStatus() == OsuUpdateHandler::STATUS::STATUS_SUCCESS_INSTALLATION)
 
+    if(m_osu->getUpdateHandler()->getStatus() == UpdateHandler::STATUS::STATUS_SUCCESS_INSTALLATION)
 
         engine->restart();
 
-    else if(m_osu->getUpdateHandler()->getStatus() == OsuUpdateHandler::STATUS::STATUS_ERROR)
 
+    else if(m_osu->getUpdateHandler()->getStatus() == UpdateHandler::STATUS::STATUS_ERROR)
 
         m_osu->getUpdateHandler()->checkForUpdates();
 
 }
 
 
 
-void OsuMainMenu::onVersionPressed() {
 
+void MainMenu::onVersionPressed() {
 
     if(m_osu->getInstanceID() > 1) return;
 
 
 
     m_bDrawVersionNotificationArrow = false;
@@ -1436,36 +1435,36 @@ void OsuMainMenu::onVersionPressed() {
 
     m_osu->toggleChangelog();
 
 }
 
 
 
-OsuMainMenuCubeButton::OsuMainMenuCubeButton(OsuMainMenu *mainMenu, float xPos, float yPos, float xSize, float ySize,
 
-                                             UString name, UString text)
 
+MainMenuCubeButton::MainMenuCubeButton(MainMenu *mainMenu, float xPos, float yPos, float xSize, float ySize,
 
+                                       UString name, UString text)
 
     : CBaseUIButton(xPos, yPos, xSize, ySize, name, text) {
 
     m_mainMenu = mainMenu;
 
 }
 
 
 
-void OsuMainMenuCubeButton::draw(Graphics *g) {
 
+void MainMenuCubeButton::draw(Graphics *g) {
 
     // draw nothing
 
     /// CBaseUIButton::draw(g);
 
 }
 
 
 
-void OsuMainMenuCubeButton::onMouseInside() {
 
+void MainMenuCubeButton::onMouseInside() {
 
     anim->moveQuadInOut(&m_mainMenu->m_fSizeAddAnim, 0.12f, 0.15f, 0.0f, true);
 
 
 
     CBaseUIButton::onMouseInside();
 
 }
 
 
 
-void OsuMainMenuCubeButton::onMouseOutside() {
 
+void MainMenuCubeButton::onMouseOutside() {
 
     anim->moveQuadInOut(&m_mainMenu->m_fSizeAddAnim, 0.0f, 0.15f, 0.0f, true);
 
 
 
     CBaseUIButton::onMouseOutside();
 
 }
 
 
 
-OsuMainMenuButton::OsuMainMenuButton(OsuMainMenu *mainMenu, float xPos, float yPos, float xSize, float ySize,
 
-                                     UString name, UString text)
 
+MainMenuButton::MainMenuButton(MainMenu *mainMenu, float xPos, float yPos, float xSize, float ySize, UString name,
 
+                               UString text)
 
     : CBaseUIButton(xPos, yPos, xSize, ySize, name, text) {
 
     m_mainMenu = mainMenu;
 
 }
 
 
 
-void OsuMainMenuButton::onMouseDownInside() {
 
+void MainMenuButton::onMouseDownInside() {
 
     if(m_mainMenu->m_cube->isMouseInside()) return;
 
 
 
     engine->getSound()->play(m_mainMenu->getOsu()->getSkin()->getMenuHit());
--- a/src/App/Osu/OsuMainMenu.h
+++ b/src/App/Osu/OsuMainMenu.h
@@ -15,22 +15,22 @@
 
 class McFont;
 
 class Osu;
 
 
 
-class OsuBeatmap;
 
-class OsuDatabaseBeatmap;
 
+class Beatmap;
 
+class DatabaseBeatmap;
 
 
 
-class OsuHitObject;
 
+class HitObject;
 
 
 
-class OsuMainMenuCubeButton;
 
-class OsuMainMenuButton;
 
-class OsuUIButton;
 
+class MainMenuCubeButton;
 
+class MainMenuButton;
 
+class UIButton;
 
 
 
 class CBaseUIContainer;
 
 
 
 class ConVar;
 
 
 
-class OsuMainMenuPauseButton : public CBaseUIButton {
 
+class MainMenuPauseButton : public CBaseUIButton {
 
    public:
 
-    OsuMainMenuPauseButton(float xPos, float yPos, float xSize, float ySize, UString name, UString text)
 
+    MainMenuPauseButton(float xPos, float yPos, float xSize, float ySize, UString name, UString text)
 
         : CBaseUIButton(xPos, yPos, xSize, ySize, name, text) {
 
         m_bIsPaused = true;
 
     }
@@ -42,23 +42,23 @@ class OsuMainMenuPauseButton : public CBaseUIButton {
 
     bool m_bIsPaused;
 
 };
 
 
 
-class OsuMainMenu : public OsuScreen, public MouseListener {
 
+class MainMenu : public OsuScreen, public MouseListener {
 
    public:
 
     static UString NEOSU_MAIN_BUTTON_TEXT;
 
     static UString NEOSU_MAIN_BUTTON_SUBTEXT;
 
 
 
-    friend class OsuMainMenuCubeButton;
 
-    friend class OsuMainMenuButton;
 
+    friend class MainMenuCubeButton;
 
+    friend class MainMenuButton;
 
     void onPausePressed();
 
     void onCubePressed();
 
 
 
-    OsuMainMenu(Osu *osu);
 
-    virtual ~OsuMainMenu();
 
+    MainMenu(Osu *osu);
 
+    virtual ~MainMenu();
 
 
 
     virtual void draw(Graphics *g);
 
     virtual void mouse_update(bool *propagate_clicks);
 
 
 
-    OsuDatabaseBeatmap *preloaded_beatmap = nullptr;
 
+    DatabaseBeatmap *preloaded_beatmap = nullptr;
 
     void selectRandomBeatmap();
 
 
 
     virtual void onKeyDown(KeyboardEvent &e);
@@ -99,7 +99,7 @@ class OsuMainMenu : public OsuScreen, public MouseListener {
 
 
 
     void writeVersionFile();
 
 
 
-    OsuMainMenuButton *addMainMenuButton(UString text);
 
+    MainMenuButton *addMainMenuButton(UString text);
 
 
 
     void onPlayButtonPressed();
 
     void onMultiplayerButtonPressed();
@@ -124,11 +124,11 @@ class OsuMainMenu : public OsuScreen, public MouseListener {
 
     bool m_bMenuElementsVisible;
 
     float m_fMainMenuButtonCloseTime = 0.f;
 
 
 
-    OsuMainMenuCubeButton *m_cube;
 
-    std::vector<OsuMainMenuButton *> m_menuElements;
 
+    MainMenuCubeButton *m_cube;
 
+    std::vector<MainMenuButton *> m_menuElements;
 
 
 
-    OsuMainMenuPauseButton *m_pauseButton;
 
-    OsuUIButton *m_updateAvailableButton;
 
+    MainMenuPauseButton *m_pauseButton;
 
+    UIButton *m_updateAvailableButton;
 
     CBaseUIButton *m_versionButton;
 
 
 
     bool m_bDrawVersionNotificationArrow;
--- a/src/App/Osu/OsuModFPoSu.cpp
+++ b/src/App/Osu/OsuModFPoSu.cpp
@@ -5,30 +5,30 @@
 
 // $NoKeywords: $fposu
 
 //=============================================================================================//
 
 
 
-#include "OsuModFPoSu.h"
 
+#include "ModFPoSu.h"
 
 
 
 #include <sstream>
 
 
 
 #include "AnimationHandler.h"
 
+#include "BackgroundImageHandler.h"
 
+#include "Beatmap.h"
 
 #include "Camera.h"
 
 #include "ConVar.h"
 
 #include "DirectX11Interface.h"
 
 #include "Engine.h"
 
 #include "Environment.h"
 
+#include "KeyBindings.h"
 
 #include "Keyboard.h"
 
+#include "ModSelector.h"
 
 #include "Mouse.h"
 
 #include "OpenGL3Interface.h"
 
 #include "OpenGLES2Interface.h"
 
 #include "OpenGLHeaders.h"
 
 #include "OpenGLLegacyInterface.h"
 
+#include "OptionsMenu.h"
 
 #include "Osu.h"
 
-#include "OsuBackgroundImageHandler.h"
 
-#include "OsuBeatmap.h"
 
-#include "OsuKeyBindings.h"
 
-#include "OsuModSelector.h"
 
-#include "OsuOptionsMenu.h"
 
-#include "OsuSkin.h"
 
 #include "ResourceManager.h"
 
+#include "Skin.h"
 
 
 
 ConVar osu_mod_fposu("osu_mod_fposu", false, FCVAR_NONE);
 
 
@@ -81,10 +81,10 @@ ConVar fposu_mod_strafing_frequency_z("fposu_mod_strafing_frequency_z", 0.15f, F
 
 
 
 ConVar fposu_mod_3d_depthwobble("fposu_mod_3d_depthwobble", false, FCVAR_NONVANILLA);
 
 
 
-constexpr const float OsuModFPoSu::SIZEDIV3D;
 
-constexpr const int OsuModFPoSu::SUBDIVISIONS;
 
+constexpr const float ModFPoSu::SIZEDIV3D;
 
+constexpr const int ModFPoSu::SUBDIVISIONS;
 
 
 
-OsuModFPoSu::OsuModFPoSu(Osu *osu) {
 
+ModFPoSu::ModFPoSu(Osu *osu) {
 
     m_osu = osu;
 
 
 
     // convar refs
@@ -115,18 +115,18 @@ OsuModFPoSu::OsuModFPoSu(Osu *osu) {
 
     m_hitcircleShader = NULL;
 
 
 
     // convar callbacks
 
-    fposu_curved.setCallback(fastdelegate::MakeDelegate(this, &OsuModFPoSu::onCurvedChange));
 
-    fposu_distance.setCallback(fastdelegate::MakeDelegate(this, &OsuModFPoSu::onDistanceChange));
 
-    fposu_noclip.setCallback(fastdelegate::MakeDelegate(this, &OsuModFPoSu::onNoclipChange));
 
+    fposu_curved.setCallback(fastdelegate::MakeDelegate(this, &ModFPoSu::onCurvedChange));
 
+    fposu_distance.setCallback(fastdelegate::MakeDelegate(this, &ModFPoSu::onDistanceChange));
 
+    fposu_noclip.setCallback(fastdelegate::MakeDelegate(this, &ModFPoSu::onNoclipChange));
 
 
 
     // init
 
     makePlayfield();
 
     makeBackgroundCube();
 
 }
 
 
 
-OsuModFPoSu::~OsuModFPoSu() { anim->deleteExistingAnimation(&m_fZoomFOVAnimPercent); }
 
+ModFPoSu::~ModFPoSu() { anim->deleteExistingAnimation(&m_fZoomFOVAnimPercent); }
 
 
 
-void OsuModFPoSu::draw(Graphics *g) {
 
+void ModFPoSu::draw(Graphics *g) {
 
     if(!osu_mod_fposu.getBool()) return;
 
 
 
     const float fov = lerp<float>(fposu_fov.getFloat(), fposu_zoom_fov.getFloat(), m_fZoomFOVAnimPercent);
@@ -244,7 +244,7 @@ void OsuModFPoSu::draw(Graphics *g) {
 
     g->setBlending(true);
 
 }
 
 
 
-void OsuModFPoSu::update() {
 
+void ModFPoSu::update() {
 
     if(!osu_mod_fposu.getBool()) return;
 
 
 
     if(fposu_noclip.getBool()) noclipMove();
@@ -352,7 +352,7 @@ void OsuModFPoSu::update() {
 
     }
 
 }
 
 
 
-void OsuModFPoSu::noclipMove() {
 
+void ModFPoSu::noclipMove() {
 
     const float noclipSpeed = fposu_noclipspeed.getFloat() * (engine->getKeyboard()->isShiftDown() ? 3.0f : 1.0f) *
 
                               (engine->getKeyboard()->isControlDown() ? 0.2f : 1);
 
     const float noclipAccelerate = fposu_noclipaccelerate.getFloat();
@@ -418,8 +418,8 @@ void OsuModFPoSu::noclipMove() {
 
     m_camera->setPos(m_camera->getPos() + m_vVelocity * engine->getFrameTime());
 
 }
 
 
 
-void OsuModFPoSu::onKeyDown(KeyboardEvent &key) {
 
-    if(key == (KEYCODE)OsuKeyBindings::FPOSU_ZOOM.getInt() && !m_bZoomKeyDown) {
 
+void ModFPoSu::onKeyDown(KeyboardEvent &key) {
 
+    if(key == (KEYCODE)KeyBindings::FPOSU_ZOOM.getInt() && !m_bZoomKeyDown) {
 
         m_bZoomKeyDown = true;
 
 
 
         if(!m_bZoomed || fposu_zoom_toggle.getBool()) {
@@ -443,8 +443,8 @@ void OsuModFPoSu::onKeyDown(KeyboardEvent &key) {
 
     }
 
 }
 
 
 
-void OsuModFPoSu::onKeyUp(KeyboardEvent &key) {
 
-    if(key == (KEYCODE)OsuKeyBindings::FPOSU_ZOOM.getInt()) {
 
+void ModFPoSu::onKeyUp(KeyboardEvent &key) {
 
+    if(key == (KEYCODE)KeyBindings::FPOSU_ZOOM.getInt()) {
 
         m_bZoomKeyDown = false;
 
 
 
         if(m_bZoomed && !fposu_zoom_toggle.getBool()) {
@@ -460,7 +460,7 @@ void OsuModFPoSu::onKeyUp(KeyboardEvent &key) {
 
     if(key == KEY_SPACE) m_bKeySpaceDown = false;
 
 }
 
 
 
-void OsuModFPoSu::handleZoomedChange() {
 
+void ModFPoSu::handleZoomedChange() {
 
     if(m_bZoomed)
 
         anim->moveQuadOut(&m_fZoomFOVAnimPercent, 1.0f,
 
                           (1.0f - m_fZoomFOVAnimPercent) * fposu_zoom_anim_duration.getFloat(), true);
@@ -469,7 +469,7 @@ void OsuModFPoSu::handleZoomedChange() {
 
                           true);
 
 }
 
 
 
-void OsuModFPoSu::setMousePosCompensated(Vector2 newMousePos) {
 
+void ModFPoSu::setMousePosCompensated(Vector2 newMousePos) {
 
     // NOTE: letterboxing uses Mouse::setOffset() to offset the virtual engine cursor coordinate system, so we have to
 
     // respect that when setting a new (absolute) position
 
     newMousePos -= engine->getMouse()->getOffset();
@@ -478,7 +478,7 @@ void OsuModFPoSu::setMousePosCompensated(Vector2 newMousePos) {
 
     env->setMousePos(newMousePos.x, newMousePos.y);
 
 }
 
 
 
-Vector2 OsuModFPoSu::intersectRayMesh(Vector3 pos, Vector3 dir) {
 
+Vector2 ModFPoSu::intersectRayMesh(Vector3 pos, Vector3 dir) {
 
     std::list<VertexPair>::iterator begin = m_meshList.begin();
 
     std::list<VertexPair>::iterator next = ++m_meshList.begin();
 
     int face = 0;
@@ -541,7 +541,7 @@ Vector2 OsuModFPoSu::intersectRayMesh(Vector3 pos, Vector3 dir) {
 
     return Vector2(0, 0);
 
 }
 
 
 
-Vector3 OsuModFPoSu::calculateUnProjectedVector(Vector2 pos) {
 
+Vector3 ModFPoSu::calculateUnProjectedVector(Vector2 pos) {
 
     // calculate 3d position of 2d cursor on screen mesh
 
     const float cursorXPercent = clamp<float>(pos.x / (float)m_osu->getScreenWidth(), 0.0f, 1.0f);
 
     const float cursorYPercent = clamp<float>(pos.y / (float)m_osu->getScreenHeight(), 0.0f, 1.0f);
@@ -583,7 +583,7 @@ Vector3 OsuModFPoSu::calculateUnProjectedVector(Vector2 pos) {
 
     return Vector3(-0.5f, 0.5f, -0.5f);
 
 }
 
 
 
-void OsuModFPoSu::makePlayfield() {
 
+void ModFPoSu::makePlayfield() {
 
     m_vao->clear();
 
     m_meshList.clear();
 
 
@@ -653,7 +653,7 @@ void OsuModFPoSu::makePlayfield() {
 
     }
 
 }
 
 
 
-void OsuModFPoSu::makeBackgroundCube() {
 
+void ModFPoSu::makeBackgroundCube() {
 
     m_vaoCube->clear();
 
 
 
     const float size = fposu_cube_size.getFloat();
@@ -749,11 +749,11 @@ void OsuModFPoSu::makeBackgroundCube() {
 
     m_vaoCube->addTexcoord(0.0f, 1.0f);
 
 }
 
 
 
-void OsuModFPoSu::onCurvedChange(UString oldValue, UString newValue) { makePlayfield(); }
 
+void ModFPoSu::onCurvedChange(UString oldValue, UString newValue) { makePlayfield(); }
 
 
 
-void OsuModFPoSu::onDistanceChange(UString oldValue, UString newValue) { makePlayfield(); }
 
+void ModFPoSu::onDistanceChange(UString oldValue, UString newValue) { makePlayfield(); }
 
 
 
-void OsuModFPoSu::onNoclipChange(UString oldValue, UString newValue) {
 
+void ModFPoSu::onNoclipChange(UString oldValue, UString newValue) {
 
     if(fposu_noclip.getBool())
 
         m_camera->setPos(m_vPrevNoclipCameraPos);
 
     else {
@@ -762,8 +762,8 @@ void OsuModFPoSu::onNoclipChange(UString oldValue, UString newValue) {
 
     }
 
 }
 
 
 
-float OsuModFPoSu::subdivide(std::list<VertexPair> &meshList, const std::list<VertexPair>::iterator &begin,
 
-                             const std::list<VertexPair>::iterator &end, int n, float edgeDistance) {
 
+float ModFPoSu::subdivide(std::list<VertexPair> &meshList, const std::list<VertexPair>::iterator &begin,
 
+                          const std::list<VertexPair>::iterator &end, int n, float edgeDistance) {
 
     const Vector3 a = Vector3((*begin).a.x, 0.0f, (*begin).a.z);
 
     const Vector3 b = Vector3((*end).a.x, 0.0f, (*end).a.z);
 
     Vector3 middlePoint =
@@ -795,7 +795,7 @@ float OsuModFPoSu::subdivide(std::list<VertexPair> &meshList, const std::list<Ve
 
     return circumLength;
 
 }
 
 
 
-Vector3 OsuModFPoSu::normalFromTriangle(Vector3 p1, Vector3 p2, Vector3 p3) {
 
+Vector3 ModFPoSu::normalFromTriangle(Vector3 p1, Vector3 p2, Vector3 p3) {
 
     const Vector3 u = (p2 - p1);
 
     const Vector3 v = (p3 - p1);
 
 
--- a/src/App/Osu/OsuModFPoSu.h
+++ b/src/App/Osu/OsuModFPoSu.h
@@ -20,16 +20,16 @@ class Image;
 
 class Shader;
 
 class VertexArrayObject;
 
 
 
-class OsuModFPoSu {
 
+class ModFPoSu {
 
    public:
 
-    static constexpr const float SIZEDIV3D = 1.0f / 512.0f;  // 1.0f / (float)OsuGameRules::OSU_COORD_WIDTH
 
+    static constexpr const float SIZEDIV3D = 1.0f / 512.0f;  // 1.0f / (float)GameRules::OSU_COORD_WIDTH
 
 
 
    private:
 
     static constexpr const int SUBDIVISIONS = 4;
 
 
 
    public:
 
-    OsuModFPoSu(Osu *osu);
 
-    ~OsuModFPoSu();
 
+    ModFPoSu(Osu *osu);
 
+    ~ModFPoSu();
 
 
 
     void draw(Graphics *g);
 
     void update();
--- a/src/App/Osu/OsuModSelector.cpp
+++ b/src/App/Osu/OsuModSelector.cpp
@@ -5,11 +5,12 @@
 
 // $NoKeywords: $osums
 
 //===============================================================================//
 
 
 
-#include "OsuModSelector.h"
 
+#include "ModSelector.h"
 
 
 
 #include "AnimationHandler.h"
 
 #include "Bancho.h"
 
 #include "BanchoNetworking.h"
 
+#include "Beatmap.h"
 
 #include "CBaseUICheckbox.h"
 
 #include "CBaseUIContainer.h"
 
 #include "CBaseUIImageButton.h"
@@ -17,37 +18,36 @@
 
 #include "CBaseUIScrollView.h"
 
 #include "CBaseUISlider.h"
 
 #include "ConVar.h"
 
+#include "DatabaseBeatmap.h"
 
 #include "Engine.h"
 
 #include "Environment.h"
 
+#include "GameRules.h"
 
+#include "HUD.h"
 
+#include "Icons.h"
 
+#include "KeyBindings.h"
 
 #include "Keyboard.h"
 
 #include "Mouse.h"
 
+#include "OptionsMenu.h"
 
 #include "Osu.h"
 
-#include "OsuBeatmap.h"
 
-#include "OsuDatabaseBeatmap.h"
 
-#include "OsuGameRules.h"
 
-#include "OsuHUD.h"
 
-#include "OsuIcons.h"
 
-#include "OsuKeyBindings.h"
 
-#include "OsuOptionsMenu.h"
 
-#include "OsuReplay.h"
 
-#include "OsuRichPresence.h"
 
-#include "OsuRoom.h"
 
-#include "OsuSkin.h"
 
-#include "OsuSkinImage.h"
 
-#include "OsuSongBrowser.h"
 
-#include "OsuTooltipOverlay.h"
 
-#include "OsuUIButton.h"
 
-#include "OsuUICheckbox.h"
 
-#include "OsuUIModSelectorModButton.h"
 
-#include "OsuUISlider.h"
 
+#include "Replay.h"
 
 #include "ResourceManager.h"
 
+#include "RichPresence.h"
 
+#include "RoomScreen.h"
 
+#include "Skin.h"
 
+#include "SkinImage.h"
 
+#include "SongBrowser.h"
 
 #include "SoundEngine.h"
 
+#include "TooltipOverlay.h"
 
+#include "UIButton.h"
 
+#include "UICheckbox.h"
 
+#include "UIModSelectorModButton.h"
 
+#include "UISlider.h"
 
 #include "VertexArrayObject.h"
 
 
 
-class OsuModSelectorOverrideSliderDescButton : public CBaseUIButton {
 
+class ModSelectorOverrideSliderDescButton : public CBaseUIButton {
 
    public:
 
-    OsuModSelectorOverrideSliderDescButton(Osu *osu, float xPos, float yPos, float xSize, float ySize, UString name,
 
-                                           UString text)
 
+    ModSelectorOverrideSliderDescButton(Osu *osu, float xPos, float yPos, float xSize, float ySize, UString name,
 
+                                        UString text)
 
         : CBaseUIButton(xPos, yPos, xSize, ySize, name, text) {
 
         m_osu = osu;
 
     }
@@ -89,10 +89,10 @@ class OsuModSelectorOverrideSliderDescButton : public CBaseUIButton {
 
     UString m_sTooltipText;
 
 };
 
 
 
-class OsuModSelectorOverrideSliderLockButton : public CBaseUICheckbox {
 
+class ModSelectorOverrideSliderLockButton : public CBaseUICheckbox {
 
    public:
 
-    OsuModSelectorOverrideSliderLockButton(Osu *osu, float xPos, float yPos, float xSize, float ySize, UString name,
 
-                                           UString text)
 
+    ModSelectorOverrideSliderLockButton(Osu *osu, float xPos, float yPos, float xSize, float ySize, UString name,
 
+                                        UString text)
 
         : CBaseUICheckbox(xPos, yPos, xSize, ySize, name, text) {
 
         m_osu = osu;
 
         m_fAnim = 1.0f;
@@ -101,7 +101,7 @@ class OsuModSelectorOverrideSliderLockButton : public CBaseUICheckbox {
 
     virtual void draw(Graphics *g) {
 
         if(!m_bVisible) return;
 
 
 
-        const wchar_t icon = (m_bChecked ? OsuIcons::LOCK : OsuIcons::UNLOCK);
 
+        const wchar_t icon = (m_bChecked ? Icons::LOCK : Icons::UNLOCK);
 
         UString iconString;
 
         iconString.insert(0, icon);
 
 
@@ -137,7 +137,7 @@ class OsuModSelectorOverrideSliderLockButton : public CBaseUICheckbox {
 
     float m_fAnim;
 
 };
 
 
 
-OsuModSelector::OsuModSelector(Osu *osu) : OsuScreen(osu) {
 
+ModSelector::ModSelector(Osu *osu) : OsuScreen(osu) {
 
     m_fAnimation = 0.0f;
 
     m_fExperimentalAnimation = 0.0f;
 
     m_bScheduledHide = false;
@@ -169,7 +169,7 @@ OsuModSelector::OsuModSelector(Osu *osu) : OsuScreen(osu) {
 
 
 
     for(int x = 0; x < m_iGridWidth; x++) {
 
         for(int y = 0; y < m_iGridHeight; y++) {
 
-            OsuUIModSelectorModButton *imageButton = new OsuUIModSelectorModButton(m_osu, this, 50, 50, 100, 100, "");
 
+            UIModSelectorModButton *imageButton = new UIModSelectorModButton(m_osu, this, 50, 50, 100, 100, "");
 
             imageButton->setDrawBackground(false);
 
             imageButton->setVisible(false);
 
 
@@ -192,13 +192,13 @@ OsuModSelector::OsuModSelector(Osu *osu) : OsuScreen(osu) {
 
 
 
     overrideCS.slider->setAnimated(false);  // quick fix for otherwise possible inconsistencies due to slider vertex
 
                                             // buffers and animated CS changes
 
-    overrideCS.slider->setChangeCallback(fastdelegate::MakeDelegate(this, &OsuModSelector::onOverrideSliderChange));
 
-    overrideAR.slider->setChangeCallback(fastdelegate::MakeDelegate(this, &OsuModSelector::onOverrideSliderChange));
 
-    overrideOD.slider->setChangeCallback(fastdelegate::MakeDelegate(this, &OsuModSelector::onOverrideSliderChange));
 
-    overrideHP.slider->setChangeCallback(fastdelegate::MakeDelegate(this, &OsuModSelector::onOverrideSliderChange));
 
+    overrideCS.slider->setChangeCallback(fastdelegate::MakeDelegate(this, &ModSelector::onOverrideSliderChange));
 
+    overrideAR.slider->setChangeCallback(fastdelegate::MakeDelegate(this, &ModSelector::onOverrideSliderChange));
 
+    overrideOD.slider->setChangeCallback(fastdelegate::MakeDelegate(this, &ModSelector::onOverrideSliderChange));
 
+    overrideHP.slider->setChangeCallback(fastdelegate::MakeDelegate(this, &ModSelector::onOverrideSliderChange));
 
 
 
-    overrideAR.desc->setClickCallback(fastdelegate::MakeDelegate(this, &OsuModSelector::onOverrideARSliderDescClicked));
 
-    overrideOD.desc->setClickCallback(fastdelegate::MakeDelegate(this, &OsuModSelector::onOverrideODSliderDescClicked));
 
+    overrideAR.desc->setClickCallback(fastdelegate::MakeDelegate(this, &ModSelector::onOverrideARSliderDescClicked));
 
+    overrideOD.desc->setClickCallback(fastdelegate::MakeDelegate(this, &ModSelector::onOverrideODSliderDescClicked));
 
 
 
     m_CSSlider = overrideCS.slider;
 
     m_ARSlider = overrideAR.slider;
@@ -210,7 +210,7 @@ OsuModSelector::OsuModSelector(Osu *osu) : OsuScreen(osu) {
 
     OVERRIDE_SLIDER overrideSpeed =
 
         addOverrideSlider("Speed/BPM Multiplier", "x", convar->getConVarByName("osu_speed_override"), 0.0f, 2.5f);
 
 
 
-    overrideSpeed.slider->setChangeCallback(fastdelegate::MakeDelegate(this, &OsuModSelector::onOverrideSliderChange));
 
+    overrideSpeed.slider->setChangeCallback(fastdelegate::MakeDelegate(this, &ModSelector::onOverrideSliderChange));
 
     // overrideSpeed.slider->setValue(-1.0f, false);
 
     overrideSpeed.slider->setAnimated(false);  // same quick fix as above
 
     overrideSpeed.slider->setLiveUpdate(false);
@@ -292,99 +292,99 @@ OsuModSelector::OsuModSelector(Osu *osu) : OsuScreen(osu) {
 
 
 
     // build action buttons
 
     m_resetModsButton = addActionButton("1. Reset All Mods");
 
-    m_resetModsButton->setClickCallback(fastdelegate::MakeDelegate(this, &OsuModSelector::resetModsUserInitiated));
 
+    m_resetModsButton->setClickCallback(fastdelegate::MakeDelegate(this, &ModSelector::resetModsUserInitiated));
 
     m_resetModsButton->setColor(0xffff3800);
 
     m_closeButton = addActionButton("2. Close");
 
-    m_closeButton->setClickCallback(fastdelegate::MakeDelegate(this, &OsuModSelector::close));
 
+    m_closeButton->setClickCallback(fastdelegate::MakeDelegate(this, &ModSelector::close));
 
     m_closeButton->setColor(0xff8f8f8f);
 
 
 
     updateButtons(true);
 
     updateLayout();
 
 }
 
 
 
-void OsuModSelector::updateButtons(bool initial) {
 
+void ModSelector::updateButtons(bool initial) {
 
     m_modButtonEasy = setModButtonOnGrid(
 
         0, 0, 0, initial && m_osu->getModEZ(), "ez",
 
         "Reduces overall difficulty - larger circles, more forgiving HP drain, less accuracy required.",
 
-        [this]() -> OsuSkinImage * { return m_osu->getSkin()->getSelectionModEasy(); });
 
+        [this]() -> SkinImage * { return m_osu->getSkin()->getSelectionModEasy(); });
 
     m_modButtonNofail =
 
         setModButtonOnGrid(1, 0, 0, initial && m_osu->getModNF(), "nf",
 
                            "You can't fail. No matter what.\nNOTE: To disable drain completely:\nOptions > Gameplay > "
 
                            "Mechanics > \"Select HP Drain\" > \"None\".",
 
-                           [this]() -> OsuSkinImage * { return m_osu->getSkin()->getSelectionModNoFail(); });
 
+                           [this]() -> SkinImage * { return m_osu->getSkin()->getSelectionModNoFail(); });
 
     m_modButtonNofail->setAvailable(m_osu_drain_type_ref->getInt() > 1);
 
     setModButtonOnGrid(4, 0, 0, initial && m_osu->getModNightmare(), "nightmare",
 
                        "Unnecessary clicks count as misses.\nMassively reduced slider follow circle radius.",
 
-                       [this]() -> OsuSkinImage * { return m_osu->getSkin()->getSelectionModNightmare(); });
 
+                       [this]() -> SkinImage * { return m_osu->getSkin()->getSelectionModNightmare(); });
 
 
 
     m_modButtonHardrock =
 
         setModButtonOnGrid(0, 1, 0, initial && m_osu->getModHR(), "hr", "Everything just got a bit harder...",
 
-                           [this]() -> OsuSkinImage * { return m_osu->getSkin()->getSelectionModHardRock(); });
 
+                           [this]() -> SkinImage * { return m_osu->getSkin()->getSelectionModHardRock(); });
 
     m_modButtonSuddendeath =
 
         setModButtonOnGrid(1, 1, 0, initial && m_osu->getModSD(), "sd", "Miss a note and fail.",
 
-                           [this]() -> OsuSkinImage * { return m_osu->getSkin()->getSelectionModSuddenDeath(); });
 
+                           [this]() -> SkinImage * { return m_osu->getSkin()->getSelectionModSuddenDeath(); });
 
     setModButtonOnGrid(1, 1, 1, initial && m_osu->getModSS(), "ss", "SS or quit.",
 
-                       [this]() -> OsuSkinImage * { return m_osu->getSkin()->getSelectionModPerfect(); });
 
+                       [this]() -> SkinImage * { return m_osu->getSkin()->getSelectionModPerfect(); });
 
 
 
     if(convar->getConVarByName("nightcore_enjoyer")->getBool()) {
 
         m_modButtonHalftime =
 
             setModButtonOnGrid(2, 0, 0, initial && m_osu->getModDC(), "dc", "A E S T H E T I C",
 
-                               [this]() -> OsuSkinImage * { return m_osu->getSkin()->getSelectionModDayCore(); });
 
+                               [this]() -> SkinImage * { return m_osu->getSkin()->getSelectionModDayCore(); });
 
         setModButtonOnGrid(2, 0, 1, initial && m_osu->getModHT(), "ht", "Less zoom.",
 
-                           [this]() -> OsuSkinImage * { return m_osu->getSkin()->getSelectionModHalfTime(); });
 
+                           [this]() -> SkinImage * { return m_osu->getSkin()->getSelectionModHalfTime(); });
 
 
 
         m_modButtonDoubletime =
 
             setModButtonOnGrid(2, 1, 0, initial && m_osu->getModNC(), "nc", "uguuuuuuuu",
 
-                               [this]() -> OsuSkinImage * { return m_osu->getSkin()->getSelectionModNightCore(); });
 
+                               [this]() -> SkinImage * { return m_osu->getSkin()->getSelectionModNightCore(); });
 
         setModButtonOnGrid(2, 1, 1, initial && m_osu->getModDT(), "dt", "Zoooooooooom.",
 
-                           [this]() -> OsuSkinImage * { return m_osu->getSkin()->getSelectionModDoubleTime(); });
 
+                           [this]() -> SkinImage * { return m_osu->getSkin()->getSelectionModDoubleTime(); });
 
     } else {
 
         m_modButtonHalftime =
 
             setModButtonOnGrid(2, 0, 0, initial && m_osu->getModHT(), "ht", "Less zoom.",
 
-                               [this]() -> OsuSkinImage * { return m_osu->getSkin()->getSelectionModHalfTime(); });
 
+                               [this]() -> SkinImage * { return m_osu->getSkin()->getSelectionModHalfTime(); });
 
         setModButtonOnGrid(2, 0, 1, initial && m_osu->getModDC(), "dc", "A E S T H E T I C",
 
-                           [this]() -> OsuSkinImage * { return m_osu->getSkin()->getSelectionModDayCore(); });
 
+                           [this]() -> SkinImage * { return m_osu->getSkin()->getSelectionModDayCore(); });
 
 
 
         m_modButtonDoubletime =
 
             setModButtonOnGrid(2, 1, 0, initial && m_osu->getModDT(), "dt", "Zoooooooooom.",
 
-                               [this]() -> OsuSkinImage * { return m_osu->getSkin()->getSelectionModDoubleTime(); });
 
+                               [this]() -> SkinImage * { return m_osu->getSkin()->getSelectionModDoubleTime(); });
 
         setModButtonOnGrid(2, 1, 1, initial && m_osu->getModNC(), "nc", "uguuuuuuuu",
 
-                           [this]() -> OsuSkinImage * { return m_osu->getSkin()->getSelectionModNightCore(); });
 
+                           [this]() -> SkinImage * { return m_osu->getSkin()->getSelectionModNightCore(); });
 
     }
 
 
 
     m_modButtonHidden =
 
         setModButtonOnGrid(3, 1, 0, initial && m_osu->getModHD(), "hd",
 
                            "Play with no approach circles and fading notes for a slight score advantage.",
 
-                           [this]() -> OsuSkinImage * { return m_osu->getSkin()->getSelectionModHidden(); });
 
-    m_modButtonFlashlight =
 
-        setModButtonOnGrid(4, 1, 0, false, "fl", "Restricted view area.",
 
-                           [this]() -> OsuSkinImage * { return m_osu->getSkin()->getSelectionModFlashlight(); });
 
+                           [this]() -> SkinImage * { return m_osu->getSkin()->getSelectionModHidden(); });
 
+    m_modButtonFlashlight = setModButtonOnGrid(4, 1, 0, false, "fl", "Restricted view area.", [this]() -> SkinImage * {
 
+        return m_osu->getSkin()->getSelectionModFlashlight();
 
+    });
 
     m_modButtonTD = setModButtonOnGrid(5, 1, 0, initial && (m_osu->getModTD() || m_osu_mod_touchdevice_ref->getBool()),
 
                                        "nerftd", "Simulate pp nerf for touch devices.\nOnly affects pp calculation.",
 
-                                       [this]() -> OsuSkinImage * { return m_osu->getSkin()->getSelectionModTD(); });
 
+                                       [this]() -> SkinImage * { return m_osu->getSkin()->getSelectionModTD(); });
 
     getModButtonOnGrid(5, 1)->setAvailable(!m_osu_mod_touchdevice_ref->getBool());
 
 
 
     m_modButtonRelax = setModButtonOnGrid(
 
         0, 2, 0, initial && m_osu->getModRelax(), "relax",
 
         "You don't need to click.\nGive your clicking/tapping fingers a break from the heat of things.\n** UNRANKED **",
 
-        [this]() -> OsuSkinImage * { return m_osu->getSkin()->getSelectionModRelax(); });
 
+        [this]() -> SkinImage * { return m_osu->getSkin()->getSelectionModRelax(); });
 
     m_modButtonAutopilot =
 
         setModButtonOnGrid(1, 2, 0, initial && m_osu->getModAutopilot(), "autopilot",
 
                            "Automatic cursor movement - just follow the rhythm.\n** UNRANKED **",
 
-                           [this]() -> OsuSkinImage * { return m_osu->getSkin()->getSelectionModAutopilot(); });
 
+                           [this]() -> SkinImage * { return m_osu->getSkin()->getSelectionModAutopilot(); });
 
     m_modButtonSpunout = setModButtonOnGrid(
 
         2, 2, 0, initial && m_osu->getModSpunout(), "spunout", "Spinners will be automatically completed.",
 
-        [this]() -> OsuSkinImage * { return m_osu->getSkin()->getSelectionModSpunOut(); });
 
+        [this]() -> SkinImage * { return m_osu->getSkin()->getSelectionModSpunOut(); });
 
     m_modButtonAuto = setModButtonOnGrid(
 
         3, 2, 0, initial && m_osu->getModAuto(), "auto", "Watch a perfect automated play through the song.",
 
-        [this]() -> OsuSkinImage * { return m_osu->getSkin()->getSelectionModAutoplay(); });
 
+        [this]() -> SkinImage * { return m_osu->getSkin()->getSelectionModAutoplay(); });
 
     setModButtonOnGrid(4, 2, 0, initial && m_osu->getModTarget(), "practicetarget",
 
                        "Accuracy is based on the distance to the center of all hitobjects.\n300s still require at "
 
                        "least being in the hit window of a 100 in addition to the rule above.",
 
-                       [this]() -> OsuSkinImage * { return m_osu->getSkin()->getSelectionModTarget(); });
 
+                       [this]() -> SkinImage * { return m_osu->getSkin()->getSelectionModTarget(); });
 
     m_modButtonScoreV2 = setModButtonOnGrid(
 
         5, 2, 0, initial && m_osu->getModScorev2(), "v2", "Try the future scoring system.\n** UNRANKED **",
 
-        [this]() -> OsuSkinImage * { return m_osu->getSkin()->getSelectionModScorev2(); });
 
+        [this]() -> SkinImage * { return m_osu->getSkin()->getSelectionModScorev2(); });
 
 
 
     // Enable all mods that we disable conditionally below
 
     getModButtonOnGrid(2, 0)->setAvailable(true);
@@ -407,7 +407,7 @@ void OsuModSelector::updateButtons(bool initial) {
 
     }
 
 }
 
 
 
-void OsuModSelector::updateScoreMultiplierLabelText() {
 
+void ModSelector::updateScoreMultiplierLabelText() {
 
     const float scoreMultiplier = m_osu->getScoreMultiplier();
 
 
 
     const int alpha = 200;
@@ -421,7 +421,7 @@ void OsuModSelector::updateScoreMultiplierLabelText() {
 
     m_scoreMultiplierLabel->setText(UString::format("Score Multiplier: %.2fX", scoreMultiplier));
 
 }
 
 
 
-void OsuModSelector::updateExperimentalButtons(bool initial) {
 
+void ModSelector::updateExperimentalButtons(bool initial) {
 
     if(initial) {
 
         for(int i = 0; i < m_experimentalMods.size(); i++) {
 
             ConVar *cvar = m_experimentalMods[i].cvar;
@@ -436,12 +436,12 @@ void OsuModSelector::updateExperimentalButtons(bool initial) {
 
     }
 
 }
 
 
 
-OsuModSelector::~OsuModSelector() {
 
+ModSelector::~ModSelector() {
 
     SAFE_DELETE(m_overrideSliderContainer);
 
     SAFE_DELETE(m_experimentalContainer);
 
 }
 
 
 
-void OsuModSelector::draw(Graphics *g) {
 
+void ModSelector::draw(Graphics *g) {
 
     if(!m_bVisible && !m_bScheduledHide) return;
 
 
 
     // for compact mode (and experimental mods)
@@ -591,7 +591,7 @@ void OsuModSelector::draw(Graphics *g) {
 
     }
 
 }
 
 
 
-void OsuModSelector::mouse_update(bool *propagate_clicks) {
 
+void ModSelector::mouse_update(bool *propagate_clicks) {
 
     // HACKHACK: updating while invisible is stupid, but the only quick solution for still animating otherwise stuck
 
     // sliders while closed
 
     if(!m_bVisible) {
@@ -703,7 +703,7 @@ void OsuModSelector::mouse_update(bool *propagate_clicks) {
 
     }
 
 }
 
 
 
-void OsuModSelector::onKeyDown(KeyboardEvent &key) {
 
+void ModSelector::onKeyDown(KeyboardEvent &key) {
 
     OsuScreen::onKeyDown(key);  // only used for options menu
 
     if(!m_bVisible || key.isConsumed()) return;
 
 
@@ -711,35 +711,35 @@ void OsuModSelector::onKeyDown(KeyboardEvent &key) {
 
 
 
     if(key == KEY_1) resetModsUserInitiated();
 
 
 
-    if(((key == KEY_F1 || key == (KEYCODE)OsuKeyBindings::TOGGLE_MODSELECT.getInt()) && !m_bWaitForF1KeyUp) ||
 
-       key == KEY_2 || key == (KEYCODE)OsuKeyBindings::GAME_PAUSE.getInt() || key == KEY_ESCAPE || key == KEY_ENTER)
 
+    if(((key == KEY_F1 || key == (KEYCODE)KeyBindings::TOGGLE_MODSELECT.getInt()) && !m_bWaitForF1KeyUp) ||
 
+       key == KEY_2 || key == (KEYCODE)KeyBindings::GAME_PAUSE.getInt() || key == KEY_ESCAPE || key == KEY_ENTER)
 
         close();
 
 
 
     // mod hotkeys
 
-    if(key == (KEYCODE)OsuKeyBindings::MOD_EASY.getInt()) m_modButtonEasy->click();
 
-    if(key == (KEYCODE)OsuKeyBindings::MOD_NOFAIL.getInt()) m_modButtonNofail->click();
 
-    if(key == (KEYCODE)OsuKeyBindings::MOD_HALFTIME.getInt()) m_modButtonHalftime->click();
 
-    if(key == (KEYCODE)OsuKeyBindings::MOD_HARDROCK.getInt()) m_modButtonHardrock->click();
 
-    if(key == (KEYCODE)OsuKeyBindings::MOD_SUDDENDEATH.getInt()) m_modButtonSuddendeath->click();
 
-    if(key == (KEYCODE)OsuKeyBindings::MOD_DOUBLETIME.getInt()) m_modButtonDoubletime->click();
 
-    if(key == (KEYCODE)OsuKeyBindings::MOD_HIDDEN.getInt()) m_modButtonHidden->click();
 
-    if(key == (KEYCODE)OsuKeyBindings::MOD_FLASHLIGHT.getInt()) m_modButtonFlashlight->click();
 
-    if(key == (KEYCODE)OsuKeyBindings::MOD_RELAX.getInt()) m_modButtonRelax->click();
 
-    if(key == (KEYCODE)OsuKeyBindings::MOD_AUTOPILOT.getInt()) m_modButtonAutopilot->click();
 
-    if(key == (KEYCODE)OsuKeyBindings::MOD_SPUNOUT.getInt()) m_modButtonSpunout->click();
 
-    if(key == (KEYCODE)OsuKeyBindings::MOD_AUTO.getInt()) m_modButtonAuto->click();
 
-    if(key == (KEYCODE)OsuKeyBindings::MOD_SCOREV2.getInt()) m_modButtonScoreV2->click();
 
+    if(key == (KEYCODE)KeyBindings::MOD_EASY.getInt()) m_modButtonEasy->click();
 
+    if(key == (KEYCODE)KeyBindings::MOD_NOFAIL.getInt()) m_modButtonNofail->click();
 
+    if(key == (KEYCODE)KeyBindings::MOD_HALFTIME.getInt()) m_modButtonHalftime->click();
 
+    if(key == (KEYCODE)KeyBindings::MOD_HARDROCK.getInt()) m_modButtonHardrock->click();
 
+    if(key == (KEYCODE)KeyBindings::MOD_SUDDENDEATH.getInt()) m_modButtonSuddendeath->click();
 
+    if(key == (KEYCODE)KeyBindings::MOD_DOUBLETIME.getInt()) m_modButtonDoubletime->click();
 
+    if(key == (KEYCODE)KeyBindings::MOD_HIDDEN.getInt()) m_modButtonHidden->click();
 
+    if(key == (KEYCODE)KeyBindings::MOD_FLASHLIGHT.getInt()) m_modButtonFlashlight->click();
 
+    if(key == (KEYCODE)KeyBindings::MOD_RELAX.getInt()) m_modButtonRelax->click();
 
+    if(key == (KEYCODE)KeyBindings::MOD_AUTOPILOT.getInt()) m_modButtonAutopilot->click();
 
+    if(key == (KEYCODE)KeyBindings::MOD_SPUNOUT.getInt()) m_modButtonSpunout->click();
 
+    if(key == (KEYCODE)KeyBindings::MOD_AUTO.getInt()) m_modButtonAuto->click();
 
+    if(key == (KEYCODE)KeyBindings::MOD_SCOREV2.getInt()) m_modButtonScoreV2->click();
 
 
 
     key.consume();
 
 }
 
 
 
-void OsuModSelector::onKeyUp(KeyboardEvent &key) {
 
+void ModSelector::onKeyUp(KeyboardEvent &key) {
 
     if(!m_bVisible) return;
 
 
 
-    if(key == KEY_F1 || key == (KEYCODE)OsuKeyBindings::TOGGLE_MODSELECT.getInt()) m_bWaitForF1KeyUp = false;
 
+    if(key == KEY_F1 || key == (KEYCODE)KeyBindings::TOGGLE_MODSELECT.getInt()) m_bWaitForF1KeyUp = false;
 
 }
 
 
 
-CBaseUIContainer *OsuModSelector::setVisible(bool visible) {
 
+CBaseUIContainer *ModSelector::setVisible(bool visible) {
 
     if(visible && !m_bVisible) {
 
         m_bScheduledHide = false;
 
 
@@ -787,13 +787,13 @@ CBaseUIContainer *OsuModSelector::setVisible(bool visible) {
 
     return this;
 
 }
 
 
 
-bool OsuModSelector::isInCompactMode() { return m_osu->isInPlayMode(); }
 
+bool ModSelector::isInCompactMode() { return m_osu->isInPlayMode(); }
 
 
 
-bool OsuModSelector::isCSOverrideSliderActive() { return m_CSSlider->isActive(); }
 
+bool ModSelector::isCSOverrideSliderActive() { return m_CSSlider->isActive(); }
 
 
 
-bool OsuModSelector::isMouseInScrollView() { return m_experimentalContainer->isMouseInside() && isVisible(); }
 
+bool ModSelector::isMouseInScrollView() { return m_experimentalContainer->isMouseInside() && isVisible(); }
 
 
 
-bool OsuModSelector::isMouseInside() {
 
+bool ModSelector::isMouseInside() {
 
     bool isMouseInsideAnyModSelectorModButton = false;
 
     for(size_t i = 0; i < m_modButtons.size(); i++) {
 
         if(m_modButtons[i]->isMouseInside()) {
@@ -816,7 +816,7 @@ bool OsuModSelector::isMouseInside() {
 
                            isMouseInsideAnyOverrideSliders);
 
 }
 
 
 
-void OsuModSelector::updateLayout() {
 
+void ModSelector::updateLayout() {
 
     if(m_modButtons.size() < 1 || m_overrideSliders.size() < 1) return;
 
 
 
     const float dpiScale = Osu::getUIScale(m_osu);
@@ -833,7 +833,7 @@ void OsuModSelector::updateLayout() {
 
 
 
         for(int x = 0; x < m_iGridWidth; x++) {
 
             for(int y = 0; y < m_iGridHeight; y++) {
 
-                OsuUIModSelectorModButton *button = getModButtonOnGrid(x, y);
 
+                UIModSelectorModButton *button = getModButtonOnGrid(x, y);
 
 
 
                 if(button != NULL) {
 
                     button->setPos(start + Vector2(size.x * x + offset.x * x, size.y * y + offset.y * y));
@@ -924,7 +924,7 @@ void OsuModSelector::updateLayout() {
 
 
 
         for(int x = 0; x < m_iGridWidth; x++) {
 
             for(int y = 0; y < m_iGridHeight; y++) {
 
-                OsuUIModSelectorModButton *button = getModButtonOnGrid(x, y);
 
+                UIModSelectorModButton *button = getModButtonOnGrid(x, y);
 
 
 
                 if(button != NULL) {
 
                     button->setPos(start + Vector2(blockSize.x * x + offset.x * x, blockSize.y * y + offset.y * y));
@@ -978,7 +978,7 @@ void OsuModSelector::updateLayout() {
 
     updateExperimentalLayout();
 
 }
 
 
 
-void OsuModSelector::updateExperimentalLayout() {
 
+void ModSelector::updateExperimentalLayout() {
 
     const float dpiScale = Osu::getUIScale(m_osu);
 
 
 
     // experimental mods
@@ -1036,12 +1036,12 @@ void OsuModSelector::updateExperimentalLayout() {
 
     m_experimentalContainer->setVisible(!bancho.is_in_a_multi_room());
 
 }
 
 
 
-void OsuModSelector::updateModConVar() {
 
+void ModSelector::updateModConVar() {
 
     ConVar *osu_mods_ref = convar->getConVarByName("osu_mods");
 
 
 
     UString modString = "";
 
     for(int i = 0; i < m_modButtons.size(); i++) {
 
-        OsuUIModSelectorModButton *button = m_modButtons[i];
 
+        UIModSelectorModButton *button = m_modButtons[i];
 
         if(button->isOn()) modString.append(button->getActiveModName());
 
     }
 
 
@@ -1052,10 +1052,10 @@ void OsuModSelector::updateModConVar() {
 
     m_osu->updateMods();
 
 }
 
 
 
-OsuUIModSelectorModButton *OsuModSelector::setModButtonOnGrid(int x, int y, int state, bool initialState,
 
-                                                              UString modName, UString tooltipText,
 
-                                                              std::function<OsuSkinImage *()> getImageFunc) {
 
-    OsuUIModSelectorModButton *modButton = getModButtonOnGrid(x, y);
 
+UIModSelectorModButton *ModSelector::setModButtonOnGrid(int x, int y, int state, bool initialState, UString modName,
 
+                                                        UString tooltipText,
 
+                                                        std::function<SkinImage *()> getImageFunc) {
 
+    UIModSelectorModButton *modButton = getModButtonOnGrid(x, y);
 
 
 
     if(modButton != NULL) {
 
         modButton->setState(state, initialState, modName, tooltipText, getImageFunc);
@@ -1065,7 +1065,7 @@ OsuUIModSelectorModButton *OsuModSelector::setModButtonOnGrid(int x, int y, int
 
     return modButton;
 
 }
 
 
 
-OsuUIModSelectorModButton *OsuModSelector::getModButtonOnGrid(int x, int y) {
 
+UIModSelectorModButton *ModSelector::getModButtonOnGrid(int x, int y) {
 
     const int index = x * m_iGridHeight + y;
 
 
 
     if(index < m_modButtons.size())
@@ -1074,19 +1074,18 @@ OsuUIModSelectorModButton *OsuModSelector::getModButtonOnGrid(int x, int y) {
 
         return NULL;
 
 }
 
 
 
-OsuModSelector::OVERRIDE_SLIDER OsuModSelector::addOverrideSlider(UString text, UString labelText, ConVar *cvar,
 
-                                                                  float min, float max, UString tooltipText,
 
-                                                                  ConVar *lockCvar) {
 
+ModSelector::OVERRIDE_SLIDER ModSelector::addOverrideSlider(UString text, UString labelText, ConVar *cvar, float min,
 
+                                                            float max, UString tooltipText, ConVar *lockCvar) {
 
     int height = 25;
 
 
 
     OVERRIDE_SLIDER os;
 
     if(lockCvar != NULL) {
 
-        os.lock = new OsuModSelectorOverrideSliderLockButton(m_osu, 0, 0, height, height, "", "");
 
-        os.lock->setChangeCallback(fastdelegate::MakeDelegate(this, &OsuModSelector::onOverrideSliderLockChange));
 
+        os.lock = new ModSelectorOverrideSliderLockButton(m_osu, 0, 0, height, height, "", "");
 
+        os.lock->setChangeCallback(fastdelegate::MakeDelegate(this, &ModSelector::onOverrideSliderLockChange));
 
     }
 
-    os.desc = new OsuModSelectorOverrideSliderDescButton(m_osu, 0, 0, 100, height, "", text);
 
+    os.desc = new ModSelectorOverrideSliderDescButton(m_osu, 0, 0, 100, height, "", text);
 
     os.desc->setTooltipText(tooltipText);
 
-    os.slider = new OsuUISlider(m_osu, 0, 0, 100, height, "");
 
+    os.slider = new UISlider(m_osu, 0, 0, 100, height, "");
 
     os.label = new CBaseUILabel(0, 0, 100, height, labelText, labelText);
 
     os.cvar = cvar;
 
     os.lockCvar = lockCvar;
@@ -1122,15 +1121,15 @@ OsuModSelector::OVERRIDE_SLIDER OsuModSelector::addOverrideSlider(UString text,
 
     return os;
 
 }
 
 
 
-OsuUIButton *OsuModSelector::addActionButton(UString text) {
 
-    OsuUIButton *actionButton = new OsuUIButton(m_osu, 50, 50, 100, 100, text, text);
 
+UIButton *ModSelector::addActionButton(UString text) {
 
+    UIButton *actionButton = new UIButton(m_osu, 50, 50, 100, 100, text, text);
 
     m_actionButtons.push_back(actionButton);
 
     addBaseUIElement(actionButton);
 
 
 
     return actionButton;
 
 }
 
 
 
-CBaseUILabel *OsuModSelector::addExperimentalLabel(UString text) {
 
+CBaseUILabel *ModSelector::addExperimentalLabel(UString text) {
 
     CBaseUILabel *label = new CBaseUILabel(0, 0, 0, 25, text, text);
 
     label->setFont(m_osu->getSubTitleFont());
 
     label->setWidthToContent(0);
@@ -1146,13 +1145,13 @@ CBaseUILabel *OsuModSelector::addExperimentalLabel(UString text) {
 
     return label;
 
 }
 
 
 
-OsuUICheckbox *OsuModSelector::addExperimentalCheckbox(UString text, UString tooltipText, ConVar *cvar) {
 
-    OsuUICheckbox *checkbox = new OsuUICheckbox(m_osu, 0, 0, 0, 35, text, text);
 
+UICheckbox *ModSelector::addExperimentalCheckbox(UString text, UString tooltipText, ConVar *cvar) {
 
+    UICheckbox *checkbox = new UICheckbox(m_osu, 0, 0, 0, 35, text, text);
 
     checkbox->setTooltipText(tooltipText);
 
     checkbox->setWidthToContent(0);
 
     if(cvar != NULL) {
 
         checkbox->setChecked(cvar->getBool());
 
-        checkbox->setChangeCallback(fastdelegate::MakeDelegate(this, &OsuModSelector::onCheckboxChange));
 
+        checkbox->setChangeCallback(fastdelegate::MakeDelegate(this, &ModSelector::onCheckboxChange));
 
     }
 
     m_experimentalContainer->getContainer()->addBaseUIElement(checkbox);
 
 
@@ -1164,7 +1163,7 @@ OsuUICheckbox *OsuModSelector::addExperimentalCheckbox(UString text, UString too
 
     return checkbox;
 
 }
 
 
 
-void OsuModSelector::resetModsUserInitiated() {
 
+void ModSelector::resetModsUserInitiated() {
 
     bancho.prefer_daycore = false;
 
     resetMods();
 
 
@@ -1172,7 +1171,7 @@ void OsuModSelector::resetModsUserInitiated() {
 
     m_resetModsButton->animateClickColor();
 
 
 
     if(bancho.is_online()) {
 
-        OsuRichPresence::updateBanchoMods();
 
+        RichPresence::updateBanchoMods();
 
     }
 
 
 
     if(bancho.is_in_a_multi_room()) {
@@ -1189,7 +1188,7 @@ void OsuModSelector::resetModsUserInitiated() {
 
 
 
             Packet packet;
 
             packet.id = MATCH_CHANGE_MODS;
 
-            write_int32(&packet, bancho.room.slots[i].mods);
 
+            write_u32(&packet, bancho.room.slots[i].mods);
 
             send_packet(packet);
 
 
 
             m_osu->m_room->updateLayout(m_osu->getScreenSize());
@@ -1198,7 +1197,7 @@ void OsuModSelector::resetModsUserInitiated() {
 
     }
 
 }
 
 
 
-void OsuModSelector::resetMods() {
 
+void ModSelector::resetMods() {
 
     convar->getConVarByName("osu_mod_fposu")->setValue(false);
 
 
 
     for(int i = 0; i < m_overrideSliders.size(); i++) {
@@ -1229,8 +1228,8 @@ void OsuModSelector::resetMods() {
 
     }
 
 }
 
 
 
-uint32_t OsuModSelector::getModFlags() {
 
-    uint32_t flags = 0;
 
+u32 ModSelector::getModFlags() {
 
+    u32 flags = 0;
 
 
 
     if(m_modButtonDoubletime->isOn()) flags |= ModFlags::DoubleTime;
 
     if(m_modButtonDoubletime->getState() == 1) flags |= ModFlags::Nightcore;
@@ -1252,7 +1251,7 @@ uint32_t OsuModSelector::getModFlags() {
 
     return flags;
 
 }
 
 
 
-void OsuModSelector::enableModsFromFlags(uint32_t flags) {
 
+void ModSelector::enableModsFromFlags(u32 flags) {
 
     if(flags & ModFlags::DoubleTime) {
 
         m_modButtonDoubletime->setOn(true, true);
 
         if(flags & ModFlags::Nightcore) {
@@ -1284,12 +1283,12 @@ void OsuModSelector::enableModsFromFlags(uint32_t flags) {
 
     getModButtonOnGrid(4, 2)->setOn(flags & ModFlags::Target, true);
 
 }
 
 
 
-void OsuModSelector::close() {
 
+void ModSelector::close() {
 
     m_closeButton->animateClickColor();
 
     m_osu->toggleModSelection();
 
 }
 
 
 
-void OsuModSelector::onOverrideSliderChange(CBaseUISlider *slider) {
 
+void ModSelector::onOverrideSliderChange(CBaseUISlider *slider) {
 
     for(int i = 0; i < m_overrideSliders.size(); i++) {
 
         if(m_overrideSliders[i].slider == slider) {
 
             float sliderValue = slider->getFloat() - 1.0f;
@@ -1342,9 +1341,9 @@ void OsuModSelector::onOverrideSliderChange(CBaseUISlider *slider) {
 
 
 
                         // force change all other depending sliders
 
                         const float newAR =
 
-                            OsuGameRules::getConstantApproachRateForSpeedMultiplier(m_osu->getSelectedBeatmap());
 
+                            GameRules::getConstantApproachRateForSpeedMultiplier(m_osu->getSelectedBeatmap());
 
                         const float newOD =
 
-                            OsuGameRules::getConstantOverallDifficultyForSpeedMultiplier(m_osu->getSelectedBeatmap());
 
+                            GameRules::getConstantOverallDifficultyForSpeedMultiplier(m_osu->getSelectedBeatmap());
 
 
 
                         m_ARSlider->setValue(newAR + 1.0f,
 
                                              false);  // '+1' to compensate for turn-off area of the override sliders
@@ -1367,7 +1366,7 @@ void OsuModSelector::onOverrideSliderChange(CBaseUISlider *slider) {
 
     }
 
 }
 
 
 
-void OsuModSelector::onOverrideSliderLockChange(CBaseUICheckbox *checkbox) {
 
+void ModSelector::onOverrideSliderLockChange(CBaseUICheckbox *checkbox) {
 
     for(int i = 0; i < m_overrideSliders.size(); i++) {
 
         if(m_overrideSliders[i].lock == checkbox) {
 
             const bool locked = m_overrideSliders[i].lock->isChecked();
@@ -1397,11 +1396,11 @@ void OsuModSelector::onOverrideSliderLockChange(CBaseUICheckbox *checkbox) {
 
     }
 
 }
 
 
 
-void OsuModSelector::onOverrideARSliderDescClicked(CBaseUIButton *button) { m_ARLock->click(); }
 
+void ModSelector::onOverrideARSliderDescClicked(CBaseUIButton *button) { m_ARLock->click(); }
 
 
 
-void OsuModSelector::onOverrideODSliderDescClicked(CBaseUIButton *button) { m_ODLock->click(); }
 
+void ModSelector::onOverrideODSliderDescClicked(CBaseUIButton *button) { m_ODLock->click(); }
 
 
 
-void OsuModSelector::updateOverrideSliderLabels() {
 
+void ModSelector::updateOverrideSliderLabels() {
 
     const Color inactiveColor = 0xff777777;
 
     const Color activeColor = 0xffffffff;
 
     const Color inactiveLabelColor = 0xff1166ff;
@@ -1434,7 +1433,7 @@ void OsuModSelector::updateOverrideSliderLabels() {
 
     }
 
 }
 
 
 
-UString OsuModSelector::getOverrideSliderLabelText(OsuModSelector::OVERRIDE_SLIDER s, bool active) {
 
+UString ModSelector::getOverrideSliderLabelText(ModSelector::OVERRIDE_SLIDER s, bool active) {
 
     float convarValue = s.cvar->getFloat();
 
 
 
     UString newLabelText = s.label->getName();
@@ -1459,23 +1458,23 @@ UString OsuModSelector::getOverrideSliderLabelText(OsuModSelector::OVERRIDE_SLID
 
                 0.0f, 10.0f);
 
             convarValue = m_osu->getSelectedBeatmap()->getCS();
 
         } else if(s.label->getName().find("AR") != -1) {
 
-            beatmapValue = active ? OsuGameRules::getRawApproachRateForSpeedMultiplier(m_osu->getSelectedBeatmap())
 
-                                  : OsuGameRules::getApproachRateForSpeedMultiplier(m_osu->getSelectedBeatmap());
 
+            beatmapValue = active ? GameRules::getRawApproachRateForSpeedMultiplier(m_osu->getSelectedBeatmap())
 
+                                  : GameRules::getApproachRateForSpeedMultiplier(m_osu->getSelectedBeatmap());
 
 
 
             // compensate and round
 
             convarValue =
 
-                OsuGameRules::getApproachRateForSpeedMultiplier(m_osu->getSelectedBeatmap(), speedMultiplierLive);
 
+                GameRules::getApproachRateForSpeedMultiplier(m_osu->getSelectedBeatmap(), speedMultiplierLive);
 
             if(!engine->getKeyboard()->isAltDown() && !forceDisplayTwoDecimalDigits)
 
                 convarValue = std::round(convarValue * 10.0f) / 10.0f;
 
             else
 
                 convarValue = std::round(convarValue * 100.0f) / 100.0f;
 
         } else if(s.label->getName().find("OD") != -1) {
 
-            beatmapValue = active ? OsuGameRules::getRawOverallDifficultyForSpeedMultiplier(m_osu->getSelectedBeatmap())
 
-                                  : OsuGameRules::getOverallDifficultyForSpeedMultiplier(m_osu->getSelectedBeatmap());
 
+            beatmapValue = active ? GameRules::getRawOverallDifficultyForSpeedMultiplier(m_osu->getSelectedBeatmap())
 
+                                  : GameRules::getOverallDifficultyForSpeedMultiplier(m_osu->getSelectedBeatmap());
 
 
 
             // compensate and round
 
             convarValue =
 
-                OsuGameRules::getOverallDifficultyForSpeedMultiplier(m_osu->getSelectedBeatmap(), speedMultiplierLive);
 
+                GameRules::getOverallDifficultyForSpeedMultiplier(m_osu->getSelectedBeatmap(), speedMultiplierLive);
 
             if(!engine->getKeyboard()->isAltDown() && !forceDisplayTwoDecimalDigits)
 
                 convarValue = std::round(convarValue * 10.0f) / 10.0f;
 
             else
@@ -1543,13 +1542,13 @@ UString OsuModSelector::getOverrideSliderLabelText(OsuModSelector::OVERRIDE_SLID
 
     return newLabelText;
 
 }
 
 
 
-void OsuModSelector::enableAuto() {
 
+void ModSelector::enableAuto() {
 
     if(!m_modButtonAuto->isOn()) m_modButtonAuto->click();
 
 }
 
 
 
-void OsuModSelector::toggleAuto() { m_modButtonAuto->click(); }
 
+void ModSelector::toggleAuto() { m_modButtonAuto->click(); }
 
 
 
-void OsuModSelector::onCheckboxChange(CBaseUICheckbox *checkbox) {
 
+void ModSelector::onCheckboxChange(CBaseUICheckbox *checkbox) {
 
     for(int i = 0; i < m_experimentalMods.size(); i++) {
 
         if(m_experimentalMods[i].element == checkbox) {
 
             if(m_experimentalMods[i].cvar != NULL) m_experimentalMods[i].cvar->setValue(checkbox->isChecked());
@@ -1565,7 +1564,7 @@ void OsuModSelector::onCheckboxChange(CBaseUICheckbox *checkbox) {
 
     }
 
 }
 
 
 
-void OsuModSelector::onResolutionChange(Vector2 newResolution) {
 
+void ModSelector::onResolutionChange(Vector2 newResolution) {
 
     setSize(newResolution);
 
     m_overrideSliderContainer->setSize(newResolution);
 
     m_experimentalContainer->setSizeY(newResolution.y + 1);
--- a/src/App/Osu/OsuModSelector.h
+++ b/src/App/Osu/OsuModSelector.h
@@ -11,8 +11,8 @@
 
 #include "OsuScreen.h"
 
 
 
 class Osu;
 
-class OsuSkinImage;
 
-class OsuSongBrowser;
 
+class SkinImage;
 
+class SongBrowser;
 
 
 
 class CBaseUIElement;
 
 class CBaseUIContainer;
@@ -22,17 +22,17 @@ class CBaseUILabel;
 
 class CBaseUISlider;
 
 class CBaseUICheckbox;
 
 
 
-class OsuUIModSelectorModButton;
 
-class OsuModSelectorOverrideSliderDescButton;
 
-class OsuUIButton;
 
-class OsuUICheckbox;
 
+class UIModSelectorModButton;
 
+class ModSelectorOverrideSliderDescButton;
 
+class UIButton;
 
+class UICheckbox;
 
 
 
 class ConVar;
 
 
 
-class OsuModSelector : public OsuScreen {
 
+class ModSelector : public OsuScreen {
 
    public:
 
-    OsuModSelector(Osu *osu);
 
-    virtual ~OsuModSelector();
 
+    ModSelector(Osu *osu);
 
+    virtual ~ModSelector();
 
 
 
     virtual void draw(Graphics *g);
 
     virtual void mouse_update(bool *propagate_clicks);
@@ -48,8 +48,8 @@ class OsuModSelector : public OsuScreen {
 
     void toggleAuto();
 
     void resetModsUserInitiated();
 
     void resetMods();
 
-    uint32_t getModFlags();
 
-    void enableModsFromFlags(uint32_t flags);
 
+    u32 getModFlags();
 
+    void enableModsFromFlags(u32 flags);
 
 
 
     void setWaitForF1KeyUp(bool waitForF1KeyUp) { m_bWaitForF1KeyUp = waitForF1KeyUp; }
 
 
@@ -62,8 +62,8 @@ class OsuModSelector : public OsuScreen {
 
     void updateModConVar();
 
 
 
     CBaseUILabel *m_nonVanillaWarning;
 
-    OsuUIModSelectorModButton *m_modButtonHalftime;
 
-    OsuUIModSelectorModButton *m_modButtonDoubletime;
 
+    UIModSelectorModButton *m_modButtonHalftime;
 
+    UIModSelectorModButton *m_modButtonDoubletime;
 
 
 
    private:
 
     struct OVERRIDE_SLIDER {
@@ -77,7 +77,7 @@ class OsuModSelector : public OsuScreen {
 
         }
 
 
 
         CBaseUICheckbox *lock;
 
-        OsuModSelectorOverrideSliderDescButton *desc;
 
+        ModSelectorOverrideSliderDescButton *desc;
 
         CBaseUISlider *slider;
 
         CBaseUILabel *label;
 
         ConVar *cvar;
@@ -94,9 +94,9 @@ class OsuModSelector : public OsuScreen {
 
     void updateLayout();
 
     void updateExperimentalLayout();
 
 
 
-    OsuUIModSelectorModButton *setModButtonOnGrid(int x, int y, int state, bool initialState, UString modName,
 
-                                                  UString tooltipText, std::function<OsuSkinImage *()> getImageFunc);
 
-    OsuUIModSelectorModButton *getModButtonOnGrid(int x, int y);
 
+    UIModSelectorModButton *setModButtonOnGrid(int x, int y, int state, bool initialState, UString modName,
 
+                                               UString tooltipText, std::function<SkinImage *()> getImageFunc);
 
+    UIModSelectorModButton *getModButtonOnGrid(int x, int y);
 
 
 
     OVERRIDE_SLIDER addOverrideSlider(UString text, UString labelText, ConVar *cvar, float min, float max,
 
                                       UString tooltipText = "", ConVar *lockCvar = NULL);
@@ -108,10 +108,10 @@ class OsuModSelector : public OsuScreen {
 
     UString getOverrideSliderLabelText(OVERRIDE_SLIDER s, bool active);
 
 
 
     CBaseUILabel *addExperimentalLabel(UString text);
 
-    OsuUICheckbox *addExperimentalCheckbox(UString text, UString tooltipText, ConVar *cvar = NULL);
 
+    UICheckbox *addExperimentalCheckbox(UString text, UString tooltipText, ConVar *cvar = NULL);
 
     void onCheckboxChange(CBaseUICheckbox *checkbox);
 
 
 
-    OsuUIButton *addActionButton(UString text);
 
+    UIButton *addActionButton(UString text);
 
 
 
     void close();
 
 
@@ -142,31 +142,31 @@ class OsuModSelector : public OsuScreen {
 
     // mod grid buttons
 
     int m_iGridWidth;
 
     int m_iGridHeight;
 
-    std::vector<OsuUIModSelectorModButton *> m_modButtons;
 
-    OsuUIModSelectorModButton *m_modButtonEasy;
 
-    OsuUIModSelectorModButton *m_modButtonNofail;
 
-    OsuUIModSelectorModButton *m_modButtonHardrock;
 
-    OsuUIModSelectorModButton *m_modButtonSuddendeath;
 
-    OsuUIModSelectorModButton *m_modButtonHidden;
 
-    OsuUIModSelectorModButton *m_modButtonFlashlight;
 
-    OsuUIModSelectorModButton *m_modButtonRelax;
 
-    OsuUIModSelectorModButton *m_modButtonAutopilot;
 
-    OsuUIModSelectorModButton *m_modButtonSpunout;
 
-    OsuUIModSelectorModButton *m_modButtonAuto;
 
-    OsuUIModSelectorModButton *m_modButtonScoreV2;
 
-    OsuUIModSelectorModButton *m_modButtonTD;
 
+    std::vector<UIModSelectorModButton *> m_modButtons;
 
+    UIModSelectorModButton *m_modButtonEasy;
 
+    UIModSelectorModButton *m_modButtonNofail;
 
+    UIModSelectorModButton *m_modButtonHardrock;
 
+    UIModSelectorModButton *m_modButtonSuddendeath;
 
+    UIModSelectorModButton *m_modButtonHidden;
 
+    UIModSelectorModButton *m_modButtonFlashlight;
 
+    UIModSelectorModButton *m_modButtonRelax;
 
+    UIModSelectorModButton *m_modButtonAutopilot;
 
+    UIModSelectorModButton *m_modButtonSpunout;
 
+    UIModSelectorModButton *m_modButtonAuto;
 
+    UIModSelectorModButton *m_modButtonScoreV2;
 
+    UIModSelectorModButton *m_modButtonTD;
 
 
 
     // experimental mods
 
     std::vector<EXPERIMENTAL_MOD> m_experimentalMods;
 
-    OsuUICheckbox *m_experimentalModRandomCheckbox;
 
+    UICheckbox *m_experimentalModRandomCheckbox;
 
 
 
     // score multiplier info label
 
     CBaseUILabel *m_scoreMultiplierLabel;
 
 
 
     // action buttons
 
-    std::vector<OsuUIButton *> m_actionButtons;
 
-    OsuUIButton *m_resetModsButton;
 
-    OsuUIButton *m_closeButton;
 
+    std::vector<UIButton *> m_actionButtons;
 
+    UIButton *m_resetModsButton;
 
+    UIButton *m_closeButton;
 
 
 
     // convar refs
 
     ConVar *m_osu_drain_type_ref;
--- a/src/App/Osu/OsuMultiplayer.cpp
+++ b/src/App/Osu/OsuMultiplayer.cpp
--- a/src/App/Osu/OsuNotificationOverlay.cpp
+++ b/src/App/Osu/OsuNotificationOverlay.cpp
@@ -5,7 +5,7 @@
 
 // $NoKeywords: $osunot
 
 //===============================================================================//
 
 
 
-#include "OsuNotificationOverlay.h"
 
+#include "NotificationOverlay.h"
 
 
 
 #include "AnimationHandler.h"
 
 #include "ConVar.h"
@@ -16,14 +16,14 @@
 
 
 
 ConVar osu_notification_duration("osu_notification_duration", 1.25f, FCVAR_NONE);
 
 
 
-OsuNotificationOverlay::OsuNotificationOverlay(Osu *osu) : OsuScreen(osu) {
 
+NotificationOverlay::NotificationOverlay(Osu *osu) : OsuScreen(osu) {
 
     m_bWaitForKey = false;
 
     m_bWaitForKeyDisallowsLeftClick = false;
 
     m_bConsumeNextChar = false;
 
     m_keyListener = NULL;
 
 }
 
 
 
-void OsuNotificationOverlay::draw(Graphics *g) {
 
+void NotificationOverlay::draw(Graphics *g) {
 
     if(!isVisible()) return;
 
 
 
     if(m_bWaitForKey) {
@@ -38,7 +38,7 @@ void OsuNotificationOverlay::draw(Graphics *g) {
 
     drawNotificationText(g, m_notification1);
 
 }
 
 
 
-void OsuNotificationOverlay::drawNotificationText(Graphics *g, OsuNotificationOverlay::NOTIFICATION &n) {
 
+void NotificationOverlay::drawNotificationText(Graphics *g, NotificationOverlay::NOTIFICATION &n) {
 
     McFont *font = m_osu->getSubTitleFont();
 
     int height = font->getHeight() * 2;
 
     int stringWidth = font->getStringWidth(n.text);
@@ -59,7 +59,7 @@ void OsuNotificationOverlay::drawNotificationText(Graphics *g, OsuNotificationOv
 
     g->popTransform();
 
 }
 
 
 
-void OsuNotificationOverlay::drawNotificationBackground(Graphics *g, OsuNotificationOverlay::NOTIFICATION &n) {
 
+void NotificationOverlay::drawNotificationBackground(Graphics *g, NotificationOverlay::NOTIFICATION &n) {
 
     McFont *font = m_osu->getSubTitleFont();
 
     int height = font->getHeight() * 2 * n.backgroundAnim;
 
 
@@ -68,7 +68,7 @@ void OsuNotificationOverlay::drawNotificationBackground(Graphics *g, OsuNotifica
 
     g->fillRect(0, m_osu->getScreenHeight() / 2 - height / 2, m_osu->getScreenWidth(), height);
 
 }
 
 
 
-void OsuNotificationOverlay::onKeyDown(KeyboardEvent &e) {
 
+void NotificationOverlay::onKeyDown(KeyboardEvent &e) {
 
     if(!isVisible()) return;
 
 
 
     // escape always stops waiting for a key
@@ -105,19 +105,19 @@ void OsuNotificationOverlay::onKeyDown(KeyboardEvent &e) {
 
     if(m_bWaitForKey) e.consume();
 
 }
 
 
 
-void OsuNotificationOverlay::onKeyUp(KeyboardEvent &e) {
 
+void NotificationOverlay::onKeyUp(KeyboardEvent &e) {
 
     if(!isVisible()) return;
 
 
 
     if(m_bWaitForKey) e.consume();
 
 }
 
 
 
-void OsuNotificationOverlay::onChar(KeyboardEvent &e) {
 
+void NotificationOverlay::onChar(KeyboardEvent &e) {
 
     if(m_bWaitForKey || m_bConsumeNextChar) e.consume();
 
 
 
     m_bConsumeNextChar = false;
 
 }
 
 
 
-void OsuNotificationOverlay::addNotification(UString text, Color textColor, bool waitForKey, float duration) {
 
+void NotificationOverlay::addNotification(UString text, Color textColor, bool waitForKey, float duration) {
 
     const float notificationDuration = (duration < 0.0f ? osu_notification_duration.getFloat() : duration);
 
 
 
     // swap effect
@@ -165,12 +165,12 @@ void OsuNotificationOverlay::addNotification(UString text, Color textColor, bool
 
     anim->moveQuadOut(&m_notification1.backgroundAnim, 1.0f, 0.15f, 0.0f, true);
 
 }
 
 
 
-void OsuNotificationOverlay::stopWaitingForKey(bool stillConsumeNextChar) {
 
+void NotificationOverlay::stopWaitingForKey(bool stillConsumeNextChar) {
 
     m_bWaitForKey = false;
 
     m_bWaitForKeyDisallowsLeftClick = false;
 
     m_bConsumeNextChar = stillConsumeNextChar;
 
 }
 
 
 
-bool OsuNotificationOverlay::isVisible() {
 
+bool NotificationOverlay::isVisible() {
 
     return engine->getTime() < m_notification1.time || engine->getTime() < m_notification2.time || m_bWaitForKey;
 
 }
--- a/src/App/Osu/OsuNotificationOverlay.h
+++ b/src/App/Osu/OsuNotificationOverlay.h
@@ -13,16 +13,16 @@
 
 
 
 class Osu;
 
 
 
-class OsuNotificationOverlayKeyListener {
 
+class NotificationOverlayKeyListener {
 
    public:
 
-    virtual ~OsuNotificationOverlayKeyListener() { ; }
 
+    virtual ~NotificationOverlayKeyListener() { ; }
 
     virtual void onKey(KeyboardEvent &e) = 0;
 
 };
 
 
 
-class OsuNotificationOverlay : public OsuScreen {
 
+class NotificationOverlay : public OsuScreen {
 
    public:
 
-    OsuNotificationOverlay(Osu *osu);
 
-    virtual ~OsuNotificationOverlay() { ; }
 
+    NotificationOverlay(Osu *osu);
 
+    virtual ~NotificationOverlay() { ; }
 
 
 
     virtual void draw(Graphics *g);
 
 
@@ -37,7 +37,7 @@ class OsuNotificationOverlay : public OsuScreen {
 
 
 
     void stopWaitingForKey(bool stillConsumeNextChar = false);
 
 
 
-    void addKeyListener(OsuNotificationOverlayKeyListener *keyListener) { m_keyListener = keyListener; }
 
+    void addKeyListener(NotificationOverlayKeyListener *keyListener) { m_keyListener = keyListener; }
 
 
 
     virtual bool isVisible();
 
 
@@ -63,7 +63,7 @@ class OsuNotificationOverlay : public OsuScreen {
 
     bool m_bWaitForKey;
 
     bool m_bWaitForKeyDisallowsLeftClick;
 
     bool m_bConsumeNextChar;
 
-    OsuNotificationOverlayKeyListener *m_keyListener;
 
+    NotificationOverlayKeyListener *m_keyListener;
 
 };
 
 
 
 #endif
--- a/src/App/Osu/OptionsMenu.cpp
+++ b/src/App/Osu/OptionsMenu.cpp
--- a/src/App/Osu/OsuOptionsMenu.h
+++ b/src/App/Osu/OsuOptionsMenu.h
@@ -8,20 +8,20 @@
 
 #ifndef OSUOPTIONSMENU_H
 
 #define OSUOPTIONSMENU_H
 
 
 
-#include "OsuNotificationOverlay.h"
 
-#include "OsuScreenBackable.h"
 
+#include "NotificationOverlay.h"
 
+#include "ScreenBackable.h"
 
 
 
 class Osu;
 
 
 
-class OsuUIButton;
 
-class OsuUISlider;
 
-class OsuUIContextMenu;
 
-class OsuUISearchOverlay;
 
+class UIButton;
 
+class UISlider;
 
+class UIContextMenu;
 
+class UISearchOverlay;
 
 
 
-class OsuOptionsMenuSliderPreviewElement;
 
-class OsuOptionsMenuCategoryButton;
 
-class OsuOptionsMenuKeyBindButton;
 
-class OsuOptionsMenuResetButton;
 
+class OptionsMenuSliderPreviewElement;
 
+class OptionsMenuCategoryButton;
 
+class OptionsMenuKeyBindButton;
 
+class OptionsMenuResetButton;
 
 
 
 class CBaseUIContainer;
 
 class CBaseUIImageButton;
@@ -34,9 +34,9 @@ class CBaseUITextbox;
 
 
 
 class ConVar;
 
 
 
-class OsuOptionsMenu : public OsuScreenBackable, public OsuNotificationOverlayKeyListener {
 
+class OptionsMenu : public ScreenBackable, public NotificationOverlayKeyListener {
 
    public:
 
-    OsuOptionsMenu(Osu *osu);
 
+    OptionsMenu(Osu *osu);
 
 
 
     virtual void draw(Graphics *g);
 
     virtual void mouse_update(bool *propagate_clicks);
@@ -86,7 +86,7 @@ class OsuOptionsMenu : public OsuScreenBackable, public OsuNotificationOverlayKe
 
             render_condition = RenderCondition::NONE;
 
         }
 
 
 
-        OsuOptionsMenuResetButton *resetButton;
 
+        OptionsMenuResetButton *resetButton;
 
         std::vector<CBaseUIElement *> elements;
 
         ConVar *cvar;
 
         int type;
@@ -187,33 +187,33 @@ class OsuOptionsMenu : public OsuScreenBackable, public OsuNotificationOverlayKe
 
     CBaseUILabel *addSection(UString text);
 
     CBaseUILabel *addSubSection(UString text, UString searchTags = "");
 
     CBaseUILabel *addLabel(UString text);
 
-    OsuUIButton *addButton(UString text);
 
+    UIButton *addButton(UString text);
 
     OPTIONS_ELEMENT addButton(UString text, UString labelText, bool withResetButton = false);
 
     OPTIONS_ELEMENT addButtonButton(UString text1, UString text2);
 
     OPTIONS_ELEMENT addButtonButtonLabel(UString text1, UString text2, UString labelText, bool withResetButton = false);
 
-    OsuOptionsMenuKeyBindButton *addKeyBindButton(UString text, ConVar *cvar);
 
+    OptionsMenuKeyBindButton *addKeyBindButton(UString text, ConVar *cvar);
 
     CBaseUICheckbox *addCheckbox(UString text, ConVar *cvar);
 
     CBaseUICheckbox *addCheckbox(UString text, UString tooltipText = "", ConVar *cvar = NULL);
 
-    OsuUISlider *addSlider(UString text, float min = 0.0f, float max = 1.0f, ConVar *cvar = NULL,
 
-                           float label1Width = 0.0f, bool allowOverscale = false, bool allowUnderscale = false);
 
+    UISlider *addSlider(UString text, float min = 0.0f, float max = 1.0f, ConVar *cvar = NULL, float label1Width = 0.0f,
 
+                        bool allowOverscale = false, bool allowUnderscale = false);
 
     CBaseUITextbox *addTextbox(UString text, ConVar *cvar = NULL);
 
     CBaseUITextbox *addTextbox(UString text, UString labelText, ConVar *cvar = NULL);
 
     CBaseUIElement *addSkinPreview();
 
     CBaseUIElement *addSliderPreview();
 
 
 
     // categories
 
-    OsuOptionsMenuCategoryButton *addCategory(CBaseUIElement *section, wchar_t icon);
 
+    OptionsMenuCategoryButton *addCategory(CBaseUIElement *section, wchar_t icon);
 
 
 
     // vars
 
     Osu *m_osu;
 
     CBaseUIScrollView *m_categories;
 
     CBaseUIScrollView *m_options;
 
-    OsuUIContextMenu *m_contextMenu;
 
-    OsuUISearchOverlay *m_search;
 
+    UIContextMenu *m_contextMenu;
 
+    UISearchOverlay *m_search;
 
     CBaseUILabel *m_spacer;
 
-    OsuOptionsMenuCategoryButton *m_fposuCategoryButton;
 
+    OptionsMenuCategoryButton *m_fposuCategoryButton;
 
 
 
-    std::vector<OsuOptionsMenuCategoryButton *> m_categoryButtons;
 
+    std::vector<OptionsMenuCategoryButton *> m_categoryButtons;
 
     std::vector<OPTIONS_ELEMENT> m_elements;
 
 
 
     // custom
@@ -245,36 +245,36 @@ class OsuOptionsMenu : public OsuScreenBackable, public OsuNotificationOverlayKe
 
     CBaseUITextbox *m_osuFolderTextbox;
 
     CBaseUIButton *m_outputDeviceSelectButton;
 
     CBaseUILabel *m_outputDeviceLabel;
 
-    OsuOptionsMenuResetButton *m_outputDeviceResetButton;
 
+    OptionsMenuResetButton *m_outputDeviceResetButton;
 
     CBaseUISlider *m_wasapiBufferSizeSlider;
 
     CBaseUISlider *m_wasapiPeriodSizeSlider;
 
-    OsuOptionsMenuResetButton *m_asioBufferSizeResetButton;
 
-    OsuOptionsMenuResetButton *m_wasapiBufferSizeResetButton;
 
-    OsuOptionsMenuResetButton *m_wasapiPeriodSizeResetButton;
 
+    OptionsMenuResetButton *m_asioBufferSizeResetButton;
 
+    OptionsMenuResetButton *m_wasapiBufferSizeResetButton;
 
+    OptionsMenuResetButton *m_wasapiPeriodSizeResetButton;
 
     CBaseUISlider *m_asioBufferSizeSlider = nullptr;
 
     CBaseUISlider *m_sliderQualitySlider;
 
     CBaseUISlider *m_letterboxingOffsetXSlider;
 
     CBaseUISlider *m_letterboxingOffsetYSlider;
 
     CBaseUIButton *m_letterboxingOffsetResetButton;
 
-    OsuOptionsMenuSliderPreviewElement *m_sliderPreviewElement;
 
+    OptionsMenuSliderPreviewElement *m_sliderPreviewElement;
 
     CBaseUITextbox *m_dpiTextbox;
 
     CBaseUITextbox *m_cm360Textbox;
 
     CBaseUIElement *m_skinSection;
 
     CBaseUISlider *m_uiScaleSlider;
 
-    OsuOptionsMenuResetButton *m_uiScaleResetButton;
 
+    OptionsMenuResetButton *m_uiScaleResetButton;
 
     CBaseUIElement *m_notelockSelectButton;
 
     CBaseUILabel *m_notelockSelectLabel;
 
-    OsuOptionsMenuResetButton *m_notelockSelectResetButton;
 
+    OptionsMenuResetButton *m_notelockSelectResetButton;
 
     CBaseUIElement *m_hpDrainSelectButton;
 
     CBaseUILabel *m_hpDrainSelectLabel;
 
-    OsuOptionsMenuResetButton *m_hpDrainSelectResetButton;
 
+    OptionsMenuResetButton *m_hpDrainSelectResetButton;
 
 
 
     CBaseUIElement *sectionOnline;
 
     CBaseUITextbox *m_serverTextbox;
 
     CBaseUICheckbox *m_submitScoresCheckbox;
 
     CBaseUITextbox *m_nameTextbox;
 
     CBaseUITextbox *m_passwordTextbox;
 
-    OsuUIButton *logInButton;
 
+    UIButton *logInButton;
 
 
 
     ConVar *m_waitingKey;
 
     ConVar *m_osu_slider_curve_points_separation_ref;
--- a/src/App/Osu/Osu.cpp
+++ b/src/App/Osu/Osu.cpp
@@ -18,50 +18,49 @@
 
 #include "ConVar.h"
 
 #include "Console.h"
 
 #include "ConsoleBox.h"
 
+#include "Database.h"
 
 #include "Downloader.h"
 
 #include "Engine.h"
 
 #include "Environment.h"
 
 #include "Keyboard.h"
 
 #include "Mouse.h"
 
-#include "OsuDatabase.h"
 
 #include "RenderTarget.h"
 
 #include "ResourceManager.h"
 
 #include "Shader.h"
 
 #include "SoundEngine.h"
 
 // #include "DebugMonitor.h"
 
 
 
-#include "OsuBackgroundImageHandler.h"
 
-#include "OsuBeatmap.h"
 
-#include "OsuChangelog.h"
 
-#include "OsuChat.h"
 
-#include "OsuDatabaseBeatmap.h"
 
-#include "OsuEditor.h"
 
-#include "OsuGameRules.h"
 
-#include "OsuHUD.h"
 
-#include "OsuHitObject.h"
 
-#include "OsuIcons.h"
 
-#include "OsuKeyBindings.h"
 
-#include "OsuLobby.h"
 
-#include "OsuMainMenu.h"
 
-#include "OsuModFPoSu.h"
 
-#include "OsuModSelector.h"
 
-#include "OsuNotificationOverlay.h"
 
-#include "OsuOptionsMenu.h"
 
-#include "OsuPauseMenu.h"
 
-#include "OsuPromptScreen.h"
 
-#include "OsuRankingScreen.h"
 
-#include "OsuReplay.h"
 
-#include "OsuRichPresence.h"
 
-#include "OsuRoom.h"
 
-#include "OsuScore.h"
 
-#include "OsuSkin.h"
 
-#include "OsuSongBrowser.h"
 
-#include "OsuTooltipOverlay.h"
 
-#include "OsuUIModSelectorModButton.h"
 
-#include "OsuUIUserContextMenu.h"
 
-#include "OsuUpdateHandler.h"
 
-#include "OsuUserStatsScreen.h"
 
-#include "OsuVolumeOverlay.h"
 
+#include "BackgroundImageHandler.h"
 
+#include "Beatmap.h"
 
+#include "Changelog.h"
 
+#include "Chat.h"
 
+#include "DatabaseBeatmap.h"
 
+#include "GameRules.h"
 
+#include "HUD.h"
 
+#include "HitObject.h"
 
+#include "Icons.h"
 
+#include "KeyBindings.h"
 
+#include "Lobby.h"
 
+#include "MainMenu.h"
 
+#include "ModFPoSu.h"
 
+#include "ModSelector.h"
 
+#include "NotificationOverlay.h"
 
+#include "OptionsMenu.h"
 
+#include "PauseMenu.h"
 
+#include "PromptScreen.h"
 
+#include "RankingScreen.h"
 
+#include "Replay.h"
 
+#include "RichPresence.h"
 
+#include "RoomScreen.h"
 
+#include "Skin.h"
 
+#include "SongBrowser.h"
 
+#include "TooltipOverlay.h"
 
+#include "UIModSelectorModButton.h"
 
+#include "UIUserContextMenu.h"
 
+#include "UpdateHandler.h"
 
+#include "UserStatsScreen.h"
 
+#include "VolumeOverlay.h"
 
+#include "score.h"
 
 
 
 // release configuration
 
 ConVar auto_update("auto_update", true, FCVAR_NONE);
@@ -277,10 +276,10 @@ Osu::Osu(int instanceID) {
 
 
 
     convar->getConVarByName("osu_playfield_mirror_horizontal")
 
         ->setCallback(fastdelegate::MakeDelegate(
 
-            this, &Osu::updateModsForConVarTemplate));  // force a mod update on OsuBeatmap if changed
 
+            this, &Osu::updateModsForConVarTemplate));  // force a mod update on Beatmap if changed
 
     convar->getConVarByName("osu_playfield_mirror_vertical")
 
         ->setCallback(fastdelegate::MakeDelegate(
 
-            this, &Osu::updateModsForConVarTemplate));  // force a mod update on OsuBeatmap if changed
 
+            this, &Osu::updateModsForConVarTemplate));  // force a mod update on Beatmap if changed
 
 
 
     osu_notification.setCallback(fastdelegate::MakeDelegate(this, &Osu::onNotification));
 
 
@@ -361,9 +360,9 @@ Osu::Osu(int instanceID) {
 
     m_frameBuffer2 = engine->getResourceManager()->createRenderTarget(0, 0, 64, 64);
 
 
 
     // load a few select subsystems very early
 
-    m_notificationOverlay = new OsuNotificationOverlay(this);
 
-    m_score = new OsuScore(this);
 
-    m_updateHandler = new OsuUpdateHandler();
 
+    m_notificationOverlay = new NotificationOverlay(this);
 
+    m_score = new LiveScore(this);
 
+    m_updateHandler = new UpdateHandler();
 
 
 
     // exec the main config file (this must be right here!)
 
     if(m_iInstanceID < 2) {
@@ -405,8 +404,8 @@ Osu::Osu(int instanceID) {
 
         engine->getResourceManager()->loadFont("SourceSansPro-Regular.otf", "FONT_OSU_SONGBROWSER", 35, true, newDPI);
 
     m_songBrowserFontBold =
 
         engine->getResourceManager()->loadFont("SourceSansPro-Bold.otf", "FONT_OSU_SONGBROWSER_BOLD", 30, true, newDPI);
 
-    m_fontIcons = engine->getResourceManager()->loadFont("fontawesome-webfont.ttf", "FONT_OSU_ICONS", OsuIcons::icons,
 
-                                                         26, true, newDPI);
 
+    m_fontIcons = engine->getResourceManager()->loadFont("fontawesome-webfont.ttf", "FONT_OSU_ICONS", Icons::icons, 26,
 
+                                                         true, newDPI);
 
     m_fonts.push_back(defaultFont);
 
     m_fonts.push_back(m_titleFont);
 
     m_fonts.push_back(m_subTitleFont);
@@ -415,9 +414,9 @@ Osu::Osu(int instanceID) {
 
     m_fonts.push_back(m_fontIcons);
 
 
 
     float averageIconHeight = 0.0f;
 
-    for(int i = 0; i < OsuIcons::icons.size(); i++) {
 
+    for(int i = 0; i < Icons::icons.size(); i++) {
 
         UString iconString;
 
-        iconString.insert(0, OsuIcons::icons[i]);
 
+        iconString.insert(0, Icons::icons[i]);
 
         const float height = m_fontIcons->getStringHeight(iconString);
 
         if(height > averageIconHeight) averageIconHeight = height;
 
     }
@@ -438,29 +437,28 @@ Osu::Osu(int instanceID) {
 
             onSkinChange("", osu_skin.getString());
 
 
 
         // enable async skin loading for user-action skin changes (but not during startup)
 
-        OsuSkin::m_osu_skin_async->setValue(1.0f);
 
+        Skin::m_osu_skin_async->setValue(1.0f);
 
     }
 
 
 
     // load subsystems, add them to the screens array
 
-    m_songBrowser2 = new OsuSongBrowser(this);
 
-    m_volumeOverlay = new OsuVolumeOverlay(this);
 
-    m_tooltipOverlay = new OsuTooltipOverlay(this);
 
-    m_mainMenu = new OsuMainMenu(this);
 
-    m_optionsMenu = new OsuOptionsMenu(this);
 
-    m_backgroundImageHandler = new OsuBackgroundImageHandler();
 
-    m_modSelector = new OsuModSelector(this);
 
-    m_rankingScreen = new OsuRankingScreen(this);
 
-    m_userStatsScreen = new OsuUserStatsScreen(this);
 
-    m_pauseMenu = new OsuPauseMenu(this);
 
-    m_hud = new OsuHUD(this);
 
-    m_changelog = new OsuChangelog(this);
 
-    m_editor = new OsuEditor(this);
 
-    m_fposu = new OsuModFPoSu(this);
 
-    m_chat = new OsuChat(this);
 
-    m_lobby = new OsuLobby(this);
 
-    m_room = new OsuRoom(this);
 
-    m_prompt = new OsuPromptScreen(this);
 
-    m_user_actions = new OsuUIUserContextMenuScreen(this);
 
+    m_songBrowser2 = new SongBrowser(this);
 
+    m_volumeOverlay = new VolumeOverlay(this);
 
+    m_tooltipOverlay = new TooltipOverlay(this);
 
+    m_mainMenu = new MainMenu(this);
 
+    m_optionsMenu = new OptionsMenu(this);
 
+    m_backgroundImageHandler = new BackgroundImageHandler();
 
+    m_modSelector = new ModSelector(this);
 
+    m_rankingScreen = new RankingScreen(this);
 
+    m_userStatsScreen = new UserStatsScreen(this);
 
+    m_pauseMenu = new PauseMenu(this);
 
+    m_hud = new HUD(this);
 
+    m_changelog = new Changelog(this);
 
+    m_fposu = new ModFPoSu(this);
 
+    m_chat = new Chat(this);
 
+    m_lobby = new Lobby(this);
 
+    m_room = new RoomScreen(this);
 
+    m_prompt = new PromptScreen(this);
 
+    m_user_actions = new UIUserContextMenuScreen(this);
 
 
 
     // the order in this vector will define in which order events are handled/consumed
 
     m_screens.push_back(m_volumeOverlay);
@@ -478,7 +476,6 @@ Osu::Osu(int instanceID) {
 
     m_screens.push_back(m_songBrowser2);
 
     m_screens.push_back(m_lobby);
 
     m_screens.push_back(m_changelog);
 
-    m_screens.push_back(m_editor);
 
     m_screens.push_back(m_mainMenu);
 
     m_screens.push_back(m_tooltipOverlay);
 
 
@@ -507,7 +504,7 @@ Osu::Osu(int instanceID) {
 
 Osu::~Osu() {
 
     bancho.osu = nullptr;
 
 
 
-    // "leak" OsuUpdateHandler object, but not relevant since shutdown:
 
+    // "leak" UpdateHandler object, but not relevant since shutdown:
 
     // this is the only way of handling instant user shutdown requests properly, there is no solution for active working
 
     // threads besides letting the OS kill them when the main threads exits. we must not delete the update handler
 
     // object, because the thread is potentially still accessing members during shutdown
@@ -543,7 +540,7 @@ void Osu::draw(Graphics *g) {
 
 
 
     // draw everything in the correct order
 
     if(isInPlayMode()) {  // if we are playing a beatmap
 
-        OsuBeatmap *beatmap = getSelectedBeatmap();
 
+        Beatmap *beatmap = getSelectedBeatmap();
 
         const bool isFPoSu = (m_osu_mod_fposu_ref->getBool());
 
 
 
         if(isFPoSu) m_playfieldBuffer->enable();
@@ -559,8 +556,8 @@ void Osu::draw(Graphics *g) {
 
 
 
             // Convert screen mouse -> osu mouse pos
 
             Vector2 cursorPos = beatmap->getCursorPos();
 
-            Vector2 mouse_position = cursorPos - OsuGameRules::getPlayfieldOffset(this);
 
-            mouse_position /= OsuGameRules::getPlayfieldScaleFactor(this);
 
+            Vector2 mouse_position = cursorPos - GameRules::getPlayfieldOffset(this);
 
+            mouse_position /= GameRules::getPlayfieldScaleFactor(this);
 
 
 
             // Update flashlight position
 
             double follow_delay = flashlight_follow_delay.getFloat();
@@ -568,10 +565,10 @@ void Osu::draw(Graphics *g) {
 
             double t = frame_time / follow_delay;
 
             t = t * (2.f - t);
 
             flashlight_position += t * (mouse_position - flashlight_position);
 
-            Vector2 flashlightPos = flashlight_position * OsuGameRules::getPlayfieldScaleFactor(this) +
 
-                                    OsuGameRules::getPlayfieldOffset(this);
 
+            Vector2 flashlightPos =
 
+                flashlight_position * GameRules::getPlayfieldScaleFactor(this) + GameRules::getPlayfieldOffset(this);
 
 
 
-            float fl_radius = flashlight_radius.getFloat() * OsuGameRules::getPlayfieldScaleFactor(this);
 
+            float fl_radius = flashlight_radius.getFloat() * GameRules::getPlayfieldScaleFactor(this);
 
             if(getScore()->getCombo() >= 200 || convar->getConVarByName("flashlight_always_hard")->getBool()) {
 
                 fl_radius *= 0.625f;
 
             } else if(getScore()->getCombo() >= 100) {
@@ -642,7 +639,6 @@ void Osu::draw(Graphics *g) {
 
 
 
         m_mainMenu->draw(g);
 
         m_changelog->draw(g);
 
-        m_editor->draw(g);
 
         m_userStatsScreen->draw(g);
 
         m_rankingScreen->draw(g);
 
         m_chat->draw(g);
@@ -934,7 +930,6 @@ void Osu::update() {
 
         m_bToggleEditorScheduled = false;
 
 
 
         m_mainMenu->setVisible(!m_mainMenu->isVisible());
 
-        m_editor->setVisible(!m_mainMenu->isVisible());
 
     }
 
 
 
     // handle cursor visibility if outside of internal resolution
@@ -1011,7 +1006,7 @@ UString getModsStringForConVar(int mods) {
 
     UString modsString = "  ";  // double space to reset if emtpy
 
 
 
     // NOTE: the order here is different on purpose, to avoid name collisions during parsing (see Osu::updateMods())
 
-    // order is the same as in OsuModSelector::updateModConVar()
 
+    // order is the same as in ModSelector::updateModConVar()
 
     if(mods & ModFlags::Easy) modsString.append("ez");
 
     if(mods & ModFlags::HardRock) modsString.append("hr");
 
     if(mods & ModFlags::Relax) modsString.append("relax");
@@ -1033,7 +1028,7 @@ UString getModsStringForConVar(int mods) {
 
     return modsString;
 
 }
 
 
 
-bool Osu::useMods(Score *score) {
 
+bool Osu::useMods(FinishedScore *score) {
 
     bool nomod = (score->modsLegacy == 0);
 
 
 
     // legacy mods (common to all scores)
@@ -1055,7 +1050,7 @@ bool Osu::useMods(Score *score) {
 
         // overrides (or leave default)
 
         // reason being that just because the speedMultiplier stored in the score = 1.5x doesn't mean that we should
 
         // move the override slider to 1.5x especially for CS/AR/OD/HP, because those get stored in the score as
 
-        // directly coming from OsuBeatmap::getAR() (so with pre-applied difficultyMultiplier etc.)
 
+        // directly coming from Beatmap::getAR() (so with pre-applied difficultyMultiplier etc.)
 
 
 
         // overrides
 
 
@@ -1065,7 +1060,7 @@ bool Osu::useMods(Score *score) {
 
         float tempCS = score->CS;
 
         float tempOD = score->OD;
 
         float tempHP = score->HP;
 
-        const OsuDatabaseBeatmap *diff2 = getSongBrowser()->getDatabase()->getBeatmapDifficulty(score->md5hash);
 
+        const DatabaseBeatmap *diff2 = getSongBrowser()->getDatabase()->getBeatmapDifficulty(score->md5hash);
 
         if(diff2 != NULL) {
 
             tempAR = diff2->getAR();
 
             tempCS = diff2->getCS();
@@ -1073,8 +1068,8 @@ bool Osu::useMods(Score *score) {
 
             tempHP = diff2->getHP();
 
         }
 
 
 
-        const OsuReplay::BEATMAP_VALUES legacyValues =
 
-            OsuReplay::getBeatmapValuesForModsLegacy(score->modsLegacy, tempAR, tempCS, tempOD, tempHP);
 
+        const Replay::BEATMAP_VALUES legacyValues =
 
+            Replay::getBeatmapValuesForModsLegacy(score->modsLegacy, tempAR, tempCS, tempOD, tempHP);
 
 
 
         // beatmap values
 
         {
@@ -1254,7 +1249,7 @@ void Osu::onKeyDown(KeyboardEvent &key) {
 
     }
 
 
 
     // disable mouse buttons hotkey
 
-    if(key == (KEYCODE)OsuKeyBindings::DISABLE_MOUSE_BUTTONS.getInt()) {
 
+    if(key == (KEYCODE)KeyBindings::DISABLE_MOUSE_BUTTONS.getInt()) {
 
         if(osu_disable_mousebuttons.getBool()) {
 
             osu_disable_mousebuttons.setValue(0.0f);
 
             m_notificationOverlay->addNotification("Mouse buttons are enabled.");
@@ -1265,7 +1260,7 @@ void Osu::onKeyDown(KeyboardEvent &key) {
 
     }
 
 
 
     // F8 toggle chat
 
-    if(key == (KEYCODE)OsuKeyBindings::TOGGLE_CHAT.getInt()) {
 
+    if(key == (KEYCODE)KeyBindings::TOGGLE_CHAT.getInt()) {
 
         // When options menu is open, instead of toggling chat, close options menu and open chat
 
         if(bancho.is_online() && m_optionsMenu->isVisible()) {
 
             m_optionsMenu->setVisible(false);
@@ -1278,10 +1273,10 @@ void Osu::onKeyDown(KeyboardEvent &key) {
 
     }
 
 
 
     // screenshots
 
-    if(key == (KEYCODE)OsuKeyBindings::SAVE_SCREENSHOT.getInt()) saveScreenshot();
 
+    if(key == (KEYCODE)KeyBindings::SAVE_SCREENSHOT.getInt()) saveScreenshot();
 
 
 
     // boss key (minimize + mute)
 
-    if(key == (KEYCODE)OsuKeyBindings::BOSS_KEY.getInt()) {
 
+    if(key == (KEYCODE)KeyBindings::BOSS_KEY.getInt()) {
 
         engine->getEnvironment()->minimize();
 
         m_bWasBossKeyPaused = getSelectedBeatmap()->isPreviewMusicPlaying();
 
         getSelectedBeatmap()->pausePreviewMusic(false);
@@ -1295,9 +1290,9 @@ void Osu::onKeyDown(KeyboardEvent &key) {
 
 
 
         // instant replay
 
         if((beatmap->isPaused() || beatmap->hasFailed())) {
 
-            if(!key.isConsumed() && key == (KEYCODE)OsuKeyBindings::INSTANT_REPLAY.getInt()) {
 
+            if(!key.isConsumed() && key == (KEYCODE)KeyBindings::INSTANT_REPLAY.getInt()) {
 
                 if(!beatmap->m_bIsWatchingReplay) {
 
-                    Score score;
 
+                    FinishedScore score;
 
                     score.isLegacyScore = false;
 
                     score.isImportedLegacyScore = false;
 
                     score.replay = beatmap->live_replay;
@@ -1343,8 +1338,8 @@ void Osu::onKeyDown(KeyboardEvent &key) {
 
 
 
             // K1
 
             {
 
-                const bool isKeyLeftClick = (key == (KEYCODE)OsuKeyBindings::LEFT_CLICK.getInt());
 
-                const bool isKeyLeftClick2 = (key == (KEYCODE)OsuKeyBindings::LEFT_CLICK_2.getInt());
 
+                const bool isKeyLeftClick = (key == (KEYCODE)KeyBindings::LEFT_CLICK.getInt());
 
+                const bool isKeyLeftClick2 = (key == (KEYCODE)KeyBindings::LEFT_CLICK_2.getInt());
 
                 if((!m_bKeyboardKey1Down && isKeyLeftClick) || (!m_bKeyboardKey12Down && isKeyLeftClick2)) {
 
                     if(isKeyLeftClick2)
 
                         m_bKeyboardKey12Down = true;
@@ -1361,8 +1356,8 @@ void Osu::onKeyDown(KeyboardEvent &key) {
 
 
 
             // K2
 
             {
 
-                const bool isKeyRightClick = (key == (KEYCODE)OsuKeyBindings::RIGHT_CLICK.getInt());
 
-                const bool isKeyRightClick2 = (key == (KEYCODE)OsuKeyBindings::RIGHT_CLICK_2.getInt());
 
+                const bool isKeyRightClick = (key == (KEYCODE)KeyBindings::RIGHT_CLICK.getInt());
 
+                const bool isKeyRightClick2 = (key == (KEYCODE)KeyBindings::RIGHT_CLICK_2.getInt());
 
                 if((!m_bKeyboardKey2Down && isKeyRightClick) || (!m_bKeyboardKey22Down && isKeyRightClick2)) {
 
                     if(isKeyRightClick2)
 
                         m_bKeyboardKey22Down = true;
@@ -1378,10 +1373,10 @@ void Osu::onKeyDown(KeyboardEvent &key) {
 
             }
 
 
 
             // handle skipping
 
-            if(key == KEY_ENTER || key == (KEYCODE)OsuKeyBindings::SKIP_CUTSCENE.getInt()) m_bSkipScheduled = true;
 
+            if(key == KEY_ENTER || key == (KEYCODE)KeyBindings::SKIP_CUTSCENE.getInt()) m_bSkipScheduled = true;
 
 
 
             // toggle ui
 
-            if(!key.isConsumed() && key == (KEYCODE)OsuKeyBindings::TOGGLE_SCOREBOARD.getInt() &&
 
+            if(!key.isConsumed() && key == (KEYCODE)KeyBindings::TOGGLE_SCOREBOARD.getInt() &&
 
                !m_bScoreboardToggleCheck) {
 
                 m_bScoreboardToggleCheck = true;
 
 
@@ -1414,12 +1409,12 @@ void Osu::onKeyDown(KeyboardEvent &key) {
 
             }
 
 
 
             // allow live mod changing while playing
 
-            if(!key.isConsumed() && (key == KEY_F1 || key == (KEYCODE)OsuKeyBindings::TOGGLE_MODSELECT.getInt()) &&
 
-               ((KEY_F1 != (KEYCODE)OsuKeyBindings::LEFT_CLICK.getInt() &&
 
-                 KEY_F1 != (KEYCODE)OsuKeyBindings::LEFT_CLICK_2.getInt()) ||
 
+            if(!key.isConsumed() && (key == KEY_F1 || key == (KEYCODE)KeyBindings::TOGGLE_MODSELECT.getInt()) &&
 
+               ((KEY_F1 != (KEYCODE)KeyBindings::LEFT_CLICK.getInt() &&
 
+                 KEY_F1 != (KEYCODE)KeyBindings::LEFT_CLICK_2.getInt()) ||
 
                 (!m_bKeyboardKey1Down && !m_bKeyboardKey12Down)) &&
 
-               ((KEY_F1 != (KEYCODE)OsuKeyBindings::RIGHT_CLICK.getInt() &&
 
-                 KEY_F1 != (KEYCODE)OsuKeyBindings::RIGHT_CLICK_2.getInt()) ||
 
+               ((KEY_F1 != (KEYCODE)KeyBindings::RIGHT_CLICK.getInt() &&
 
+                 KEY_F1 != (KEYCODE)KeyBindings::RIGHT_CLICK_2.getInt()) ||
 
                 (!m_bKeyboardKey2Down && !m_bKeyboardKey22Down)) &&
 
                !m_bF1 && !getSelectedBeatmap()->hasFailed() &&
 
                !bancho.is_playing_a_multi_map())  // only if not failed though
@@ -1430,10 +1425,10 @@ void Osu::onKeyDown(KeyboardEvent &key) {
 
 
 
             // quick save/load
 
             if(!bancho.is_playing_a_multi_map()) {
 
-                if(key == (KEYCODE)OsuKeyBindings::QUICK_SAVE.getInt())
 
+                if(key == (KEYCODE)KeyBindings::QUICK_SAVE.getInt())
 
                     m_fQuickSaveTime = getSelectedBeatmap()->getPercentFinished();
 
 
 
-                if(key == (KEYCODE)OsuKeyBindings::QUICK_LOAD.getInt()) {
 
+                if(key == (KEYCODE)KeyBindings::QUICK_LOAD.getInt()) {
 
                     // special case: allow cancelling the failing animation here
 
                     if(getSelectedBeatmap()->hasFailed()) getSelectedBeatmap()->cancelFailing();
 
 
@@ -1443,8 +1438,8 @@ void Osu::onKeyDown(KeyboardEvent &key) {
 
 
 
             // quick seek
 
             if(!bancho.is_playing_a_multi_map()) {
 
-                const bool backward = (key == (KEYCODE)OsuKeyBindings::SEEK_TIME_BACKWARD.getInt());
 
-                const bool forward = (key == (KEYCODE)OsuKeyBindings::SEEK_TIME_FORWARD.getInt());
 
+                const bool backward = (key == (KEYCODE)KeyBindings::SEEK_TIME_BACKWARD.getInt());
 
+                const bool forward = (key == (KEYCODE)KeyBindings::SEEK_TIME_FORWARD.getInt());
 
 
 
                 if(backward || forward) {
 
                     const unsigned long lengthMS = getSelectedBeatmap()->getLength();
@@ -1471,7 +1466,7 @@ void Osu::onKeyDown(KeyboardEvent &key) {
 
         // while paused or maybe not paused
 
 
 
         // handle quick restart
 
-        if(((key == (KEYCODE)OsuKeyBindings::QUICK_RETRY.getInt() ||
 
+        if(((key == (KEYCODE)KeyBindings::QUICK_RETRY.getInt() ||
 
              (engine->getKeyboard()->isControlDown() && !engine->getKeyboard()->isAltDown() && key == KEY_R)) &&
 
             !m_bQuickRetryDown)) {
 
             m_bQuickRetryDown = true;
@@ -1479,7 +1474,7 @@ void Osu::onKeyDown(KeyboardEvent &key) {
 
         }
 
 
 
         // handle seeking
 
-        if(key == (KEYCODE)OsuKeyBindings::SEEK_TIME.getInt()) m_bSeekKey = true;
 
+        if(key == (KEYCODE)KeyBindings::SEEK_TIME.getInt()) m_bSeekKey = true;
 
 
 
         // handle fposu key handling
 
         m_fposu->onKeyDown(key);
@@ -1497,7 +1492,7 @@ void Osu::onKeyDown(KeyboardEvent &key) {
 
         // if playing
 
         if(isInPlayMode()) {
 
             // toggle pause menu
 
-            if((key == (KEYCODE)OsuKeyBindings::GAME_PAUSE.getInt() || key == KEY_ESCAPE) && !m_bEscape) {
 
+            if((key == (KEYCODE)KeyBindings::GAME_PAUSE.getInt() || key == KEY_ESCAPE) && !m_bEscape) {
 
                 if(!bancho.is_playing_a_multi_map() || m_iMultiplayerClientNumEscPresses > 1) {
 
                     if(m_iMultiplayerClientNumEscPresses > 1) {
 
                         getSelectedBeatmap()->stop(true);
@@ -1527,7 +1522,7 @@ void Osu::onKeyDown(KeyboardEvent &key) {
 
             }
 
 
 
             // local offset
 
-            if(key == (KEYCODE)OsuKeyBindings::INCREASE_LOCAL_OFFSET.getInt()) {
 
+            if(key == (KEYCODE)KeyBindings::INCREASE_LOCAL_OFFSET.getInt()) {
 
                 long offsetAdd = engine->getKeyboard()->isAltDown() ? 1 : 5;
 
                 getSelectedBeatmap()->getSelectedDifficulty2()->setLocalOffset(
 
                     getSelectedBeatmap()->getSelectedDifficulty2()->getLocalOffset() + offsetAdd);
@@ -1535,7 +1530,7 @@ void Osu::onKeyDown(KeyboardEvent &key) {
 
                     UString::format("Local beatmap offset set to %ld ms",
 
                                     getSelectedBeatmap()->getSelectedDifficulty2()->getLocalOffset()));
 
             }
 
-            if(key == (KEYCODE)OsuKeyBindings::DECREASE_LOCAL_OFFSET.getInt()) {
 
+            if(key == (KEYCODE)KeyBindings::DECREASE_LOCAL_OFFSET.getInt()) {
 
                 long offsetAdd = -(engine->getKeyboard()->isAltDown() ? 1 : 5);
 
                 getSelectedBeatmap()->getSelectedDifficulty2()->setLocalOffset(
 
                     getSelectedBeatmap()->getSelectedDifficulty2()->getLocalOffset() + offsetAdd);
@@ -1552,8 +1547,8 @@ void Osu::onKeyUp(KeyboardEvent &key) {
 
     {
 
         // K1
 
         {
 
-            const bool isKeyLeftClick = (key == (KEYCODE)OsuKeyBindings::LEFT_CLICK.getInt());
 
-            const bool isKeyLeftClick2 = (key == (KEYCODE)OsuKeyBindings::LEFT_CLICK_2.getInt());
 
+            const bool isKeyLeftClick = (key == (KEYCODE)KeyBindings::LEFT_CLICK.getInt());
 
+            const bool isKeyLeftClick2 = (key == (KEYCODE)KeyBindings::LEFT_CLICK_2.getInt());
 
             if((isKeyLeftClick && m_bKeyboardKey1Down) || (isKeyLeftClick2 && m_bKeyboardKey12Down)) {
 
                 if(isKeyLeftClick2)
 
                     m_bKeyboardKey12Down = false;
@@ -1566,8 +1561,8 @@ void Osu::onKeyUp(KeyboardEvent &key) {
 
 
 
         // K2
 
         {
 
-            const bool isKeyRightClick = (key == (KEYCODE)OsuKeyBindings::RIGHT_CLICK.getInt());
 
-            const bool isKeyRightClick2 = (key == (KEYCODE)OsuKeyBindings::RIGHT_CLICK_2.getInt());
 
+            const bool isKeyRightClick = (key == (KEYCODE)KeyBindings::RIGHT_CLICK.getInt());
 
+            const bool isKeyRightClick2 = (key == (KEYCODE)KeyBindings::RIGHT_CLICK_2.getInt());
 
             if((isKeyRightClick && m_bKeyboardKey2Down) || (isKeyRightClick2 && m_bKeyboardKey22Down)) {
 
                 if(isKeyRightClick2)
 
                     m_bKeyboardKey22Down = false;
@@ -1587,15 +1582,15 @@ void Osu::onKeyUp(KeyboardEvent &key) {
 
     }
 
 
 
     // misc hotkeys release
 
-    if(key == KEY_F1 || key == (KEYCODE)OsuKeyBindings::TOGGLE_MODSELECT.getInt()) m_bF1 = false;
 
-    if(key == (KEYCODE)OsuKeyBindings::GAME_PAUSE.getInt() || key == KEY_ESCAPE) m_bEscape = false;
 
+    if(key == KEY_F1 || key == (KEYCODE)KeyBindings::TOGGLE_MODSELECT.getInt()) m_bF1 = false;
 
+    if(key == (KEYCODE)KeyBindings::GAME_PAUSE.getInt() || key == KEY_ESCAPE) m_bEscape = false;
 
     if(key == KEY_SHIFT) m_bUIToggleCheck = false;
 
-    if(key == (KEYCODE)OsuKeyBindings::TOGGLE_SCOREBOARD.getInt()) {
 
+    if(key == (KEYCODE)KeyBindings::TOGGLE_SCOREBOARD.getInt()) {
 
         m_bScoreboardToggleCheck = false;
 
         m_bUIToggleCheck = false;
 
     }
 
-    if(key == (KEYCODE)OsuKeyBindings::QUICK_RETRY.getInt() || key == KEY_R) m_bQuickRetryDown = false;
 
-    if(key == (KEYCODE)OsuKeyBindings::SEEK_TIME.getInt()) m_bSeekKey = false;
 
+    if(key == (KEYCODE)KeyBindings::QUICK_RETRY.getInt() || key == KEY_R) m_bQuickRetryDown = false;
 
+    if(key == (KEYCODE)KeyBindings::SEEK_TIME.getInt()) m_bSeekKey = false;
 
 
 
     // handle fposu key handling
 
     m_fposu->onKeyUp(key);
@@ -1693,7 +1688,7 @@ void Osu::onPlayStart() {
 
     updateConfineCursor();
 
     updateWindowsKeyDisable();
 
 
 
-    OsuRichPresence::onPlayStart(this);
 
+    RichPresence::onPlayStart(this);
 
 }
 
 
 
 void Osu::onPlayEnd(bool quit, bool aborted) {
@@ -1722,7 +1717,7 @@ void Osu::onPlayEnd(bool quit, bool aborted) {
 
 
 
     if(m_songBrowser2 != NULL) m_songBrowser2->onPlayEnd(quit);
 
 
 
-    // When playing in multiplayer, screens are toggled in OsuRoom
 
+    // When playing in multiplayer, screens are toggled in Room
 
     if(!bancho.is_playing_a_multi_map()) {
 
         if(quit) {
 
             if(m_iInstanceID < 2) {
@@ -1739,7 +1734,7 @@ void Osu::onPlayEnd(bool quit, bool aborted) {
 
     updateWindowsKeyDisable();
 
 }
 
 
 
-OsuBeatmap *Osu::getSelectedBeatmap() {
 
+Beatmap *Osu::getSelectedBeatmap() {
 
     if(m_songBrowser2 != NULL) return m_songBrowser2->getSelectedBeatmap();
 
 
 
     return NULL;
@@ -2072,8 +2067,7 @@ bool Osu::onShutdown() {
 
     disconnect();
 
 
 
     // the only time where a shutdown could be problematic is while an update is being installed, so we block it here
 
-    return m_updateHandler == NULL ||
 
-           m_updateHandler->getStatus() != OsuUpdateHandler::STATUS::STATUS_INSTALLING_UPDATE;
 
+    return m_updateHandler == NULL || m_updateHandler->getStatus() != UpdateHandler::STATUS::STATUS_INSTALLING_UPDATE;
 
 }
 
 
 
 void Osu::onSkinReload() {
@@ -2093,7 +2087,7 @@ void Osu::onSkinChange(UString oldValue, UString newValue) {
 
     skinFolder.append("/");
 
     std::string sf = skinFolder.toUtf8();
 
 
 
-    m_skinScheduledToLoad = new OsuSkin(this, newValue, sf, (newValue == UString("default")));
 
+    m_skinScheduledToLoad = new Skin(this, newValue, sf, (newValue == UString("default")));
 
 
 
     // initial load
 
     if(m_skin == NULL) m_skin = m_skinScheduledToLoad;
@@ -2123,7 +2117,7 @@ void Osu::onSpeedChange(UString oldValue, UString newValue) {
 
             btn_state = (getModDT() || getModHT()) ? 1 : 0;
 
         }
 
 
 
-        // Why 0.0001f you ask? See OsuModSelector::resetMods()
 
+        // Why 0.0001f you ask? See ModSelector::resetMods()
 
         if(speed > 0.0001f && speed < 1.0) {
 
             m_modSelector->m_modButtonDoubletime->setOn(false, true);
 
             m_modSelector->m_modButtonDoubletime->setState(btn_state, false);
--- a/src/App/Osu/Osu.h
+++ b/src/App/Osu/Osu.h
@@ -11,35 +11,33 @@
 
 #include "App.h"
 
 #include "BanchoNetworking.h"
 
 #include "MouseListener.h"
 
-#include "Score.h"
 
+#include "score.h"
 
 
 
 class CWindowManager;
 
 
 
-class OsuVolumeOverlay;
 
-class OsuChat;
 
-class OsuLobby;
 
-class OsuRoom;
 
-class OsuPromptScreen;
 
-class OsuUIUserContextMenuScreen;
 
-class OsuMainMenu;
 
-class OsuPauseMenu;
 
-class OsuOptionsMenu;
 
-class OsuModSelector;
 
-class OsuSongBrowser;
 
-class OsuBackgroundImageHandler;
 
-class OsuRankingScreen;
 
-class OsuUserStatsScreen;
 
-class OsuUpdateHandler;
 
-class OsuNotificationOverlay;
 
-class OsuTooltipOverlay;
 
-class OsuBeatmap;
 
+class VolumeOverlay;
 
+class Chat;
 
+class Lobby;
 
+class RoomScreen;
 
+class PromptScreen;
 
+class UIUserContextMenuScreen;
 
+class MainMenu;
 
+class PauseMenu;
 
+class OptionsMenu;
 
+class ModSelector;
 
+class SongBrowser;
 
+class BackgroundImageHandler;
 
+class RankingScreen;
 
+class UserStatsScreen;
 
+class UpdateHandler;
 
+class NotificationOverlay;
 
+class TooltipOverlay;
 
+class Beatmap;
 
 class OsuScreen;
 
-class OsuScore;
 
-class OsuSkin;
 
-class OsuHUD;
 
-class OsuChangelog;
 
-class OsuEditor;
 
-class OsuModFPoSu;
 
+class Skin;
 
+class HUD;
 
+class Changelog;
 
+class ModFPoSu;
 
 
 
 class ConVar;
 
 class Image;
@@ -114,23 +112,23 @@ class Osu : public App, public MouseListener {
 
     inline int getScreenWidth() const { return (int)g_vInternalResolution.x; }
 
     inline int getScreenHeight() const { return (int)g_vInternalResolution.y; }
 
 
 
-    OsuBeatmap *getSelectedBeatmap();
 
-
 
-    inline OsuOptionsMenu *getOptionsMenu() const { return m_optionsMenu; }
 
-    inline OsuSongBrowser *getSongBrowser() const { return m_songBrowser2; }
 
-    inline OsuBackgroundImageHandler *getBackgroundImageHandler() const { return m_backgroundImageHandler; }
 
-    inline OsuSkin *getSkin() const { return m_skin; }
 
-    inline OsuHUD *getHUD() const { return m_hud; }
 
-    inline OsuNotificationOverlay *getNotificationOverlay() const { return m_notificationOverlay; }
 
-    inline OsuTooltipOverlay *getTooltipOverlay() const { return m_tooltipOverlay; }
 
-    inline OsuModSelector *getModSelector() const { return m_modSelector; }
 
-    inline OsuModFPoSu *getFPoSu() const { return m_fposu; }
 
-    inline OsuPauseMenu *getPauseMenu() const { return m_pauseMenu; }
 
-    inline OsuMainMenu *getMainMenu() const { return m_mainMenu; }
 
-    inline OsuRankingScreen *getRankingScreen() const { return m_rankingScreen; }
 
-    inline OsuScore *getScore() const { return m_score; }
 
-    inline OsuUpdateHandler *getUpdateHandler() const { return m_updateHandler; }
 
-    inline OsuUserStatsScreen *getUserStatsScreen() const { return m_userStatsScreen; }
 
+    Beatmap *getSelectedBeatmap();
 
+
 
+    inline OptionsMenu *getOptionsMenu() const { return m_optionsMenu; }
 
+    inline SongBrowser *getSongBrowser() const { return m_songBrowser2; }
 
+    inline BackgroundImageHandler *getBackgroundImageHandler() const { return m_backgroundImageHandler; }
 
+    inline Skin *getSkin() const { return m_skin; }
 
+    inline HUD *getHUD() const { return m_hud; }
 
+    inline NotificationOverlay *getNotificationOverlay() const { return m_notificationOverlay; }
 
+    inline TooltipOverlay *getTooltipOverlay() const { return m_tooltipOverlay; }
 
+    inline ModSelector *getModSelector() const { return m_modSelector; }
 
+    inline ModFPoSu *getFPoSu() const { return m_fposu; }
 
+    inline PauseMenu *getPauseMenu() const { return m_pauseMenu; }
 
+    inline MainMenu *getMainMenu() const { return m_mainMenu; }
 
+    inline RankingScreen *getRankingScreen() const { return m_rankingScreen; }
 
+    inline LiveScore *getScore() const { return m_score; }
 
+    inline UpdateHandler *getUpdateHandler() const { return m_updateHandler; }
 
+    inline UserStatsScreen *getUserStatsScreen() const { return m_userStatsScreen; }
 
 
 
     inline RenderTarget *getPlayfieldBuffer() const { return m_playfieldBuffer; }
 
     inline RenderTarget *getSliderFrameBuffer() const { return m_sliderFrameBuffer; }
@@ -179,10 +177,10 @@ class Osu : public App, public MouseListener {
 
     inline bool isSeeking() const { return m_bSeeking; }
 
     inline float getQuickSaveTime() const { return m_fQuickSaveTime; }
 
 
 
-    bool shouldFallBackToLegacySliderRenderer();  // certain mods or actions require OsuSliders to render dynamically
 
+    bool shouldFallBackToLegacySliderRenderer();  // certain mods or actions require Sliders to render dynamically
 
                                                   // (e.g. wobble or the CS override slider)
 
 
 
-    bool useMods(Score *score);
 
+    bool useMods(FinishedScore *score);
 
     void updateMods();
 
     void updateConfineCursor();
 
     void updateMouseSettings();
@@ -256,29 +254,28 @@ class Osu : public App, public MouseListener {
 
     ConVar *m_win_disable_windows_key_ref;
 
 
 
     // interfaces
 
-    OsuVolumeOverlay *m_volumeOverlay;
 
-    OsuMainMenu *m_mainMenu;
 
-    OsuOptionsMenu *m_optionsMenu;
 
-    OsuChat *m_chat = nullptr;
 
-    OsuLobby *m_lobby = nullptr;
 
-    OsuRoom *m_room = nullptr;
 
-    OsuPromptScreen *m_prompt = nullptr;
 
-    OsuUIUserContextMenuScreen *m_user_actions = nullptr;
 
-    OsuSongBrowser *m_songBrowser2 = nullptr;
 
-    OsuBackgroundImageHandler *m_backgroundImageHandler;
 
-    OsuModSelector *m_modSelector;
 
-    OsuRankingScreen *m_rankingScreen;
 
-    OsuUserStatsScreen *m_userStatsScreen;
 
-    OsuPauseMenu *m_pauseMenu;
 
-    OsuSkin *m_skin;
 
-    OsuHUD *m_hud;
 
-    OsuTooltipOverlay *m_tooltipOverlay;
 
-    OsuNotificationOverlay *m_notificationOverlay;
 
-    OsuScore *m_score;
 
-    OsuChangelog *m_changelog;
 
-    OsuEditor *m_editor;
 
-    OsuUpdateHandler *m_updateHandler;
 
-    OsuModFPoSu *m_fposu;
 
+    VolumeOverlay *m_volumeOverlay;
 
+    MainMenu *m_mainMenu;
 
+    OptionsMenu *m_optionsMenu;
 
+    Chat *m_chat = nullptr;
 
+    Lobby *m_lobby = nullptr;
 
+    RoomScreen *m_room = nullptr;
 
+    PromptScreen *m_prompt = nullptr;
 
+    UIUserContextMenuScreen *m_user_actions = nullptr;
 
+    SongBrowser *m_songBrowser2 = nullptr;
 
+    BackgroundImageHandler *m_backgroundImageHandler;
 
+    ModSelector *m_modSelector;
 
+    RankingScreen *m_rankingScreen;
 
+    UserStatsScreen *m_userStatsScreen;
 
+    PauseMenu *m_pauseMenu;
 
+    Skin *m_skin;
 
+    HUD *m_hud;
 
+    TooltipOverlay *m_tooltipOverlay;
 
+    NotificationOverlay *m_notificationOverlay;
 
+    LiveScore *m_score;
 
+    Changelog *m_changelog;
 
+    UpdateHandler *m_updateHandler;
 
+    ModFPoSu *m_fposu;
 
 
 
     std::vector<OsuScreen *> m_screens;
 
 
@@ -360,7 +357,7 @@ class Osu : public App, public MouseListener {
 
     CWindowManager *m_windowManager;
 
 
 
     // replay
 
-    Score replay_score;
 
+    FinishedScore replay_score;
 
 
 
     // custom
 
     bool m_bScheduleEndlessModNextBeatmap;
@@ -369,7 +366,7 @@ class Osu : public App, public MouseListener {
 
     bool m_bWasBossKeyPaused;
 
     bool m_bSkinLoadScheduled;
 
     bool m_bSkinLoadWasReload;
 
-    OsuSkin *m_skinScheduledToLoad;
 
+    Skin *m_skinScheduledToLoad;
 
     bool m_bFontReloadScheduled;
 
     bool m_bFireResolutionChangedScheduled;
 
     bool m_bFireDelayedFontReloadAndResolutionChangeToFixDesyncedUIScaleScheduled;
--- a/src/App/Osu/OsuEditor.cpp
+++ b/src/App/Osu/OsuEditor.cpp
@@ -1,45 +0,0 @@
 
-/*
 
- * OsuEditor.h
 
- *
 
- *  Created on: 30. Mai 2017
 
- *      Author: Psy
 
- */
 
-
 
-#include "OsuEditor.h"
 
-
 
-#include "ConVar.h"
 
-#include "Engine.h"
 
-#include "Osu.h"
 
-#include "OsuSkin.h"
 
-#include "ResourceManager.h"
 
-#include "SoundEngine.h"
 
-
 
-OsuEditor::OsuEditor(Osu *osu) : OsuScreenBackable(osu) {}
 
-
 
-OsuEditor::~OsuEditor() {}
 
-
 
-void OsuEditor::draw(Graphics *g) {
 
-    if(!m_bVisible) return;
 
-
 
-    // draw back button on top of (after) everything else
 
-    OsuScreenBackable::draw(g);
 
-}
 
-
 
-void OsuEditor::mouse_update(bool *propagate_clicks) {
 
-    if(!m_bVisible) return;
 
-    OsuScreenBackable::mouse_update(propagate_clicks);
 
-
 
-    // update stuff if visible
 
-}
 
-
 
-void OsuEditor::onBack() {
 
-    engine->getSound()->play(m_osu->getSkin()->getMenuClick());
 
-
 
-    m_osu->toggleEditor();
 
-}
 
-
 
-void OsuEditor::onResolutionChange(Vector2 newResolution) {
 
-    OsuScreenBackable::onResolutionChange(newResolution);
 
-
 
-    debugLog("OsuEditor::onResolutionChange(%i, %i)\n", (int)newResolution.x, (int)newResolution.y);
 
-}
--- a/src/App/Osu/OsuEditor.h
+++ b/src/App/Osu/OsuEditor.h
@@ -1,27 +0,0 @@
 
-/*
 
- * OsuEditor.h
 
- *
 
- *  Created on: 30. Mai 2017
 
- *      Author: Psy
 
- */
 
-
 
-#ifndef OSUEDITOR_H
 
-#define OSUEDITOR_H
 
-
 
-#include "OsuScreenBackable.h"
 
-
 
-class OsuEditor : public OsuScreenBackable {
 
-   public:
 
-    OsuEditor(Osu *osu);
 
-    virtual ~OsuEditor();
 
-
 
-    virtual void draw(Graphics *g);
 
-    virtual void mouse_update(bool *propagate_clicks);
 
-
 
-    virtual void onResolutionChange(Vector2 newResolution);
 
-
 
-   private:
 
-    virtual void onBack();
 
-};
 
-
 
-#endif
--- a/src/App/Osu/OsuGameRules.cpp
+++ b/src/App/Osu/OsuGameRules.cpp
@@ -1,85 +0,0 @@
 
-//================ Copyright (c) 2016, PG, All rights reserved. =================//
 
-//
 
-// Purpose:		difficulty & playfield behaviour
 
-//
 
-// $NoKeywords: $osugr
 
-//===============================================================================//
 
-
 
-#include "OsuGameRules.h"
 
-
 
-ConVar OsuGameRules::osu_playfield_border_top_percent("osu_playfield_border_top_percent", 0.117f, FCVAR_NONE);
 
-ConVar OsuGameRules::osu_playfield_border_bottom_percent("osu_playfield_border_bottom_percent", 0.0834f, FCVAR_NONE);
 
-
 
-ConVar OsuGameRules::osu_hitobject_hittable_dim(
 
-    "osu_hitobject_hittable_dim", true, FCVAR_NONE,
 
-    "whether to dim objects not yet within the miss-range (when they can't even be missed yet)");
 
-ConVar OsuGameRules::osu_hitobject_hittable_dim_start_percent(
 
-    "osu_hitobject_hittable_dim_start_percent", 0.7647f, FCVAR_NONE,
 
-    "dimmed objects start at this brightness value before becoming fullbright (only RGB, this does not affect "
 
-    "alpha/transparency)");
 
-ConVar OsuGameRules::osu_hitobject_hittable_dim_duration("osu_hitobject_hittable_dim_duration", 100, FCVAR_NONE,
 
-                                                         "in milliseconds (!)");
 
-
 
-ConVar OsuGameRules::osu_hitobject_fade_in_time("osu_hitobject_fade_in_time", 400, FCVAR_CHEAT, "in milliseconds (!)");
 
-ConVar OsuGameRules::osu_hitobject_fade_out_time("osu_hitobject_fade_out_time", 0.293f, FCVAR_CHEAT, "in seconds (!)");
 
-ConVar OsuGameRules::osu_hitobject_fade_out_time_speed_multiplier_min(
 
-    "osu_hitobject_fade_out_time_speed_multiplier_min", 0.5f, FCVAR_CHEAT,
 
-    "The minimum multiplication factor allowed for the speed multiplier influencing the fadeout duration");
 
-
 
-ConVar OsuGameRules::osu_circle_fade_out_scale("osu_circle_fade_out_scale", 0.4f, FCVAR_CHEAT);
 
-
 
-ConVar OsuGameRules::osu_slider_followcircle_fadein_fade_time("osu_slider_followcircle_fadein_fade_time", 0.06f,
 
-                                                              FCVAR_NONE);
 
-ConVar OsuGameRules::osu_slider_followcircle_fadeout_fade_time("osu_slider_followcircle_fadeout_fade_time", 0.25f,
 
-                                                               FCVAR_NONE);
 
-ConVar OsuGameRules::osu_slider_followcircle_fadein_scale("osu_slider_followcircle_fadein_scale", 0.5f, FCVAR_NONE);
 
-ConVar OsuGameRules::osu_slider_followcircle_fadein_scale_time("osu_slider_followcircle_fadein_scale_time", 0.18f,
 
-                                                               FCVAR_NONE);
 
-ConVar OsuGameRules::osu_slider_followcircle_fadeout_scale("osu_slider_followcircle_fadeout_scale", 0.8f, FCVAR_NONE);
 
-ConVar OsuGameRules::osu_slider_followcircle_fadeout_scale_time("osu_slider_followcircle_fadeout_scale_time", 0.25f,
 
-                                                                FCVAR_NONE);
 
-ConVar OsuGameRules::osu_slider_followcircle_tick_pulse_time("osu_slider_followcircle_tick_pulse_time", 0.2f,
 
-                                                             FCVAR_NONE);
 
-ConVar OsuGameRules::osu_slider_followcircle_tick_pulse_scale("osu_slider_followcircle_tick_pulse_scale", 0.1f,
 
-                                                              FCVAR_NONE);
 
-
 
-ConVar OsuGameRules::osu_spinner_fade_out_time_multiplier("osu_spinner_fade_out_time_multiplier", 0.7f, FCVAR_CHEAT);
 
-
 
-ConVar OsuGameRules::osu_slider_followcircle_size_multiplier("osu_slider_followcircle_size_multiplier", 2.4f,
 
-                                                             FCVAR_CHEAT);
 
-
 
-ConVar OsuGameRules::osu_mod_fps("osu_mod_fps", false, FCVAR_NONVANILLA);
 
-ConVar OsuGameRules::osu_mod_no50s("osu_mod_no50s", false, FCVAR_NONVANILLA);
 
-ConVar OsuGameRules::osu_mod_no100s("osu_mod_no100s", false, FCVAR_NONVANILLA);
 
-ConVar OsuGameRules::osu_mod_ming3012("osu_mod_ming3012", false, FCVAR_NONVANILLA);
 
-ConVar OsuGameRules::osu_mod_millhioref("osu_mod_millhioref", false, FCVAR_NONVANILLA);
 
-ConVar OsuGameRules::osu_mod_millhioref_multiplier("osu_mod_millhioref_multiplier", 2.0f, FCVAR_CHEAT);
 
-ConVar OsuGameRules::osu_mod_mafham("osu_mod_mafham", false, FCVAR_NONVANILLA);
 
-ConVar OsuGameRules::osu_mod_mafham_render_livesize(
 
-    "osu_mod_mafham_render_livesize", 25, FCVAR_NONE,
 
-    "render this many hitobjects without any scene buffering, higher = more lag but more up-to-date scene");
 
-ConVar OsuGameRules::osu_stacking_ar_override("osu_stacking_ar_override", -1, FCVAR_CHEAT,
 
-                                              "allows overriding the approach time used for the stacking calculations. "
 
-                                              "behaves as if disabled if the value is less than 0.");
 
-ConVar OsuGameRules::osu_mod_halfwindow("osu_mod_halfwindow", false, FCVAR_NONVANILLA);
 
-ConVar OsuGameRules::osu_mod_halfwindow_allow_300s("osu_mod_halfwindow_allow_300s", true, FCVAR_NONE,
 
-                                                   "should positive hit deltas be allowed within 300 range");
 
-
 
-// all values here are in milliseconds
 
-ConVar OsuGameRules::osu_approachtime_min("osu_approachtime_min", 1800, FCVAR_CHEAT);
 
-ConVar OsuGameRules::osu_approachtime_mid("osu_approachtime_mid", 1200, FCVAR_CHEAT);
 
-ConVar OsuGameRules::osu_approachtime_max("osu_approachtime_max", 450, FCVAR_CHEAT);
 
-
 
-ConVar OsuGameRules::osu_hitwindow_300_min("osu_hitwindow_300_min", 80, FCVAR_CHEAT);
 
-ConVar OsuGameRules::osu_hitwindow_300_mid("osu_hitwindow_300_mid", 50, FCVAR_CHEAT);
 
-ConVar OsuGameRules::osu_hitwindow_300_max("osu_hitwindow_300_max", 20, FCVAR_CHEAT);
 
-
 
-ConVar OsuGameRules::osu_hitwindow_100_min("osu_hitwindow_100_min", 140, FCVAR_CHEAT);
 
-ConVar OsuGameRules::osu_hitwindow_100_mid("osu_hitwindow_100_mid", 100, FCVAR_CHEAT);
 
-ConVar OsuGameRules::osu_hitwindow_100_max("osu_hitwindow_100_max", 60, FCVAR_CHEAT);
 
-
 
-ConVar OsuGameRules::osu_hitwindow_50_min("osu_hitwindow_50_min", 200, FCVAR_CHEAT);
 
-ConVar OsuGameRules::osu_hitwindow_50_mid("osu_hitwindow_50_mid", 150, FCVAR_CHEAT);
 
-ConVar OsuGameRules::osu_hitwindow_50_max("osu_hitwindow_50_max", 100, FCVAR_CHEAT);
 
-
 
-ConVar OsuGameRules::osu_hitwindow_miss("osu_hitwindow_miss", 400, FCVAR_CHEAT);
--- a/src/App/Osu/OsuIcons.cpp
+++ b/src/App/Osu/OsuIcons.cpp
@@ -1,37 +0,0 @@
 
-//================ Copyright (c) 2018, PG, All rights reserved. =================//
 
-//
 
-// Purpose:		font awesome icon enum
 
-//
 
-// $NoKeywords: $
 
-//===============================================================================//
 
-
 
-#include "OsuIcons.h"
 
-
 
-#include "Font.h"
 
-
 
-std::vector<wchar_t> OsuIcons::icons;
 
-
 
-wchar_t OsuIcons::Z_UNKNOWN_CHAR = OsuIcons::addIcon(McFont::UNKNOWN_CHAR);
 
-wchar_t OsuIcons::Z_SPACE = OsuIcons::addIcon(0x20);
 
-
 
-wchar_t OsuIcons::GEAR = OsuIcons::addIcon(0xf013);
 
-wchar_t OsuIcons::DESKTOP = OsuIcons::addIcon(0xf108);
 
-wchar_t OsuIcons::CIRCLE = OsuIcons::addIcon(0xf10c);
 
-wchar_t OsuIcons::CUBE = OsuIcons::addIcon(0xf1b2);
 
-wchar_t OsuIcons::VOLUME_UP = OsuIcons::addIcon(0xf028);
 
-wchar_t OsuIcons::VOLUME_DOWN = OsuIcons::addIcon(0xf027);
 
-wchar_t OsuIcons::VOLUME_OFF = OsuIcons::addIcon(0xf026);
 
-wchar_t OsuIcons::PAINTBRUSH = OsuIcons::addIcon(0xf1fc);
 
-wchar_t OsuIcons::GAMEPAD = OsuIcons::addIcon(0xf11b);
 
-wchar_t OsuIcons::WRENCH = OsuIcons::addIcon(0xf0ad);
 
-wchar_t OsuIcons::EYE = OsuIcons::addIcon(0xf06e);
 
-wchar_t OsuIcons::ARROW_CIRCLE_UP = OsuIcons::addIcon(0xf01b);
 
-wchar_t OsuIcons::TROPHY = OsuIcons::addIcon(0xf091);
 
-wchar_t OsuIcons::CARET_DOWN = OsuIcons::addIcon(0xf0d7);
 
-wchar_t OsuIcons::ARROW_DOWN = OsuIcons::addIcon(0xf063);
 
-wchar_t OsuIcons::GLOBE = OsuIcons::addIcon(0xf0ac);
 
-wchar_t OsuIcons::USER = OsuIcons::addIcon(0xf2be);
 
-wchar_t OsuIcons::UNDO = OsuIcons::addIcon(0xf0e2);
 
-wchar_t OsuIcons::KEYBOARD = OsuIcons::addIcon(0xf11c);
 
-wchar_t OsuIcons::LOCK = OsuIcons::addIcon(0xf023);
 
-wchar_t OsuIcons::UNLOCK = OsuIcons::addIcon(0xf09c);
--- a/src/App/Osu/OsuKeyBindings.cpp
+++ b/src/App/Osu/OsuKeyBindings.cpp
@@ -1,100 +0,0 @@
 
-//================ Copyright (c) 2016, PG, All rights reserved. =================//
 
-//
 
-// Purpose:		key bindings container
 
-//
 
-// $NoKeywords: $osukey
 
-//===============================================================================//
 
-
 
-#include "OsuKeyBindings.h"
 
-
 
-#include "Keyboard.h"
 
-
 
-ConVar OsuKeyBindings::LEFT_CLICK("osu_key_left_click", (int)KEY_Z, FCVAR_NONE);
 
-ConVar OsuKeyBindings::RIGHT_CLICK("osu_key_right_click", (int)KEY_X, FCVAR_NONE);
 
-ConVar OsuKeyBindings::LEFT_CLICK_2("osu_key_left_click_2", 0, FCVAR_NONE);
 
-ConVar OsuKeyBindings::RIGHT_CLICK_2("osu_key_right_click_2", 0, FCVAR_NONE);
 
-
 
-ConVar OsuKeyBindings::FPOSU_ZOOM("osu_key_fposu_zoom", 0, FCVAR_NONE);
 
-
 
-ConVar OsuKeyBindings::INCREASE_VOLUME("osu_key_increase_volume", (int)KEY_UP, FCVAR_NONE);
 
-ConVar OsuKeyBindings::DECREASE_VOLUME("osu_key_decrease_volume", (int)KEY_DOWN, FCVAR_NONE);
 
-
 
-ConVar OsuKeyBindings::INCREASE_LOCAL_OFFSET("osu_key_increase_local_offset", (int)KEY_ADD, FCVAR_NONE);
 
-ConVar OsuKeyBindings::DECREASE_LOCAL_OFFSET("osu_key_decrease_local_offset", (int)KEY_SUBTRACT, FCVAR_NONE);
 
-
 
-ConVar OsuKeyBindings::GAME_PAUSE("osu_key_game_pause", (int)KEY_ESCAPE, FCVAR_NONE);
 
-ConVar OsuKeyBindings::SKIP_CUTSCENE("osu_key_skip_cutscene", (int)KEY_SPACE, FCVAR_NONE);
 
-ConVar OsuKeyBindings::TOGGLE_SCOREBOARD("osu_key_toggle_scoreboard", (int)KEY_TAB, FCVAR_NONE);
 
-ConVar OsuKeyBindings::SEEK_TIME("osu_key_seek_time", (int)KEY_SHIFT, FCVAR_NONE);
 
-ConVar OsuKeyBindings::SEEK_TIME_BACKWARD("osu_key_seek_time_backward", (int)KEY_LEFT, FCVAR_NONE);
 
-ConVar OsuKeyBindings::SEEK_TIME_FORWARD("osu_key_seek_time_forward", (int)KEY_RIGHT, FCVAR_NONE);
 
-ConVar OsuKeyBindings::QUICK_RETRY("osu_key_quick_retry", (int)KEY_BACKSPACE, FCVAR_NONE);
 
-ConVar OsuKeyBindings::QUICK_SAVE("osu_key_quick_save", (int)KEY_F6, FCVAR_NONE);
 
-ConVar OsuKeyBindings::QUICK_LOAD("osu_key_quick_load", (int)KEY_F7, FCVAR_NONE);
 
-ConVar OsuKeyBindings::INSTANT_REPLAY("osu_key_instant_replay", (int)KEY_F2, FCVAR_NONE);
 
-ConVar OsuKeyBindings::TOGGLE_CHAT("osu_key_toggle_chat", (int)KEY_F8, FCVAR_NONE);
 
-ConVar OsuKeyBindings::SAVE_SCREENSHOT("osu_key_save_screenshot", (int)KEY_F12, FCVAR_NONE);
 
-ConVar OsuKeyBindings::DISABLE_MOUSE_BUTTONS("osu_key_disable_mouse_buttons", (int)KEY_F10, FCVAR_NONE);
 
-ConVar OsuKeyBindings::BOSS_KEY("osu_key_boss", (int)KEY_INSERT, FCVAR_NONE);
 
-
 
-ConVar OsuKeyBindings::TOGGLE_MODSELECT("osu_key_toggle_modselect", (int)KEY_F1, FCVAR_NONE);
 
-ConVar OsuKeyBindings::RANDOM_BEATMAP("osu_key_random_beatmap", (int)KEY_F2, FCVAR_NONE);
 
-
 
-ConVar OsuKeyBindings::MOD_EASY("osu_key_mod_easy", (int)KEY_Q, FCVAR_NONE);
 
-ConVar OsuKeyBindings::MOD_NOFAIL("osu_key_mod_nofail", (int)KEY_W, FCVAR_NONE);
 
-ConVar OsuKeyBindings::MOD_HALFTIME("osu_key_mod_halftime", (int)KEY_E, FCVAR_NONE);
 
-ConVar OsuKeyBindings::MOD_HARDROCK("osu_key_mod_hardrock", (int)KEY_A, FCVAR_NONE);
 
-ConVar OsuKeyBindings::MOD_SUDDENDEATH("osu_key_mod_suddendeath", (int)KEY_S, FCVAR_NONE);
 
-ConVar OsuKeyBindings::MOD_DOUBLETIME("osu_key_mod_doubletime", (int)KEY_D, FCVAR_NONE);
 
-ConVar OsuKeyBindings::MOD_HIDDEN("osu_key_mod_hidden", (int)KEY_F, FCVAR_NONE);
 
-ConVar OsuKeyBindings::MOD_FLASHLIGHT("osu_key_mod_flashlight", (int)KEY_G, FCVAR_NONE);
 
-ConVar OsuKeyBindings::MOD_RELAX("osu_key_mod_relax", (int)KEY_Z, FCVAR_NONE);
 
-ConVar OsuKeyBindings::MOD_AUTOPILOT("osu_key_mod_autopilot", (int)KEY_X, FCVAR_NONE);
 
-ConVar OsuKeyBindings::MOD_SPUNOUT("osu_key_mod_spunout", (int)KEY_C, FCVAR_NONE);
 
-ConVar OsuKeyBindings::MOD_AUTO("osu_key_mod_auto", (int)KEY_V, FCVAR_NONE);
 
-ConVar OsuKeyBindings::MOD_SCOREV2("osu_key_mod_scorev2", (int)KEY_B, FCVAR_NONE);
 
-
 
-std::vector<ConVar*> OsuKeyBindings::ALL = {&OsuKeyBindings::LEFT_CLICK,
 
-                                            &OsuKeyBindings::RIGHT_CLICK,
 
-                                            &OsuKeyBindings::LEFT_CLICK_2,
 
-                                            &OsuKeyBindings::RIGHT_CLICK_2,
 
-
 
-                                            &OsuKeyBindings::FPOSU_ZOOM,
 
-
 
-                                            &OsuKeyBindings::INCREASE_VOLUME,
 
-                                            &OsuKeyBindings::DECREASE_VOLUME,
 
-
 
-                                            &OsuKeyBindings::INCREASE_LOCAL_OFFSET,
 
-                                            &OsuKeyBindings::DECREASE_LOCAL_OFFSET,
 
-
 
-                                            &OsuKeyBindings::GAME_PAUSE,
 
-                                            &OsuKeyBindings::SKIP_CUTSCENE,
 
-                                            &OsuKeyBindings::TOGGLE_SCOREBOARD,
 
-                                            &OsuKeyBindings::SEEK_TIME,
 
-                                            &OsuKeyBindings::SEEK_TIME_BACKWARD,
 
-                                            &OsuKeyBindings::SEEK_TIME_FORWARD,
 
-                                            &OsuKeyBindings::QUICK_RETRY,
 
-                                            &OsuKeyBindings::QUICK_SAVE,
 
-                                            &OsuKeyBindings::QUICK_LOAD,
 
-                                            &OsuKeyBindings::INSTANT_REPLAY,
 
-                                            &OsuKeyBindings::TOGGLE_CHAT,
 
-                                            &OsuKeyBindings::SAVE_SCREENSHOT,
 
-                                            &OsuKeyBindings::DISABLE_MOUSE_BUTTONS,
 
-                                            &OsuKeyBindings::BOSS_KEY,
 
-
 
-                                            &OsuKeyBindings::TOGGLE_MODSELECT,
 
-                                            &OsuKeyBindings::RANDOM_BEATMAP,
 
-
 
-                                            &OsuKeyBindings::MOD_EASY,
 
-                                            &OsuKeyBindings::MOD_NOFAIL,
 
-                                            &OsuKeyBindings::MOD_HALFTIME,
 
-                                            &OsuKeyBindings::MOD_HARDROCK,
 
-                                            &OsuKeyBindings::MOD_SUDDENDEATH,
 
-                                            &OsuKeyBindings::MOD_DOUBLETIME,
 
-                                            &OsuKeyBindings::MOD_HIDDEN,
 
-                                            &OsuKeyBindings::MOD_FLASHLIGHT,
 
-                                            &OsuKeyBindings::MOD_RELAX,
 
-                                            &OsuKeyBindings::MOD_AUTOPILOT,
 
-                                            &OsuKeyBindings::MOD_SPUNOUT,
 
-                                            &OsuKeyBindings::MOD_AUTO,
 
-                                            &OsuKeyBindings::MOD_SCOREV2};
--- a/src/App/Osu/OsuScore.h
+++ b/src/App/Osu/OsuScore.h
@@ -1,168 +0,0 @@
 
-//================ Copyright (c) 2015, PG, All rights reserved. =================//
 
-//
 
-// Purpose:		score handler (calculation, storage, hud)
 
-//
 
-// $NoKeywords: $osu
 
-//===============================================================================//
 
-
 
-#ifndef OSUSCORE_H
 
-#define OSUSCORE_H
 
-
 
-#include "Score.h"
 
-
 
-class ConVar;
 
-
 
-class Osu;
 
-class OsuBeatmap;
 
-class OsuHitObject;
 
-
 
-class OsuScore {
 
-   public:
 
-    static const uint32_t VERSION = 20240412;
 
-
 
-    enum class HIT {
 
-        // score
 
-        HIT_NULL,
 
-        HIT_MISS,
 
-        HIT_50,
 
-        HIT_100,
 
-        HIT_300,
 
-
 
-        // only used for health + SS/PF mods
 
-        HIT_MISS_SLIDERBREAK,
 
-        HIT_MU,
 
-        HIT_100K,
 
-        HIT_300K,
 
-        HIT_300G,
 
-        HIT_SLIDER10,  // tick
 
-        HIT_SLIDER30,  // repeat
 
-        HIT_SPINNERSPIN,
 
-        HIT_SPINNERBONUS
 
-    };
 
-
 
-    static float calculateAccuracy(int num300s, int num100s, int num50s, int numMisses);
 
-    static Score::Grade calculateGrade(int num300s, int num100s, int num50s, int numMisses, bool modHidden,
 
-                                       bool modFlashlight);
 
-
 
-   public:
 
-    OsuScore(Osu *osu);
 
-
 
-    void reset();  // only OsuBeatmap may call this function!
 
-
 
-    void addHitResult(OsuBeatmap *beatmap, OsuHitObject *hitObject, OsuScore::HIT hit, long delta,
 
-                      bool ignoreOnHitErrorBar, bool hitErrorBarOnly, bool ignoreCombo,
 
-                      bool ignoreScore);  // only OsuBeatmap may call this function!
 
-    void addHitResultComboEnd(OsuScore::HIT hit);
 
-    void addSliderBreak();  // only OsuBeatmap may call this function!
 
-    void addPoints(int points, bool isSpinner);
 
-    void setComboFull(int comboFull) { m_iComboFull = comboFull; }
 
-    void setComboEndBitmask(int comboEndBitmask) { m_iComboEndBitmask = comboEndBitmask; }
 
-    void setDead(bool dead);
 
-
 
-    void addKeyCount(int key);
 
-
 
-    void setStarsTomTotal(float starsTomTotal) { m_fStarsTomTotal = starsTomTotal; }
 
-    void setStarsTomAim(float starsTomAim) { m_fStarsTomAim = starsTomAim; }
 
-    void setStarsTomSpeed(float starsTomSpeed) { m_fStarsTomSpeed = starsTomSpeed; }
 
-    void setPPv2(float ppv2) { m_fPPv2 = ppv2; }
 
-    void setIndex(int index) { m_iIndex = index; }
 
-
 
-    void setNumEZRetries(int numEZRetries) { m_iNumEZRetries = numEZRetries; }
 
-
 
-    inline float getStarsTomTotal() const { return m_fStarsTomTotal; }
 
-    inline float getStarsTomAim() const { return m_fStarsTomAim; }
 
-    inline float getStarsTomSpeed() const { return m_fStarsTomSpeed; }
 
-    inline float getPPv2() const { return m_fPPv2; }
 
-    inline int getIndex() const { return m_iIndex; }
 
-
 
-    unsigned long long getScore();
 
-    inline Score::Grade getGrade() const { return m_grade; }
 
-    inline int getCombo() const { return m_iCombo; }
 
-    inline int getComboMax() const { return m_iComboMax; }
 
-    inline int getComboFull() const { return m_iComboFull; }
 
-    inline int getComboEndBitmask() const { return m_iComboEndBitmask; }
 
-    inline float getAccuracy() const { return m_fAccuracy; }
 
-    inline float getUnstableRate() const { return m_fUnstableRate; }
 
-    inline float getHitErrorAvgMin() const { return m_fHitErrorAvgMin; }
 
-    inline float getHitErrorAvgMax() const { return m_fHitErrorAvgMax; }
 
-    inline float getHitErrorAvgCustomMin() const { return m_fHitErrorAvgCustomMin; }
 
-    inline float getHitErrorAvgCustomMax() const { return m_fHitErrorAvgCustomMax; }
 
-    inline int getNumMisses() const { return m_iNumMisses; }
 
-    inline int getNumSliderBreaks() const { return m_iNumSliderBreaks; }
 
-    inline int getNum50s() const { return m_iNum50s; }
 
-    inline int getNum100s() const { return m_iNum100s; }
 
-    inline int getNum100ks() const { return m_iNum100ks; }
 
-    inline int getNum300s() const { return m_iNum300s; }
 
-    inline int getNum300gs() const { return m_iNum300gs; }
 
-
 
-    inline int getNumEZRetries() const { return m_iNumEZRetries; }
 
-
 
-    inline bool isDead() const { return m_bDead; }
 
-    inline bool hasDied() const { return m_bDied; }
 
-
 
-    inline bool isUnranked() const { return m_bIsUnranked; }
 
-
 
-    static double getHealthIncrease(OsuBeatmap *beatmap, OsuScore::HIT hit);
 
-    static double getHealthIncrease(OsuScore::HIT hit, double HP = 5.0f, double hpMultiplierNormal = 1.0f,
 
-                                    double hpMultiplierComboEnd = 1.0f, double hpBarMaximumForNormalization = 200.0f);
 
-
 
-    int getKeyCount(int key);
 
-    int getModsLegacy();
 
-    UString getModsStringForRichPresence();
 
-
 
-   private:
 
-    static ConVar *m_osu_draw_statistics_pp_ref;
 
-    static ConVar *m_osu_drain_type_ref;
 
-
 
-    void onScoreChange();
 
-
 
-    Osu *m_osu;
 
-
 
-    std::vector<HIT> m_hitresults;
 
-    std::vector<int> m_hitdeltas;
 
-
 
-    Score::Grade m_grade;
 
-
 
-    float m_fStarsTomTotal;
 
-    float m_fStarsTomAim;
 
-    float m_fStarsTomSpeed;
 
-    float m_fPPv2;
 
-    int m_iIndex;
 
-
 
-    unsigned long long m_iScoreV1;
 
-    unsigned long long m_iScoreV2;
 
-    unsigned long long m_iScoreV2ComboPortion;
 
-    unsigned long long m_iBonusPoints;
 
-    int m_iCombo;
 
-    int m_iComboMax;
 
-    int m_iComboFull;
 
-    int m_iComboEndBitmask;
 
-    float m_fAccuracy;
 
-    float m_fHitErrorAvgMin;
 
-    float m_fHitErrorAvgMax;
 
-    float m_fHitErrorAvgCustomMin;
 
-    float m_fHitErrorAvgCustomMax;
 
-    float m_fUnstableRate;
 
-
 
-    int m_iNumMisses;
 
-    int m_iNumSliderBreaks;
 
-    int m_iNum50s;
 
-    int m_iNum100s;
 
-    int m_iNum100ks;
 
-    int m_iNum300s;
 
-    int m_iNum300gs;
 
-
 
-    bool m_bDead;
 
-    bool m_bDied;
 
-
 
-    int m_iNumK1;
 
-    int m_iNumK2;
 
-    int m_iNumM1;
 
-    int m_iNumM2;
 
-
 
-    // custom
 
-    int m_iNumEZRetries;
 
-    bool m_bIsUnranked;
 
-};
 
-
 
-#endif
--- a/src/App/Osu/OsuUIRankingScreenRankingPanel.h
+++ b/src/App/Osu/OsuUIRankingScreenRankingPanel.h
@@ -1,45 +0,0 @@
 
-//================ Copyright (c) 2016, PG, All rights reserved. =================//
 
-//
 
-// Purpose:		score + results panel (300, 100, 50, miss, combo, accuracy, score)
 
-//
 
-// $NoKeywords: $osursp
 
-//===============================================================================//
 
-
 
-#ifndef OSUUIRANKINGSCREENRANKINGPANEL_H
 
-#define OSUUIRANKINGSCREENRANKINGPANEL_H
 
-
 
-#include "CBaseUIImage.h"
 
-#include "OsuDatabase.h"
 
-
 
-class Osu;
 
-class OsuScore;
 
-class OsuSkinImage;
 
-
 
-class OsuUIRankingScreenRankingPanel : public CBaseUIImage {
 
-   public:
 
-    OsuUIRankingScreenRankingPanel(Osu *osu);
 
-
 
-    virtual void draw(Graphics *g);
 
-
 
-    void setScore(OsuScore *score);
 
-    void setScore(Score score);
 
-
 
-   private:
 
-    void drawHitImage(Graphics *g, OsuSkinImage *img, float scale, Vector2 pos);
 
-    void drawNumHits(Graphics *g, int numHits, float scale, Vector2 pos);
 
-
 
-    Osu *m_osu;
 
-
 
-    unsigned long long m_iScore;
 
-    int m_iNum300s;
 
-    int m_iNum300gs;
 
-    int m_iNum100s;
 
-    int m_iNum100ks;
 
-    int m_iNum50s;
 
-    int m_iNumMisses;
 
-    int m_iCombo;
 
-    float m_fAccuracy;
 
-    bool m_bPerfect;
 
-};
 
-
 
-#endif
--- a/src/App/Osu/OsuPauseMenu.cpp
+++ b/src/App/Osu/OsuPauseMenu.cpp
@@ -5,33 +5,33 @@
 
 // $NoKeywords: $
 
 //===============================================================================//
 
 
 
-#include "OsuPauseMenu.h"
 
+#include "PauseMenu.h"
 
 
 
 #include "AnimationHandler.h"
 
+#include "Beatmap.h"
 
 #include "CBaseUIContainer.h"
 
+#include "Chat.h"
 
 #include "ConVar.h"
 
 #include "Engine.h"
 
 #include "Environment.h"
 
+#include "HUD.h"
 
+#include "KeyBindings.h"
 
 #include "Keyboard.h"
 
+#include "ModSelector.h"
 
 #include "Mouse.h"
 
+#include "OptionsMenu.h"
 
 #include "Osu.h"
 
-#include "OsuBeatmap.h"
 
-#include "OsuChat.h"
 
-#include "OsuHUD.h"
 
-#include "OsuKeyBindings.h"
 
-#include "OsuModSelector.h"
 
-#include "OsuOptionsMenu.h"
 
-#include "OsuRichPresence.h"
 
-#include "OsuSkin.h"
 
-#include "OsuUIPauseMenuButton.h"
 
 #include "ResourceManager.h"
 
+#include "RichPresence.h"
 
+#include "Skin.h"
 
 #include "SoundEngine.h"
 
+#include "UIPauseMenuButton.h"
 
 
 
 ConVar osu_pause_dim_background("osu_pause_dim_background", true, FCVAR_NONE);
 
 ConVar osu_pause_dim_alpha("osu_pause_dim_alpha", 0.58f, FCVAR_NONE);
 
 ConVar osu_pause_anim_duration("osu_pause_anim_duration", 0.15f, FCVAR_NONE);
 
 
 
-OsuPauseMenu::OsuPauseMenu(Osu *osu) : OsuScreen(osu) {
 
+PauseMenu::PauseMenu(Osu *osu) : OsuScreen(osu) {
 
     m_bScheduledVisibility = false;
 
     m_bScheduledVisibilityChange = false;
 
 
@@ -50,19 +50,18 @@ OsuPauseMenu::OsuPauseMenu(Osu *osu) : OsuScreen(osu) {
 
 
 
     setSize(m_osu->getScreenWidth(), m_osu->getScreenHeight());
 
 
 
-    OsuUIPauseMenuButton *continueButton =
 
-        addButton([this]() -> Image * { return m_osu->getSkin()->getPauseContinue(); });
 
-    OsuUIPauseMenuButton *retryButton = addButton([this]() -> Image * { return m_osu->getSkin()->getPauseRetry(); });
 
-    OsuUIPauseMenuButton *backButton = addButton([this]() -> Image * { return m_osu->getSkin()->getPauseBack(); });
 
+    UIPauseMenuButton *continueButton = addButton([this]() -> Image * { return m_osu->getSkin()->getPauseContinue(); });
 
+    UIPauseMenuButton *retryButton = addButton([this]() -> Image * { return m_osu->getSkin()->getPauseRetry(); });
 
+    UIPauseMenuButton *backButton = addButton([this]() -> Image * { return m_osu->getSkin()->getPauseBack(); });
 
 
 
-    continueButton->setClickCallback(fastdelegate::MakeDelegate(this, &OsuPauseMenu::onContinueClicked));
 
-    retryButton->setClickCallback(fastdelegate::MakeDelegate(this, &OsuPauseMenu::onRetryClicked));
 
-    backButton->setClickCallback(fastdelegate::MakeDelegate(this, &OsuPauseMenu::onBackClicked));
 
+    continueButton->setClickCallback(fastdelegate::MakeDelegate(this, &PauseMenu::onContinueClicked));
 
+    retryButton->setClickCallback(fastdelegate::MakeDelegate(this, &PauseMenu::onRetryClicked));
 
+    backButton->setClickCallback(fastdelegate::MakeDelegate(this, &PauseMenu::onBackClicked));
 
 
 
     updateLayout();
 
 }
 
 
 
-void OsuPauseMenu::draw(Graphics *g) {
 
+void PauseMenu::draw(Graphics *g) {
 
     const bool isAnimating = anim->isAnimating(&m_fDimAnim);
 
     if(!m_bVisible && !isAnimating) return;
 
 
@@ -124,7 +123,7 @@ void OsuPauseMenu::draw(Graphics *g) {
 
     }
 
 }
 
 
 
-void OsuPauseMenu::mouse_update(bool *propagate_clicks) {
 
+void PauseMenu::mouse_update(bool *propagate_clicks) {
 
     if(!m_bVisible) return;
 
 
 
     // update and focus handling
@@ -138,7 +137,7 @@ void OsuPauseMenu::mouse_update(bool *propagate_clicks) {
 
     if(anim->isAnimating(&m_fWarningArrowsAnimX)) m_fWarningArrowsAnimStartTime = engine->getTime();
 
 }
 
 
 
-void OsuPauseMenu::onContinueClicked() {
 
+void PauseMenu::onContinueClicked() {
 
     if(!m_bContinueEnabled) return;
 
     if(anim->isAnimating(&m_fDimAnim)) return;
 
 
@@ -148,7 +147,7 @@ void OsuPauseMenu::onContinueClicked() {
 
     scheduleVisibilityChange(false);
 
 }
 
 
 
-void OsuPauseMenu::onRetryClicked() {
 
+void PauseMenu::onRetryClicked() {
 
     if(anim->isAnimating(&m_fDimAnim)) return;
 
 
 
     engine->getSound()->play(m_osu->getSkin()->getMenuHit());
@@ -157,7 +156,7 @@ void OsuPauseMenu::onRetryClicked() {
 
     scheduleVisibilityChange(false);
 
 }
 
 
 
-void OsuPauseMenu::onBackClicked() {
 
+void PauseMenu::onBackClicked() {
 
     if(anim->isAnimating(&m_fDimAnim)) return;
 
 
 
     engine->getSound()->play(m_osu->getSkin()->getMenuHit());
@@ -166,7 +165,7 @@ void OsuPauseMenu::onBackClicked() {
 
     scheduleVisibilityChange(false);
 
 }
 
 
 
-void OsuPauseMenu::onSelectionChange() {
 
+void PauseMenu::onSelectionChange() {
 
     if(m_selectedButton != NULL) {
 
         if(m_bInitialWarningArrowFlyIn) {
 
             m_bInitialWarningArrowFlyIn = false;
@@ -185,20 +184,19 @@ void OsuPauseMenu::onSelectionChange() {
 
     }
 
 }
 
 
 
-void OsuPauseMenu::onKeyDown(KeyboardEvent &e) {
 
+void PauseMenu::onKeyDown(KeyboardEvent &e) {
 
     OsuScreen::onKeyDown(e);  // only used for options menu
 
     if(!m_bVisible || e.isConsumed()) return;
 
 
 
-    if(e == (KEYCODE)OsuKeyBindings::LEFT_CLICK.getInt() || e == (KEYCODE)OsuKeyBindings::RIGHT_CLICK.getInt() ||
 
-       e == (KEYCODE)OsuKeyBindings::LEFT_CLICK_2.getInt() || e == (KEYCODE)OsuKeyBindings::RIGHT_CLICK_2.getInt()) {
 
+    if(e == (KEYCODE)KeyBindings::LEFT_CLICK.getInt() || e == (KEYCODE)KeyBindings::RIGHT_CLICK.getInt() ||
 
+       e == (KEYCODE)KeyBindings::LEFT_CLICK_2.getInt() || e == (KEYCODE)KeyBindings::RIGHT_CLICK_2.getInt()) {
 
         bool fireButtonClick = false;
 
-        if((e == (KEYCODE)OsuKeyBindings::LEFT_CLICK.getInt() || e == (KEYCODE)OsuKeyBindings::LEFT_CLICK_2.getInt()) &&
 
+        if((e == (KEYCODE)KeyBindings::LEFT_CLICK.getInt() || e == (KEYCODE)KeyBindings::LEFT_CLICK_2.getInt()) &&
 
            !m_bClick1Down) {
 
             m_bClick1Down = true;
 
             fireButtonClick = true;
 
         }
 
-        if((e == (KEYCODE)OsuKeyBindings::RIGHT_CLICK.getInt() ||
 
-            e == (KEYCODE)OsuKeyBindings::RIGHT_CLICK_2.getInt()) &&
 
+        if((e == (KEYCODE)KeyBindings::RIGHT_CLICK.getInt() || e == (KEYCODE)KeyBindings::RIGHT_CLICK_2.getInt()) &&
 
            !m_bClick2Down) {
 
             m_bClick2Down = true;
 
             fireButtonClick = true;
@@ -216,7 +214,7 @@ void OsuPauseMenu::onKeyDown(KeyboardEvent &e) {
 
     // handle arrow keys selection
 
     if(m_buttons.size() > 0) {
 
         if(!engine->getKeyboard()->isAltDown() && e == KEY_DOWN) {
 
-            OsuUIPauseMenuButton *nextSelectedButton = m_buttons[0];
 
+            UIPauseMenuButton *nextSelectedButton = m_buttons[0];
 
 
 
             // get first visible button
 
             for(int i = 0; i < m_buttons.size(); i++) {
@@ -242,7 +240,7 @@ void OsuPauseMenu::onKeyDown(KeyboardEvent &e) {
 
         }
 
 
 
         if(!engine->getKeyboard()->isAltDown() && e == KEY_UP) {
 
-            OsuUIPauseMenuButton *nextSelectedButton = m_buttons[m_buttons.size() - 1];
 
+            UIPauseMenuButton *nextSelectedButton = m_buttons[m_buttons.size() - 1];
 
 
 
             // get first visible button
 
             for(int i = m_buttons.size() - 1; i >= 0; i--) {
@@ -272,27 +270,27 @@ void OsuPauseMenu::onKeyDown(KeyboardEvent &e) {
 
 
 
     // consume ALL events, except for a few special binds which are allowed through (e.g. for unpause or changing the
 
     // local offset in Osu.cpp)
 
-    if(e != KEY_ESCAPE && e != (KEYCODE)OsuKeyBindings::GAME_PAUSE.getInt() &&
 
-       e != (KEYCODE)OsuKeyBindings::INCREASE_LOCAL_OFFSET.getInt() &&
 
-       e != (KEYCODE)OsuKeyBindings::DECREASE_LOCAL_OFFSET.getInt())
 
+    if(e != KEY_ESCAPE && e != (KEYCODE)KeyBindings::GAME_PAUSE.getInt() &&
 
+       e != (KEYCODE)KeyBindings::INCREASE_LOCAL_OFFSET.getInt() &&
 
+       e != (KEYCODE)KeyBindings::DECREASE_LOCAL_OFFSET.getInt())
 
         e.consume();
 
 }
 
 
 
-void OsuPauseMenu::onKeyUp(KeyboardEvent &e) {
 
-    if(e == (KEYCODE)OsuKeyBindings::LEFT_CLICK.getInt() || e == (KEYCODE)OsuKeyBindings::LEFT_CLICK_2.getInt())
 
+void PauseMenu::onKeyUp(KeyboardEvent &e) {
 
+    if(e == (KEYCODE)KeyBindings::LEFT_CLICK.getInt() || e == (KEYCODE)KeyBindings::LEFT_CLICK_2.getInt())
 
         m_bClick1Down = false;
 
 
 
-    if(e == (KEYCODE)OsuKeyBindings::RIGHT_CLICK.getInt() || e == (KEYCODE)OsuKeyBindings::RIGHT_CLICK_2.getInt())
 
+    if(e == (KEYCODE)KeyBindings::RIGHT_CLICK.getInt() || e == (KEYCODE)KeyBindings::RIGHT_CLICK_2.getInt())
 
         m_bClick2Down = false;
 
 }
 
 
 
-void OsuPauseMenu::onChar(KeyboardEvent &e) {
 
+void PauseMenu::onChar(KeyboardEvent &e) {
 
     if(!m_bVisible) return;
 
 
 
     e.consume();
 
 }
 
 
 
-void OsuPauseMenu::scheduleVisibilityChange(bool visible) {
 
+void PauseMenu::scheduleVisibilityChange(bool visible) {
 
     if(visible != m_bVisible) {
 
         m_bScheduledVisibilityChange = true;
 
         m_bScheduledVisibility = visible;
@@ -302,7 +300,7 @@ void OsuPauseMenu::scheduleVisibilityChange(bool visible) {
 
     if(!visible) setContinueEnabled(true);
 
 }
 
 
 
-void OsuPauseMenu::updateLayout() {
 
+void PauseMenu::updateLayout() {
 
     const float height = (m_osu->getScreenHeight() / (float)m_buttons.size());
 
     const float half = (m_buttons.size() - 1) / 2.0f;
 
 
@@ -339,12 +337,12 @@ void OsuPauseMenu::updateLayout() {
 
     onSelectionChange();
 
 }
 
 
 
-void OsuPauseMenu::onResolutionChange(Vector2 newResolution) {
 
+void PauseMenu::onResolutionChange(Vector2 newResolution) {
 
     setSize(newResolution);
 
     updateLayout();
 
 }
 
 
 
-CBaseUIContainer *OsuPauseMenu::setVisible(bool visible) {
 
+CBaseUIContainer *PauseMenu::setVisible(bool visible) {
 
     m_bVisible = visible;
 
 
 
     if(m_osu->isInPlayMode())
@@ -354,13 +352,13 @@ CBaseUIContainer *OsuPauseMenu::setVisible(bool visible) {
 
 
 
     if(visible) {
 
         if(m_bContinueEnabled) {
 
-            OsuRichPresence::setStatus(m_osu, "Paused");
 
-            OsuRichPresence::setBanchoStatus(m_osu, "Taking a break", PAUSED);
 
+            RichPresence::setStatus(m_osu, "Paused");
 
+            RichPresence::setBanchoStatus(m_osu, "Taking a break", PAUSED);
 
         } else {
 
-            OsuRichPresence::setBanchoStatus(m_osu, "Failed", SUBMITTING);
 
+            RichPresence::setBanchoStatus(m_osu, "Failed", SUBMITTING);
 
         }
 
     } else {
 
-        OsuRichPresence::onPlayStart(m_osu);
 
+        RichPresence::onPlayStart(m_osu);
 
     }
 
 
 
     // HACKHACK: force disable mod selection screen in case it was open and the beatmap ended/failed
@@ -384,13 +382,13 @@ CBaseUIContainer *OsuPauseMenu::setVisible(bool visible) {
 
     return this;
 
 }
 
 
 
-void OsuPauseMenu::setContinueEnabled(bool continueEnabled) {
 
+void PauseMenu::setContinueEnabled(bool continueEnabled) {
 
     m_bContinueEnabled = continueEnabled;
 
     if(m_buttons.size() > 0) m_buttons[0]->setVisible(m_bContinueEnabled);
 
 }
 
 
 
-OsuUIPauseMenuButton *OsuPauseMenu::addButton(std::function<Image *()> getImageFunc) {
 
-    OsuUIPauseMenuButton *button = new OsuUIPauseMenuButton(m_osu, getImageFunc, 0, 0, 0, 0, "");
 
+UIPauseMenuButton *PauseMenu::addButton(std::function<Image *()> getImageFunc) {
 
+    UIPauseMenuButton *button = new UIPauseMenuButton(m_osu, getImageFunc, 0, 0, 0, 0, "");
 
     addBaseUIElement(button);
 
     m_buttons.push_back(button);
 
     return button;
--- a/src/App/Osu/OsuPauseMenu.h
+++ b/src/App/Osu/OsuPauseMenu.h
@@ -11,13 +11,13 @@
 
 #include "OsuScreen.h"
 
 
 
 class Osu;
 
-class OsuSongBrowser;
 
+class SongBrowser;
 
 class CBaseUIContainer;
 
-class OsuUIPauseMenuButton;
 
+class UIPauseMenuButton;
 
 
 
-class OsuPauseMenu : public OsuScreen {
 
+class PauseMenu : public OsuScreen {
 
    public:
 
-    OsuPauseMenu(Osu *osu);
 
+    PauseMenu(Osu *osu);
 
 
 
     virtual void draw(Graphics *g);
 
     virtual void mouse_update(bool *propagate_clicks);
@@ -43,13 +43,13 @@ class OsuPauseMenu : public OsuScreen {
 
 
 
     void scheduleVisibilityChange(bool visible);
 
 
 
-    OsuUIPauseMenuButton *addButton(std::function<Image *()> getImageFunc);
 
+    UIPauseMenuButton *addButton(std::function<Image *()> getImageFunc);
 
 
 
     bool m_bScheduledVisibilityChange;
 
     bool m_bScheduledVisibility;
 
 
 
-    std::vector<OsuUIPauseMenuButton *> m_buttons;
 
-    OsuUIPauseMenuButton *m_selectedButton;
 
+    std::vector<UIPauseMenuButton *> m_buttons;
 
+    UIPauseMenuButton *m_selectedButton;
 
     float m_fWarningArrowsAnimStartTime;
 
     float m_fWarningArrowsAnimAlpha;
 
     float m_fWarningArrowsAnimX;
--- a/src/App/Osu/OsuPromptScreen.cpp
+++ b/src/App/Osu/OsuPromptScreen.cpp
@@ -1,12 +1,12 @@
 
-#include "OsuPromptScreen.h"
 
+#include "PromptScreen.h"
 
 
 
 #include "CBaseUILabel.h"
 
 #include "CBaseUITextbox.h"
 
 #include "Keyboard.h"
 
 #include "Osu.h"
 
-#include "OsuUIButton.h"
 
+#include "UIButton.h"
 
 
 
-OsuPromptScreen::OsuPromptScreen(Osu *osu) : OsuScreen(osu) {
 
+PromptScreen::PromptScreen(Osu *osu) : OsuScreen(osu) {
 
     m_prompt_label = new CBaseUILabel(0, 0, 0, 0, "", "");
 
     m_prompt_label->setDrawFrame(false);
 
     m_prompt_label->setDrawBackground(false);
@@ -15,20 +15,20 @@ OsuPromptScreen::OsuPromptScreen(Osu *osu) : OsuScreen(osu) {
 
     m_prompt_input = new CBaseUITextbox(0, 0, 400, 40, "");
 
     addBaseUIElement(m_prompt_input);
 
 
 
-    m_ok_btn = new OsuUIButton(osu, 0, 0, 110, 35, "ok_btn", "OK");
 
+    m_ok_btn = new UIButton(osu, 0, 0, 110, 35, "ok_btn", "OK");
 
     m_ok_btn->setColor(0xff00ff00);
 
     m_ok_btn->setUseDefaultSkin();
 
-    m_ok_btn->setClickCallback(fastdelegate::MakeDelegate(this, &OsuPromptScreen::on_ok));
 
+    m_ok_btn->setClickCallback(fastdelegate::MakeDelegate(this, &PromptScreen::on_ok));
 
     addBaseUIElement(m_ok_btn);
 
 
 
-    m_cancel_btn = new OsuUIButton(osu, 0, 0, 110, 35, "cancel_btn", "Cancel");
 
+    m_cancel_btn = new UIButton(osu, 0, 0, 110, 35, "cancel_btn", "Cancel");
 
     m_cancel_btn->setColor(0xff0e94b5);
 
     m_cancel_btn->setUseDefaultSkin();
 
-    m_cancel_btn->setClickCallback(fastdelegate::MakeDelegate(this, &OsuPromptScreen::on_cancel));
 
+    m_cancel_btn->setClickCallback(fastdelegate::MakeDelegate(this, &PromptScreen::on_cancel));
 
     addBaseUIElement(m_cancel_btn);
 
 }
 
 
 
-void OsuPromptScreen::onResolutionChange(Vector2 newResolution) {
 
+void PromptScreen::onResolutionChange(Vector2 newResolution) {
 
     const float xmiddle = newResolution.x / 2;
 
     const float ymiddle = newResolution.y / 2;
 
 
@@ -43,7 +43,7 @@ void OsuPromptScreen::onResolutionChange(Vector2 newResolution) {
 
     m_cancel_btn->setPos(xmiddle + 10, ymiddle + 50);
 
 }
 
 
 
-void OsuPromptScreen::draw(Graphics *g) {
 
+void PromptScreen::draw(Graphics *g) {
 
     if(!m_bVisible) return;
 
 
 
     g->setColor(COLOR(200, 0, 0, 0));
@@ -52,14 +52,14 @@ void OsuPromptScreen::draw(Graphics *g) {
 
     OsuScreen::draw(g);
 
 }
 
 
 
-void OsuPromptScreen::mouse_update(bool *propagate_clicks) {
 
+void PromptScreen::mouse_update(bool *propagate_clicks) {
 
     if(!m_bVisible) return;
 
 
 
     OsuScreen::mouse_update(propagate_clicks);
 
     *propagate_clicks = false;
 
 }
 
 
 
-void OsuPromptScreen::onKeyDown(KeyboardEvent &e) {
 
+void PromptScreen::onKeyDown(KeyboardEvent &e) {
 
     if(!m_bVisible) return;
 
 
 
     if(e == KEY_ENTER) {
@@ -78,19 +78,19 @@ void OsuPromptScreen::onKeyDown(KeyboardEvent &e) {
 
     e.consume();
 
 }
 
 
 
-void OsuPromptScreen::onKeyUp(KeyboardEvent &e) {
 
+void PromptScreen::onKeyUp(KeyboardEvent &e) {
 
     if(!m_bVisible) return;
 
     m_prompt_input->onKeyUp(e);
 
     e.consume();
 
 }
 
 
 
-void OsuPromptScreen::onChar(KeyboardEvent &e) {
 
+void PromptScreen::onChar(KeyboardEvent &e) {
 
     if(!m_bVisible) return;
 
     m_prompt_input->onChar(e);
 
     e.consume();
 
 }
 
 
 
-void OsuPromptScreen::prompt(UString msg, PromptResponseCallback callback) {
 
+void PromptScreen::prompt(UString msg, PromptResponseCallback callback) {
 
     m_prompt_label->setText(msg);
 
     m_prompt_input->setText("");
 
     m_prompt_input->focus();
@@ -100,9 +100,9 @@ void OsuPromptScreen::prompt(UString msg, PromptResponseCallback callback) {
 
     onResolutionChange(m_osu->getScreenSize());
 
 }
 
 
 
-void OsuPromptScreen::on_ok() {
 
+void PromptScreen::on_ok() {
 
     m_bVisible = false;
 
     m_callback(m_prompt_input->getText());
 
 }
 
 
 
-void OsuPromptScreen::on_cancel() { m_bVisible = false; }
 
+void PromptScreen::on_cancel() { m_bVisible = false; }
--- a/src/App/Osu/OsuPromptScreen.h
+++ b/src/App/Osu/OsuPromptScreen.h
@@ -5,11 +5,11 @@ class CBaseUILabel;
 
 class CBaseUITextbox;
 
 class Graphics;
 
 class Osu;
 
-class OsuUIButton;
 
+class UIButton;
 
 
 
-class OsuPromptScreen : public OsuScreen {
 
+class PromptScreen : public OsuScreen {
 
    public:
 
-    OsuPromptScreen(Osu *osu);
 
+    PromptScreen(Osu *osu);
 
     virtual void onResolutionChange(Vector2 newResolution);
 
 
 
     virtual void draw(Graphics *g);
@@ -27,7 +27,7 @@ class OsuPromptScreen : public OsuScreen {
 
 
 
     CBaseUILabel *m_prompt_label;
 
     CBaseUITextbox *m_prompt_input;
 
-    OsuUIButton *m_ok_btn;
 
-    OsuUIButton *m_cancel_btn;
 
+    UIButton *m_ok_btn;
 
+    UIButton *m_cancel_btn;
 
     PromptResponseCallback m_callback;
 
 };
--- a/src/App/Osu/OsuRankingScreen.cpp
+++ b/src/App/Osu/OsuRankingScreen.cpp
@@ -5,45 +5,45 @@
 
 // $NoKeywords: $osuss
 
 //===============================================================================//
 
 
 
-#include "OsuRankingScreen.h"
 
+#include "RankingScreen.h"
 
 
 
 #include "AnimationHandler.h"
 
 #include "Bancho.h"
 
+#include "Beatmap.h"
 
 #include "CBaseUIContainer.h"
 
 #include "CBaseUIImage.h"
 
 #include "CBaseUILabel.h"
 
 #include "CBaseUIScrollView.h"
 
+#include "Chat.h"
 
 #include "ConVar.h"
 
 #include "Engine.h"
 
+#include "GameRules.h"
 
+#include "Icons.h"
 
 #include "Keyboard.h"
 
+#include "ModSelector.h"
 
 #include "Mouse.h"
 
+#include "OptionsMenu.h"
 
 #include "Osu.h"
 
-#include "OsuBeatmap.h"
 
-#include "OsuChat.h"
 
-#include "OsuGameRules.h"
 
-#include "OsuIcons.h"
 
-#include "OsuModSelector.h"
 
-#include "OsuOptionsMenu.h"
 
-#include "OsuReplay.h"
 
-#include "OsuRoom.h"
 
-#include "OsuScore.h"
 
-#include "OsuSkin.h"
 
-#include "OsuSkinImage.h"
 
-#include "OsuSongBrowser.h"
 
-#include "OsuTooltipOverlay.h"
 
-#include "OsuUIRankingScreenInfoLabel.h"
 
-#include "OsuUIRankingScreenRankingPanel.h"
 
-#include "OsuUISongBrowserScoreButton.h"
 
+#include "Replay.h"
 
 #include "ResourceManager.h"
 
+#include "RoomScreen.h"
 
+#include "Skin.h"
 
+#include "SkinImage.h"
 
+#include "SongBrowser.h"
 
 #include "SoundEngine.h"
 
+#include "TooltipOverlay.h"
 
+#include "UIRankingScreenInfoLabel.h"
 
+#include "UIRankingScreenRankingPanel.h"
 
+#include "UISongBrowserScoreButton.h"
 
+#include "score.h"
 
 
 
 ConVar osu_rankingscreen_topbar_height_percent("osu_rankingscreen_topbar_height_percent", 0.785f, FCVAR_NONE);
 
 ConVar osu_rankingscreen_pp("osu_rankingscreen_pp", true, FCVAR_NONE);
 
 ConVar osu_draw_rankingscreen_background_image("osu_draw_rankingscreen_background_image", true, FCVAR_NONE);
 
 
 
-class OsuRankingScreenIndexLabel : public CBaseUILabel {
 
+class RankingScreenIndexLabel : public CBaseUILabel {
 
    public:
 
-    OsuRankingScreenIndexLabel() : CBaseUILabel(-1, 0, 0, 0, "", "You achieved the #1 score on local rankings!") {
 
+    RankingScreenIndexLabel() : CBaseUILabel(-1, 0, 0, 0, "", "You achieved the #1 score on local rankings!") {
 
         m_bVisible2 = false;
 
     }
 
 
@@ -82,9 +82,9 @@ class OsuRankingScreenIndexLabel : public CBaseUILabel {
 
     bool m_bVisible2;
 
 };
 
 
 
-class OsuRankingScreenBottomElement : public CBaseUILabel {
 
+class RankingScreenBottomElement : public CBaseUILabel {
 
    public:
 
-    OsuRankingScreenBottomElement() : CBaseUILabel(-1, 0, 0, 0, "", "") { m_bVisible2 = false; }
 
+    RankingScreenBottomElement() : CBaseUILabel(-1, 0, 0, 0, "", "") { m_bVisible2 = false; }
 
 
 
     virtual void draw(Graphics *g) {
 
         if(!m_bVisible || !m_bVisible2) return;
@@ -103,9 +103,9 @@ class OsuRankingScreenBottomElement : public CBaseUILabel {
 
     bool m_bVisible2;
 
 };
 
 
 
-class OsuRankingScreenScrollDownInfoButton : public CBaseUIButton {
 
+class RankingScreenScrollDownInfoButton : public CBaseUIButton {
 
    public:
 
-    OsuRankingScreenScrollDownInfoButton() : CBaseUIButton(0, 0, 0, 0, "") {
 
+    RankingScreenScrollDownInfoButton() : CBaseUIButton(0, 0, 0, 0, "") {
 
         m_bVisible2 = false;
 
         m_fAlpha = 1.0f;
 
     }
@@ -154,7 +154,7 @@ class OsuRankingScreenScrollDownInfoButton : public CBaseUIButton {
 
     float m_fAlpha;
 
 };
 
 
 
-OsuRankingScreen::OsuRankingScreen(Osu *osu) : OsuScreenBackable(osu) {
 
+RankingScreen::RankingScreen(Osu *osu) : ScreenBackable(osu) {
 
     m_osu_scores_enabled = convar->getConVarByName("osu_scores_enabled");
 
 
 
     m_rankings = new CBaseUIScrollView(-1, 0, 0, 0, "");
@@ -165,7 +165,7 @@ OsuRankingScreen::OsuRankingScreen(Osu *osu) : OsuScreenBackable(osu) {
 
     m_rankings->setDrawScrollbars(true);
 
     addBaseUIElement(m_rankings);
 
 
 
-    m_songInfo = new OsuUIRankingScreenInfoLabel(m_osu, 5, 5, 0, 0, "");
 
+    m_songInfo = new UIRankingScreenInfoLabel(m_osu, 5, 5, 0, 0, "");
 
     addBaseUIElement(m_songInfo);
 
 
 
     m_rankingTitle = new CBaseUIImage(m_osu->getSkin()->getRankingTitle()->getName(), 0, 0, 0, 0, "");
@@ -173,7 +173,7 @@ OsuRankingScreen::OsuRankingScreen(Osu *osu) : OsuScreenBackable(osu) {
 
     m_rankingTitle->setDrawFrame(false);
 
     addBaseUIElement(m_rankingTitle);
 
 
 
-    m_rankingPanel = new OsuUIRankingScreenRankingPanel(osu);
 
+    m_rankingPanel = new UIRankingScreenRankingPanel(osu);
 
     m_rankingPanel->setDrawBackground(false);
 
     m_rankingPanel->setDrawFrame(false);
 
     m_rankings->getContainer()->addBaseUIElement(m_rankingPanel);
@@ -183,31 +183,31 @@ OsuRankingScreen::OsuRankingScreen(Osu *osu) : OsuScreenBackable(osu) {
 
     m_rankingGrade->setDrawFrame(false);
 
     m_rankings->getContainer()->addBaseUIElement(m_rankingGrade);
 
 
 
-    m_rankingBottom = new OsuRankingScreenBottomElement();
 
+    m_rankingBottom = new RankingScreenBottomElement();
 
     m_rankings->getContainer()->addBaseUIElement(m_rankingBottom);
 
 
 
-    m_rankingIndex = new OsuRankingScreenIndexLabel();
 
+    m_rankingIndex = new RankingScreenIndexLabel();
 
     m_rankingIndex->setDrawFrame(false);
 
     m_rankingIndex->setCenterText(true);
 
     m_rankingIndex->setFont(m_osu->getSongBrowserFont());
 
     m_rankingIndex->setTextColor(0xffffcb21);
 
     m_rankings->getContainer()->addBaseUIElement(m_rankingIndex);
 
 
 
-    m_rankingScrollDownInfoButton = new OsuRankingScreenScrollDownInfoButton();
 
+    m_rankingScrollDownInfoButton = new RankingScreenScrollDownInfoButton();
 
     m_rankingScrollDownInfoButton->setFont(m_osu->getFontIcons());
 
     m_rankingScrollDownInfoButton->setClickCallback(
 
-        fastdelegate::MakeDelegate(this, &OsuRankingScreen::onScrollDownClicked));
 
+        fastdelegate::MakeDelegate(this, &RankingScreen::onScrollDownClicked));
 
     UString iconString;
 
-    iconString.insert(0, OsuIcons::ARROW_DOWN);
 
+    iconString.insert(0, Icons::ARROW_DOWN);
 
     iconString.append("   ");
 
-    iconString.insert(iconString.length(), OsuIcons::ARROW_DOWN);
 
+    iconString.insert(iconString.length(), Icons::ARROW_DOWN);
 
     iconString.append("   ");
 
-    iconString.insert(iconString.length(), OsuIcons::ARROW_DOWN);
 
+    iconString.insert(iconString.length(), Icons::ARROW_DOWN);
 
     m_rankingScrollDownInfoButton->setText(iconString);
 
     addBaseUIElement(m_rankingScrollDownInfoButton);
 
     m_fRankingScrollDownInfoButtonAlphaAnim = 1.0f;
 
 
 
-    setGrade(Score::Grade::D);
 
+    setGrade(FinishedScore::Grade::D);
 
     setIndex(0);  // TEMP
 
 
 
     m_fUnstableRate = 0.0f;
@@ -247,11 +247,11 @@ OsuRankingScreen::OsuRankingScreen(Osu *osu) : OsuScreenBackable(osu) {
 
     m_bIsUnranked = false;
 
 }
 
 
 
-void OsuRankingScreen::draw(Graphics *g) {
 
+void RankingScreen::draw(Graphics *g) {
 
     if(!m_bVisible) return;
 
 
 
     // draw background image
 
-    if(osu_draw_rankingscreen_background_image.getBool()) OsuSongBrowser::drawSelectedBeatmapBackgroundImage(g, m_osu);
 
+    if(osu_draw_rankingscreen_background_image.getBool()) SongBrowser::drawSelectedBeatmapBackgroundImage(g, m_osu);
 
 
 
     m_rankings->draw(g);
 
 
@@ -357,10 +357,10 @@ void OsuRankingScreen::draw(Graphics *g) {
 
     m_rankingTitle->draw(g);
 
     m_songInfo->draw(g);
 
 
 
-    OsuScreenBackable::draw(g);
 
+    ScreenBackable::draw(g);
 
 }
 
 
 
-void OsuRankingScreen::drawModImage(Graphics *g, OsuSkinImage *image, Vector2 &pos, Vector2 &max) {
 
+void RankingScreen::drawModImage(Graphics *g, SkinImage *image, Vector2 &pos, Vector2 &max) {
 
     g->setColor(0xffffffff);
 
     image->draw(g, Vector2(pos.x - image->getSize().x / 2.0f, pos.y));
 
 
@@ -369,9 +369,9 @@ void OsuRankingScreen::drawModImage(Graphics *g, OsuSkinImage *image, Vector2 &p
 
     if(pos.y + image->getSize().y / 2 > max.y) max.y = pos.y + image->getSize().y / 2;
 
 }
 
 
 
-void OsuRankingScreen::mouse_update(bool *propagate_clicks) {
 
+void RankingScreen::mouse_update(bool *propagate_clicks) {
 
     if(!m_bVisible) return;
 
-    OsuScreenBackable::mouse_update(propagate_clicks);
 
+    ScreenBackable::mouse_update(propagate_clicks);
 
 
 
     // HACKHACK:
 
     if(m_osu->getOptionsMenu()->isMouseInside()) engine->getMouse()->resetWheelDelta();
@@ -430,8 +430,8 @@ void OsuRankingScreen::mouse_update(bool *propagate_clicks) {
 
     m_rankingScrollDownInfoButton->setAlpha(m_fRankingScrollDownInfoButtonAlphaAnim);
 
 }
 
 
 
-CBaseUIContainer *OsuRankingScreen::setVisible(bool visible) {
 
-    OsuScreenBackable::setVisible(visible);
 
+CBaseUIContainer *RankingScreen::setVisible(bool visible) {
 
+    ScreenBackable::setVisible(visible);
 
 
 
     if(m_bVisible) {
 
         m_backButton->resetAnimation();
@@ -450,7 +450,7 @@ CBaseUIContainer *OsuRankingScreen::setVisible(bool visible) {
 
     return this;
 
 }
 
 
 
-void OsuRankingScreen::setScore(OsuScore *score) {
 
+void RankingScreen::setScore(LiveScore *score) {
 
     m_rankingPanel->setScore(score);
 
     setGrade(score->getGrade());
 
     setIndex(score->getIndex());
@@ -463,7 +463,7 @@ void OsuRankingScreen::setScore(OsuScore *score) {
 
     m_fStarsTomSpeed = score->getStarsTomSpeed();
 
     m_fPPv2 = score->getPPv2();
 
 
 
-    const UString modsString = OsuUISongBrowserScoreButton::getModsStringForDisplay(score->getModsLegacy());
 
+    const UString modsString = UISongBrowserScoreButton::getModsStringForDisplay(score->getModsLegacy());
 
     if(modsString.length() > 0) {
 
         m_sMods = "Mods: ";
 
         m_sMods.append(modsString);
@@ -499,7 +499,7 @@ void OsuRankingScreen::setScore(OsuScore *score) {
 
     m_bIsUnranked = score->isUnranked();
 
 }
 
 
 
-void OsuRankingScreen::setScore(Score score, UString dateTime) {
 
+void RankingScreen::setScore(FinishedScore score, UString dateTime) {
 
     m_bIsLegacyScore = score.isLegacyScore;
 
     m_bIsImportedLegacyScore = score.isImportedLegacyScore;
 
     m_bIsUnranked = false;
@@ -508,8 +508,8 @@ void OsuRankingScreen::setScore(Score score, UString dateTime) {
 
     m_songInfo->setPlayer(score.playerName);
 
 
 
     m_rankingPanel->setScore(score);
 
-    setGrade(OsuScore::calculateGrade(score.num300s, score.num100s, score.num50s, score.numMisses,
 
-                                      score.modsLegacy & ModFlags::Hidden, score.modsLegacy & ModFlags::Flashlight));
 
+    setGrade(LiveScore::calculateGrade(score.num300s, score.num100s, score.num50s, score.numMisses,
 
+                                       score.modsLegacy & ModFlags::Hidden, score.modsLegacy & ModFlags::Flashlight));
 
     setIndex(-1);
 
 
 
     m_fUnstableRate = score.unstableRate;
@@ -522,17 +522,17 @@ void OsuRankingScreen::setScore(Score score, UString dateTime) {
 
 
 
     m_fSpeedMultiplier = std::round(score.speedMultiplier * 100.0f) / 100.0f;
 
     m_fCS = std::round(score.CS * 100.0f) / 100.0f;
 
-    m_fAR = std::round(OsuGameRules::getRawApproachRateForSpeedMultiplier(OsuGameRules::getRawApproachTime(score.AR),
 
-                                                                          score.speedMultiplier) *
 
+    m_fAR = std::round(GameRules::getRawApproachRateForSpeedMultiplier(GameRules::getRawApproachTime(score.AR),
 
+                                                                       score.speedMultiplier) *
 
                        100.0f) /
 
             100.0f;
 
-    m_fOD = std::round(OsuGameRules::getRawOverallDifficultyForSpeedMultiplier(
 
-                           OsuGameRules::getRawHitWindow300(score.OD), score.speedMultiplier) *
 
+    m_fOD = std::round(GameRules::getRawOverallDifficultyForSpeedMultiplier(GameRules::getRawHitWindow300(score.OD),
 
+                                                                            score.speedMultiplier) *
 
                        100.0f) /
 
             100.0f;
 
     m_fHP = std::round(score.HP * 100.0f) / 100.0f;
 
 
 
-    const UString modsString = OsuUISongBrowserScoreButton::getModsStringForDisplay(score.modsLegacy);
 
+    const UString modsString = UISongBrowserScoreButton::getModsStringForDisplay(score.modsLegacy);
 
     if(modsString.length() > 0) {
 
         m_sMods = "Mods: ";
 
         m_sMods.append(modsString);
@@ -570,7 +570,7 @@ void OsuRankingScreen::setScore(Score score, UString dateTime) {
 
     }
 
 }
 
 
 
-void OsuRankingScreen::setBeatmapInfo(OsuBeatmap *beatmap, OsuDatabaseBeatmap *diff2) {
 
+void RankingScreen::setBeatmapInfo(Beatmap *beatmap, DatabaseBeatmap *diff2) {
 
     m_songInfo->setFromBeatmap(beatmap, diff2);
 
 
 
     UString local_name = convar->getConVarByName("name")->getString();
@@ -579,13 +579,13 @@ void OsuRankingScreen::setBeatmapInfo(OsuBeatmap *beatmap, OsuDatabaseBeatmap *d
 
     // round all here to 2 decimal places
 
     m_fSpeedMultiplier = std::round(m_osu->getSpeedMultiplier() * 100.0f) / 100.0f;
 
     m_fCS = std::round(beatmap->getCS() * 100.0f) / 100.0f;
 
-    m_fAR = std::round(OsuGameRules::getApproachRateForSpeedMultiplier(beatmap) * 100.0f) / 100.0f;
 
-    m_fOD = std::round(OsuGameRules::getOverallDifficultyForSpeedMultiplier(beatmap) * 100.0f) / 100.0f;
 
+    m_fAR = std::round(GameRules::getApproachRateForSpeedMultiplier(beatmap) * 100.0f) / 100.0f;
 
+    m_fOD = std::round(GameRules::getOverallDifficultyForSpeedMultiplier(beatmap) * 100.0f) / 100.0f;
 
     m_fHP = std::round(beatmap->getHP() * 100.0f) / 100.0f;
 
 }
 
 
 
-void OsuRankingScreen::updateLayout() {
 
-    OsuScreenBackable::updateLayout();
 
+void RankingScreen::updateLayout() {
 
+    ScreenBackable::updateLayout();
 
 
 
     const float uiScale = Osu::ui_scale->getFloat();
 
 
@@ -636,7 +636,7 @@ void OsuRankingScreen::updateLayout() {
 
     m_rankings->setScrollSizeToContent(0);
 
 }
 
 
 
-void OsuRankingScreen::onBack() {
 
+void RankingScreen::onBack() {
 
     engine->getSound()->play(m_osu->getSkin()->getMenuClick());
 
 
 
     // stop applause sound
@@ -649,38 +649,38 @@ void OsuRankingScreen::onBack() {
 
     }
 
 }
 
 
 
-void OsuRankingScreen::onScrollDownClicked() { m_rankings->scrollToBottom(); }
 
+void RankingScreen::onScrollDownClicked() { m_rankings->scrollToBottom(); }
 
 
 
-void OsuRankingScreen::setGrade(Score::Grade grade) {
 
+void RankingScreen::setGrade(FinishedScore::Grade grade) {
 
     m_grade = grade;
 
 
 
     Vector2 hardcodedOsuRankingGradeImageSize = Vector2(369, 422);
 
     switch(grade) {
 
-        case Score::Grade::XH:
 
+        case FinishedScore::Grade::XH:
 
             hardcodedOsuRankingGradeImageSize *= (m_osu->getSkin()->isRankingXH2x() ? 2.0f : 1.0f);
 
             m_rankingGrade->setImage(m_osu->getSkin()->getRankingXH());
 
             break;
 
-        case Score::Grade::SH:
 
+        case FinishedScore::Grade::SH:
 
             hardcodedOsuRankingGradeImageSize *= (m_osu->getSkin()->isRankingSH2x() ? 2.0f : 1.0f);
 
             m_rankingGrade->setImage(m_osu->getSkin()->getRankingSH());
 
             break;
 
-        case Score::Grade::X:
 
+        case FinishedScore::Grade::X:
 
             hardcodedOsuRankingGradeImageSize *= (m_osu->getSkin()->isRankingX2x() ? 2.0f : 1.0f);
 
             m_rankingGrade->setImage(m_osu->getSkin()->getRankingX());
 
             break;
 
-        case Score::Grade::S:
 
+        case FinishedScore::Grade::S:
 
             hardcodedOsuRankingGradeImageSize *= (m_osu->getSkin()->isRankingS2x() ? 2.0f : 1.0f);
 
             m_rankingGrade->setImage(m_osu->getSkin()->getRankingS());
 
             break;
 
-        case Score::Grade::A:
 
+        case FinishedScore::Grade::A:
 
             hardcodedOsuRankingGradeImageSize *= (m_osu->getSkin()->isRankingA2x() ? 2.0f : 1.0f);
 
             m_rankingGrade->setImage(m_osu->getSkin()->getRankingA());
 
             break;
 
-        case Score::Grade::B:
 
+        case FinishedScore::Grade::B:
 
             hardcodedOsuRankingGradeImageSize *= (m_osu->getSkin()->isRankingB2x() ? 2.0f : 1.0f);
 
             m_rankingGrade->setImage(m_osu->getSkin()->getRankingB());
 
             break;
 
-        case Score::Grade::C:
 
+        case FinishedScore::Grade::C:
 
             hardcodedOsuRankingGradeImageSize *= (m_osu->getSkin()->isRankingC2x() ? 2.0f : 1.0f);
 
             m_rankingGrade->setImage(m_osu->getSkin()->getRankingC());
 
             break;
@@ -704,7 +704,7 @@ void OsuRankingScreen::setGrade(Score::Grade grade) {
 
                                   m_rankingGrade->getImage()->getHeight() * m_rankingGrade->getScale().x / 2.0f);
 
 }
 
 
 
-void OsuRankingScreen::setIndex(int index) {
 
+void RankingScreen::setIndex(int index) {
 
     if(!m_osu_scores_enabled->getBool()) index = -1;
 
 
 
     if(index > -1) {
@@ -719,9 +719,9 @@ void OsuRankingScreen::setIndex(int index) {
 
     }
 
 }
 
 
 
-UString OsuRankingScreen::getPPString() { return UString::format("%ipp", (int)(std::round(m_fPPv2))); }
 
+UString RankingScreen::getPPString() { return UString::format("%ipp", (int)(std::round(m_fPPv2))); }
 
 
 
-Vector2 OsuRankingScreen::getPPPosRaw() {
 
+Vector2 RankingScreen::getPPPosRaw() {
 
     const UString ppString = getPPString();
 
     float ppStringWidth = m_osu->getTitleFont()->getStringWidth(ppString);
 
     return Vector2(m_rankingGrade->getPos().x, 0) +
@@ -730,7 +730,7 @@ Vector2 OsuRankingScreen::getPPPosRaw() {
 
                m_rankings->getScrollPosY() + m_osu->getUIScale(m_osu, 400) + m_osu->getTitleFont()->getHeight() / 2);
 
 }
 
 
 
-Vector2 OsuRankingScreen::getPPPosCenterRaw() {
 
+Vector2 RankingScreen::getPPPosCenterRaw() {
 
     return Vector2(m_rankingGrade->getPos().x, 0) +
 
            Vector2(m_rankingGrade->getSize().x / 2, m_rankings->getScrollPosY() + m_osu->getUIScale(m_osu, 400) +
 
                                                         m_osu->getTitleFont()->getHeight() / 2);
--- a/src/App/Osu/OsuRankingScreen.h
+++ b/src/App/Osu/OsuRankingScreen.h
@@ -8,50 +8,50 @@
 
 #ifndef OSU_OSURANKINGSCREEN_H
 
 #define OSU_OSURANKINGSCREEN_H
 
 
 
-#include "OsuDatabase.h"
 
-#include "OsuScore.h"
 
-#include "OsuScreenBackable.h"
 
+#include "Database.h"
 
+#include "ScreenBackable.h"
 
+#include "score.h"
 
 
 
 class CBaseUIContainer;
 
 class CBaseUIScrollView;
 
 class CBaseUIImage;
 
 class CBaseUILabel;
 
 
 
-class OsuBeatmap;
 
-class OsuDatabaseBeatmap;
 
-class OsuSkinImage;
 
+class Beatmap;
 
+class DatabaseBeatmap;
 
+class SkinImage;
 
 
 
-class OsuUIRankingScreenInfoLabel;
 
-class OsuUIRankingScreenRankingPanel;
 
+class UIRankingScreenInfoLabel;
 
+class UIRankingScreenRankingPanel;
 
 
 
-class OsuRankingScreenIndexLabel;
 
-class OsuRankingScreenBottomElement;
 
-class OsuRankingScreenScrollDownInfoButton;
 
+class RankingScreenIndexLabel;
 
+class RankingScreenBottomElement;
 
+class RankingScreenScrollDownInfoButton;
 
 
 
 class ConVar;
 
 
 
-class OsuRankingScreen : public OsuScreenBackable {
 
+class RankingScreen : public ScreenBackable {
 
    public:
 
-    OsuRankingScreen(Osu *osu);
 
+    RankingScreen(Osu *osu);
 
 
 
     virtual void draw(Graphics *g);
 
     virtual void mouse_update(bool *propagate_clicks);
 
 
 
     virtual CBaseUIContainer *setVisible(bool visible);
 
 
 
-    void setScore(OsuScore *score);
 
-    void setScore(Score score, UString dateTime);
 
-    void setBeatmapInfo(OsuBeatmap *beatmap, OsuDatabaseBeatmap *diff2);
 
+    void setScore(LiveScore *score);
 
+    void setScore(FinishedScore score, UString dateTime);
 
+    void setBeatmapInfo(Beatmap *beatmap, DatabaseBeatmap *diff2);
 
 
 
    private:
 
     virtual void updateLayout();
 
     virtual void onBack();
 
 
 
-    void drawModImage(Graphics *g, OsuSkinImage *image, Vector2 &pos, Vector2 &max);
 
+    void drawModImage(Graphics *g, SkinImage *image, Vector2 &pos, Vector2 &max);
 
 
 
     void onScrollDownClicked();
 
 
 
-    void setGrade(Score::Grade grade);
 
+    void setGrade(FinishedScore::Grade grade);
 
     void setIndex(int index);
 
 
 
     UString getPPString();
@@ -62,17 +62,17 @@ class OsuRankingScreen : public OsuScreenBackable {
 
 
 
     CBaseUIScrollView *m_rankings;
 
 
 
-    OsuUIRankingScreenInfoLabel *m_songInfo;
 
-    OsuUIRankingScreenRankingPanel *m_rankingPanel;
 
+    UIRankingScreenInfoLabel *m_songInfo;
 
+    UIRankingScreenRankingPanel *m_rankingPanel;
 
     CBaseUIImage *m_rankingTitle;
 
     CBaseUIImage *m_rankingGrade;
 
-    OsuRankingScreenIndexLabel *m_rankingIndex;
 
-    OsuRankingScreenBottomElement *m_rankingBottom;
 
+    RankingScreenIndexLabel *m_rankingIndex;
 
+    RankingScreenBottomElement *m_rankingBottom;
 
 
 
-    OsuRankingScreenScrollDownInfoButton *m_rankingScrollDownInfoButton;
 
+    RankingScreenScrollDownInfoButton *m_rankingScrollDownInfoButton;
 
     float m_fRankingScrollDownInfoButtonAlphaAnim;
 
 
 
-    Score::Grade m_grade;
 
+    FinishedScore::Grade m_grade;
 
     float m_fUnstableRate;
 
     float m_fHitErrorAvgMin;
 
     float m_fHitErrorAvgMax;
--- a/src/App/Osu/OsuReplay.cpp
+++ b/src/App/Osu/OsuReplay.cpp
@@ -1,20 +1,20 @@
 
-#include "OsuReplay.h"
 
+#include "Replay.h"
 
 
 
 #include <lzma.h>
 
 
 
 #include "Bancho.h"
 
 #include "BanchoProtocol.h"
 
+#include "Beatmap.h"
 
+#include "Database.h"
 
 #include "Engine.h"
 
+#include "NotificationOverlay.h"
 
 #include "Osu.h"
 
-#include "OsuBeatmap.h"
 
-#include "OsuDatabase.h"
 
-#include "OsuNotificationOverlay.h"
 
-#include "OsuSongBrowser.h"
 
-#include "Score.h"
 
+#include "SongBrowser.h"
 
+#include "score.h"
 
 
 
-OsuReplay::BEATMAP_VALUES OsuReplay::getBeatmapValuesForModsLegacy(int modsLegacy, float legacyAR, float legacyCS,
 
-                                                                   float legacyOD, float legacyHP) {
 
-    OsuReplay::BEATMAP_VALUES v;
 
+Replay::BEATMAP_VALUES Replay::getBeatmapValuesForModsLegacy(int modsLegacy, float legacyAR, float legacyCS,
 
+                                                             float legacyOD, float legacyHP) {
 
+    Replay::BEATMAP_VALUES v;
 
 
 
     // HACKHACK: code duplication, see Osu::getRawSpeedMultiplier()
 
     v.speedMultiplier = 1.0f;
@@ -46,8 +46,8 @@ OsuReplay::BEATMAP_VALUES OsuReplay::getBeatmapValuesForModsLegacy(int modsLegac
 
     return v;
 
 }
 
 
 
-std::vector<OsuReplay::Frame> OsuReplay::get_frames(uint8_t* replay_data, int32_t replay_size) {
 
-    std::vector<OsuReplay::Frame> replay_frames;
 
+std::vector<Replay::Frame> Replay::get_frames(u8* replay_data, i32 replay_size) {
 
+    std::vector<Replay::Frame> replay_frames;
 
     if(replay_size <= 0) return replay_frames;
 
 
 
     lzma_stream strm = LZMA_STREAM_INIT;
@@ -60,7 +60,7 @@ std::vector<OsuReplay::Frame> OsuReplay::get_frames(uint8_t* replay_data, int32_
 
     long cur_music_pos = 0;
 
     std::stringstream ss;
 
     std::string frame_str;
 
-    uint8_t outbuf[BUFSIZ];
 
+    u8 outbuf[BUFSIZ];
 
     strm.next_in = replay_data;
 
     strm.avail_in = replay_size;
 
     do {
@@ -77,7 +77,7 @@ std::vector<OsuReplay::Frame> OsuReplay::get_frames(uint8_t* replay_data, int32_
 
     } while(strm.avail_out == 0);
 
 
 
     while(std::getline(ss, frame_str, ',')) {
 
-        OsuReplay::Frame frame;
 
+        Replay::Frame frame;
 
         sscanf(frame_str.c_str(), "%lld|%f|%f|%hhu", &frame.milliseconds_since_last_frame, &frame.x, &frame.y,
 
                &frame.key_flags);
 
 
@@ -93,8 +93,7 @@ end:
 
     return replay_frames;
 
 }
 
 
 
-void OsuReplay::compress_frames(const std::vector<OsuReplay::Frame>& frames, uint8_t** compressed,
 
-                                size_t* s_compressed) {
 
+void Replay::compress_frames(const std::vector<Replay::Frame>& frames, u8** compressed, size_t* s_compressed) {
 
     lzma_stream stream = LZMA_STREAM_INIT;
 
     lzma_options_lzma options;
 
     lzma_lzma_preset(&options, LZMA_PRESET_DEFAULT);
@@ -117,17 +116,17 @@ void OsuReplay::compress_frames(const std::vector<OsuReplay::Frame>& frames, uin
 
     replay_string.append("-12345|0.0000|0.0000|0,");
 
 
 
     *s_compressed = replay_string.length();
 
-    *compressed = (uint8_t*)malloc(*s_compressed);
 
+    *compressed = (u8*)malloc(*s_compressed);
 
 
 
     stream.avail_in = replay_string.length();
 
-    stream.next_in = (const uint8_t*)replay_string.c_str();
 
+    stream.next_in = (const u8*)replay_string.c_str();
 
     stream.avail_out = *s_compressed;
 
     stream.next_out = *compressed;
 
     do {
 
         ret = lzma_code(&stream, LZMA_FINISH);
 
         if(ret == LZMA_OK) {
 
             *s_compressed *= 2;
 
-            *compressed = (uint8_t*)realloc(*compressed, *s_compressed);
 
+            *compressed = (u8*)realloc(*compressed, *s_compressed);
 
             stream.avail_out = *s_compressed - stream.total_out;
 
             stream.next_out = *compressed + stream.total_out;
 
         } else if(ret != LZMA_STREAM_END) {
@@ -143,47 +142,47 @@ void OsuReplay::compress_frames(const std::vector<OsuReplay::Frame>& frames, uin
 
     lzma_end(&stream);
 
 }
 
 
 
-OsuReplay::Info OsuReplay::from_bytes(uint8_t* data, int s_data) {
 
-    OsuReplay::Info info;
 
+Replay::Info Replay::from_bytes(u8* data, int s_data) {
 
+    Replay::Info info;
 
 
 
     Packet replay;
 
     replay.memory = data;
 
     replay.size = s_data;
 
 
 
-    info.gamemode = read_byte(&replay);
 
+    info.gamemode = read<u8>(&replay);
 
     if(info.gamemode != 0) {
 
         debugLog("Replay has unexpected gamemode %d!", info.gamemode);
 
         return info;
 
     }
 
 
 
-    info.osu_version = read_int32(&replay);
 
+    info.osu_version = read<u32>(&replay);
 
     info.diff2_md5 = read_string(&replay);
 
     info.username = read_string(&replay);
 
     info.replay_md5 = read_string(&replay);
 
-    info.num300s = read_short(&replay);
 
-    info.num100s = read_short(&replay);
 
-    info.num50s = read_short(&replay);
 
-    info.numGekis = read_short(&replay);
 
-    info.numKatus = read_short(&replay);
 
-    info.numMisses = read_short(&replay);
 
-    info.score = read_int32(&replay);
 
-    info.comboMax = read_short(&replay);
 
-    info.perfect = read_byte(&replay);
 
-    info.mod_flags = read_int32(&replay);
 
+    info.num300s = read<u16>(&replay);
 
+    info.num100s = read<u16>(&replay);
 
+    info.num50s = read<u16>(&replay);
 
+    info.numGekis = read<u16>(&replay);
 
+    info.numKatus = read<u16>(&replay);
 
+    info.numMisses = read<u16>(&replay);
 
+    info.score = read<u32>(&replay);
 
+    info.comboMax = read<u16>(&replay);
 
+    info.perfect = read<u8>(&replay);
 
+    info.mod_flags = read<u32>(&replay);
 
     info.life_bar_graph = read_string(&replay);
 
-    info.timestamp = read_int64(&replay) / 10;
 
+    info.timestamp = read<u64>(&replay) / 10;
 
 
 
-    int32_t replay_size = read_int32(&replay);
 
+    i32 replay_size = read<u32>(&replay);
 
     if(replay_size <= 0) return info;
 
-    auto replay_data = new uint8_t[replay_size];
 
+    auto replay_data = new u8[replay_size];
 
     read_bytes(&replay, replay_data, replay_size);
 
-    info.frames = OsuReplay::get_frames(replay_data, replay_size);
 
+    info.frames = Replay::get_frames(replay_data, replay_size);
 
     delete[] replay_data;
 
 
 
     return info;
 
 }
 
 
 
-bool OsuReplay::load_from_disk(Score* score) {
 
+bool Replay::load_from_disk(FinishedScore* score) {
 
     if(score->legacyReplayTimestamp > 0) {
 
         auto osu_folder = convar->getConVarByName("osu_folder")->getString();
 
         auto path = UString::format("%s/Data/r/%s-%llu.osr", osu_folder.toUtf8(), score->md5hash.hash,
@@ -196,10 +195,10 @@ bool OsuReplay::load_from_disk(Score* score) {
 
         size_t s_full_replay = ftell(replay_file);
 
         rewind(replay_file);
 
 
 
-        uint8_t* full_replay = new uint8_t[s_full_replay];
 
+        u8* full_replay = new u8[s_full_replay];
 
         fread(full_replay, s_full_replay, 1, replay_file);
 
         fclose(replay_file);
 
-        auto info = OsuReplay::from_bytes(full_replay, s_full_replay);
 
+        auto info = Replay::from_bytes(full_replay, s_full_replay);
 
         score->replay = info.frames;
 
         delete[] full_replay;
 
     } else {
@@ -213,10 +212,10 @@ bool OsuReplay::load_from_disk(Score* score) {
 
         size_t s_compressed_replay = ftell(replay_file);
 
         rewind(replay_file);
 
 
 
-        uint8_t* compressed_replay = new uint8_t[s_compressed_replay];
 
+        u8* compressed_replay = new u8[s_compressed_replay];
 
         fread(compressed_replay, s_compressed_replay, 1, replay_file);
 
         fclose(replay_file);
 
-        score->replay = OsuReplay::get_frames(compressed_replay, s_compressed_replay);
 
+        score->replay = Replay::get_frames(compressed_replay, s_compressed_replay);
 
         delete[] compressed_replay;
 
     }
 
 
@@ -233,7 +232,7 @@ bool OsuReplay::load_from_disk(Score* score) {
 
     return true;
 
 }
 
 
 
-void OsuReplay::load_and_watch(Score score) {
 
+void Replay::load_and_watch(FinishedScore score) {
 
     // Check if replay is loaded
 
     if(score.replay.empty()) {
 
         if(!load_from_disk(&score)) {
@@ -243,8 +242,8 @@ void OsuReplay::load_and_watch(Score score) {
 
             }
 
 
 
             // Need to allocate with calloc since APIRequests free() the .extra
 
-            void* mem = calloc(1, sizeof(Score));
 
-            Score* score_cpy = new(mem) Score;
 
+            void* mem = calloc(1, sizeof(FinishedScore));
 
+            FinishedScore* score_cpy = new(mem) FinishedScore;
 
             *score_cpy = score;
 
 
 
             APIRequest request;
@@ -252,7 +251,7 @@ void OsuReplay::load_and_watch(Score score) {
 
             request.path = UString::format("/web/osu-getreplay.php?u=%s&h=%s&m=0&c=%d", bancho.username.toUtf8(),
 
                                            bancho.pw_md5.toUtf8(), score.online_score_id);
 
             request.mime = NULL;
 
-            request.extra = (uint8_t*)score_cpy;
 
+            request.extra = (u8*)score_cpy;
 
             send_api_request(request);
 
 
 
             bancho.osu->m_notificationOverlay->addNotification("Downloading replay...");
--- a/src/App/Osu/OsuReplay.h
+++ b/src/App/Osu/OsuReplay.h
@@ -2,9 +2,9 @@
 
 #include "ModFlags.h"
 
 #include "cbase.h"
 
 
 
-struct Score;
 
+struct FinishedScore;
 
 
 
-namespace OsuReplay {
 
+namespace Replay {
 
 struct Frame {
 
     long long int cur_music_pos;
 
     long long int milliseconds_since_last_frame;
@@ -12,7 +12,7 @@ struct Frame {
 
     float x;  // 0 - 512
 
     float y;  // 0 - 384
 
 
 
-    uint8_t key_flags;
 
+    u8 key_flags;
 
 };
 
 
 
 enum KeyFlags {
@@ -36,8 +36,8 @@ struct BEATMAP_VALUES {
 
 };
 
 
 
 struct Info {
 
-    uint8_t gamemode;
 
-    uint32_t osu_version;
 
+    u8 gamemode;
 
+    u32 osu_version;
 
     UString diff2_md5;
 
     UString username;
 
     UString replay_md5;
@@ -47,22 +47,22 @@ struct Info {
 
     int numGekis;
 
     int numKatus;
 
     int numMisses;
 
-    int32_t score;
 
+    i32 score;
 
     int comboMax;
 
     bool perfect;
 
-    int32_t mod_flags;
 
+    i32 mod_flags;
 
     UString life_bar_graph;
 
-    int64_t timestamp;
 
+    i64 timestamp;
 
     std::vector<Frame> frames;
 
 };
 
 
 
 BEATMAP_VALUES getBeatmapValuesForModsLegacy(int modsLegacy, float legacyAR, float legacyCS, float legacyOD,
 
                                              float legacyHP);
 
 
 
-Info from_bytes(uint8_t* data, int s_data);
 
-std::vector<Frame> get_frames(uint8_t* replay_data, int32_t replay_size);
 
-void compress_frames(const std::vector<Frame>& frames, uint8_t** compressed, size_t* s_compressed);
 
-bool load_from_disk(Score* score);
 
-void load_and_watch(Score score);
 
+Info from_bytes(u8* data, int s_data);
 
+std::vector<Frame> get_frames(u8* replay_data, i32 replay_size);
 
+void compress_frames(const std::vector<Frame>& frames, u8** compressed, size_t* s_compressed);
 
+bool load_from_disk(FinishedScore* score);
 
+void load_and_watch(FinishedScore score);
 
 
 
-}  // namespace OsuReplay
 
+}  // namespace Replay
--- a/src/App/Osu/OsuRichPresence.cpp
+++ b/src/App/Osu/OsuRichPresence.cpp
@@ -5,44 +5,44 @@
 
 // $NoKeywords: $rpt
 
 //===============================================================================//
 
 
 
-#include "OsuRichPresence.h"
 
+#include "RichPresence.h"
 
 
 
 #include "Bancho.h"
 
 #include "BanchoNetworking.h"
 
+#include "Beatmap.h"
 
 #include "ConVar.h"
 
+#include "Database.h"
 
+#include "DatabaseBeatmap.h"
 
 #include "DiscordInterface.h"
 
 #include "Engine.h"
 
 #include "Environment.h"
 
+#include "ModSelector.h"
 
 #include "Osu.h"
 
-#include "OsuBeatmap.h"
 
-#include "OsuDatabase.h"
 
-#include "OsuDatabaseBeatmap.h"
 
-#include "OsuModSelector.h"
 
-#include "OsuRoom.h"
 
-#include "OsuScore.h"
 
-#include "OsuSongBrowser.h"
 
-
 
-ConVar osu_rich_presence("osu_rich_presence", true, FCVAR_NONE, OsuRichPresence::onRichPresenceChange);
 
+#include "RoomScreen.h"
 
+#include "SongBrowser.h"
 
+#include "score.h"
 
+
 
+ConVar osu_rich_presence("osu_rich_presence", true, FCVAR_NONE, RichPresence::onRichPresenceChange);
 
 ConVar osu_rich_presence_dynamic_windowtitle(
 
     "osu_rich_presence_dynamic_windowtitle", true, FCVAR_NONE,
 
     "should the window title show the currently playing beatmap Artist - Title and [Difficulty] name");
 
 ConVar osu_rich_presence_show_recentplaystats("osu_rich_presence_show_recentplaystats", true, FCVAR_NONE);
 
 ConVar osu_rich_presence_discord_show_totalpp("osu_rich_presence_discord_show_totalpp", true, FCVAR_NONE);
 
 
 
-ConVar *OsuRichPresence::m_name_ref = NULL;
 
+ConVar *RichPresence::m_name_ref = NULL;
 
 
 
-const UString OsuRichPresence::KEY_STEAM_STATUS = "status";
 
-const UString OsuRichPresence::KEY_DISCORD_STATUS = "state";
 
-const UString OsuRichPresence::KEY_DISCORD_DETAILS = "details";
 
+const UString RichPresence::KEY_STEAM_STATUS = "status";
 
+const UString RichPresence::KEY_DISCORD_STATUS = "state";
 
+const UString RichPresence::KEY_DISCORD_DETAILS = "details";
 
 
 
 UString last_status = "[neosu]\nWaking up";
 
 Action last_action = IDLE;
 
 
 
-void OsuRichPresence::setBanchoStatus(Osu *osu, const char *info_text, Action action) {
 
+void RichPresence::setBanchoStatus(Osu *osu, const char *info_text, Action action) {
 
     if(osu == NULL) return;
 
 
 
     MD5Hash map_md5("");
 
-    uint32_t map_id = 0;
 
+    u32 map_id = 0;
 
 
 
     auto selected_beatmap = osu->getSelectedBeatmap();
 
     if(selected_beatmap != nullptr) {
@@ -61,18 +61,18 @@ void OsuRichPresence::setBanchoStatus(Osu *osu, const char *info_text, Action ac
 
 
 
     Packet packet;
 
     packet.id = CHANGE_ACTION;
 
-    write_byte(&packet, action);
 
+    write_u8(&packet, action);
 
     write_string(&packet, fancy_text);
 
     write_string(&packet, map_md5.hash);
 
-    write_int32(&packet, osu->m_modSelector->getModFlags());
 
-    write_byte(&packet, 0);  // osu!std
 
-    write_int32(&packet, map_id);
 
+    write_u32(&packet, osu->m_modSelector->getModFlags());
 
+    write_u8(&packet, 0);  // osu!std
 
+    write_u32(&packet, map_id);
 
     send_packet(packet);
 
 }
 
 
 
-void OsuRichPresence::updateBanchoMods() {
 
+void RichPresence::updateBanchoMods() {
 
     MD5Hash map_md5("");
 
-    uint32_t map_id = 0;
 
+    u32 map_id = 0;
 
 
 
     auto selected_beatmap = bancho.osu->getSelectedBeatmap();
 
     if(selected_beatmap != nullptr) {
@@ -85,12 +85,12 @@ void OsuRichPresence::updateBanchoMods() {
 
 
 
     Packet packet;
 
     packet.id = CHANGE_ACTION;
 
-    write_byte(&packet, last_action);
 
+    write_u8(&packet, last_action);
 
     write_string(&packet, last_status.toUtf8());
 
     write_string(&packet, map_md5.hash);
 
-    write_int32(&packet, bancho.osu->m_modSelector->getModFlags());
 
-    write_byte(&packet, 0);  // osu!std
 
-    write_int32(&packet, map_id);
 
+    write_u32(&packet, bancho.osu->m_modSelector->getModFlags());
 
+    write_u8(&packet, 0);  // osu!std
 
+    write_u32(&packet, map_id);
 
     send_packet(packet);
 
 
 
     // Servers like akatsuki send different leaderboards based on what mods
@@ -99,12 +99,12 @@ void OsuRichPresence::updateBanchoMods() {
 
     bancho.osu->m_songBrowser2->rebuildScoreButtons();
 
 }
 
 
 
-void OsuRichPresence::onMainMenu(Osu *osu) {
 
+void RichPresence::onMainMenu(Osu *osu) {
 
     setStatus(osu, "Main Menu");
 
     setBanchoStatus(osu, "Main Menu", AFK);
 
 }
 
 
 
-void OsuRichPresence::onSongBrowser(Osu *osu) {
 
+void RichPresence::onSongBrowser(Osu *osu) {
 
     setStatus(osu, "Song Selection");
 
 
 
     if(osu->m_room->isVisible()) {
@@ -117,7 +117,7 @@ void OsuRichPresence::onSongBrowser(Osu *osu) {
 
     if(osu_rich_presence_dynamic_windowtitle.getBool()) env->setWindowTitle("neosu");
 
 }
 
 
 
-void OsuRichPresence::onPlayStart(Osu *osu) {
 
+void RichPresence::onPlayStart(Osu *osu) {
 
     UString playingInfo /*= "Playing "*/;
 
     playingInfo.append(osu->getSelectedBeatmap()->getSelectedDifficulty2()->getArtist().c_str());
 
     playingInfo.append(" - ");
@@ -137,7 +137,7 @@ void OsuRichPresence::onPlayStart(Osu *osu) {
 
     }
 
 }
 
 
 
-void OsuRichPresence::onPlayEnd(Osu *osu, bool quit) {
 
+void RichPresence::onPlayEnd(Osu *osu, bool quit) {
 
     if(!quit && osu_rich_presence_show_recentplaystats.getBool()) {
 
         // e.g.: 230pp 900x 95.50% HDHRDT 6*
 
 
@@ -165,7 +165,7 @@ void OsuRichPresence::onPlayEnd(Osu *osu, bool quit) {
 
     }
 
 }
 
 
 
-void OsuRichPresence::setStatus(Osu *osu, UString status, bool force) {
 
+void RichPresence::setStatus(Osu *osu, UString status, bool force) {
 
     if(!osu_rich_presence.getBool() && !force) return;
 
 
 
     // discord
@@ -195,13 +195,13 @@ void OsuRichPresence::setStatus(Osu *osu, UString status, bool force) {
 
         discord->setRichPresence(KEY_DISCORD_STATUS, "");
 
 }
 
 
 
-void OsuRichPresence::onRichPresenceChange(UString oldValue, UString newValue) {
 
+void RichPresence::onRichPresenceChange(UString oldValue, UString newValue) {
 
     if(!osu_rich_presence.getBool())
 
         onRichPresenceDisable();
 
     else
 
         onRichPresenceEnable();
 
 }
 
 
 
-void OsuRichPresence::onRichPresenceEnable() { setStatus(NULL, "..."); }
 
+void RichPresence::onRichPresenceEnable() { setStatus(NULL, "..."); }
 
 
 
-void OsuRichPresence::onRichPresenceDisable() { setStatus(NULL, "", true); }
 
+void RichPresence::onRichPresenceDisable() { setStatus(NULL, "", true); }
--- a/src/App/Osu/OsuRichPresence.h
+++ b/src/App/Osu/OsuRichPresence.h
@@ -15,7 +15,7 @@ class ConVar;
 
 
 
 class Osu;
 
 
 
-class OsuRichPresence {
 
+class RichPresence {
 
    public:
 
     static void onMainMenu(Osu *osu);
 
     static void onSongBrowser(Osu *osu);
--- a/src/App/Osu/RoomScreen.cpp
+++ b/src/App/Osu/RoomScreen.cpp
@@ -1,45 +1,45 @@
 
-#include "OsuRoom.h"
 
+#include "RoomScreen.h"
 
 
 
 #include <sstream>
 
 
 
+#include "BackgroundImageHandler.h"
 
 #include "Bancho.h"
 
 #include "BanchoNetworking.h"
 
 #include "BanchoUsers.h"
 
+#include "Beatmap.h"
 
 #include "CBaseUIButton.h"
 
 #include "CBaseUIContainer.h"
 
 #include "CBaseUILabel.h"
 
 #include "CBaseUITextbox.h"
 
+#include "Chat.h"
 
+#include "Database.h"
 
 #include "Downloader.h"
 
 #include "Engine.h"
 
+#include "HUD.h"
 
 #include "Keyboard.h"
 
+#include "Lobby.h"
 
+#include "MainMenu.h"
 
+#include "ModSelector.h"
 
 #include "Mouse.h"
 
 #include "Osu.h"
 
-#include "OsuBackgroundImageHandler.h"
 
-#include "OsuBeatmap.h"
 
-#include "OsuChat.h"
 
-#include "OsuDatabase.h"
 
-#include "OsuHUD.h"
 
-#include "OsuLobby.h"
 
-#include "OsuMainMenu.h"
 
-#include "OsuModSelector.h"
 
-#include "OsuPromptScreen.h"
 
-#include "OsuRankingScreen.h"
 
-#include "OsuReplay.h"
 
-#include "OsuRichPresence.h"
 
-#include "OsuSkin.h"
 
-#include "OsuSkinImage.h"
 
-#include "OsuSongBrowser.h"
 
-#include "OsuUIAvatar.h"
 
-#include "OsuUIButton.h"
 
-#include "OsuUICheckbox.h"
 
-#include "OsuUIContextMenu.h"
 
-#include "OsuUISongBrowserSongButton.h"
 
-#include "OsuUIUserContextMenu.h"
 
+#include "PromptScreen.h"
 
+#include "RankingScreen.h"
 
+#include "Replay.h"
 
 #include "ResourceManager.h"
 
+#include "RichPresence.h"
 
+#include "Skin.h"
 
+#include "SkinImage.h"
 
+#include "SongBrowser.h"
 
 #include "SoundEngine.h"
 
+#include "UIAvatar.h"
 
+#include "UIButton.h"
 
+#include "UICheckbox.h"
 
+#include "UIContextMenu.h"
 
+#include "UISongBrowserSongButton.h"
 
+#include "UIUserContextMenu.h"
 
 
 
-void OsuUIModList::draw(Graphics *g) {
 
-    std::vector<OsuSkinImage *> mods;
 
+void UIModList::draw(Graphics *g) {
 
+    std::vector<SkinImage *> mods;
 
 
 
     if(*m_flags & ModFlags::Nightcore)
 
         mods.push_back(bancho.osu->getSkin()->getSelectionModNightCore());
@@ -86,7 +86,7 @@ void OsuUIModList::draw(Graphics *g) {
 
     }
 
 }
 
 
 
-bool OsuUIModList::isVisible() { return *m_flags != 0; }
 
+bool UIModList::isVisible() { return *m_flags != 0; }
 
 
 
 #define INIT_LABEL(label_name, default_text, is_big)                      \
 
     do {                                                                  \
@@ -110,12 +110,12 @@ bool OsuUIModList::isVisible() { return *m_flags != 0; }
 
         m_settings->getContainer()->addBaseUIElement(button);           \
 
     } while(0)
 
 
 
-OsuRoom::OsuRoom(Osu *osu) : OsuScreen(osu) {
 
+RoomScreen::RoomScreen(Osu *osu) : OsuScreen(osu) {
 
     font = engine->getResourceManager()->getFont("FONT_DEFAULT");
 
     lfont = osu->getSubTitleFont();
 
 
 
-    m_pauseButton = new OsuMainMenuPauseButton(0, 0, 0, 0, "pause_btn", "");
 
-    m_pauseButton->setClickCallback(fastdelegate::MakeDelegate(osu->m_mainMenu, &OsuMainMenu::onPausePressed));
 
+    m_pauseButton = new MainMenuPauseButton(0, 0, 0, 0, "pause_btn", "");
 
+    m_pauseButton->setClickCallback(fastdelegate::MakeDelegate(osu->m_mainMenu, &MainMenu::onPausePressed));
 
     addBaseUIElement(m_pauseButton);
 
 
 
     m_settings = new CBaseUIScrollView(0, 0, 0, 0, "room_settings");
@@ -126,30 +126,29 @@ OsuRoom::OsuRoom(Osu *osu) : OsuScreen(osu) {
 
     addBaseUIElement(m_settings);
 
 
 
     INIT_LABEL(m_room_name, "Multiplayer room", true);
 
-    INIT_LABEL(m_host, "Host: None", false);  // XXX: make it an OsuUIUserLabel
 
+    INIT_LABEL(m_host, "Host: None", false);  // XXX: make it an UIUserLabel
 
 
 
     INIT_LABEL(m_room_name_iptl, "Room name", false);
 
     m_room_name_ipt = new CBaseUITextbox(0, 0, m_settings->getSize().x, 40, "");
 
     m_room_name_ipt->setText("Multiplayer room");
 
 
 
-    m_change_password_btn = new OsuUIButton(osu, 0, 0, 190, 40, "change_password_btn", "Change password");
 
+    m_change_password_btn = new UIButton(osu, 0, 0, 190, 40, "change_password_btn", "Change password");
 
     m_change_password_btn->setColor(0xff0e94b5);
 
     m_change_password_btn->setUseDefaultSkin();
 
-    m_change_password_btn->setClickCallback(fastdelegate::MakeDelegate(this, &OsuRoom::onChangePasswordClicked));
 
+    m_change_password_btn->setClickCallback(fastdelegate::MakeDelegate(this, &RoomScreen::onChangePasswordClicked));
 
 
 
     INIT_LABEL(m_win_condition, "Win condition: Score", false);
 
-    m_change_win_condition_btn =
 
-        new OsuUIButton(osu, 0, 0, 240, 40, "change_win_condition_btn", "Win condition: Score");
 
+    m_change_win_condition_btn = new UIButton(osu, 0, 0, 240, 40, "change_win_condition_btn", "Win condition: Score");
 
     m_change_win_condition_btn->setColor(0xff00ff00);
 
     m_change_win_condition_btn->setUseDefaultSkin();
 
     m_change_win_condition_btn->setClickCallback(
 
-        fastdelegate::MakeDelegate(this, &OsuRoom::onChangeWinConditionClicked));
 
+        fastdelegate::MakeDelegate(this, &RoomScreen::onChangeWinConditionClicked));
 
 
 
     INIT_LABEL(map_label, "Beatmap", true);
 
-    m_select_map_btn = new OsuUIButton(osu, 0, 0, 130, 40, "select_map_btn", "Select map");
 
+    m_select_map_btn = new UIButton(osu, 0, 0, 130, 40, "select_map_btn", "Select map");
 
     m_select_map_btn->setColor(0xff0e94b5);
 
     m_select_map_btn->setUseDefaultSkin();
 
-    m_select_map_btn->setClickCallback(fastdelegate::MakeDelegate(this, &OsuRoom::onSelectMapClicked));
 
+    m_select_map_btn->setClickCallback(fastdelegate::MakeDelegate(this, &RoomScreen::onSelectMapClicked));
 
 
 
     INIT_LABEL(m_map_title, "(no map selected)", false);
 
     INIT_LABEL(m_map_stars, "", false);
@@ -157,21 +156,21 @@ OsuRoom::OsuRoom(Osu *osu) : OsuScreen(osu) {
 
     INIT_LABEL(m_map_attributes2, "", false);
 
 
 
     INIT_LABEL(mods_label, "Mods", true);
 
-    m_select_mods_btn = new OsuUIButton(osu, 0, 0, 180, 40, "select_mods_btn", "Select mods [F1]");
 
+    m_select_mods_btn = new UIButton(osu, 0, 0, 180, 40, "select_mods_btn", "Select mods [F1]");
 
     m_select_mods_btn->setColor(0xff0e94b5);
 
     m_select_mods_btn->setUseDefaultSkin();
 
-    m_select_mods_btn->setClickCallback(fastdelegate::MakeDelegate(this, &OsuRoom::onSelectModsClicked));
 
-    m_freemod = new OsuUICheckbox(m_osu, 0, 0, 200, 50, "allow_freemod", "Freemod");
 
+    m_select_mods_btn->setClickCallback(fastdelegate::MakeDelegate(this, &RoomScreen::onSelectModsClicked));
 
+    m_freemod = new UICheckbox(m_osu, 0, 0, 200, 50, "allow_freemod", "Freemod");
 
     m_freemod->setDrawFrame(false);
 
     m_freemod->setDrawBackground(false);
 
-    m_freemod->setChangeCallback(fastdelegate::MakeDelegate(this, &OsuRoom::onFreemodCheckboxChanged));
 
-    m_mods = new OsuUIModList(&bancho.room.mods);
 
+    m_freemod->setChangeCallback(fastdelegate::MakeDelegate(this, &RoomScreen::onFreemodCheckboxChanged));
 
+    m_mods = new UIModList(&bancho.room.mods);
 
     INIT_LABEL(m_no_mods_selected, "No mods selected.", false);
 
 
 
-    m_ready_btn = new OsuUIButton(osu, 0, 0, 300, 50, "start_game_btn", "Start game");
 
+    m_ready_btn = new UIButton(osu, 0, 0, 300, 50, "start_game_btn", "Start game");
 
     m_ready_btn->setColor(0xff00ff00);
 
     m_ready_btn->setUseDefaultSkin();
 
-    m_ready_btn->setClickCallback(fastdelegate::MakeDelegate(this, &OsuRoom::onReadyButtonClick));
 
+    m_ready_btn->setClickCallback(fastdelegate::MakeDelegate(this, &RoomScreen::onReadyButtonClick));
 
     m_ready_btn->is_loading = true;
 
 
 
     auto player_list_label = new CBaseUILabel(50, 50, 0, 0, "label", "Player list");
@@ -187,24 +186,24 @@ OsuRoom::OsuRoom(Osu *osu) : OsuScreen(osu) {
 
     m_slotlist->setHorizontalScrolling(false);
 
     addBaseUIElement(m_slotlist);
 
 
 
-    m_contextMenu = new OsuUIContextMenu(m_osu, 50, 50, 150, 0, "", m_settings);
 
+    m_contextMenu = new UIContextMenu(m_osu, 50, 50, 150, 0, "", m_settings);
 
     addBaseUIElement(m_contextMenu);
 
 
 
     updateLayout(m_osu->getScreenSize());
 
 }
 
 
 
-void OsuRoom::draw(Graphics *g) {
 
+void RoomScreen::draw(Graphics *g) {
 
     if(!m_bVisible) return;
 
 
 
     // XXX: Add convar for toggling room backgrounds
 
-    OsuSongBrowser::drawSelectedBeatmapBackgroundImage(g, m_osu, 1.0);
 
+    SongBrowser::drawSelectedBeatmapBackgroundImage(g, m_osu, 1.0);
 
     OsuScreen::draw(g);
 
 
 
     // Update avatar visibility status
 
     for(auto elm : m_slotlist->getContainer()->getElements()) {
 
         if(elm->getName() == UString("avatar")) {
 
             // NOTE: Not checking horizontal visibility
 
-            auto avatar = (OsuUIAvatar *)elm;
 
+            auto avatar = (UIAvatar *)elm;
 
             bool is_below_top = avatar->getPos().y + avatar->getSize().y >= m_slotlist->getPos().y;
 
             bool is_above_bottom = avatar->getPos().y <= m_slotlist->getPos().y + m_slotlist->getSize().y;
 
             avatar->on_screen = is_below_top && is_above_bottom;
@@ -222,7 +221,7 @@ void OsuRoom::draw(Graphics *g) {
 
 
 
     auto search = mapset_by_mapid.find(bancho.room.map_id);
 
     if(search == mapset_by_mapid.end()) return;
 
-    uint32_t set_id = search->second;
 
+    u32 set_id = search->second;
 
     if(set_id == 0) {
 
         auto error_str = UString::format("Could not find beatmapset for map ID %d", bancho.room.map_id);
 
         m_map_title->setText(error_str);
@@ -257,7 +256,7 @@ void OsuRoom::draw(Graphics *g) {
 
     }
 
 }
 
 
 
-void OsuRoom::mouse_update(bool *propagate_clicks) {
 
+void RoomScreen::mouse_update(bool *propagate_clicks) {
 
     if(!m_bVisible || m_osu->m_songBrowser2->isVisible()) return;
 
 
 
     const bool room_name_changed = m_room_name_ipt->getText() != bancho.room.name;
@@ -279,7 +278,7 @@ void OsuRoom::mouse_update(bool *propagate_clicks) {
 
     OsuScreen::mouse_update(propagate_clicks);
 
 }
 
 
 
-void OsuRoom::onKeyDown(KeyboardEvent &key) {
 
+void RoomScreen::onKeyDown(KeyboardEvent &key) {
 
     if(!m_bVisible || m_osu->m_songBrowser2->isVisible()) return;
 
 
 
     if(key.getKeyCode() == KEY_ESCAPE) {
@@ -300,25 +299,25 @@ void OsuRoom::onKeyDown(KeyboardEvent &key) {
 
     OsuScreen::onKeyDown(key);
 
 }
 
 
 
-void OsuRoom::onKeyUp(KeyboardEvent &key) {
 
+void RoomScreen::onKeyUp(KeyboardEvent &key) {
 
     if(!m_bVisible || m_osu->m_songBrowser2->isVisible()) return;
 
     OsuScreen::onKeyUp(key);
 
 }
 
 
 
-void OsuRoom::onChar(KeyboardEvent &key) {
 
+void RoomScreen::onChar(KeyboardEvent &key) {
 
     if(!m_bVisible || m_osu->m_songBrowser2->isVisible()) return;
 
     OsuScreen::onChar(key);
 
 }
 
 
 
-void OsuRoom::onResolutionChange(Vector2 newResolution) { updateLayout(newResolution); }
 
+void RoomScreen::onResolutionChange(Vector2 newResolution) { updateLayout(newResolution); }
 
 
 
-CBaseUIContainer *OsuRoom::setVisible(bool visible) {
 
+CBaseUIContainer *RoomScreen::setVisible(bool visible) {
 
     // NOTE: Calling setVisible(false) does not quit the room! Call ragequit() instead.
 
     m_bVisible = visible;
 
     return this;
 
 }
 
 
 
-void OsuRoom::updateSettingsLayout(Vector2 newResolution) {
 
+void RoomScreen::updateSettingsLayout(Vector2 newResolution) {
 
     const bool is_host = bancho.room.is_host();
 
     int settings_y = 10;
 
 
@@ -403,7 +402,7 @@ void OsuRoom::updateSettingsLayout(Vector2 newResolution) {
 
     // Ready button
 
     int nb_ready = 0;
 
     bool is_ready = false;
 
-    for(uint8_t i = 0; i < 16; i++) {
 
+    for(u8 i = 0; i < 16; i++) {
 
         if(bancho.room.slots[i].has_player() && bancho.room.slots[i].is_ready()) {
 
             nb_ready++;
 
             if(bancho.room.slots[i].player_id == bancho.user_id) {
@@ -427,7 +426,7 @@ void OsuRoom::updateSettingsLayout(Vector2 newResolution) {
 
     m_settings->setScrollSizeToContent();
 
 }
 
 
 
-void OsuRoom::updateLayout(Vector2 newResolution) {
 
+void RoomScreen::updateLayout(Vector2 newResolution) {
 
     setSize(newResolution);
 
     updateSettingsLayout(newResolution);
 
 
@@ -449,10 +448,10 @@ void OsuRoom::updateLayout(Vector2 newResolution) {
 
             }
 
 
 
             const float SLOT_HEIGHT = 40.f;
 
-            auto avatar = new OsuUIAvatar(bancho.room.slots[i].player_id, 10, y_total, SLOT_HEIGHT, SLOT_HEIGHT);
 
+            auto avatar = new UIAvatar(bancho.room.slots[i].player_id, 10, y_total, SLOT_HEIGHT, SLOT_HEIGHT);
 
             m_slotlist->getContainer()->addBaseUIElement(avatar);
 
 
 
-            auto user_box = new OsuUIUserLabel(m_osu, bancho.room.slots[i].player_id, username);
 
+            auto user_box = new UIUserLabel(m_osu, bancho.room.slots[i].player_id, username);
 
             user_box->setFont(lfont);
 
             user_box->setPos(avatar->getRelPos().x + avatar->getSize().x + 10, y_total);
 
 
@@ -467,7 +466,7 @@ void OsuRoom::updateLayout(Vector2 newResolution) {
 
             user_box->setSize(user_box->getSize().x, SLOT_HEIGHT);
 
             m_slotlist->getContainer()->addBaseUIElement(user_box);
 
 
 
-            auto user_mods = new OsuUIModList(&bancho.room.slots[i].mods);
 
+            auto user_mods = new UIModList(&bancho.room.slots[i].mods);
 
             user_mods->setPos(user_box->getPos().x + user_box->getSize().x + 30, y_total);
 
             user_mods->setSize(350, SLOT_HEIGHT);
 
             m_slotlist->getContainer()->addBaseUIElement(user_mods);
@@ -479,7 +478,7 @@ void OsuRoom::updateLayout(Vector2 newResolution) {
 
 }
 
 
 
 // Exit to main menu
 
-void OsuRoom::ragequit() {
 
+void RoomScreen::ragequit() {
 
     m_bVisible = false;
 
     bancho.match_started = false;
 
 
@@ -498,8 +497,8 @@ void OsuRoom::ragequit() {
 
     ConVars::sv_cheats.setValue(!bancho.submit_scores());
 
 }
 
 
 
-void OsuRoom::process_beatmapset_info_response(Packet packet) {
 
-    uint32_t map_id = packet.extra_int;
 
+void RoomScreen::process_beatmapset_info_response(Packet packet) {
 
+    u32 map_id = packet.extra_int;
 
     if(packet.size == 0) {
 
         bancho.osu->m_room->mapset_by_mapid[map_id] = 0;
 
         return;
@@ -542,7 +541,7 @@ void OsuRoom::process_beatmapset_info_response(Packet packet) {
 
     // Do nothing with the rest
 
 }
 
 
 
-void OsuRoom::on_map_change(bool download) {
 
+void RoomScreen::on_map_change(bool download) {
 
     // Results screen has map background and such showing, so prevent map from changing while we're on it.
 
     if(m_osu->m_rankingScreen->isVisible()) return;
 
 
@@ -589,7 +588,7 @@ void OsuRoom::on_map_change(bool download) {
 
             request.type = GET_BEATMAPSET_INFO;
 
             request.path = path;
 
             request.mime = NULL;
 
-            request.extra_int = (uint32_t)bancho.room.map_id;
 
+            request.extra_int = (u32)bancho.room.map_id;
 
 
 
             send_api_request(request);
 
 
@@ -615,7 +614,7 @@ void OsuRoom::on_map_change(bool download) {
 
     updateLayout(m_osu->getScreenSize());
 
 }
 
 
 
-void OsuRoom::on_room_joined(Room room) {
 
+void RoomScreen::on_room_joined(Room room) {
 
     ConVars::sv_cheats.setValue(false);
 
 
 
     bancho.room = room;
@@ -636,7 +635,7 @@ void OsuRoom::on_room_joined(Room room) {
 
     updateLayout(m_osu->getScreenSize());
 
     m_bVisible = true;
 
 
 
-    OsuRichPresence::setBanchoStatus(m_osu, room.name.toUtf8(), MULTIPLAYER);
 
+    RichPresence::setBanchoStatus(m_osu, room.name.toUtf8(), MULTIPLAYER);
 
     m_osu->m_chat->addChannel("#multiplayer");
 
     m_osu->m_chat->updateVisibility();
 
 
@@ -644,7 +643,7 @@ void OsuRoom::on_room_joined(Room room) {
 
     m_osu->m_modSelector->enableModsFromFlags(bancho.room.mods);
 
 }
 
 
 
-void OsuRoom::on_room_updated(Room room) {
 
+void RoomScreen::on_room_updated(Room room) {
 
     if(bancho.is_playing_a_multi_map() || !bancho.is_in_a_multi_room()) return;
 
 
 
     bool was_host = bancho.room.is_host();
@@ -679,7 +678,7 @@ void OsuRoom::on_room_updated(Room room) {
 
     updateLayout(m_osu->getScreenSize());
 
 }
 
 
 
-void OsuRoom::on_match_started(Room room) {
 
+void RoomScreen::on_match_started(Room room) {
 
     bancho.room = room;
 
     if(m_osu->getSelectedBeatmap() == nullptr) {
 
         debugLog("We received MATCH_STARTED without being ready, wtf!\n");
@@ -699,47 +698,47 @@ void OsuRoom::on_match_started(Room room) {
 
     }
 
 }
 
 
 
-void OsuRoom::on_match_score_updated(Packet *packet) {
 
-    int32_t update_tms = read_int32(packet);
 
-    uint8_t slot_id = read_byte(packet);
 
+void RoomScreen::on_match_score_updated(Packet *packet) {
 
+    i32 update_tms = read<u32>(packet);
 
+    u8 slot_id = read<u8>(packet);
 
     if(slot_id > 15) return;
 
 
 
     auto slot = &bancho.room.slots[slot_id];
 
     slot->last_update_tms = update_tms;
 
-    slot->num300 = read_short(packet);
 
-    slot->num100 = read_short(packet);
 
-    slot->num50 = read_short(packet);
 
-    slot->num_geki = read_short(packet);
 
-    slot->num_katu = read_short(packet);
 
-    slot->num_miss = read_short(packet);
 
-    slot->total_score = read_int32(packet);
 
-    slot->max_combo = read_short(packet);
 
-    slot->current_combo = read_short(packet);
 
-    slot->is_perfect = read_byte(packet);
 
-    slot->current_hp = read_byte(packet);
 
-    slot->tag = read_byte(packet);
 
-
 
-    bool is_scorev2 = read_byte(packet);
 
+    slot->num300 = read<u16>(packet);
 
+    slot->num100 = read<u16>(packet);
 
+    slot->num50 = read<u16>(packet);
 
+    slot->num_geki = read<u16>(packet);
 
+    slot->num_katu = read<u16>(packet);
 
+    slot->num_miss = read<u16>(packet);
 
+    slot->total_score = read<u32>(packet);
 
+    slot->max_combo = read<u16>(packet);
 
+    slot->current_combo = read<u16>(packet);
 
+    slot->is_perfect = read<u8>(packet);
 
+    slot->current_hp = read<u8>(packet);
 
+    slot->tag = read<u8>(packet);
 
+
 
+    bool is_scorev2 = read<u8>(packet);
 
     if(is_scorev2) {
 
-        slot->sv2_combo = read_float64(packet);
 
-        slot->sv2_bonus = read_float64(packet);
 
+        slot->sv2_combo = read<f64>(packet);
 
+        slot->sv2_bonus = read<f64>(packet);
 
     }
 
 
 
     bancho.osu->m_hud->updateScoreboard(true);
 
 }
 
 
 
-void OsuRoom::on_all_players_loaded() {
 
+void RoomScreen::on_all_players_loaded() {
 
     bancho.room.all_players_loaded = true;
 
     m_osu->m_chat->updateVisibility();
 
 }
 
 
 
-void OsuRoom::on_player_failed(int32_t slot_id) {
 
+void RoomScreen::on_player_failed(i32 slot_id) {
 
     if(slot_id < 0 || slot_id > 15) return;
 
     bancho.room.slots[slot_id].died = true;
 
 }
 
 
 
 // All players have finished.
 
-void OsuRoom::on_match_finished() {
 
+void RoomScreen::on_match_finished() {
 
     if(!bancho.is_playing_a_multi_map()) return;
 
     memcpy(bancho.last_scores, bancho.room.slots, sizeof(bancho.room.slots));
 
     m_osu->onPlayEnd(false, false);
@@ -748,9 +747,9 @@ void OsuRoom::on_match_finished() {
 
     m_osu->m_chat->updateVisibility();
 
 }
 
 
 
-void OsuRoom::on_all_players_skipped() { bancho.room.all_players_skipped = true; }
 
+void RoomScreen::on_all_players_skipped() { bancho.room.all_players_skipped = true; }
 
 
 
-void OsuRoom::on_player_skip(int32_t user_id) {
 
+void RoomScreen::on_player_skip(i32 user_id) {
 
     for(int i = 0; i < 16; i++) {
 
         if(bancho.room.slots[i].player_id == user_id) {
 
             bancho.room.slots[i].skipped = true;
@@ -759,14 +758,14 @@ void OsuRoom::on_player_skip(int32_t user_id) {
 
     }
 
 }
 
 
 
-void OsuRoom::on_match_aborted() {
 
+void RoomScreen::on_match_aborted() {
 
     if(!bancho.is_playing_a_multi_map()) return;
 
     m_osu->onPlayEnd(false, true);
 
     m_bVisible = true;
 
     bancho.match_started = false;
 
 }
 
 
 
-void OsuRoom::onClientScoreChange(bool force) {
 
+void RoomScreen::onClientScoreChange(bool force) {
 
     if(!bancho.is_playing_a_multi_map()) return;
 
 
 
     // Update at most once every 250ms
@@ -776,43 +775,43 @@ void OsuRoom::onClientScoreChange(bool force) {
 
     Packet packet;
 
     packet.id = UPDATE_MATCH_SCORE;
 
 
 
-    write_int32(&packet, (int32_t)m_osu->getSelectedBeatmap()->getTime());
 
+    write_u32(&packet, (i32)m_osu->getSelectedBeatmap()->getTime());
 
 
 
-    uint8_t slot_id = 0;
 
-    for(uint8_t i = 0; i < 16; i++) {
 
+    u8 slot_id = 0;
 
+    for(u8 i = 0; i < 16; i++) {
 
         if(bancho.room.slots[i].player_id == bancho.user_id) {
 
             slot_id = i;
 
             break;
 
         }
 
     }
 
-    write_byte(&packet, slot_id);
 
-
 
-    write_short(&packet, (uint16_t)m_osu->getScore()->getNum300s());
 
-    write_short(&packet, (uint16_t)m_osu->getScore()->getNum100s());
 
-    write_short(&packet, (uint16_t)m_osu->getScore()->getNum50s());
 
-    write_short(&packet, (uint16_t)m_osu->getScore()->getNum300gs());
 
-    write_short(&packet, (uint16_t)m_osu->getScore()->getNum100ks());
 
-    write_short(&packet, (uint16_t)m_osu->getScore()->getNumMisses());
 
-    write_int32(&packet, (int32_t)m_osu->getScore()->getScore());
 
-    write_short(&packet, (uint16_t)m_osu->getScore()->getCombo());
 
-    write_short(&packet, (uint16_t)m_osu->getScore()->getComboMax());
 
-    write_byte(&packet, m_osu->getScore()->getNumSliderBreaks() == 0 && m_osu->getScore()->getNumMisses() == 0 &&
 
-                            m_osu->getScore()->getNum50s() == 0 && m_osu->getScore()->getNum100s() == 0);
 
-    write_byte(&packet, m_osu->getSelectedBeatmap()->getHealth() * 200);
 
-    write_byte(&packet, 0);  // 4P, not supported
 
-    write_byte(&packet, m_osu->getModScorev2());
 
+    write_u8(&packet, slot_id);
 
+
 
+    write_u16(&packet, (u16)m_osu->getScore()->getNum300s());
 
+    write_u16(&packet, (u16)m_osu->getScore()->getNum100s());
 
+    write_u16(&packet, (u16)m_osu->getScore()->getNum50s());
 
+    write_u16(&packet, (u16)m_osu->getScore()->getNum300gs());
 
+    write_u16(&packet, (u16)m_osu->getScore()->getNum100ks());
 
+    write_u16(&packet, (u16)m_osu->getScore()->getNumMisses());
 
+    write_u32(&packet, (i32)m_osu->getScore()->getScore());
 
+    write_u16(&packet, (u16)m_osu->getScore()->getCombo());
 
+    write_u16(&packet, (u16)m_osu->getScore()->getComboMax());
 
+    write_u8(&packet, m_osu->getScore()->getNumSliderBreaks() == 0 && m_osu->getScore()->getNumMisses() == 0 &&
 
+                          m_osu->getScore()->getNum50s() == 0 && m_osu->getScore()->getNum100s() == 0);
 
+    write_u8(&packet, m_osu->getSelectedBeatmap()->getHealth() * 200);
 
+    write_u8(&packet, 0);  // 4P, not supported
 
+    write_u8(&packet, m_osu->getModScorev2());
 
     send_packet(packet);
 
 
 
     last_packet_tms = time(NULL);
 
 }
 
 
 
-void OsuRoom::onReadyButtonClick() {
 
+void RoomScreen::onReadyButtonClick() {
 
     if(m_ready_btn->is_loading) return;
 
     engine->getSound()->play(m_osu->getSkin()->getMenuHit());
 
 
 
     int nb_ready = 0;
 
     bool is_ready = false;
 
-    for(uint8_t i = 0; i < 16; i++) {
 
+    for(u8 i = 0; i < 16; i++) {
 
         if(bancho.room.slots[i].has_player() && bancho.room.slots[i].is_ready()) {
 
             nb_ready++;
 
             if(bancho.room.slots[i].player_id == bancho.user_id) {
@@ -831,13 +830,13 @@ void OsuRoom::onReadyButtonClick() {
 
     }
 
 }
 
 
 
-void OsuRoom::onSelectModsClicked() {
 
+void RoomScreen::onSelectModsClicked() {
 
     engine->getSound()->play(m_osu->getSkin()->getMenuHit());
 
     m_osu->m_modSelector->setVisible(true);
 
     m_bVisible = false;
 
 }
 
 
 
-void OsuRoom::onSelectMapClicked() {
 
+void RoomScreen::onSelectMapClicked() {
 
     if(!bancho.room.is_host()) return;
 
 
 
     engine->getSound()->play(m_osu->getSkin()->getMenuHit());
@@ -853,11 +852,11 @@ void OsuRoom::onSelectMapClicked() {
 
     m_osu->m_songBrowser2->setVisible(true);
 
 }
 
 
 
-void OsuRoom::onChangePasswordClicked() {
 
-    m_osu->m_prompt->prompt("New password:", fastdelegate::MakeDelegate(this, &OsuRoom::set_new_password));
 
+void RoomScreen::onChangePasswordClicked() {
 
+    m_osu->m_prompt->prompt("New password:", fastdelegate::MakeDelegate(this, &RoomScreen::set_new_password));
 
 }
 
 
 
-void OsuRoom::onChangeWinConditionClicked() {
 
+void RoomScreen::onChangeWinConditionClicked() {
 
     m_contextMenu->setVisible(false);
 
     m_contextMenu->begin();
 
     m_contextMenu->addButton("Score V1", SCOREV1);
@@ -866,11 +865,11 @@ void OsuRoom::onChangeWinConditionClicked() {
 
     m_contextMenu->addButton("Combo", COMBO);
 
     m_contextMenu->end(false, false);
 
     m_contextMenu->setPos(engine->getMouse()->getPos());
 
-    m_contextMenu->setClickCallback(fastdelegate::MakeDelegate(this, &OsuRoom::onWinConditionSelected));
 
+    m_contextMenu->setClickCallback(fastdelegate::MakeDelegate(this, &RoomScreen::onWinConditionSelected));
 
     m_contextMenu->setVisible(true);
 
 }
 
 
 
-void OsuRoom::onWinConditionSelected(UString win_condition_str, int win_condition) {
 
+void RoomScreen::onWinConditionSelected(UString win_condition_str, int win_condition) {
 
     bancho.room.win_condition = win_condition;
 
 
 
     Packet packet;
@@ -881,7 +880,7 @@ void OsuRoom::onWinConditionSelected(UString win_condition_str, int win_conditio
 
     updateLayout(m_osu->getScreenSize());
 
 }
 
 
 
-void OsuRoom::set_new_password(UString new_password) {
 
+void RoomScreen::set_new_password(UString new_password) {
 
     bancho.room.has_password = new_password.length() > 0;
 
     bancho.room.password = new_password;
 
 
@@ -891,7 +890,7 @@ void OsuRoom::set_new_password(UString new_password) {
 
     send_packet(packet);
 
 }
 
 
 
-void OsuRoom::onFreemodCheckboxChanged(CBaseUICheckbox *checkbox) {
 
+void RoomScreen::onFreemodCheckboxChanged(CBaseUICheckbox *checkbox) {
 
     if(!bancho.room.is_host()) return;
 
 
 
     bancho.room.freemods = checkbox->isChecked();
--- a/src/App/Osu/RoomScreen.h
+++ b/src/App/Osu/RoomScreen.h
@@ -8,25 +8,25 @@
 
 class CBaseUICheckbox;
 
 class CBaseUILabel;
 
 class CBaseUITextbox;
 
-class OsuDatabaseBeatmap;
 
-class OsuMainMenuPauseButton;
 
-class OsuUIButton;
 
-class OsuUICheckbox;
 
-class OsuUIContextMenu;
 
+class DatabaseBeatmap;
 
+class MainMenuPauseButton;
 
+class UIButton;
 
+class UICheckbox;
 
+class UIContextMenu;
 
 
 
-class OsuUIModList : public CBaseUIContainer {
 
+class UIModList : public CBaseUIContainer {
 
    public:
 
-    OsuUIModList(uint32_t *flags) : CBaseUIContainer(0, 0, 0, 0, "mod_list") { m_flags = flags; }
 
+    UIModList(u32 *flags) : CBaseUIContainer(0, 0, 0, 0, "mod_list") { m_flags = flags; }
 
 
 
-    uint32_t *m_flags;
 
+    u32 *m_flags;
 
 
 
     virtual void draw(Graphics *g) override;
 
     virtual bool isVisible() override;
 
 };
 
 
 
-class OsuRoom : public OsuScreen {
 
+class RoomScreen : public OsuScreen {
 
    public:
 
-    OsuRoom(Osu *osu);
 
+    RoomScreen(Osu *osu);
 
 
 
     virtual void draw(Graphics *g) override;
 
     virtual void mouse_update(bool *propagate_clicks) override;
@@ -47,10 +47,10 @@ class OsuRoom : public OsuScreen {
 
     void on_match_started(Room room);
 
     void on_match_score_updated(Packet *packet);
 
     void on_all_players_loaded();
 
-    void on_player_failed(int32_t slot_id);
 
+    void on_player_failed(i32 slot_id);
 
     void on_match_finished();
 
     void on_all_players_skipped();
 
-    void on_player_skip(int32_t user_id);
 
+    void on_player_skip(i32 user_id);
 
     void on_match_aborted();
 
     void onClientScoreChange(bool force = false);
 
     void onReadyButtonClick();
@@ -65,7 +65,7 @@ class OsuRoom : public OsuScreen {
 
     void set_new_password(UString new_password);
 
     void onFreemodCheckboxChanged(CBaseUICheckbox *checkbox);
 
 
 
-    std::unordered_map<uint32_t, uint32_t> mapset_by_mapid;
 
+    std::unordered_map<u32, u32> mapset_by_mapid;
 
 
 
     CBaseUILabel *map_label = nullptr;
 
     CBaseUILabel *mods_label = nullptr;
@@ -76,22 +76,22 @@ class OsuRoom : public OsuScreen {
 
     CBaseUILabel *m_room_name = nullptr;
 
     CBaseUILabel *m_room_name_iptl = nullptr;
 
     CBaseUITextbox *m_room_name_ipt = nullptr;
 
-    OsuUIButton *m_change_password_btn = nullptr;
 
+    UIButton *m_change_password_btn = nullptr;
 
     CBaseUILabel *m_win_condition = nullptr;
 
-    OsuUIButton *m_change_win_condition_btn = nullptr;
 
+    UIButton *m_change_win_condition_btn = nullptr;
 
     CBaseUILabel *m_map_title = nullptr;
 
     CBaseUILabel *m_map_attributes = nullptr;
 
     CBaseUILabel *m_map_attributes2 = nullptr;
 
     CBaseUILabel *m_map_stars = nullptr;
 
-    OsuUIButton *m_select_map_btn = nullptr;
 
-    OsuUIButton *m_select_mods_btn = nullptr;
 
-    OsuUICheckbox *m_freemod = nullptr;
 
-    OsuUIModList *m_mods = nullptr;
 
+    UIButton *m_select_map_btn = nullptr;
 
+    UIButton *m_select_mods_btn = nullptr;
 
+    UICheckbox *m_freemod = nullptr;
 
+    UIModList *m_mods = nullptr;
 
     CBaseUILabel *m_no_mods_selected = nullptr;
 
-    OsuUIButton *m_ready_btn = nullptr;
 
-    OsuUIContextMenu *m_contextMenu = nullptr;
 
+    UIButton *m_ready_btn = nullptr;
 
+    UIContextMenu *m_contextMenu = nullptr;
 
 
 
-    OsuMainMenuPauseButton *m_pauseButton = nullptr;
 
+    MainMenuPauseButton *m_pauseButton = nullptr;
 
     McFont *font = nullptr;
 
     McFont *lfont = nullptr;
 
     time_t last_packet_tms = {0};
--- a/src/App/Osu/Score.h
+++ b/src/App/Osu/Score.h
@@ -1,118 +0,0 @@
 
-#pragma once
 
-#include "OsuReplay.h"
 
-#include "cbase.h"
 
-
 
-class OsuDatabaseBeatmap;
 
-
 
-struct Score {
 
-    enum class Grade {
 
-        XH,
 
-        SH,
 
-        X,
 
-        S,
 
-        A,
 
-        B,
 
-        C,
 
-        D,
 
-        F,
 
-        N  // means "no grade"
 
-    };
 
-
 
-    bool isLegacyScore;          // used for identifying loaded osu! scores (which don't have any custom data available)
 
-    bool isImportedLegacyScore;  // used for identifying imported osu! scores (which were previously legacy scores,
 
-                                 // so they don't have any
 
-                                 // numSliderBreaks/unstableRate/hitErrorAvgMin/hitErrorAvgMax)
 
-    uint32_t version;
 
-    uint64_t unixTimestamp;
 
-
 
-    uint32_t player_id = 0;
 
-    std::string playerName;
 
-    bool passed = false;
 
-    bool ragequit = false;
 
-    Grade grade = Grade::N;
 
-    OsuDatabaseBeatmap *diff2;
 
-    uint64_t play_time_ms = 0;
 
-
 
-    std::string server;
 
-    uint64_t online_score_id = 0;
 
-    bool has_replay = false;
 
-    std::vector<OsuReplay::Frame> replay;
 
-    uint64_t legacyReplayTimestamp = 0;
 
-
 
-    int num300s;
 
-    int num100s;
 
-    int num50s;
 
-    int numGekis;
 
-    int numKatus;
 
-    int numMisses;
 
-
 
-    unsigned long long score;
 
-    int comboMax;
 
-    bool perfect;
 
-    int modsLegacy;
 
-
 
-    // custom
 
-    int numSliderBreaks;
 
-    float pp;
 
-    float unstableRate;
 
-    float hitErrorAvgMin;
 
-    float hitErrorAvgMax;
 
-    float starsTomTotal;
 
-    float starsTomAim;
 
-    float starsTomSpeed;
 
-    float speedMultiplier;
 
-    float CS, AR, OD, HP;
 
-    int maxPossibleCombo;
 
-    int numHitObjects;
 
-    int numCircles;
 
-    std::string experimentalModsConVars;
 
-
 
-    // runtime
 
-    unsigned long long sortHack;
 
-    MD5Hash md5hash;
 
-
 
-    bool isLegacyScoreEqualToImportedLegacyScore(const Score &importedLegacyScore) const {
 
-        if(!isLegacyScore) return false;
 
-        if(!importedLegacyScore.isImportedLegacyScore) return false;
 
-
 
-        const bool isScoreValueEqual = (score == importedLegacyScore.score);
 
-        const bool isTimestampEqual = (unixTimestamp == importedLegacyScore.unixTimestamp);
 
-        const bool isComboMaxEqual = (comboMax == importedLegacyScore.comboMax);
 
-        const bool isModsLegacyEqual = (modsLegacy == importedLegacyScore.modsLegacy);
 
-        const bool isNum300sEqual = (num300s == importedLegacyScore.num300s);
 
-        const bool isNum100sEqual = (num100s == importedLegacyScore.num100s);
 
-        const bool isNum50sEqual = (num50s == importedLegacyScore.num50s);
 
-        const bool isNumGekisEqual = (numGekis == importedLegacyScore.numGekis);
 
-        const bool isNumKatusEqual = (numKatus == importedLegacyScore.numKatus);
 
-        const bool isNumMissesEqual = (numMisses == importedLegacyScore.numMisses);
 
-
 
-        return (isScoreValueEqual && isTimestampEqual && isComboMaxEqual && isModsLegacyEqual && isNum300sEqual &&
 
-                isNum100sEqual && isNum50sEqual && isNumGekisEqual && isNumKatusEqual && isNumMissesEqual);
 
-    }
 
-
 
-    bool isScoreEqualToCopiedScoreIgnoringPlayerName(const Score &copiedScore) const {
 
-        const bool isScoreValueEqual = (score == copiedScore.score);
 
-        const bool isTimestampEqual = (unixTimestamp == copiedScore.unixTimestamp);
 
-        const bool isComboMaxEqual = (comboMax == copiedScore.comboMax);
 
-        const bool isModsLegacyEqual = (modsLegacy == copiedScore.modsLegacy);
 
-        const bool isNum300sEqual = (num300s == copiedScore.num300s);
 
-        const bool isNum100sEqual = (num100s == copiedScore.num100s);
 
-        const bool isNum50sEqual = (num50s == copiedScore.num50s);
 
-        const bool isNumGekisEqual = (numGekis == copiedScore.numGekis);
 
-        const bool isNumKatusEqual = (numKatus == copiedScore.numKatus);
 
-        const bool isNumMissesEqual = (numMisses == copiedScore.numMisses);
 
-
 
-        const bool isSpeedMultiplierEqual = (speedMultiplier == copiedScore.speedMultiplier);
 
-        const bool isCSEqual = (CS == copiedScore.CS);
 
-        const bool isAREqual = (AR == copiedScore.AR);
 
-        const bool isODEqual = (OD == copiedScore.OD);
 
-        const bool isHPEqual = (HP == copiedScore.HP);
 
-        const bool areExperimentalModsConVarsEqual = (experimentalModsConVars == copiedScore.experimentalModsConVars);
 
-
 
-        return (isScoreValueEqual && isTimestampEqual && isComboMaxEqual && isModsLegacyEqual && isNum300sEqual &&
 
-                isNum100sEqual && isNum50sEqual && isNumGekisEqual && isNumKatusEqual && isNumMissesEqual
 
-
 
-                && isSpeedMultiplierEqual && isCSEqual && isAREqual && isODEqual && isHPEqual &&
 
-                areExperimentalModsConVarsEqual);
 
-    }
 
-};
--- a/src/App/Osu/OsuScoreboardSlot.cpp
+++ b/src/App/Osu/OsuScoreboardSlot.cpp
@@ -1,4 +1,4 @@
 
-#include "OsuScoreboardSlot.h"
 
+#include "ScoreboardSlot.h"
 
 
 
 #include "AnimationHandler.h"
 
 #include "Bancho.h"
@@ -6,11 +6,11 @@
 
 #include "Engine.h"
 
 #include "Font.h"
 
 #include "Osu.h"
 
-#include "OsuSkin.h"
 
-#include "OsuSkinImage.h"
 
+#include "Skin.h"
 
+#include "SkinImage.h"
 
 
 
-OsuScoreboardSlot::OsuScoreboardSlot(SCORE_ENTRY score, int index) {
 
-    m_avatar = new OsuUIAvatar(score.player_id, 0, 0, 0, 0);
 
+ScoreboardSlot::ScoreboardSlot(SCORE_ENTRY score, int index) {
 
+    m_avatar = new UIAvatar(score.player_id, 0, 0, 0, 0);
 
     m_score = score;
 
     m_index = index;
 
 
@@ -18,7 +18,7 @@ OsuScoreboardSlot::OsuScoreboardSlot(SCORE_ENTRY score, int index) {
 
     is_friend = user->is_friend();
 
 }
 
 
 
-OsuScoreboardSlot::~OsuScoreboardSlot() {
 
+ScoreboardSlot::~ScoreboardSlot() {
 
     anim->deleteExistingAnimation(&m_fAlpha);
 
     anim->deleteExistingAnimation(&m_fFlash);
 
     anim->deleteExistingAnimation(&m_y);
@@ -26,7 +26,7 @@ OsuScoreboardSlot::~OsuScoreboardSlot() {
 
     delete m_avatar;
 
 }
 
 
 
-void OsuScoreboardSlot::draw(Graphics *g) {
 
+void ScoreboardSlot::draw(Graphics *g) {
 
     if(m_fAlpha == 0.f) return;
 
     if(!convar->getConVarByName("osu_draw_scoreboard")->getBool() && !bancho.is_playing_a_multi_map()) return;
 
     if(!convar->getConVarByName("osu_draw_scoreboard_mp")->getBool() && bancho.is_playing_a_multi_map()) return;
@@ -252,7 +252,7 @@ void OsuScoreboardSlot::draw(Graphics *g) {
 
     g->popTransform();
 
 }
 
 
 
-void OsuScoreboardSlot::updateIndex(int new_index, bool animate) {
 
+void ScoreboardSlot::updateIndex(int new_index, bool animate) {
 
     bool is_player = bancho.osu->m_hud->player_slot == this;
 
     int player_idx = bancho.osu->m_hud->player_slot->m_index;
 
     if(is_player) {
--- a/src/App/Osu/OsuScoreboardSlot.h
+++ b/src/App/Osu/OsuScoreboardSlot.h
@@ -1,16 +1,16 @@
 
 #pragma once
 
 
 
-#include "OsuHUD.h"
 
-#include "OsuUIAvatar.h"
 
+#include "HUD.h"
 
+#include "UIAvatar.h"
 
 
 
-struct OsuScoreboardSlot {
 
-    OsuScoreboardSlot(SCORE_ENTRY score, int index);
 
-    ~OsuScoreboardSlot();
 
+struct ScoreboardSlot {
 
+    ScoreboardSlot(SCORE_ENTRY score, int index);
 
+    ~ScoreboardSlot();
 
 
 
     void draw(Graphics *g);
 
     void updateIndex(int new_index, bool animate);
 
 
 
-    OsuUIAvatar *m_avatar = nullptr;
 
+    UIAvatar *m_avatar = nullptr;
 
     SCORE_ENTRY m_score;
 
     int m_index;
 
     float m_y = 0.f;
--- a/src/App/Osu/OsuScreenBackable.cpp
+++ b/src/App/Osu/OsuScreenBackable.cpp
@@ -5,51 +5,51 @@
 
 // $NoKeywords: $
 
 //===============================================================================//
 
 
 
-#include "OsuScreenBackable.h"
 
+#include "ScreenBackable.h"
 
 
 
+#include "KeyBindings.h"
 
 #include "Keyboard.h"
 
 #include "Osu.h"
 
-#include "OsuKeyBindings.h"
 
-#include "OsuSkin.h"
 
-#include "OsuUIBackButton.h"
 
 #include "ResourceManager.h"
 
+#include "Skin.h"
 
+#include "UIBackButton.h"
 
 
 
-OsuScreenBackable::OsuScreenBackable(Osu *osu) : OsuScreen(osu) {
 
-    m_backButton = new OsuUIBackButton(m_osu, -1, 0, 0, 0, "");
 
-    m_backButton->setClickCallback(fastdelegate::MakeDelegate(this, &OsuScreenBackable::onBack));
 
+ScreenBackable::ScreenBackable(Osu *osu) : OsuScreen(osu) {
 
+    m_backButton = new UIBackButton(m_osu, -1, 0, 0, 0, "");
 
+    m_backButton->setClickCallback(fastdelegate::MakeDelegate(this, &ScreenBackable::onBack));
 
 
 
     updateLayout();
 
 }
 
 
 
-OsuScreenBackable::~OsuScreenBackable() { SAFE_DELETE(m_backButton); }
 
+ScreenBackable::~ScreenBackable() { SAFE_DELETE(m_backButton); }
 
 
 
-void OsuScreenBackable::draw(Graphics *g) {
 
+void ScreenBackable::draw(Graphics *g) {
 
     if(!m_bVisible) return;
 
     OsuScreen::draw(g);
 
     m_backButton->draw(g);
 
 }
 
 
 
-void OsuScreenBackable::mouse_update(bool *propagate_clicks) {
 
+void ScreenBackable::mouse_update(bool *propagate_clicks) {
 
     if(!m_bVisible) return;
 
     m_backButton->mouse_update(propagate_clicks);
 
     if(!*propagate_clicks) return;
 
     OsuScreen::mouse_update(propagate_clicks);
 
 }
 
 
 
-void OsuScreenBackable::onKeyDown(KeyboardEvent &e) {
 
+void ScreenBackable::onKeyDown(KeyboardEvent &e) {
 
     OsuScreen::onKeyDown(e);
 
     if(!m_bVisible || e.isConsumed()) return;
 
 
 
-    if(e == KEY_ESCAPE || e == (KEYCODE)OsuKeyBindings::GAME_PAUSE.getInt()) {
 
+    if(e == KEY_ESCAPE || e == (KEYCODE)KeyBindings::GAME_PAUSE.getInt()) {
 
         onBack();
 
         e.consume();
 
         return;
 
     }
 
 }
 
 
 
-void OsuScreenBackable::updateLayout() {
 
+void ScreenBackable::updateLayout() {
 
     m_backButton->updateLayout();
 
     m_backButton->setPosY(m_osu->getScreenHeight() - m_backButton->getSize().y);
 
 }
 
 
 
-void OsuScreenBackable::onResolutionChange(Vector2 newResolution) { updateLayout(); }
 
+void ScreenBackable::onResolutionChange(Vector2 newResolution) { updateLayout(); }
--- a/src/App/Osu/OsuScreenBackable.h
+++ b/src/App/Osu/OsuScreenBackable.h
@@ -9,14 +9,14 @@
 
 #define OSUSCREENBACKABLE_H
 
 
 
 #include "OsuScreen.h"
 
-#include "OsuUIBackButton.h"
 
+#include "UIBackButton.h"
 
 
 
 class Osu;
 
 
 
-class OsuScreenBackable : public OsuScreen {
 
+class ScreenBackable : public OsuScreen {
 
    public:
 
-    OsuScreenBackable(Osu *osu);
 
-    virtual ~OsuScreenBackable();
 
+    ScreenBackable(Osu *osu);
 
+    virtual ~ScreenBackable();
 
 
 
     virtual void draw(Graphics *g);
 
     virtual void mouse_update(bool *propagate_clicks);
@@ -28,7 +28,7 @@ class OsuScreenBackable : public OsuScreen {
 
 
 
     virtual void updateLayout();
 
 
 
-    OsuUIBackButton *m_backButton;
 
+    UIBackButton *m_backButton;
 
 };
 
 
 
 #endif
--- a/src/App/Osu/OsuSkin.cpp
+++ b/src/App/Osu/OsuSkin.cpp
@@ -5,22 +5,22 @@
 
 // $NoKeywords: $osusk
 
 //===============================================================================//
 
 
 
-#include "OsuSkin.h"
 
+#include "Skin.h"
 
 
 
 #include <string.h>
 
 
 
+#include "Beatmap.h"
 
 #include "ConVar.h"
 
 #include "Engine.h"
 
 #include "Environment.h"
 
 #include "File.h"
 
+#include "GameRules.h"
 
+#include "NotificationOverlay.h"
 
 #include "Osu.h"
 
-#include "OsuBeatmap.h"
 
-#include "OsuGameRules.h"
 
-#include "OsuNotificationOverlay.h"
 
-#include "OsuSkinImage.h"
 
-#include "OsuVolumeOverlay.h"
 
 #include "ResourceManager.h"
 
+#include "SkinImage.h"
 
 #include "SoundEngine.h"
 
+#include "VolumeOverlay.h"
 
 
 
 #define OSU_BITMASK_HITWHISTLE 0x2
 
 #define OSU_BITMASK_HITFINISH 0x4
@@ -56,16 +56,16 @@ ConVar osu_sound_panning_multiplier("osu_sound_panning_multiplier", 1.0f, FCVAR_
 
 ConVar osu_ignore_beatmap_combo_colors("osu_ignore_beatmap_combo_colors", false, FCVAR_NONE);
 
 ConVar osu_ignore_beatmap_sample_volume("osu_ignore_beatmap_sample_volume", false, FCVAR_NONE);
 
 
 
-const char *OsuSkin::OSUSKIN_DEFAULT_SKIN_PATH = "";  // set dynamically below in the constructor
 
-Image *OsuSkin::m_missingTexture = NULL;
 
+const char *Skin::OSUSKIN_DEFAULT_SKIN_PATH = "";  // set dynamically below in the constructor
 
+Image *Skin::m_missingTexture = NULL;
 
 
 
-ConVar *OsuSkin::m_osu_skin_async = &osu_skin_async;
 
-ConVar *OsuSkin::m_osu_skin_hd = &osu_skin_hd;
 
+ConVar *Skin::m_osu_skin_async = &osu_skin_async;
 
+ConVar *Skin::m_osu_skin_hd = &osu_skin_hd;
 
 
 
-ConVar *OsuSkin::m_osu_skin_ref = NULL;
 
-ConVar *OsuSkin::m_osu_mod_fposu_ref = NULL;
 
+ConVar *Skin::m_osu_skin_ref = NULL;
 
+ConVar *Skin::m_osu_mod_fposu_ref = NULL;
 
 
 
-OsuSkin::OsuSkin(Osu *osu, UString name, std::string filepath, bool isDefaultSkin) {
 
+Skin::Skin(Osu *osu, UString name, std::string filepath, bool isDefaultSkin) {
 
     m_osu = osu;
 
     m_sName = name;
 
     m_sFilePath = filepath;
@@ -314,10 +314,10 @@ OsuSkin::OsuSkin(Osu *osu, UString name, std::string filepath, bool isDefaultSki
 
 
 
     // convar callbacks
 
     osu_ignore_beatmap_sample_volume.setCallback(
 
-        fastdelegate::MakeDelegate(this, &OsuSkin::onIgnoreBeatmapSampleVolumeChange));
 
+        fastdelegate::MakeDelegate(this, &Skin::onIgnoreBeatmapSampleVolumeChange));
 
 }
 
 
 
-OsuSkin::~OsuSkin() {
 
+Skin::~Skin() {
 
     for(int i = 0; i < m_resources.size(); i++) {
 
         if(m_resources[i] != (Resource *)m_missingTexture)
 
             engine->getResourceManager()->destroyResource(m_resources[i]);
@@ -334,7 +334,7 @@ OsuSkin::~OsuSkin() {
 
     m_filepathsForExport.clear();
 
 }
 
 
 
-void OsuSkin::update() {
 
+void Skin::update() {
 
     // tasks which have to be run after async loading finishes
 
     if(!m_bReady && isReady()) {
 
         m_bReady = true;
@@ -354,7 +354,7 @@ void OsuSkin::update() {
 
     }
 
 }
 
 
 
-bool OsuSkin::isReady() {
 
+bool Skin::isReady() {
 
     if(m_bReady) return true;
 
 
 
     for(int i = 0; i < m_resources.size(); i++) {
@@ -370,7 +370,7 @@ bool OsuSkin::isReady() {
 
     return true;
 
 }
 
 
 
-void OsuSkin::load() {
 
+void Skin::load() {
 
     // random skins
 
     {
 
         filepathsForRandomSkin.clear();
@@ -452,7 +452,7 @@ void OsuSkin::load() {
 
     // images
 
     randomizeFilePath();
 
     checkLoadImage(&m_hitCircle, "hitcircle", "OSU_SKIN_HITCIRCLE");
 
-    m_hitCircleOverlay2 = createOsuSkinImage("hitcircleoverlay", Vector2(128, 128), 64);
 
+    m_hitCircleOverlay2 = createSkinImage("hitcircleoverlay", Vector2(128, 128), 64);
 
     m_hitCircleOverlay2->setAnimationFramerate(2);
 
 
 
     randomizeFilePath();
@@ -461,7 +461,7 @@ void OsuSkin::load() {
 
     checkLoadImage(&m_reverseArrow, "reversearrow", "OSU_SKIN_REVERSEARROW");
 
 
 
     randomizeFilePath();
 
-    m_followPoint2 = createOsuSkinImage("followpoint", Vector2(16, 22), 64);
 
+    m_followPoint2 = createSkinImage("followpoint", Vector2(16, 22), 64);
 
 
 
     randomizeFilePath();
 
     {
@@ -635,47 +635,47 @@ void OsuSkin::load() {
 
     }
 
 
 
     randomizeFilePath();
 
-    m_playSkip = createOsuSkinImage("play-skip", Vector2(193, 147), 94);
 
+    m_playSkip = createSkinImage("play-skip", Vector2(193, 147), 94);
 
     randomizeFilePath();
 
     checkLoadImage(&m_playWarningArrow, "play-warningarrow", "OSU_SKIN_PLAYWARNINGARROW");
 
-    m_playWarningArrow2 = createOsuSkinImage("play-warningarrow", Vector2(167, 129), 128);
 
+    m_playWarningArrow2 = createSkinImage("play-warningarrow", Vector2(167, 129), 128);
 
     randomizeFilePath();
 
     checkLoadImage(&m_circularmetre, "circularmetre", "OSU_SKIN_CIRCULARMETRE");
 
     randomizeFilePath();
 
-    m_scorebarBg = createOsuSkinImage("scorebar-bg", Vector2(695, 44), 27.5f);
 
-    m_scorebarColour = createOsuSkinImage("scorebar-colour", Vector2(645, 10), 6.25f);
 
-    m_scorebarMarker = createOsuSkinImage("scorebar-marker", Vector2(24, 24), 15.0f);
 
-    m_scorebarKi = createOsuSkinImage("scorebar-ki", Vector2(116, 116), 72.0f);
 
-    m_scorebarKiDanger = createOsuSkinImage("scorebar-kidanger", Vector2(116, 116), 72.0f);
 
-    m_scorebarKiDanger2 = createOsuSkinImage("scorebar-kidanger2", Vector2(116, 116), 72.0f);
 
+    m_scorebarBg = createSkinImage("scorebar-bg", Vector2(695, 44), 27.5f);
 
+    m_scorebarColour = createSkinImage("scorebar-colour", Vector2(645, 10), 6.25f);
 
+    m_scorebarMarker = createSkinImage("scorebar-marker", Vector2(24, 24), 15.0f);
 
+    m_scorebarKi = createSkinImage("scorebar-ki", Vector2(116, 116), 72.0f);
 
+    m_scorebarKiDanger = createSkinImage("scorebar-kidanger", Vector2(116, 116), 72.0f);
 
+    m_scorebarKiDanger2 = createSkinImage("scorebar-kidanger2", Vector2(116, 116), 72.0f);
 
     randomizeFilePath();
 
-    m_sectionPassImage = createOsuSkinImage("section-pass", Vector2(650, 650), 400.0f);
 
+    m_sectionPassImage = createSkinImage("section-pass", Vector2(650, 650), 400.0f);
 
     randomizeFilePath();
 
-    m_sectionFailImage = createOsuSkinImage("section-fail", Vector2(650, 650), 400.0f);
 
+    m_sectionFailImage = createSkinImage("section-fail", Vector2(650, 650), 400.0f);
 
     randomizeFilePath();
 
-    m_inputoverlayBackground = createOsuSkinImage("inputoverlay-background", Vector2(193, 55), 34.25f);
 
-    m_inputoverlayKey = createOsuSkinImage("inputoverlay-key", Vector2(43, 46), 26.75f);
 
+    m_inputoverlayBackground = createSkinImage("inputoverlay-background", Vector2(193, 55), 34.25f);
 
+    m_inputoverlayKey = createSkinImage("inputoverlay-key", Vector2(43, 46), 26.75f);
 
 
 
     randomizeFilePath();
 
-    m_hit0 = createOsuSkinImage("hit0", Vector2(128, 128), 42);
 
+    m_hit0 = createSkinImage("hit0", Vector2(128, 128), 42);
 
     m_hit0->setAnimationFramerate(60);
 
-    m_hit50 = createOsuSkinImage("hit50", Vector2(128, 128), 42);
 
+    m_hit50 = createSkinImage("hit50", Vector2(128, 128), 42);
 
     m_hit50->setAnimationFramerate(60);
 
-    m_hit50g = createOsuSkinImage("hit50g", Vector2(128, 128), 42);
 
+    m_hit50g = createSkinImage("hit50g", Vector2(128, 128), 42);
 
     m_hit50g->setAnimationFramerate(60);
 
-    m_hit50k = createOsuSkinImage("hit50k", Vector2(128, 128), 42);
 
+    m_hit50k = createSkinImage("hit50k", Vector2(128, 128), 42);
 
     m_hit50k->setAnimationFramerate(60);
 
-    m_hit100 = createOsuSkinImage("hit100", Vector2(128, 128), 42);
 
+    m_hit100 = createSkinImage("hit100", Vector2(128, 128), 42);
 
     m_hit100->setAnimationFramerate(60);
 
-    m_hit100g = createOsuSkinImage("hit100g", Vector2(128, 128), 42);
 
+    m_hit100g = createSkinImage("hit100g", Vector2(128, 128), 42);
 
     m_hit100g->setAnimationFramerate(60);
 
-    m_hit100k = createOsuSkinImage("hit100k", Vector2(128, 128), 42);
 
+    m_hit100k = createSkinImage("hit100k", Vector2(128, 128), 42);
 
     m_hit100k->setAnimationFramerate(60);
 
-    m_hit300 = createOsuSkinImage("hit300", Vector2(128, 128), 42);
 
+    m_hit300 = createSkinImage("hit300", Vector2(128, 128), 42);
 
     m_hit300->setAnimationFramerate(60);
 
-    m_hit300g = createOsuSkinImage("hit300g", Vector2(128, 128), 42);
 
+    m_hit300g = createSkinImage("hit300g", Vector2(128, 128), 42);
 
     m_hit300g->setAnimationFramerate(60);
 
-    m_hit300k = createOsuSkinImage("hit300k", Vector2(128, 128), 42);
 
+    m_hit300k = createSkinImage("hit300k", Vector2(128, 128), 42);
 
     m_hit300k->setAnimationFramerate(60);
 
 
 
     randomizeFilePath();
@@ -686,28 +686,27 @@ void OsuSkin::load() {
 
     randomizeFilePath();
 
     checkLoadImage(&m_sliderGradient, "slidergradient", "OSU_SKIN_SLIDERGRADIENT");
 
     randomizeFilePath();
 
-    m_sliderb = createOsuSkinImage("sliderb", Vector2(128, 128), 64, false, "");
 
+    m_sliderb = createSkinImage("sliderb", Vector2(128, 128), 64, false, "");
 
     m_sliderb->setAnimationFramerate(/*45.0f*/ 50.0f);
 
     randomizeFilePath();
 
     checkLoadImage(&m_sliderScorePoint, "sliderscorepoint", "OSU_SKIN_SLIDERSCOREPOINT");
 
     randomizeFilePath();
 
-    m_sliderFollowCircle2 = createOsuSkinImage("sliderfollowcircle", Vector2(259, 259), 64);
 
+    m_sliderFollowCircle2 = createSkinImage("sliderfollowcircle", Vector2(259, 259), 64);
 
     randomizeFilePath();
 
     checkLoadImage(
 
         &m_sliderStartCircle, "sliderstartcircle", "OSU_SKIN_SLIDERSTARTCIRCLE",
 
         !m_bIsDefaultSkin);  // !m_bIsDefaultSkin ensures that default doesn't override user, in these special cases
 
-    m_sliderStartCircle2 = createOsuSkinImage("sliderstartcircle", Vector2(128, 128), 64, !m_bIsDefaultSkin);
 
+    m_sliderStartCircle2 = createSkinImage("sliderstartcircle", Vector2(128, 128), 64, !m_bIsDefaultSkin);
 
     checkLoadImage(&m_sliderStartCircleOverlay, "sliderstartcircleoverlay", "OSU_SKIN_SLIDERSTARTCIRCLEOVERLAY",
 
                    !m_bIsDefaultSkin);
 
-    m_sliderStartCircleOverlay2 =
 
-        createOsuSkinImage("sliderstartcircleoverlay", Vector2(128, 128), 64, !m_bIsDefaultSkin);
 
+    m_sliderStartCircleOverlay2 = createSkinImage("sliderstartcircleoverlay", Vector2(128, 128), 64, !m_bIsDefaultSkin);
 
     m_sliderStartCircleOverlay2->setAnimationFramerate(2);
 
     randomizeFilePath();
 
     checkLoadImage(&m_sliderEndCircle, "sliderendcircle", "OSU_SKIN_SLIDERENDCIRCLE", !m_bIsDefaultSkin);
 
-    m_sliderEndCircle2 = createOsuSkinImage("sliderendcircle", Vector2(128, 128), 64, !m_bIsDefaultSkin);
 
+    m_sliderEndCircle2 = createSkinImage("sliderendcircle", Vector2(128, 128), 64, !m_bIsDefaultSkin);
 
     checkLoadImage(&m_sliderEndCircleOverlay, "sliderendcircleoverlay", "OSU_SKIN_SLIDERENDCIRCLEOVERLAY",
 
                    !m_bIsDefaultSkin);
 
-    m_sliderEndCircleOverlay2 = createOsuSkinImage("sliderendcircleoverlay", Vector2(128, 128), 64, !m_bIsDefaultSkin);
 
+    m_sliderEndCircleOverlay2 = createSkinImage("sliderendcircleoverlay", Vector2(128, 128), 64, !m_bIsDefaultSkin);
 
     m_sliderEndCircleOverlay2->setAnimationFramerate(2);
 
 
 
     randomizeFilePath();
@@ -726,26 +725,26 @@ void OsuSkin::load() {
 
     }
 
 
 
     randomizeFilePath();
 
-    m_selectionModEasy = createOsuSkinImage("selection-mod-easy", Vector2(68, 66), 38);
 
-    m_selectionModNoFail = createOsuSkinImage("selection-mod-nofail", Vector2(68, 66), 38);
 
-    m_selectionModHalfTime = createOsuSkinImage("selection-mod-halftime", Vector2(68, 66), 38);
 
-    m_selectionModHardRock = createOsuSkinImage("selection-mod-hardrock", Vector2(68, 66), 38);
 
-    m_selectionModSuddenDeath = createOsuSkinImage("selection-mod-suddendeath", Vector2(68, 66), 38);
 
-    m_selectionModPerfect = createOsuSkinImage("selection-mod-perfect", Vector2(68, 66), 38);
 
-    m_selectionModDoubleTime = createOsuSkinImage("selection-mod-doubletime", Vector2(68, 66), 38);
 
-    m_selectionModNightCore = createOsuSkinImage("selection-mod-nightcore", Vector2(68, 66), 38);
 
-    m_selectionModDayCore = createOsuSkinImage("selection-mod-daycore", Vector2(68, 66), 38);
 
-    m_selectionModHidden = createOsuSkinImage("selection-mod-hidden", Vector2(68, 66), 38);
 
-    m_selectionModFlashlight = createOsuSkinImage("selection-mod-flashlight", Vector2(68, 66), 38);
 
-    m_selectionModRelax = createOsuSkinImage("selection-mod-relax", Vector2(68, 66), 38);
 
-    m_selectionModAutopilot = createOsuSkinImage("selection-mod-relax2", Vector2(68, 66), 38);
 
-    m_selectionModSpunOut = createOsuSkinImage("selection-mod-spunout", Vector2(68, 66), 38);
 
-    m_selectionModAutoplay = createOsuSkinImage("selection-mod-autoplay", Vector2(68, 66), 38);
 
-    m_selectionModNightmare = createOsuSkinImage("selection-mod-nightmare", Vector2(68, 66), 38);
 
-    m_selectionModTarget = createOsuSkinImage("selection-mod-target", Vector2(68, 66), 38);
 
-    m_selectionModScorev2 = createOsuSkinImage("selection-mod-scorev2", Vector2(68, 66), 38);
 
-    m_selectionModTD = createOsuSkinImage("selection-mod-touchdevice", Vector2(68, 66), 38);
 
-    m_selectionModCinema = createOsuSkinImage("selection-mod-cinema", Vector2(68, 66), 38);
 
+    m_selectionModEasy = createSkinImage("selection-mod-easy", Vector2(68, 66), 38);
 
+    m_selectionModNoFail = createSkinImage("selection-mod-nofail", Vector2(68, 66), 38);
 
+    m_selectionModHalfTime = createSkinImage("selection-mod-halftime", Vector2(68, 66), 38);
 
+    m_selectionModHardRock = createSkinImage("selection-mod-hardrock", Vector2(68, 66), 38);
 
+    m_selectionModSuddenDeath = createSkinImage("selection-mod-suddendeath", Vector2(68, 66), 38);
 
+    m_selectionModPerfect = createSkinImage("selection-mod-perfect", Vector2(68, 66), 38);
 
+    m_selectionModDoubleTime = createSkinImage("selection-mod-doubletime", Vector2(68, 66), 38);
 
+    m_selectionModNightCore = createSkinImage("selection-mod-nightcore", Vector2(68, 66), 38);
 
+    m_selectionModDayCore = createSkinImage("selection-mod-daycore", Vector2(68, 66), 38);
 
+    m_selectionModHidden = createSkinImage("selection-mod-hidden", Vector2(68, 66), 38);
 
+    m_selectionModFlashlight = createSkinImage("selection-mod-flashlight", Vector2(68, 66), 38);
 
+    m_selectionModRelax = createSkinImage("selection-mod-relax", Vector2(68, 66), 38);
 
+    m_selectionModAutopilot = createSkinImage("selection-mod-relax2", Vector2(68, 66), 38);
 
+    m_selectionModSpunOut = createSkinImage("selection-mod-spunout", Vector2(68, 66), 38);
 
+    m_selectionModAutoplay = createSkinImage("selection-mod-autoplay", Vector2(68, 66), 38);
 
+    m_selectionModNightmare = createSkinImage("selection-mod-nightmare", Vector2(68, 66), 38);
 
+    m_selectionModTarget = createSkinImage("selection-mod-target", Vector2(68, 66), 38);
 
+    m_selectionModScorev2 = createSkinImage("selection-mod-scorev2", Vector2(68, 66), 38);
 
+    m_selectionModTD = createSkinImage("selection-mod-touchdevice", Vector2(68, 66), 38);
 
+    m_selectionModCinema = createSkinImage("selection-mod-cinema", Vector2(68, 66), 38);
 
 
 
     randomizeFilePath();
 
     checkLoadImage(&m_pauseContinue, "pause-continue", "OSU_SKIN_PAUSE_CONTINUE");
@@ -765,25 +764,25 @@ void OsuSkin::load() {
 
     checkLoadImage(&m_buttonMiddle, "button-middle", "OSU_SKIN_BUTTON_MIDDLE");
 
     checkLoadImage(&m_buttonRight, "button-right", "OSU_SKIN_BUTTON_RIGHT");
 
     randomizeFilePath();
 
-    m_menuBack = createOsuSkinImage("menu-back", Vector2(225, 87), 54);
 
+    m_menuBack = createSkinImage("menu-back", Vector2(225, 87), 54);
 
     randomizeFilePath();
 
-    m_selectionMode = createOsuSkinImage("selection-mode", Vector2(90, 90),
 
-                                         38);  // NOTE: should actually be Vector2(88, 90), but slightly overscale to
 
-                                               // make most skins fit better on the bottombar blue line
 
-    m_selectionModeOver = createOsuSkinImage("selection-mode-over", Vector2(88, 90), 38);
 
-    m_selectionMods = createOsuSkinImage("selection-mods", Vector2(74, 90), 38);
 
-    m_selectionModsOver = createOsuSkinImage("selection-mods-over", Vector2(74, 90), 38);
 
-    m_selectionRandom = createOsuSkinImage("selection-random", Vector2(74, 90), 38);
 
-    m_selectionRandomOver = createOsuSkinImage("selection-random-over", Vector2(74, 90), 38);
 
-    m_selectionOptions = createOsuSkinImage("selection-options", Vector2(74, 90), 38);
 
-    m_selectionOptionsOver = createOsuSkinImage("selection-options-over", Vector2(74, 90), 38);
 
+    m_selectionMode = createSkinImage("selection-mode", Vector2(90, 90),
 
+                                      38);  // NOTE: should actually be Vector2(88, 90), but slightly overscale to
 
+                                            // make most skins fit better on the bottombar blue line
 
+    m_selectionModeOver = createSkinImage("selection-mode-over", Vector2(88, 90), 38);
 
+    m_selectionMods = createSkinImage("selection-mods", Vector2(74, 90), 38);
 
+    m_selectionModsOver = createSkinImage("selection-mods-over", Vector2(74, 90), 38);
 
+    m_selectionRandom = createSkinImage("selection-random", Vector2(74, 90), 38);
 
+    m_selectionRandomOver = createSkinImage("selection-random-over", Vector2(74, 90), 38);
 
+    m_selectionOptions = createSkinImage("selection-options", Vector2(74, 90), 38);
 
+    m_selectionOptionsOver = createSkinImage("selection-options-over", Vector2(74, 90), 38);
 
 
 
     randomizeFilePath();
 
     checkLoadImage(&m_songSelectTop, "songselect-top", "OSU_SKIN_SONGSELECT_TOP");
 
     checkLoadImage(&m_songSelectBottom, "songselect-bottom", "OSU_SKIN_SONGSELECT_BOTTOM");
 
     randomizeFilePath();
 
     checkLoadImage(&m_menuButtonBackground, "menu-button-background", "OSU_SKIN_MENU_BUTTON_BACKGROUND");
 
-    m_menuButtonBackground2 = createOsuSkinImage("menu-button-background", Vector2(699, 103), 64.0f);
 
+    m_menuButtonBackground2 = createSkinImage("menu-button-background", Vector2(699, 103), 64.0f);
 
     randomizeFilePath();
 
     checkLoadImage(&m_star, "star", "OSU_SKIN_STAR");
 
 
@@ -803,16 +802,16 @@ void OsuSkin::load() {
 
     checkLoadImage(&m_rankingX, "ranking-X", "OSU_SKIN_RANKING_X");
 
     checkLoadImage(&m_rankingXH, "ranking-XH", "OSU_SKIN_RANKING_XH");
 
 
 
-    m_rankingAsmall = createOsuSkinImage("ranking-A-small", Vector2(34, 38), 128);
 
-    m_rankingBsmall = createOsuSkinImage("ranking-B-small", Vector2(33, 38), 128);
 
-    m_rankingCsmall = createOsuSkinImage("ranking-C-small", Vector2(30, 38), 128);
 
-    m_rankingDsmall = createOsuSkinImage("ranking-D-small", Vector2(33, 38), 128);
 
-    m_rankingSsmall = createOsuSkinImage("ranking-S-small", Vector2(31, 38), 128);
 
-    m_rankingSHsmall = createOsuSkinImage("ranking-SH-small", Vector2(31, 38), 128);
 
-    m_rankingXsmall = createOsuSkinImage("ranking-X-small", Vector2(34, 40), 128);
 
-    m_rankingXHsmall = createOsuSkinImage("ranking-XH-small", Vector2(34, 41), 128);
 
+    m_rankingAsmall = createSkinImage("ranking-A-small", Vector2(34, 38), 128);
 
+    m_rankingBsmall = createSkinImage("ranking-B-small", Vector2(33, 38), 128);
 
+    m_rankingCsmall = createSkinImage("ranking-C-small", Vector2(30, 38), 128);
 
+    m_rankingDsmall = createSkinImage("ranking-D-small", Vector2(33, 38), 128);
 
+    m_rankingSsmall = createSkinImage("ranking-S-small", Vector2(31, 38), 128);
 
+    m_rankingSHsmall = createSkinImage("ranking-SH-small", Vector2(31, 38), 128);
 
+    m_rankingXsmall = createSkinImage("ranking-X-small", Vector2(34, 40), 128);
 
+    m_rankingXHsmall = createSkinImage("ranking-XH-small", Vector2(34, 41), 128);
 
 
 
-    m_rankingPerfect = createOsuSkinImage("ranking-perfect", Vector2(478, 150), 128);
 
+    m_rankingPerfect = createSkinImage("ranking-perfect", Vector2(478, 150), 128);
 
 
 
     randomizeFilePath();
 
     checkLoadImage(&m_beatmapImportSpinner, "beatmapimport-spinner", "OSU_SKIN_BEATMAP_IMPORT_SPINNER");
@@ -953,8 +952,8 @@ void OsuSkin::load() {
 
         m_defaultButtonRight = defaultButtonRight2;
 
 
 
     // print some debug info
 
-    debugLog("OsuSkin: Version %f\n", m_fVersion);
 
-    debugLog("OsuSkin: HitCircleOverlap = %i\n", m_iHitCircleOverlap);
 
+    debugLog("Skin: Version %f\n", m_fVersion);
 
+    debugLog("Skin: HitCircleOverlap = %i\n", m_iHitCircleOverlap);
 
 
 
     // delayed error notifications due to resource loading potentially blocking engine time
 
     if(!parseSkinIni1Status && parseSkinIni2Status && m_osu_skin_ref->getString() != UString("default"))
@@ -972,21 +971,21 @@ void OsuSkin::load() {
 
     }
 
 }
 
 
 
-void OsuSkin::loadBeatmapOverride(std::string filepath) {
 
-    // debugLog("OsuSkin::loadBeatmapOverride( %s )\n", filepath.c_str());
 
+void Skin::loadBeatmapOverride(std::string filepath) {
 
+    // debugLog("Skin::loadBeatmapOverride( %s )\n", filepath.c_str());
 
     //  TODO: beatmap skin support
 
 }
 
 
 
-void OsuSkin::reloadSounds() {
 
+void Skin::reloadSounds() {
 
     for(int i = 0; i < m_sounds.size(); i++) {
 
         m_sounds[i]->reload();
 
     }
 
 }
 
 
 
-bool OsuSkin::parseSkinINI(std::string filepath) {
 
+bool Skin::parseSkinINI(std::string filepath) {
 
     File file(filepath);
 
     if(!file.canRead()) {
 
-        debugLog("OsuSkin Error: Couldn't load %s\n", filepath.c_str());
 
+        debugLog("Skin Error: Couldn't load %s\n", filepath.c_str());
 
         return false;
 
     }
 
 
@@ -1110,18 +1109,18 @@ bool OsuSkin::parseSkinINI(std::string filepath) {
 
     return true;
 
 }
 
 
 
-void OsuSkin::onIgnoreBeatmapSampleVolumeChange(UString oldValue, UString newValue) { resetSampleVolume(); }
 
+void Skin::onIgnoreBeatmapSampleVolumeChange(UString oldValue, UString newValue) { resetSampleVolume(); }
 
 
 
-void OsuSkin::setSampleSet(int sampleSet) {
 
+void Skin::setSampleSet(int sampleSet) {
 
     if(m_iSampleSet == sampleSet) return;
 
 
 
     /// debugLog("sample set = %i\n", sampleSet);
 
     m_iSampleSet = sampleSet;
 
 }
 
 
 
-void OsuSkin::resetSampleVolume() { setSampleVolume(clamp<float>((float)m_iSampleVolume / 100.0f, 0.0f, 1.0f), true); }
 
+void Skin::resetSampleVolume() { setSampleVolume(clamp<float>((float)m_iSampleVolume / 100.0f, 0.0f, 1.0f), true); }
 
 
 
-void OsuSkin::setSampleVolume(float volume, bool force) {
 
+void Skin::setSampleVolume(float volume, bool force) {
 
     auto osu_volume_effects = convar->getConVarByName("osu_volume_effects");
 
     if(osu_ignore_beatmap_sample_volume.getBool() && (int)(osu_volume_effects->getFloat() * 100.0f) == m_iSampleVolume)
 
         return;
@@ -1138,7 +1137,7 @@ void OsuSkin::setSampleVolume(float volume, bool force) {
 
     }
 
 }
 
 
 
-Color OsuSkin::getComboColorForCounter(int i, int offset) {
 
+Color Skin::getComboColorForCounter(int i, int offset) {
 
     i += osu_skin_color_index_add.getInt();
 
     i = std::max(i, 0);
 
 
@@ -1150,14 +1149,14 @@ Color OsuSkin::getComboColorForCounter(int i, int offset) {
 
         return COLOR(255, 0, 255, 0);
 
 }
 
 
 
-void OsuSkin::setBeatmapComboColors(std::vector<Color> colors) { m_beatmapComboColors = colors; }
 
+void Skin::setBeatmapComboColors(std::vector<Color> colors) { m_beatmapComboColors = colors; }
 
 
 
-void OsuSkin::playHitCircleSound(int sampleType, float pan) {
 
+void Skin::playHitCircleSound(int sampleType, float pan) {
 
     if(m_iSampleVolume <= 0 || (m_osu->getInstanceID() > 0 && m_osu->getInstanceID() != osu2_sound_source_id.getInt()))
 
         return;
 
 
 
     if(!osu_sound_panning.getBool() || (m_osu_mod_fposu_ref->getBool() && !osu_mod_fposu_sound_panning.getBool()) ||
 
-       (OsuGameRules::osu_mod_fps.getBool() && !osu_mod_fps_sound_panning.getBool()))
 
+       (GameRules::osu_mod_fps.getBool() && !osu_mod_fps_sound_panning.getBool()))
 
         pan = 0.0f;
 
     else
 
         pan *= osu_sound_panning_multiplier.getFloat();
@@ -1190,12 +1189,12 @@ void OsuSkin::playHitCircleSound(int sampleType, float pan) {
 
     }
 
 }
 
 
 
-void OsuSkin::playSliderTickSound(float pan) {
 
+void Skin::playSliderTickSound(float pan) {
 
     if(m_iSampleVolume <= 0 || (m_osu->getInstanceID() > 0 && m_osu->getInstanceID() != osu2_sound_source_id.getInt()))
 
         return;
 
 
 
     if(!osu_sound_panning.getBool() || (m_osu_mod_fposu_ref->getBool() && !osu_mod_fposu_sound_panning.getBool()) ||
 
-       (OsuGameRules::osu_mod_fps.getBool() && !osu_mod_fps_sound_panning.getBool()))
 
+       (GameRules::osu_mod_fps.getBool() && !osu_mod_fps_sound_panning.getBool()))
 
         pan = 0.0f;
 
     else
 
         pan *= osu_sound_panning_multiplier.getFloat();
@@ -1213,11 +1212,11 @@ void OsuSkin::playSliderTickSound(float pan) {
 
     }
 
 }
 
 
 
-void OsuSkin::playSliderSlideSound(float pan) {
 
+void Skin::playSliderSlideSound(float pan) {
 
     if((m_osu->getInstanceID() > 0 && m_osu->getInstanceID() != osu2_sound_source_id.getInt())) return;
 
 
 
     if(!osu_sound_panning.getBool() || (m_osu_mod_fposu_ref->getBool() && !osu_mod_fposu_sound_panning.getBool()) ||
 
-       (OsuGameRules::osu_mod_fps.getBool() && !osu_mod_fps_sound_panning.getBool()))
 
+       (GameRules::osu_mod_fps.getBool() && !osu_mod_fps_sound_panning.getBool()))
 
         pan = 0.0f;
 
     else
 
         pan *= osu_sound_panning_multiplier.getFloat();
@@ -1253,20 +1252,20 @@ void OsuSkin::playSliderSlideSound(float pan) {
 
     }
 
 }
 
 
 
-void OsuSkin::playSpinnerSpinSound() {
 
+void Skin::playSpinnerSpinSound() {
 
     if((m_osu->getInstanceID() > 0 && m_osu->getInstanceID() != osu2_sound_source_id.getInt())) return;
 
 
 
     if(!m_spinnerSpinSound->isPlaying()) engine->getSound()->play(m_spinnerSpinSound);
 
 }
 
 
 
-void OsuSkin::playSpinnerBonusSound() {
 
+void Skin::playSpinnerBonusSound() {
 
     if(m_iSampleVolume <= 0 || (m_osu->getInstanceID() > 0 && m_osu->getInstanceID() != osu2_sound_source_id.getInt()))
 
         return;
 
 
 
     engine->getSound()->play(m_spinnerBonus);
 
 }
 
 
 
-void OsuSkin::stopSliderSlideSound(int sampleSet) {
 
+void Skin::stopSliderSlideSound(int sampleSet) {
 
     if((sampleSet == -2 || sampleSet == 3) && m_drumSliderSlide->isPlaying())
 
         engine->getSound()->stop(m_drumSliderSlide);
 
     if((sampleSet == -2 || sampleSet == 2) && m_softSliderSlide->isPlaying())
@@ -1275,19 +1274,19 @@ void OsuSkin::stopSliderSlideSound(int sampleSet) {
 
         engine->getSound()->stop(m_normalSliderSlide);
 
 }
 
 
 
-void OsuSkin::stopSpinnerSpinSound() {
 
+void Skin::stopSpinnerSpinSound() {
 
     if(m_spinnerSpinSound->isPlaying()) engine->getSound()->stop(m_spinnerSpinSound);
 
 }
 
 
 
-void OsuSkin::randomizeFilePath() {
 
+void Skin::randomizeFilePath() {
 
     if(m_bIsRandomElements && filepathsForRandomSkin.size() > 0)
 
         m_sFilePath = filepathsForRandomSkin[rand() % filepathsForRandomSkin.size()];
 
 }
 
 
 
-OsuSkinImage *OsuSkin::createOsuSkinImage(std::string skinElementName, Vector2 baseSizeForScaling2x, float osuSize,
 
-                                          bool ignoreDefaultSkin, std::string animationSeparator) {
 
-    OsuSkinImage *skinImage =
 
-        new OsuSkinImage(this, skinElementName, baseSizeForScaling2x, osuSize, animationSeparator, ignoreDefaultSkin);
 
+SkinImage *Skin::createSkinImage(std::string skinElementName, Vector2 baseSizeForScaling2x, float osuSize,
 
+                                 bool ignoreDefaultSkin, std::string animationSeparator) {
 
+    SkinImage *skinImage =
 
+        new SkinImage(this, skinElementName, baseSizeForScaling2x, osuSize, animationSeparator, ignoreDefaultSkin);
 
     m_images.push_back(skinImage);
 
 
 
     const std::vector<std::string> &filepathsForExport = skinImage->getFilepathsForExport();
@@ -1296,8 +1295,8 @@ OsuSkinImage *OsuSkin::createOsuSkinImage(std::string skinElementName, Vector2 b
 
     return skinImage;
 
 }
 
 
 
-void OsuSkin::checkLoadImage(Image **addressOfPointer, std::string skinElementName, std::string resourceName,
 
-                             bool ignoreDefaultSkin, std::string fileExtension, bool forceLoadMipmaps) {
 
+void Skin::checkLoadImage(Image **addressOfPointer, std::string skinElementName, std::string resourceName,
 
+                          bool ignoreDefaultSkin, std::string fileExtension, bool forceLoadMipmaps) {
 
     if(*addressOfPointer != m_missingTexture) return;  // we are already loaded
 
 
 
     // NOTE: only the default skin is loaded with a resource name (it must never be unloaded by other instances), and it
@@ -1426,8 +1425,8 @@ void OsuSkin::checkLoadImage(Image **addressOfPointer, std::string skinElementNa
 
     }
 
 }
 
 
 
-void OsuSkin::checkLoadSound(Sound **addressOfPointer, std::string skinElementName, std::string resourceName,
 
-                             bool isOverlayable, bool isSample, bool loop, float hardcodedVolumeMultiplier) {
 
+void Skin::checkLoadSound(Sound **addressOfPointer, std::string skinElementName, std::string resourceName,
 
+                          bool isOverlayable, bool isSample, bool loop, float hardcodedVolumeMultiplier) {
 
     if(*addressOfPointer != NULL) return;  // we are already loaded
 
 
 
     // NOTE: only the default skin is loaded with a resource name (it must never be unloaded by other instances), and it
@@ -1475,7 +1474,7 @@ void OsuSkin::checkLoadSound(Sound **addressOfPointer, std::string skinElementNa
 
 
 
     Sound *sound = *addressOfPointer;
 
     if(sound == nullptr) {
 
-        debugLog("OsuSkin Warning: NULL sound %s!\n", skinElementName.c_str());
 
+        debugLog("Skin Warning: NULL sound %s!\n", skinElementName.c_str());
 
         return;
 
     }
 
 
@@ -1499,7 +1498,7 @@ void OsuSkin::checkLoadSound(Sound **addressOfPointer, std::string skinElementNa
 
     m_filepathsForExport.push_back(sound->getFilePath());
 
 }
 
 
 
-bool OsuSkin::compareFilenameWithSkinElementName(std::string filename, std::string skinElementName) {
 
+bool Skin::compareFilenameWithSkinElementName(std::string filename, std::string skinElementName) {
 
     if(filename.length() == 0 || skinElementName.length() == 0) return false;
 
     return filename.substr(0, filename.find_last_of('.')) == skinElementName;
 
 }
--- a/src/App/Osu/OsuSkin.h
+++ b/src/App/Osu/OsuSkin.h
@@ -16,17 +16,17 @@ class Resource;
 
 class ConVar;
 
 
 
 class Osu;
 
-class OsuSkinImage;
 
+class SkinImage;
 
 
 
-class OsuSkin {
 
+class Skin {
 
    public:
 
     static const char *OSUSKIN_DEFAULT_SKIN_PATH;
 
 
 
     static ConVar *m_osu_skin_async;
 
     static ConVar *m_osu_skin_hd;
 
 
 
-    OsuSkin(Osu *osu, UString name, std::string filepath, bool isDefaultSkin = false);
 
-    virtual ~OsuSkin();
 
+    Skin(Osu *osu, UString name, std::string filepath, bool isDefaultSkin = false);
 
+    virtual ~Skin();
 
 
 
     void update();
 
 
@@ -65,10 +65,10 @@ class OsuSkin {
 
     inline Image *getMissingTexture() { return m_missingTexture; }
 
 
 
     inline Image *getHitCircle() { return m_hitCircle; }
 
-    inline OsuSkinImage *getHitCircleOverlay2() { return m_hitCircleOverlay2; }
 
+    inline SkinImage *getHitCircleOverlay2() { return m_hitCircleOverlay2; }
 
     inline Image *getApproachCircle() { return m_approachCircle; }
 
     inline Image *getReverseArrow() { return m_reverseArrow; }
 
-    inline OsuSkinImage *getFollowPoint2() { return m_followPoint2; }
 
+    inline SkinImage *getFollowPoint2() { return m_followPoint2; }
 
 
 
     inline Image *getDefault0() { return m_default0; }
 
     inline Image *getDefault1() { return m_default1; }
@@ -107,48 +107,48 @@ class OsuSkin {
 
     inline Image *getCombo9() { return m_combo9; }
 
     inline Image *getComboX() { return m_comboX; }
 
 
 
-    inline OsuSkinImage *getPlaySkip() { return m_playSkip; }
 
+    inline SkinImage *getPlaySkip() { return m_playSkip; }
 
     inline Image *getPlayWarningArrow() { return m_playWarningArrow; }
 
-    inline OsuSkinImage *getPlayWarningArrow2() { return m_playWarningArrow2; }
 
+    inline SkinImage *getPlayWarningArrow2() { return m_playWarningArrow2; }
 
     inline Image *getCircularmetre() { return m_circularmetre; }
 
-    inline OsuSkinImage *getScorebarBg() { return m_scorebarBg; }
 
-    inline OsuSkinImage *getScorebarColour() { return m_scorebarColour; }
 
-    inline OsuSkinImage *getScorebarMarker() { return m_scorebarMarker; }
 
-    inline OsuSkinImage *getScorebarKi() { return m_scorebarKi; }
 
-    inline OsuSkinImage *getScorebarKiDanger() { return m_scorebarKiDanger; }
 
-    inline OsuSkinImage *getScorebarKiDanger2() { return m_scorebarKiDanger2; }
 
-    inline OsuSkinImage *getSectionPassImage() { return m_sectionPassImage; }
 
-    inline OsuSkinImage *getSectionFailImage() { return m_sectionFailImage; }
 
-    inline OsuSkinImage *getInputoverlayBackground() { return m_inputoverlayBackground; }
 
-    inline OsuSkinImage *getInputoverlayKey() { return m_inputoverlayKey; }
 
-
 
-    inline OsuSkinImage *getHit0() { return m_hit0; }
 
-    inline OsuSkinImage *getHit50() { return m_hit50; }
 
-    inline OsuSkinImage *getHit50g() { return m_hit50g; }
 
-    inline OsuSkinImage *getHit50k() { return m_hit50k; }
 
-    inline OsuSkinImage *getHit100() { return m_hit100; }
 
-    inline OsuSkinImage *getHit100g() { return m_hit100g; }
 
-    inline OsuSkinImage *getHit100k() { return m_hit100k; }
 
-    inline OsuSkinImage *getHit300() { return m_hit300; }
 
-    inline OsuSkinImage *getHit300g() { return m_hit300g; }
 
-    inline OsuSkinImage *getHit300k() { return m_hit300k; }
 
+    inline SkinImage *getScorebarBg() { return m_scorebarBg; }
 
+    inline SkinImage *getScorebarColour() { return m_scorebarColour; }
 
+    inline SkinImage *getScorebarMarker() { return m_scorebarMarker; }
 
+    inline SkinImage *getScorebarKi() { return m_scorebarKi; }
 
+    inline SkinImage *getScorebarKiDanger() { return m_scorebarKiDanger; }
 
+    inline SkinImage *getScorebarKiDanger2() { return m_scorebarKiDanger2; }
 
+    inline SkinImage *getSectionPassImage() { return m_sectionPassImage; }
 
+    inline SkinImage *getSectionFailImage() { return m_sectionFailImage; }
 
+    inline SkinImage *getInputoverlayBackground() { return m_inputoverlayBackground; }
 
+    inline SkinImage *getInputoverlayKey() { return m_inputoverlayKey; }
 
+
 
+    inline SkinImage *getHit0() { return m_hit0; }
 
+    inline SkinImage *getHit50() { return m_hit50; }
 
+    inline SkinImage *getHit50g() { return m_hit50g; }
 
+    inline SkinImage *getHit50k() { return m_hit50k; }
 
+    inline SkinImage *getHit100() { return m_hit100; }
 
+    inline SkinImage *getHit100g() { return m_hit100g; }
 
+    inline SkinImage *getHit100k() { return m_hit100k; }
 
+    inline SkinImage *getHit300() { return m_hit300; }
 
+    inline SkinImage *getHit300g() { return m_hit300g; }
 
+    inline SkinImage *getHit300k() { return m_hit300k; }
 
 
 
     inline Image *getParticle50() { return m_particle50; }
 
     inline Image *getParticle100() { return m_particle100; }
 
     inline Image *getParticle300() { return m_particle300; }
 
 
 
     inline Image *getSliderGradient() { return m_sliderGradient; }
 
-    inline OsuSkinImage *getSliderb() { return m_sliderb; }
 
-    inline OsuSkinImage *getSliderFollowCircle2() { return m_sliderFollowCircle2; }
 
+    inline SkinImage *getSliderb() { return m_sliderb; }
 
+    inline SkinImage *getSliderFollowCircle2() { return m_sliderFollowCircle2; }
 
     inline Image *getSliderScorePoint() { return m_sliderScorePoint; }
 
     inline Image *getSliderStartCircle() { return m_sliderStartCircle; }
 
-    inline OsuSkinImage *getSliderStartCircle2() { return m_sliderStartCircle2; }
 
+    inline SkinImage *getSliderStartCircle2() { return m_sliderStartCircle2; }
 
     inline Image *getSliderStartCircleOverlay() { return m_sliderStartCircleOverlay; }
 
-    inline OsuSkinImage *getSliderStartCircleOverlay2() { return m_sliderStartCircleOverlay2; }
 
+    inline SkinImage *getSliderStartCircleOverlay2() { return m_sliderStartCircleOverlay2; }
 
     inline Image *getSliderEndCircle() { return m_sliderEndCircle; }
 
-    inline OsuSkinImage *getSliderEndCircle2() { return m_sliderEndCircle2; }
 
+    inline SkinImage *getSliderEndCircle2() { return m_sliderEndCircle2; }
 
     inline Image *getSliderEndCircleOverlay() { return m_sliderEndCircleOverlay; }
 
-    inline OsuSkinImage *getSliderEndCircleOverlay2() { return m_sliderEndCircleOverlay2; }
 
+    inline SkinImage *getSliderEndCircleOverlay2() { return m_sliderEndCircleOverlay2; }
 
 
 
     inline Image *getSpinnerBackground() { return m_spinnerBackground; }
 
     inline Image *getSpinnerCircle() { return m_spinnerCircle; }
@@ -166,25 +166,25 @@ class OsuSkin {
 
     inline Image *getCursorTrail() { return m_cursorTrail; }
 
     inline Image *getCursorRipple() { return m_cursorRipple; }
 
 
 
-    inline OsuSkinImage *getSelectionModEasy() { return m_selectionModEasy; }
 
-    inline OsuSkinImage *getSelectionModNoFail() { return m_selectionModNoFail; }
 
-    inline OsuSkinImage *getSelectionModHalfTime() { return m_selectionModHalfTime; }
 
-    inline OsuSkinImage *getSelectionModDayCore() { return m_selectionModDayCore; }
 
-    inline OsuSkinImage *getSelectionModHardRock() { return m_selectionModHardRock; }
 
-    inline OsuSkinImage *getSelectionModSuddenDeath() { return m_selectionModSuddenDeath; }
 
-    inline OsuSkinImage *getSelectionModPerfect() { return m_selectionModPerfect; }
 
-    inline OsuSkinImage *getSelectionModDoubleTime() { return m_selectionModDoubleTime; }
 
-    inline OsuSkinImage *getSelectionModNightCore() { return m_selectionModNightCore; }
 
-    inline OsuSkinImage *getSelectionModHidden() { return m_selectionModHidden; }
 
-    inline OsuSkinImage *getSelectionModFlashlight() { return m_selectionModFlashlight; }
 
-    inline OsuSkinImage *getSelectionModRelax() { return m_selectionModRelax; }
 
-    inline OsuSkinImage *getSelectionModAutopilot() { return m_selectionModAutopilot; }
 
-    inline OsuSkinImage *getSelectionModSpunOut() { return m_selectionModSpunOut; }
 
-    inline OsuSkinImage *getSelectionModAutoplay() { return m_selectionModAutoplay; }
 
-    inline OsuSkinImage *getSelectionModNightmare() { return m_selectionModNightmare; }
 
-    inline OsuSkinImage *getSelectionModTarget() { return m_selectionModTarget; }
 
-    inline OsuSkinImage *getSelectionModScorev2() { return m_selectionModScorev2; }
 
-    inline OsuSkinImage *getSelectionModTD() { return m_selectionModTD; }
 
+    inline SkinImage *getSelectionModEasy() { return m_selectionModEasy; }
 
+    inline SkinImage *getSelectionModNoFail() { return m_selectionModNoFail; }
 
+    inline SkinImage *getSelectionModHalfTime() { return m_selectionModHalfTime; }
 
+    inline SkinImage *getSelectionModDayCore() { return m_selectionModDayCore; }
 
+    inline SkinImage *getSelectionModHardRock() { return m_selectionModHardRock; }
 
+    inline SkinImage *getSelectionModSuddenDeath() { return m_selectionModSuddenDeath; }
 
+    inline SkinImage *getSelectionModPerfect() { return m_selectionModPerfect; }
 
+    inline SkinImage *getSelectionModDoubleTime() { return m_selectionModDoubleTime; }
 
+    inline SkinImage *getSelectionModNightCore() { return m_selectionModNightCore; }
 
+    inline SkinImage *getSelectionModHidden() { return m_selectionModHidden; }
 
+    inline SkinImage *getSelectionModFlashlight() { return m_selectionModFlashlight; }
 
+    inline SkinImage *getSelectionModRelax() { return m_selectionModRelax; }
 
+    inline SkinImage *getSelectionModAutopilot() { return m_selectionModAutopilot; }
 
+    inline SkinImage *getSelectionModSpunOut() { return m_selectionModSpunOut; }
 
+    inline SkinImage *getSelectionModAutoplay() { return m_selectionModAutoplay; }
 
+    inline SkinImage *getSelectionModNightmare() { return m_selectionModNightmare; }
 
+    inline SkinImage *getSelectionModTarget() { return m_selectionModTarget; }
 
+    inline SkinImage *getSelectionModScorev2() { return m_selectionModScorev2; }
 
+    inline SkinImage *getSelectionModTD() { return m_selectionModTD; }
 
 
 
     inline Image *getPauseContinue() { return m_pauseContinue; }
 
     inline Image *getPauseRetry() { return m_pauseRetry; }
@@ -199,20 +199,20 @@ class OsuSkin {
 
     inline Image *getDefaultButtonLeft() { return m_defaultButtonLeft; }
 
     inline Image *getDefaultButtonMiddle() { return m_defaultButtonMiddle; }
 
     inline Image *getDefaultButtonRight() { return m_defaultButtonRight; }
 
-    inline OsuSkinImage *getMenuBack2() { return m_menuBack; }
 
-    inline OsuSkinImage *getSelectionMode() { return m_selectionMode; }
 
-    inline OsuSkinImage *getSelectionModeOver() { return m_selectionModeOver; }
 
-    inline OsuSkinImage *getSelectionMods() { return m_selectionMods; }
 
-    inline OsuSkinImage *getSelectionModsOver() { return m_selectionModsOver; }
 
-    inline OsuSkinImage *getSelectionRandom() { return m_selectionRandom; }
 
-    inline OsuSkinImage *getSelectionRandomOver() { return m_selectionRandomOver; }
 
-    inline OsuSkinImage *getSelectionOptions() { return m_selectionOptions; }
 
-    inline OsuSkinImage *getSelectionOptionsOver() { return m_selectionOptionsOver; }
 
+    inline SkinImage *getMenuBack2() { return m_menuBack; }
 
+    inline SkinImage *getSelectionMode() { return m_selectionMode; }
 
+    inline SkinImage *getSelectionModeOver() { return m_selectionModeOver; }
 
+    inline SkinImage *getSelectionMods() { return m_selectionMods; }
 
+    inline SkinImage *getSelectionModsOver() { return m_selectionModsOver; }
 
+    inline SkinImage *getSelectionRandom() { return m_selectionRandom; }
 
+    inline SkinImage *getSelectionRandomOver() { return m_selectionRandomOver; }
 
+    inline SkinImage *getSelectionOptions() { return m_selectionOptions; }
 
+    inline SkinImage *getSelectionOptionsOver() { return m_selectionOptionsOver; }
 
 
 
     inline Image *getSongSelectTop() { return m_songSelectTop; }
 
     inline Image *getSongSelectBottom() { return m_songSelectBottom; }
 
     inline Image *getMenuButtonBackground() { return m_menuButtonBackground; }
 
-    inline OsuSkinImage *getMenuButtonBackground2() { return m_menuButtonBackground2; }
 
+    inline SkinImage *getMenuButtonBackground2() { return m_menuButtonBackground2; }
 
     inline Image *getStar() { return m_star; }
 
     inline Image *getRankingPanel() { return m_rankingPanel; }
 
     inline Image *getRankingGraph() { return m_rankingGraph; }
@@ -227,15 +227,15 @@ class OsuSkin {
 
     inline Image *getRankingSH() { return m_rankingSH; }
 
     inline Image *getRankingX() { return m_rankingX; }
 
     inline Image *getRankingXH() { return m_rankingXH; }
 
-    inline OsuSkinImage *getRankingAsmall() { return m_rankingAsmall; }
 
-    inline OsuSkinImage *getRankingBsmall() { return m_rankingBsmall; }
 
-    inline OsuSkinImage *getRankingCsmall() { return m_rankingCsmall; }
 
-    inline OsuSkinImage *getRankingDsmall() { return m_rankingDsmall; }
 
-    inline OsuSkinImage *getRankingSsmall() { return m_rankingSsmall; }
 
-    inline OsuSkinImage *getRankingSHsmall() { return m_rankingSHsmall; }
 
-    inline OsuSkinImage *getRankingXsmall() { return m_rankingXsmall; }
 
-    inline OsuSkinImage *getRankingXHsmall() { return m_rankingXHsmall; }
 
-    inline OsuSkinImage *getRankingPerfect() { return m_rankingPerfect; }
 
+    inline SkinImage *getRankingAsmall() { return m_rankingAsmall; }
 
+    inline SkinImage *getRankingBsmall() { return m_rankingBsmall; }
 
+    inline SkinImage *getRankingCsmall() { return m_rankingCsmall; }
 
+    inline SkinImage *getRankingDsmall() { return m_rankingDsmall; }
 
+    inline SkinImage *getRankingSsmall() { return m_rankingSsmall; }
 
+    inline SkinImage *getRankingSHsmall() { return m_rankingSHsmall; }
 
+    inline SkinImage *getRankingXsmall() { return m_rankingXsmall; }
 
+    inline SkinImage *getRankingXHsmall() { return m_rankingXHsmall; }
 
+    inline SkinImage *getRankingPerfect() { return m_rankingPerfect; }
 
 
 
     inline Image *getBeatmapImportSpinner() { return m_beatmapImportSpinner; }
 
     inline Image *getLoadingSpinner() { return m_loadingSpinner; }
@@ -353,8 +353,8 @@ class OsuSkin {
 
 
 
     bool compareFilenameWithSkinElementName(std::string filename, std::string skinElementName);
 
 
 
-    OsuSkinImage *createOsuSkinImage(std::string skinElementName, Vector2 baseSizeForScaling2x, float osuSize,
 
-                                     bool ignoreDefaultSkin = false, std::string animationSeparator = "-");
 
+    SkinImage *createSkinImage(std::string skinElementName, Vector2 baseSizeForScaling2x, float osuSize,
 
+                               bool ignoreDefaultSkin = false, std::string animationSeparator = "-");
 
     void checkLoadImage(Image **addressOfPointer, std::string skinElementName, std::string resourceName,
 
                         bool ignoreDefaultSkin = false, std::string fileExtension = "png",
 
                         bool forceLoadMipmaps = false);
@@ -376,14 +376,14 @@ class OsuSkin {
 
     std::vector<Resource *> m_resources;
 
     std::vector<Sound *> m_sounds;
 
     std::vector<SOUND_SAMPLE> m_soundSamples;
 
-    std::vector<OsuSkinImage *> m_images;
 
+    std::vector<SkinImage *> m_images;
 
 
 
     // images
 
     Image *m_hitCircle;
 
-    OsuSkinImage *m_hitCircleOverlay2;
 
+    SkinImage *m_hitCircleOverlay2;
 
     Image *m_approachCircle;
 
     Image *m_reverseArrow;
 
-    OsuSkinImage *m_followPoint2;
 
+    SkinImage *m_followPoint2;
 
 
 
     Image *m_default0;
 
     Image *m_default1;
@@ -422,48 +422,48 @@ class OsuSkin {
 
     Image *m_combo9;
 
     Image *m_comboX;
 
 
 
-    OsuSkinImage *m_playSkip;
 
+    SkinImage *m_playSkip;
 
     Image *m_playWarningArrow;
 
-    OsuSkinImage *m_playWarningArrow2;
 
+    SkinImage *m_playWarningArrow2;
 
     Image *m_circularmetre;
 
-    OsuSkinImage *m_scorebarBg;
 
-    OsuSkinImage *m_scorebarColour;
 
-    OsuSkinImage *m_scorebarMarker;
 
-    OsuSkinImage *m_scorebarKi;
 
-    OsuSkinImage *m_scorebarKiDanger;
 
-    OsuSkinImage *m_scorebarKiDanger2;
 
-    OsuSkinImage *m_sectionPassImage;
 
-    OsuSkinImage *m_sectionFailImage;
 
-    OsuSkinImage *m_inputoverlayBackground;
 
-    OsuSkinImage *m_inputoverlayKey;
 
-
 
-    OsuSkinImage *m_hit0;
 
-    OsuSkinImage *m_hit50;
 
-    OsuSkinImage *m_hit50g;
 
-    OsuSkinImage *m_hit50k;
 
-    OsuSkinImage *m_hit100;
 
-    OsuSkinImage *m_hit100g;
 
-    OsuSkinImage *m_hit100k;
 
-    OsuSkinImage *m_hit300;
 
-    OsuSkinImage *m_hit300g;
 
-    OsuSkinImage *m_hit300k;
 
+    SkinImage *m_scorebarBg;
 
+    SkinImage *m_scorebarColour;
 
+    SkinImage *m_scorebarMarker;
 
+    SkinImage *m_scorebarKi;
 
+    SkinImage *m_scorebarKiDanger;
 
+    SkinImage *m_scorebarKiDanger2;
 
+    SkinImage *m_sectionPassImage;
 
+    SkinImage *m_sectionFailImage;
 
+    SkinImage *m_inputoverlayBackground;
 
+    SkinImage *m_inputoverlayKey;
 
+
 
+    SkinImage *m_hit0;
 
+    SkinImage *m_hit50;
 
+    SkinImage *m_hit50g;
 
+    SkinImage *m_hit50k;
 
+    SkinImage *m_hit100;
 
+    SkinImage *m_hit100g;
 
+    SkinImage *m_hit100k;
 
+    SkinImage *m_hit300;
 
+    SkinImage *m_hit300g;
 
+    SkinImage *m_hit300k;
 
 
 
     Image *m_particle50;
 
     Image *m_particle100;
 
     Image *m_particle300;
 
 
 
     Image *m_sliderGradient;
 
-    OsuSkinImage *m_sliderb;
 
-    OsuSkinImage *m_sliderFollowCircle2;
 
+    SkinImage *m_sliderb;
 
+    SkinImage *m_sliderFollowCircle2;
 
     Image *m_sliderScorePoint;
 
     Image *m_sliderStartCircle;
 
-    OsuSkinImage *m_sliderStartCircle2;
 
+    SkinImage *m_sliderStartCircle2;
 
     Image *m_sliderStartCircleOverlay;
 
-    OsuSkinImage *m_sliderStartCircleOverlay2;
 
+    SkinImage *m_sliderStartCircleOverlay2;
 
     Image *m_sliderEndCircle;
 
-    OsuSkinImage *m_sliderEndCircle2;
 
+    SkinImage *m_sliderEndCircle2;
 
     Image *m_sliderEndCircleOverlay;
 
-    OsuSkinImage *m_sliderEndCircleOverlay2;
 
+    SkinImage *m_sliderEndCircleOverlay2;
 
 
 
     Image *m_spinnerBackground;
 
     Image *m_spinnerCircle;
@@ -481,26 +481,26 @@ class OsuSkin {
 
     Image *m_cursorTrail;
 
     Image *m_cursorRipple;
 
 
 
-    OsuSkinImage *m_selectionModEasy;
 
-    OsuSkinImage *m_selectionModNoFail;
 
-    OsuSkinImage *m_selectionModHalfTime;
 
-    OsuSkinImage *m_selectionModDayCore;
 
-    OsuSkinImage *m_selectionModHardRock;
 
-    OsuSkinImage *m_selectionModSuddenDeath;
 
-    OsuSkinImage *m_selectionModPerfect;
 
-    OsuSkinImage *m_selectionModDoubleTime;
 
-    OsuSkinImage *m_selectionModNightCore;
 
-    OsuSkinImage *m_selectionModHidden;
 
-    OsuSkinImage *m_selectionModFlashlight;
 
-    OsuSkinImage *m_selectionModRelax;
 
-    OsuSkinImage *m_selectionModAutopilot;
 
-    OsuSkinImage *m_selectionModSpunOut;
 
-    OsuSkinImage *m_selectionModAutoplay;
 
-    OsuSkinImage *m_selectionModNightmare;
 
-    OsuSkinImage *m_selectionModTarget;
 
-    OsuSkinImage *m_selectionModScorev2;
 
-    OsuSkinImage *m_selectionModTD;
 
-    OsuSkinImage *m_selectionModCinema;
 
+    SkinImage *m_selectionModEasy;
 
+    SkinImage *m_selectionModNoFail;
 
+    SkinImage *m_selectionModHalfTime;
 
+    SkinImage *m_selectionModDayCore;
 
+    SkinImage *m_selectionModHardRock;
 
+    SkinImage *m_selectionModSuddenDeath;
 
+    SkinImage *m_selectionModPerfect;
 
+    SkinImage *m_selectionModDoubleTime;
 
+    SkinImage *m_selectionModNightCore;
 
+    SkinImage *m_selectionModHidden;
 
+    SkinImage *m_selectionModFlashlight;
 
+    SkinImage *m_selectionModRelax;
 
+    SkinImage *m_selectionModAutopilot;
 
+    SkinImage *m_selectionModSpunOut;
 
+    SkinImage *m_selectionModAutoplay;
 
+    SkinImage *m_selectionModNightmare;
 
+    SkinImage *m_selectionModTarget;
 
+    SkinImage *m_selectionModScorev2;
 
+    SkinImage *m_selectionModTD;
 
+    SkinImage *m_selectionModCinema;
 
 
 
     Image *m_pauseContinue;
 
     Image *m_pauseReplay;
@@ -516,20 +516,20 @@ class OsuSkin {
 
     Image *m_defaultButtonLeft;
 
     Image *m_defaultButtonMiddle;
 
     Image *m_defaultButtonRight;
 
-    OsuSkinImage *m_menuBack;
 
-    OsuSkinImage *m_selectionMode;
 
-    OsuSkinImage *m_selectionModeOver;
 
-    OsuSkinImage *m_selectionMods;
 
-    OsuSkinImage *m_selectionModsOver;
 
-    OsuSkinImage *m_selectionRandom;
 
-    OsuSkinImage *m_selectionRandomOver;
 
-    OsuSkinImage *m_selectionOptions;
 
-    OsuSkinImage *m_selectionOptionsOver;
 
+    SkinImage *m_menuBack;
 
+    SkinImage *m_selectionMode;
 
+    SkinImage *m_selectionModeOver;
 
+    SkinImage *m_selectionMods;
 
+    SkinImage *m_selectionModsOver;
 
+    SkinImage *m_selectionRandom;
 
+    SkinImage *m_selectionRandomOver;
 
+    SkinImage *m_selectionOptions;
 
+    SkinImage *m_selectionOptionsOver;
 
 
 
     Image *m_songSelectTop;
 
     Image *m_songSelectBottom;
 
     Image *m_menuButtonBackground;
 
-    OsuSkinImage *m_menuButtonBackground2;
 
+    SkinImage *m_menuButtonBackground2;
 
     Image *m_star;
 
     Image *m_rankingPanel;
 
     Image *m_rankingGraph;
@@ -544,15 +544,15 @@ class OsuSkin {
 
     Image *m_rankingSH;
 
     Image *m_rankingX;
 
     Image *m_rankingXH;
 
-    OsuSkinImage *m_rankingAsmall;
 
-    OsuSkinImage *m_rankingBsmall;
 
-    OsuSkinImage *m_rankingCsmall;
 
-    OsuSkinImage *m_rankingDsmall;
 
-    OsuSkinImage *m_rankingSsmall;
 
-    OsuSkinImage *m_rankingSHsmall;
 
-    OsuSkinImage *m_rankingXsmall;
 
-    OsuSkinImage *m_rankingXHsmall;
 
-    OsuSkinImage *m_rankingPerfect;
 
+    SkinImage *m_rankingAsmall;
 
+    SkinImage *m_rankingBsmall;
 
+    SkinImage *m_rankingCsmall;
 
+    SkinImage *m_rankingDsmall;
 
+    SkinImage *m_rankingSsmall;
 
+    SkinImage *m_rankingSHsmall;
 
+    SkinImage *m_rankingXsmall;
 
+    SkinImage *m_rankingXHsmall;
 
+    SkinImage *m_rankingPerfect;
 
 
 
     Image *m_beatmapImportSpinner;
 
     Image *m_loadingSpinner;
--- a/src/App/Osu/OsuSkinImage.cpp
+++ b/src/App/Osu/OsuSkinImage.cpp
@@ -5,21 +5,21 @@
 
 // $NoKeywords: $osuskimg
 
 //===============================================================================//
 
 
 
-#include "OsuSkinImage.h"
 
+#include "SkinImage.h"
 
 
 
 #include "ConVar.h"
 
 #include "Engine.h"
 
 #include "Environment.h"
 
 #include "Osu.h"
 
-#include "OsuSkin.h"
 
 #include "ResourceManager.h"
 
+#include "Skin.h"
 
 
 
 ConVar osu_skin_animation_fps_override("osu_skin_animation_fps_override", -1.0f, FCVAR_NONE);
 
 
 
-ConVar *OsuSkinImage::m_osu_skin_mipmaps_ref = NULL;
 
+ConVar *SkinImage::m_osu_skin_mipmaps_ref = NULL;
 
 
 
-OsuSkinImage::OsuSkinImage(OsuSkin *skin, std::string skinElementName, Vector2 baseSizeForScaling2x, float osuSize,
 
-                           std::string animationSeparator, bool ignoreDefaultSkin) {
 
+SkinImage::SkinImage(Skin *skin, std::string skinElementName, Vector2 baseSizeForScaling2x, float osuSize,
 
+                     std::string animationSeparator, bool ignoreDefaultSkin) {
 
     m_skin = skin;
 
     m_vBaseSizeForScaling2x = baseSizeForScaling2x;
 
     m_fOsuSize = osuSize;
@@ -65,7 +65,7 @@ OsuSkinImage::OsuSkinImage(OsuSkin *skin, std::string skinElementName, Vector2 b
 
         m_fFrameDuration = 1.0f / (float)m_images.size();
 
 }
 
 
 
-bool OsuSkinImage::load(std::string skinElementName, std::string animationSeparator, bool ignoreDefaultSkin) {
 
+bool SkinImage::load(std::string skinElementName, std::string animationSeparator, bool ignoreDefaultSkin) {
 
     std::string animatedSkinElementStartName = skinElementName;
 
     animatedSkinElementStartName.append(animationSeparator);
 
     animatedSkinElementStartName.append("0");
@@ -86,7 +86,7 @@ bool OsuSkinImage::load(std::string skinElementName, std::string animationSepara
 
 
 
             // sanity check
 
             if(frame > 511) {
 
-                debugLog("OsuSkinImage WARNING: Force stopped loading after 512 frames!\n");
 
+                debugLog("SkinImage WARNING: Force stopped loading after 512 frames!\n");
 
                 break;
 
             }
 
         }
@@ -96,7 +96,7 @@ bool OsuSkinImage::load(std::string skinElementName, std::string animationSepara
 
     return m_images.size() > 0;  // if any image was found
 
 }
 
 
 
-bool OsuSkinImage::loadImage(std::string skinElementName, bool ignoreDefaultSkin) {
 
+bool SkinImage::loadImage(std::string skinElementName, bool ignoreDefaultSkin) {
 
     std::string filepath1 = m_skin->getFilePath();
 
     filepath1.append(skinElementName);
 
     filepath1.append("@2x.png");
@@ -106,12 +106,12 @@ bool OsuSkinImage::loadImage(std::string skinElementName, bool ignoreDefaultSkin
 
     filepath2.append(".png");
 
 
 
     std::string defaultFilePath1 = "./materials/";
 
-    defaultFilePath1.append(OsuSkin::OSUSKIN_DEFAULT_SKIN_PATH);
 
+    defaultFilePath1.append(Skin::OSUSKIN_DEFAULT_SKIN_PATH);
 
     defaultFilePath1.append(skinElementName);
 
     defaultFilePath1.append("@2x.png");
 
 
 
     std::string defaultFilePath2 = "./materials/";
 
-    defaultFilePath2.append(OsuSkin::OSUSKIN_DEFAULT_SKIN_PATH);
 
+    defaultFilePath2.append(Skin::OSUSKIN_DEFAULT_SKIN_PATH);
 
     defaultFilePath2.append(skinElementName);
 
     defaultFilePath2.append(".png");
 
 
@@ -123,13 +123,13 @@ bool OsuSkinImage::loadImage(std::string skinElementName, bool ignoreDefaultSkin
 
     // load user skin
 
 
 
     // check if an @2x version of this image exists
 
-    if(OsuSkin::m_osu_skin_hd->getBool()) {
 
+    if(Skin::m_osu_skin_hd->getBool()) {
 
         // load user skin
 
 
 
         if(existsFilepath1) {
 
             IMAGE image;
 
 
 
-            if(OsuSkin::m_osu_skin_async->getBool()) engine->getResourceManager()->requestNextLoadAsync();
 
+            if(Skin::m_osu_skin_async->getBool()) engine->getResourceManager()->requestNextLoadAsync();
 
 
 
             image.img = engine->getResourceManager()->loadImageAbsUnnamed(filepath1, m_osu_skin_mipmaps_ref->getBool());
 
             image.scale = 2.0f;
@@ -153,7 +153,7 @@ bool OsuSkinImage::loadImage(std::string skinElementName, bool ignoreDefaultSkin
 
     if(existsFilepath2) {
 
         IMAGE image;
 
 
 
-        if(OsuSkin::m_osu_skin_async->getBool()) engine->getResourceManager()->requestNextLoadAsync();
 
+        if(Skin::m_osu_skin_async->getBool()) engine->getResourceManager()->requestNextLoadAsync();
 
 
 
         image.img = engine->getResourceManager()->loadImageAbsUnnamed(filepath2, m_osu_skin_mipmaps_ref->getBool());
 
         image.scale = 1.0f;
@@ -177,11 +177,11 @@ bool OsuSkinImage::loadImage(std::string skinElementName, bool ignoreDefaultSkin
 
     m_bIsFromDefaultSkin = true;
 
 
 
     // check if an @2x version of this image exists
 
-    if(OsuSkin::m_osu_skin_hd->getBool()) {
 
+    if(Skin::m_osu_skin_hd->getBool()) {
 
         if(existsDefaultFilePath1) {
 
             IMAGE image;
 
 
 
-            if(OsuSkin::m_osu_skin_async->getBool()) engine->getResourceManager()->requestNextLoadAsync();
 
+            if(Skin::m_osu_skin_async->getBool()) engine->getResourceManager()->requestNextLoadAsync();
 
 
 
             image.img =
 
                 engine->getResourceManager()->loadImageAbsUnnamed(defaultFilePath1, m_osu_skin_mipmaps_ref->getBool());
@@ -204,7 +204,7 @@ bool OsuSkinImage::loadImage(std::string skinElementName, bool ignoreDefaultSkin
 
     if(existsDefaultFilePath2) {
 
         IMAGE image;
 
 
 
-        if(OsuSkin::m_osu_skin_async->getBool()) engine->getResourceManager()->requestNextLoadAsync();
 
+        if(Skin::m_osu_skin_async->getBool()) engine->getResourceManager()->requestNextLoadAsync();
 
 
 
         image.img =
 
             engine->getResourceManager()->loadImageAbsUnnamed(defaultFilePath2, m_osu_skin_mipmaps_ref->getBool());
@@ -225,7 +225,7 @@ bool OsuSkinImage::loadImage(std::string skinElementName, bool ignoreDefaultSkin
 
     return false;
 
 }
 
 
 
-OsuSkinImage::~OsuSkinImage() {
 
+SkinImage::~SkinImage() {
 
     for(int i = 0; i < m_images.size(); i++) {
 
         if(m_images[i].img != m_skin->getMissingTexture())
 
             engine->getResourceManager()->destroyResource(m_images[i].img);
@@ -235,7 +235,7 @@ OsuSkinImage::~OsuSkinImage() {
 
     m_filepathsForExport.clear();
 
 }
 
 
 
-void OsuSkinImage::draw(Graphics *g, Vector2 pos, float scale) {
 
+void SkinImage::draw(Graphics *g, Vector2 pos, float scale) {
 
     if(m_images.size() < 1) return;
 
 
 
     scale *= getScale();  // auto scale to current resolution
@@ -281,7 +281,7 @@ void OsuSkinImage::draw(Graphics *g, Vector2 pos, float scale) {
 
     g->popTransform();
 
 }
 
 
 
-void OsuSkinImage::drawRaw(Graphics *g, Vector2 pos, float scale) {
 
+void SkinImage::drawRaw(Graphics *g, Vector2 pos, float scale) {
 
     if(m_images.size() < 1) return;
 
 
 
     g->pushTransform();
@@ -325,7 +325,7 @@ void OsuSkinImage::drawRaw(Graphics *g, Vector2 pos, float scale) {
 
     g->popTransform();
 
 }
 
 
 
-void OsuSkinImage::update(float speedMultiplier, bool useEngineTimeForAnimations, long curMusicPos) {
 
+void SkinImage::update(float speedMultiplier, bool useEngineTimeForAnimations, long curMusicPos) {
 
     if(m_images.size() < 1) return;
 
 
 
     m_iCurMusicPos = curMusicPos;
@@ -358,48 +358,48 @@ void OsuSkinImage::update(float speedMultiplier, bool useEngineTimeForAnimations
 
     }
 
 }
 
 
 
-void OsuSkinImage::setAnimationTimeOffset(float speedMultiplier, long offset) {
 
+void SkinImage::setAnimationTimeOffset(float speedMultiplier, long offset) {
 
     m_iBeatmapAnimationTimeStartOffset = offset;
 
     update(speedMultiplier, false, m_iCurMusicPos);  // force update
 
 }
 
 
 
-void OsuSkinImage::setAnimationFrameForce(int frame) {
 
+void SkinImage::setAnimationFrameForce(int frame) {
 
     if(m_images.size() < 1) return;
 
     m_iFrameCounter = frame % m_images.size();
 
     m_iFrameCounterUnclamped = m_iFrameCounter;
 
 }
 
 
 
-void OsuSkinImage::setAnimationFrameClampUp() {
 
+void SkinImage::setAnimationFrameClampUp() {
 
     if(m_images.size() > 0 && m_iFrameCounterUnclamped > m_images.size() - 1) m_iFrameCounter = m_images.size() - 1;
 
 }
 
 
 
-Vector2 OsuSkinImage::getSize() {
 
+Vector2 SkinImage::getSize() {
 
     if(m_images.size() > 0)
 
         return getImageForCurrentFrame().img->getSize() * getScale();
 
     else
 
         return getSizeBase();
 
 }
 
 
 
-Vector2 OsuSkinImage::getSizeBase() { return m_vBaseSizeForScaling2x * getResolutionScale(); }
 
+Vector2 SkinImage::getSizeBase() { return m_vBaseSizeForScaling2x * getResolutionScale(); }
 
 
 
-Vector2 OsuSkinImage::getSizeBaseRaw() { return m_vBaseSizeForScaling2x * getImageForCurrentFrame().scale; }
 
+Vector2 SkinImage::getSizeBaseRaw() { return m_vBaseSizeForScaling2x * getImageForCurrentFrame().scale; }
 
 
 
-Vector2 OsuSkinImage::getImageSizeForCurrentFrame() { return getImageForCurrentFrame().img->getSize(); }
 
+Vector2 SkinImage::getImageSizeForCurrentFrame() { return getImageForCurrentFrame().img->getSize(); }
 
 
 
-float OsuSkinImage::getScale() { return getImageScale() * getResolutionScale(); }
 
+float SkinImage::getScale() { return getImageScale() * getResolutionScale(); }
 
 
 
-float OsuSkinImage::getImageScale() {
 
+float SkinImage::getImageScale() {
 
     if(m_images.size() > 0)
 
         return m_vBaseSizeForScaling2x.x / getSizeBaseRaw().x;  // allow overscale and underscale
 
     else
 
         return 1.0f;
 
 }
 
 
 
-float OsuSkinImage::getResolutionScale() {
 
+float SkinImage::getResolutionScale() {
 
     return Osu::getImageScale(m_skin->getOsu(), m_vBaseSizeForScaling2x, m_fOsuSize);
 
 }
 
 
 
-bool OsuSkinImage::isReady() {
 
+bool SkinImage::isReady() {
 
     if(m_bReady) return true;
 
 
 
     for(int i = 0; i < m_images.size(); i++) {
@@ -410,7 +410,7 @@ bool OsuSkinImage::isReady() {
 
     return m_bReady;
 
 }
 
 
 
-OsuSkinImage::IMAGE OsuSkinImage::getImageForCurrentFrame() {
 
+SkinImage::IMAGE SkinImage::getImageForCurrentFrame() {
 
     if(m_images.size() > 0)
 
         return m_images[m_iFrameCounter % m_images.size()];
 
     else {
--- a/src/App/Osu/OsuSkinImage.h
+++ b/src/App/Osu/OsuSkinImage.h
@@ -10,11 +10,11 @@
 
 
 
 #include "cbase.h"
 
 
 
-class OsuSkin;
 
+class Skin;
 
 
 
 class Image;
 
 
 
-class OsuSkinImage {
 
+class SkinImage {
 
    public:
 
     struct IMAGE {
 
         Image *img;
@@ -22,9 +22,9 @@ class OsuSkinImage {
 
     };
 
 
 
    public:
 
-    OsuSkinImage(OsuSkin *skin, std::string skinElementName, Vector2 baseSizeForScaling2x, float osuSize,
 
-                 std::string animationSeparator = "-", bool ignoreDefaultSkin = false);
 
-    virtual ~OsuSkinImage();
 
+    SkinImage(Skin *skin, std::string skinElementName, Vector2 baseSizeForScaling2x, float osuSize,
 
+              std::string animationSeparator = "-", bool ignoreDefaultSkin = false);
 
+    virtual ~SkinImage();
 
 
 
     virtual void draw(Graphics *g, Vector2 pos,
 
                       float scale = 1.0f);  // for objects scaled automatically to the current resolution
@@ -38,13 +38,13 @@ class OsuSkinImage {
 
                                 long offset);  // set this every frame (before drawing) to a fixed point in time
 
                                                // relative to curMusicPos where we become visible
 
     void setAnimationFrameForce(
 
-        int frame);  // force set a frame, before drawing (e.g. for hitresults in OsuUIRankingScreenRankingPanel)
 
+        int frame);  // force set a frame, before drawing (e.g. for hitresults in UIRankingScreenRankingPanel)
 
     void setAnimationFrameClampUp();  // force stop the animation after the last frame, before drawing
 
 
 
     void setDrawClipWidthPercent(float drawClipWidthPercent) { m_fDrawClipWidthPercent = drawClipWidthPercent; }
 
 
 
     Vector2 getSize();      // absolute size scaled to the current resolution (depending on the osuSize as defined when
 
-                            // loaded in OsuSkin.cpp)
 
+                            // loaded in Skin.cpp)
 
     Vector2 getSizeBase();  // default assumed size scaled to the current resolution. this is the base resolution which
 
                             // is used for all scaling calculations (to allow skins to overscale or underscale objects)
 
     Vector2 getSizeBaseRaw();  // default assumed size UNSCALED. that means that e.g. hitcircles will return either
@@ -75,7 +75,7 @@ class OsuSkinImage {
 
     float getScale();
 
     float getImageScale();
 
 
 
-    OsuSkin *m_skin;
 
+    Skin *m_skin;
 
     bool m_bReady;
 
 
 
     // scaling
--- a/src/App/Osu/OsuSlider.cpp
+++ b/src/App/Osu/OsuSlider.cpp
@@ -5,25 +5,25 @@
 
 // $NoKeywords: $slider
 
 //===============================================================================//
 
 
 
-#include "OsuSlider.h"
 
+#include "Slider.h"
 
 
 
 #include "AnimationHandler.h"
 
 #include "Bancho.h"
 
+#include "Beatmap.h"
 
 #include "Camera.h"
 
+#include "Circle.h"
 
 #include "ConVar.h"
 
 #include "Engine.h"
 
+#include "GameRules.h"
 
+#include "ModFPoSu.h"
 
 #include "Osu.h"
 
-#include "OsuBeatmap.h"
 
-#include "OsuCircle.h"
 
-#include "OsuGameRules.h"
 
-#include "OsuModFPoSu.h"
 
-#include "OsuSkin.h"
 
-#include "OsuSkinImage.h"
 
-#include "OsuSliderCurves.h"
 
-#include "OsuSliderRenderer.h"
 
 #include "RenderTarget.h"
 
 #include "ResourceManager.h"
 
 #include "Shader.h"
 
+#include "Skin.h"
 
+#include "SkinImage.h"
 
+#include "SliderCurves.h"
 
+#include "SliderRenderer.h"
 
 #include "SoundEngine.h"
 
 #include "VertexArrayObject.h"
 
 
@@ -63,21 +63,20 @@ ConVar osu_slider_reverse_arrow_animated("osu_slider_reverse_arrow_animated", tr
 
                                          "pulse animation on reverse arrows");
 
 ConVar osu_slider_reverse_arrow_alpha_multiplier("osu_slider_reverse_arrow_alpha_multiplier", 1.0f, FCVAR_NONE);
 
 
 
-ConVar *OsuSlider::m_osu_playfield_mirror_horizontal_ref = NULL;
 
-ConVar *OsuSlider::m_osu_playfield_mirror_vertical_ref = NULL;
 
-ConVar *OsuSlider::m_osu_playfield_rotation_ref = NULL;
 
-ConVar *OsuSlider::m_osu_mod_fps_ref = NULL;
 
-ConVar *OsuSlider::m_osu_mod_strict_tracking_ref = NULL;
 
-ConVar *OsuSlider::m_osu_slider_border_size_multiplier_ref = NULL;
 
-ConVar *OsuSlider::m_epilepsy_ref = NULL;
 
-ConVar *OsuSlider::m_osu_auto_cursordance_ref = NULL;
 
-ConVar *OsuSlider::m_osu_drain_type_ref = NULL;
 
-
 
-OsuSlider::OsuSlider(char type, int repeat, float pixelLength, std::vector<Vector2> points, std::vector<int> hitSounds,
 
-                     std::vector<float> ticks, float sliderTime, float sliderTimeWithoutRepeats, long time,
 
-                     int sampleType, int comboNumber, bool isEndOfCombo, int colorCounter, int colorOffset,
 
-                     OsuBeatmap *beatmap)
 
-    : OsuHitObject(time, sampleType, comboNumber, isEndOfCombo, colorCounter, colorOffset, beatmap) {
 
+ConVar *Slider::m_osu_playfield_mirror_horizontal_ref = NULL;
 
+ConVar *Slider::m_osu_playfield_mirror_vertical_ref = NULL;
 
+ConVar *Slider::m_osu_playfield_rotation_ref = NULL;
 
+ConVar *Slider::m_osu_mod_fps_ref = NULL;
 
+ConVar *Slider::m_osu_mod_strict_tracking_ref = NULL;
 
+ConVar *Slider::m_osu_slider_border_size_multiplier_ref = NULL;
 
+ConVar *Slider::m_epilepsy_ref = NULL;
 
+ConVar *Slider::m_osu_auto_cursordance_ref = NULL;
 
+ConVar *Slider::m_osu_drain_type_ref = NULL;
 
+
 
+Slider::Slider(char type, int repeat, float pixelLength, std::vector<Vector2> points, std::vector<int> hitSounds,
 
+               std::vector<float> ticks, float sliderTime, float sliderTimeWithoutRepeats, long time, int sampleType,
 
+               int comboNumber, bool isEndOfCombo, int colorCounter, int colorOffset, Beatmap *beatmap)
 
+    : HitObject(time, sampleType, comboNumber, isEndOfCombo, colorCounter, colorOffset, beatmap) {
 
     if(m_osu_playfield_mirror_horizontal_ref == NULL)
 
         m_osu_playfield_mirror_horizontal_ref = convar->getConVarByName("osu_playfield_mirror_horizontal");
 
     if(m_osu_playfield_mirror_vertical_ref == NULL)
@@ -112,7 +111,7 @@ OsuSlider::OsuSlider(char type, int repeat, float pixelLength, std::vector<Vecto
 
     }
 
 
 
     // build curve
 
-    m_curve = OsuSliderCurve::createCurve(m_cType, m_points, m_fPixelLength);
 
+    m_curve = SliderCurve::createCurve(m_cType, m_points, m_fPixelLength);
 
 
 
     // build repeats
 
     for(int i = 0; i < (m_iRepeat - 1); i++) {
@@ -166,8 +165,8 @@ OsuSlider::OsuSlider(char type, int repeat, float pixelLength, std::vector<Vecto
 
     m_fReverseArrowAlpha = 0.0f;
 
     m_fBodyAlpha = 0.0f;
 
 
 
-    m_startResult = OsuScore::HIT::HIT_NULL;
 
-    m_endResult = OsuScore::HIT::HIT_NULL;
 
+    m_startResult = LiveScore::HIT::HIT_NULL;
 
+    m_endResult = LiveScore::HIT::HIT_NULL;
 
     m_bStartFinished = false;
 
     m_fStartHitAnimation = 0.0f;
 
     m_bEndFinished = false;
@@ -196,23 +195,23 @@ OsuSlider::OsuSlider(char type, int repeat, float pixelLength, std::vector<Vecto
 
     m_vao = NULL;
 
 }
 
 
 
-OsuSlider::~OsuSlider() {
 
+Slider::~Slider() {
 
     onReset(0);
 
 
 
     SAFE_DELETE(m_curve);
 
     SAFE_DELETE(m_vao);
 
 }
 
 
 
-void OsuSlider::draw(Graphics *g) {
 
+void Slider::draw(Graphics *g) {
 
     if(m_points.size() <= 0) return;
 
 
 
-    const float foscale = OsuGameRules::osu_circle_fade_out_scale.getFloat();
 
-    OsuSkin *skin = m_beatmap->getSkin();
 
+    const float foscale = GameRules::osu_circle_fade_out_scale.getFloat();
 
+    Skin *skin = m_beatmap->getSkin();
 
 
 
     const bool isCompletelyFinished = m_bStartFinished && m_bEndFinished && m_bFinished;
 
 
 
     if((m_bVisible || (m_bStartFinished && !m_bFinished)) &&
 
-       !isCompletelyFinished)  // extra possibility to avoid flicker between OsuHitObject::m_bVisible delay and the
 
+       !isCompletelyFinished)  // extra possibility to avoid flicker between HitObject::m_bVisible delay and the
 
                                // fadeout animation below this if block
 
     {
 
         float alpha = (osu_mod_hd_slider_fast_fade.getBool() ? m_fAlpha : m_fBodyAlpha);
@@ -270,7 +269,7 @@ void OsuSlider::draw(Graphics *g) {
 
             }
 
 
 
             const bool ifStrictTrackingModShouldDrawEndCircle =
 
-                (!m_osu_mod_strict_tracking_ref->getBool() || m_endResult != OsuScore::HIT::HIT_MISS);
 
+                (!m_osu_mod_strict_tracking_ref->getBool() || m_endResult != LiveScore::HIT::HIT_MISS);
 
 
 
             // end circle
 
             if((!m_bEndFinished && m_iRepeat % 2 != 0 && ifStrictTrackingModShouldDrawEndCircle) ||
@@ -380,10 +379,10 @@ void OsuSlider::draw(Graphics *g) {
 
         if(!osu_slider_shrink.getBool())
 
             drawBody(g, 1.0f - m_fEndSliderBodyFadeAnimation, 0, 1);
 
         else if(osu_slider_body_lazer_fadeout_style.getBool())
 
-            OsuSliderRenderer::draw(g, m_beatmap->getOsu(), emptyVector, alwaysPoints,
 
-                                    m_beatmap->getHitcircleDiameter(), 0.0f, 0.0f,
 
-                                    m_beatmap->getSkin()->getComboColorForCounter(m_iColorCounter, m_iColorOffset),
 
-                                    1.0f, 1.0f - m_fEndSliderBodyFadeAnimation, getTime());
 
+            SliderRenderer::draw(g, m_beatmap->getOsu(), emptyVector, alwaysPoints, m_beatmap->getHitcircleDiameter(),
 
+                                 0.0f, 0.0f,
 
+                                 m_beatmap->getSkin()->getComboColorForCounter(m_iColorCounter, m_iColorOffset), 1.0f,
 
+                                 1.0f - m_fEndSliderBodyFadeAnimation, getTime());
 
     }
 
 
 
     if(m_fStartHitAnimation > 0.0f && m_fStartHitAnimation != 1.0f && !m_beatmap->getOsu()->getModHD()) {
@@ -407,8 +406,8 @@ void OsuSlider::draw(Graphics *g) {
 
                                                    ? m_iTime - m_iApproachTime
 
                                                    : m_beatmap->getCurMusicPosWithOffsets());
 
 
 
-                OsuCircle::drawSliderStartCircle(g, m_beatmap, m_curve->pointAt(0.0f), m_iComboNumber, m_iColorCounter,
 
-                                                 m_iColorOffset, 1.0f, 1.0f, alpha, alpha, drawNumber);
 
+                Circle::drawSliderStartCircle(g, m_beatmap, m_curve->pointAt(0.0f), m_iComboNumber, m_iColorCounter,
 
+                                              m_iColorOffset, 1.0f, 1.0f, alpha, alpha, drawNumber);
 
             } else {
 
                 skin->getHitCircleOverlay2()->setAnimationTimeOffset(
 
                     skin->getAnimationSpeed(),
@@ -417,8 +416,8 @@ void OsuSlider::draw(Graphics *g) {
 
                     skin->getAnimationSpeed(),
 
                     !m_beatmap->isInMafhamRenderChunk() ? m_iTime : m_beatmap->getCurMusicPosWithOffsets());
 
 
 
-                OsuCircle::drawSliderEndCircle(g, m_beatmap, m_curve->pointAt(0.0f), m_iComboNumber, m_iColorCounter,
 
-                                               m_iColorOffset, 1.0f, 1.0f, alpha, alpha, drawNumber);
 
+                Circle::drawSliderEndCircle(g, m_beatmap, m_curve->pointAt(0.0f), m_iComboNumber, m_iColorCounter,
 
+                                            m_iColorOffset, 1.0f, 1.0f, alpha, alpha, drawNumber);
 
             }
 
         }
 
         g->popTransform();
@@ -443,26 +442,26 @@ void OsuSlider::draw(Graphics *g) {
 
                                                    ? m_iTime - m_iFadeInTime
 
                                                    : m_beatmap->getCurMusicPosWithOffsets());
 
 
 
-                OsuCircle::drawSliderEndCircle(g, m_beatmap, m_curve->pointAt(1.0f), m_iComboNumber, m_iColorCounter,
 
-                                               m_iColorOffset, 1.0f, 1.0f, alpha, 0.0f, false);
 
+                Circle::drawSliderEndCircle(g, m_beatmap, m_curve->pointAt(1.0f), m_iComboNumber, m_iColorCounter,
 
+                                            m_iColorOffset, 1.0f, 1.0f, alpha, 0.0f, false);
 
             }
 
         }
 
         g->popTransform();
 
     }
 
 
 
-    OsuHitObject::draw(g);
 
+    HitObject::draw(g);
 
 }
 
 
 
-void OsuSlider::draw2(Graphics *g) { draw2(g, true, false); }
 
+void Slider::draw2(Graphics *g) { draw2(g, true, false); }
 
 
 
-void OsuSlider::draw2(Graphics *g, bool drawApproachCircle, bool drawOnlyApproachCircle) {
 
-    OsuHitObject::draw2(g);
 
+void Slider::draw2(Graphics *g, bool drawApproachCircle, bool drawOnlyApproachCircle) {
 
+    HitObject::draw2(g);
 
 
 
-    OsuSkin *skin = m_beatmap->getSkin();
 
+    Skin *skin = m_beatmap->getSkin();
 
 
 
     // HACKHACK: so much code duplication aaaaaaah
 
     if((m_bVisible || (m_bStartFinished && !m_bFinished)) &&
 
-       drawApproachCircle)  // extra possibility to avoid flicker between OsuHitObject::m_bVisible delay and the fadeout
 
+       drawApproachCircle)  // extra possibility to avoid flicker between HitObject::m_bVisible delay and the fadeout
 
                             // animation below this if block
 
     {
 
         if(m_points.size() > 1) {
@@ -476,9 +475,9 @@ void OsuSlider::draw2(Graphics *g, bool drawApproachCircle, bool drawOnlyApproac
 
 
 
             // start circle
 
             if(!m_bStartFinished || !sliderRepeatStartCircleFinished || (!m_bEndFinished && m_iRepeat % 2 == 0)) {
 
-                OsuCircle::drawApproachCircle(g, m_beatmap, m_curve->pointAt(0.0f), m_iComboNumber, m_iColorCounter,
 
-                                              m_iColorOffset, m_fHittableDimRGBColorMultiplierPercent, m_fApproachScale,
 
-                                              m_fAlphaForApproachCircle, m_bOverrideHDApproachCircle);
 
+                Circle::drawApproachCircle(g, m_beatmap, m_curve->pointAt(0.0f), m_iComboNumber, m_iColorCounter,
 
+                                           m_iColorOffset, m_fHittableDimRGBColorMultiplierPercent, m_fApproachScale,
 
+                                           m_fAlphaForApproachCircle, m_bOverrideHDApproachCircle);
 
             }
 
         }
 
     }
@@ -502,7 +501,7 @@ void OsuSlider::draw2(Graphics *g, bool drawApproachCircle, bool drawOnlyApproac
 
             tickAnimation = clamp<float>(tickAnimation / 0.02f, 0.0f, 1.0f);
 
         }
 
         float tickAnimationScale =
 
-            1.0f + tickAnimation * OsuGameRules::osu_slider_followcircle_tick_pulse_scale.getFloat();
 
+            1.0f + tickAnimation * GameRules::osu_slider_followcircle_tick_pulse_scale.getFloat();
 
 
 
         g->setColor(0xffffffff);
 
         g->setAlpha(m_fFollowCircleAnimationAlpha);
@@ -518,7 +517,7 @@ void OsuSlider::draw2(Graphics *g, bool drawApproachCircle, bool drawOnlyApproac
 
 
 
     // draw sliderb on top of everything
 
     if((m_bVisible || (m_bStartFinished && !m_bFinished)) &&
 
-       !isCompletelyFinished)  // extra possibility in the if-block to avoid flicker between OsuHitObject::m_bVisible
 
+       !isCompletelyFinished)  // extra possibility in the if-block to avoid flicker between HitObject::m_bVisible
 
                                // delay and the fadeout animation below this if-block
 
     {
 
         if(m_fSlidePercent > 0.0f) {
@@ -548,8 +547,8 @@ void OsuSlider::draw2(Graphics *g, bool drawApproachCircle, bool drawOnlyApproac
 
     }
 
 }
 
 
 
-void OsuSlider::drawStartCircle(Graphics *g, float alpha) {
 
-    OsuSkin *skin = m_beatmap->getSkin();
 
+void Slider::drawStartCircle(Graphics *g, float alpha) {
 
+    Skin *skin = m_beatmap->getSkin();
 
 
 
     if(m_bStartFinished) {
 
         skin->getHitCircleOverlay2()->setAnimationTimeOffset(
@@ -559,9 +558,9 @@ void OsuSlider::drawStartCircle(Graphics *g, float alpha) {
 
             skin->getAnimationSpeed(),
 
             !m_beatmap->isInMafhamRenderChunk() ? m_iTime : m_beatmap->getCurMusicPosWithOffsets());
 
 
 
-        OsuCircle::drawSliderEndCircle(g, m_beatmap, m_curve->pointAt(0.0f), m_iComboNumber, m_iColorCounter,
 
-                                       m_iColorOffset, m_fHittableDimRGBColorMultiplierPercent, 1.0f, m_fAlpha, 0.0f,
 
-                                       false, false);
 
+        Circle::drawSliderEndCircle(g, m_beatmap, m_curve->pointAt(0.0f), m_iComboNumber, m_iColorCounter,
 
+                                    m_iColorOffset, m_fHittableDimRGBColorMultiplierPercent, 1.0f, m_fAlpha, 0.0f,
 
+                                    false, false);
 
     } else {
 
         skin->getHitCircleOverlay2()->setAnimationTimeOffset(
 
             skin->getAnimationSpeed(),
@@ -570,15 +569,15 @@ void OsuSlider::drawStartCircle(Graphics *g, float alpha) {
 
             skin->getAnimationSpeed(),
 
             !m_beatmap->isInMafhamRenderChunk() ? m_iTime - m_iApproachTime : m_beatmap->getCurMusicPosWithOffsets());
 
 
 
-        OsuCircle::drawSliderStartCircle(g, m_beatmap, m_curve->pointAt(0.0f), m_iComboNumber, m_iColorCounter,
 
-                                         m_iColorOffset, m_fHittableDimRGBColorMultiplierPercent, m_fApproachScale,
 
-                                         m_fAlpha, m_fAlpha, !m_bHideNumberAfterFirstRepeatHit,
 
-                                         m_bOverrideHDApproachCircle);
 
+        Circle::drawSliderStartCircle(g, m_beatmap, m_curve->pointAt(0.0f), m_iComboNumber, m_iColorCounter,
 
+                                      m_iColorOffset, m_fHittableDimRGBColorMultiplierPercent, m_fApproachScale,
 
+                                      m_fAlpha, m_fAlpha, !m_bHideNumberAfterFirstRepeatHit,
 
+                                      m_bOverrideHDApproachCircle);
 
     }
 
 }
 
 
 
-void OsuSlider::drawEndCircle(Graphics *g, float alpha, float sliderSnake) {
 
-    OsuSkin *skin = m_beatmap->getSkin();
 
+void Slider::drawEndCircle(Graphics *g, float alpha, float sliderSnake) {
 
+    Skin *skin = m_beatmap->getSkin();
 
 
 
     skin->getHitCircleOverlay2()->setAnimationTimeOffset(
 
         skin->getAnimationSpeed(),
@@ -587,12 +586,12 @@ void OsuSlider::drawEndCircle(Graphics *g, float alpha, float sliderSnake) {
 
         skin->getAnimationSpeed(),
 
         !m_beatmap->isInMafhamRenderChunk() ? m_iTime - m_iFadeInTime : m_beatmap->getCurMusicPosWithOffsets());
 
 
 
-    OsuCircle::drawSliderEndCircle(g, m_beatmap, m_curve->pointAt(sliderSnake), m_iComboNumber, m_iColorCounter,
 
-                                   m_iColorOffset, m_fHittableDimRGBColorMultiplierPercent, 1.0f, m_fAlpha, 0.0f, false,
 
-                                   false);
 
+    Circle::drawSliderEndCircle(g, m_beatmap, m_curve->pointAt(sliderSnake), m_iComboNumber, m_iColorCounter,
 
+                                m_iColorOffset, m_fHittableDimRGBColorMultiplierPercent, 1.0f, m_fAlpha, 0.0f, false,
 
+                                false);
 
 }
 
 
 
-void OsuSlider::drawBody(Graphics *g, float alpha, float from, float to) {
 
+void Slider::drawBody(Graphics *g, float alpha, float from, float to) {
 
     // smooth begin/end while snaking/shrinking
 
     std::vector<Vector2> alwaysPoints;
 
     if(osu_slider_body_smoothsnake.getBool()) {
@@ -616,35 +615,34 @@ void OsuSlider::drawBody(Graphics *g, float alpha, float from, float to) {
 
         }
 
 
 
         // peppy sliders
 
-        OsuSliderRenderer::draw(g, m_beatmap->getOsu(), screenPoints, alwaysPoints, m_beatmap->getHitcircleDiameter(),
 
-                                from, to, undimmedComboColor, m_fHittableDimRGBColorMultiplierPercent, alpha,
 
-                                getTime());
 
+        SliderRenderer::draw(g, m_beatmap->getOsu(), screenPoints, alwaysPoints, m_beatmap->getHitcircleDiameter(),
 
+                             from, to, undimmedComboColor, m_fHittableDimRGBColorMultiplierPercent, alpha, getTime());
 
 
 
         // mm sliders
 
-        /// OsuSliderRenderer::drawMM(g, m_beatmap->getOsu(), screenPoints, m_beatmap->getHitcircleDiameter(), from, to,
 
+        /// SliderRenderer::drawMM(g, m_beatmap->getOsu(), screenPoints, m_beatmap->getHitcircleDiameter(), from, to,
 
         /// m_beatmap->getSkin()->getComboColorForCounter(m_iColorCounter, m_iColorOffset),
 
         /// m_fHittableDimRGBColorMultiplierPercent, alpha, getTime());
 
     } else {
 
         // vertex buffered sliders
 
         // as the base mesh is centered at (0, 0, 0) and in raw osu coordinates, we have to scale and translate it to
 
         // make it fit the actual desktop playfield
 
-        const float scale = OsuGameRules::getPlayfieldScaleFactor(m_beatmap->getOsu());
 
-        Vector2 translation = OsuGameRules::getPlayfieldCenter(m_beatmap->getOsu());
 
+        const float scale = GameRules::getPlayfieldScaleFactor(m_beatmap->getOsu());
 
+        Vector2 translation = GameRules::getPlayfieldCenter(m_beatmap->getOsu());
 
 
 
         if(m_beatmap->hasFailed())
 
-            translation = m_beatmap->osuCoords2Pixels(
 
-                Vector2(OsuGameRules::OSU_COORD_WIDTH / 2, OsuGameRules::OSU_COORD_HEIGHT / 2));
 
+            translation =
 
+                m_beatmap->osuCoords2Pixels(Vector2(GameRules::OSU_COORD_WIDTH / 2, GameRules::OSU_COORD_HEIGHT / 2));
 
 
 
         if(m_osu_mod_fps_ref->getBool()) translation += m_beatmap->getFirstPersonCursorDelta();
 
 
 
-        OsuSliderRenderer::draw(g, m_beatmap->getOsu(), m_vao, alwaysPoints, translation, scale,
 
-                                m_beatmap->getHitcircleDiameter(), from, to, undimmedComboColor,
 
-                                m_fHittableDimRGBColorMultiplierPercent, alpha, getTime());
 
+        SliderRenderer::draw(g, m_beatmap->getOsu(), m_vao, alwaysPoints, translation, scale,
 
+                             m_beatmap->getHitcircleDiameter(), from, to, undimmedComboColor,
 
+                             m_fHittableDimRGBColorMultiplierPercent, alpha, getTime());
 
     }
 
 }
 
 
 
-void OsuSlider::update(long curPos) {
 
-    OsuHitObject::update(curPos);
 
+void Slider::update(long curPos) {
 
+    HitObject::update(curPos);
 
 
 
     if(m_fSliderBreakRapeTime != 0.0f && engine->getTime() > m_fSliderBreakRapeTime) {
 
         m_fSliderBreakRapeTime = 0.0f;
@@ -753,7 +751,7 @@ void OsuSlider::update(long curPos) {
 
     if(!m_bStartFinished) {
 
         if(m_beatmap->getOsu()->getModAuto()) {
 
             if(curPos >= m_iTime) {
 
-                onHit(OsuScore::HIT::HIT_300, 0, false);
 
+                onHit(LiveScore::HIT::HIT_300, 0, false);
 
                 bancho.osu->holding_slider = true;
 
             }
 
         } else {
@@ -765,9 +763,9 @@ void OsuSlider::update(long curPos) {
 
                     const Vector2 pos = m_beatmap->osuCoords2Pixels(m_curve->pointAt(0.0f));
 
                     const float cursorDelta = (m_beatmap->getCursorPos() - pos).length();
 
                     if((cursorDelta < m_beatmap->getHitcircleDiameter() / 2.0f && m_beatmap->getOsu()->getModRelax())) {
 
-                        OsuScore::HIT result = OsuGameRules::getHitResult(delta, m_beatmap);
 
+                        LiveScore::HIT result = GameRules::getHitResult(delta, m_beatmap);
 
 
 
-                        if(result != OsuScore::HIT::HIT_NULL) {
 
+                        if(result != LiveScore::HIT::HIT_NULL) {
 
                             const float targetDelta = cursorDelta / (m_beatmap->getHitcircleDiameter() / 2.0f);
 
                             const float targetAngle = rad2deg(
 
                                 atan2(m_beatmap->getCursorPos().y - pos.y, m_beatmap->getCursorPos().x - pos.x));
@@ -783,8 +781,8 @@ void OsuSlider::update(long curPos) {
 
             // wait for a miss
 
             if(delta >= 0) {
 
                 // if this is a miss after waiting
 
-                if(delta > (long)OsuGameRules::getHitWindow50(m_beatmap)) {
 
-                    m_startResult = OsuScore::HIT::HIT_MISS;
 
+                if(delta > (long)GameRules::getHitWindow50(m_beatmap)) {
 
+                    m_startResult = LiveScore::HIT::HIT_MISS;
 
                     onHit(m_startResult, delta, false);
 
                     bancho.osu->holding_slider = false;
 
                 }
@@ -844,8 +842,8 @@ void OsuSlider::update(long curPos) {
 
                                                     // miss, since the slider is then already considered fully finished
 
                                                     // gameplay wise
 
                 {
 
-                    if(m_endResult == OsuScore::HIT::HIT_NULL)  // force miss the end once, if it has not already been
 
-                                                                // force missed by notelock
 
+                    if(m_endResult == LiveScore::HIT::HIT_NULL)  // force miss the end once, if it has not already been
 
+                                                                 // force missed by notelock
 
                     {
 
                         // force miss endcircle
 
                         {
@@ -854,7 +852,7 @@ void OsuSlider::update(long curPos) {
 
                             m_bHeldTillEnd = false;
 
                             m_bHeldTillEndForLenienceHack = false;
 
                             m_bHeldTillEndForLenienceHackCheck = true;
 
-                            m_endResult = OsuScore::HIT::HIT_MISS;
 
+                            m_endResult = LiveScore::HIT::HIT_MISS;
 
 
 
                             addHitResult(m_endResult, 0, m_bIsEndOfCombo, getRawPosAt(m_iTime + m_iObjectDuration),
 
                                          -1.0f, 0.0f, true, true,
@@ -884,7 +882,7 @@ void OsuSlider::update(long curPos) {
 
         if(m_beatmap->getOsu()->getModAuto()) {
 
             if(curPos >= m_iTime + m_iObjectDuration) {
 
                 m_bHeldTillEnd = true;
 
-                onHit(OsuScore::HIT::HIT_300, 0, true);
 
+                onHit(LiveScore::HIT::HIT_300, 0, true);
 
                 bancho.osu->holding_slider = false;
 
             }
 
         } else {
@@ -892,32 +890,32 @@ void OsuSlider::update(long curPos) {
 
                 // handle leftover startcircle
 
                 {
 
                     // this may happen (if the slider time is shorter than the miss window of the startcircle)
 
-                    if(m_startResult == OsuScore::HIT::HIT_NULL) {
 
+                    if(m_startResult == LiveScore::HIT::HIT_NULL) {
 
                         // we still want to cause a sliderbreak in this case!
 
                         onSliderBreak();
 
 
 
                         // special case: missing the startcircle drains HIT_MISS_SLIDERBREAK health (and not HIT_MISS
 
                         // health)
 
-                        m_beatmap->addHitResult(this, OsuScore::HIT::HIT_MISS_SLIDERBREAK, 0, false, true, true, true,
 
+                        m_beatmap->addHitResult(this, LiveScore::HIT::HIT_MISS_SLIDERBREAK, 0, false, true, true, true,
 
                                                 true, false);  // only decrease health
 
 
 
-                        m_startResult = OsuScore::HIT::HIT_MISS;
 
+                        m_startResult = LiveScore::HIT::HIT_MISS;
 
                     }
 
                 }
 
 
 
                 // handle endcircle
 
                 bool isEndResultComingFromStrictTrackingMod = false;
 
-                if(m_endResult == OsuScore::HIT::HIT_NULL) {
 
+                if(m_endResult == LiveScore::HIT::HIT_NULL) {
 
                     m_bHeldTillEnd = m_bHeldTillEndForLenienceHack;
 
-                    m_endResult = m_bHeldTillEnd ? OsuScore::HIT::HIT_300 : OsuScore::HIT::HIT_MISS;
 
+                    m_endResult = m_bHeldTillEnd ? LiveScore::HIT::HIT_300 : LiveScore::HIT::HIT_MISS;
 
 
 
                     // handle total slider result (currently startcircle + repeats + ticks + endcircle)
 
                     // clicks = (repeats + ticks)
 
                     const float numMaxPossibleHits = 1 + m_clicks.size() + 1;
 
                     float numActualHits = 0;
 
 
 
-                    if(m_startResult != OsuScore::HIT::HIT_MISS) numActualHits++;
 
-                    if(m_endResult != OsuScore::HIT::HIT_MISS) numActualHits++;
 
+                    if(m_startResult != LiveScore::HIT::HIT_MISS) numActualHits++;
 
+                    if(m_endResult != LiveScore::HIT::HIT_MISS) numActualHits++;
 
 
 
                     for(int i = 0; i < m_clicks.size(); i++) {
 
                         if(m_clicks[i].successful) numActualHits++;
@@ -926,24 +924,24 @@ void OsuSlider::update(long curPos) {
 
                     const float percent = numActualHits / numMaxPossibleHits;
 
 
 
                     const bool allow300 = (osu_slider_scorev2.getBool() || m_beatmap->getOsu()->getModScorev2())
 
-                                              ? (m_startResult == OsuScore::HIT::HIT_300)
 
+                                              ? (m_startResult == LiveScore::HIT::HIT_300)
 
                                               : true;
 
                     const bool allow100 =
 
                         (osu_slider_scorev2.getBool() || m_beatmap->getOsu()->getModScorev2())
 
-                            ? (m_startResult == OsuScore::HIT::HIT_300 || m_startResult == OsuScore::HIT::HIT_100)
 
+                            ? (m_startResult == LiveScore::HIT::HIT_300 || m_startResult == LiveScore::HIT::HIT_100)
 
                             : true;
 
 
 
                     // rewrite m_endResult as the whole slider result, then use it for the final onHit()
 
                     if(percent >= 0.999f && allow300)
 
-                        m_endResult = OsuScore::HIT::HIT_300;
 
-                    else if(percent >= 0.5f && allow100 && !OsuGameRules::osu_mod_ming3012.getBool() &&
 
-                            !OsuGameRules::osu_mod_no100s.getBool())
 
-                        m_endResult = OsuScore::HIT::HIT_100;
 
-                    else if(percent > 0.0f && !OsuGameRules::osu_mod_no100s.getBool() &&
 
-                            !OsuGameRules::osu_mod_no50s.getBool())
 
-                        m_endResult = OsuScore::HIT::HIT_50;
 
+                        m_endResult = LiveScore::HIT::HIT_300;
 
+                    else if(percent >= 0.5f && allow100 && !GameRules::osu_mod_ming3012.getBool() &&
 
+                            !GameRules::osu_mod_no100s.getBool())
 
+                        m_endResult = LiveScore::HIT::HIT_100;
 
+                    else if(percent > 0.0f && !GameRules::osu_mod_no100s.getBool() &&
 
+                            !GameRules::osu_mod_no50s.getBool())
 
+                        m_endResult = LiveScore::HIT::HIT_50;
 
                     else
 
-                        m_endResult = OsuScore::HIT::HIT_MISS;
 
+                        m_endResult = LiveScore::HIT::HIT_MISS;
 
 
 
                     // debugLog("percent = %f\n", percent);
 
 
@@ -962,7 +960,7 @@ void OsuSlider::update(long curPos) {
 
            !m_beatmap->isPaused() && !m_beatmap->isWaiting() && m_beatmap->isPlaying()) {
 
             const Vector2 osuCoords = m_beatmap->pixels2OsuCoords(m_beatmap->osuCoords2Pixels(m_vCurPointRaw));
 
 
 
-            m_beatmap->getSkin()->playSliderSlideSound(OsuGameRules::osuCoords2Pan(osuCoords.x));
 
+            m_beatmap->getSkin()->playSliderSlideSound(GameRules::osuCoords2Pan(osuCoords.x));
 
             m_iPrevSliderSlideSoundSampleSet = m_beatmap->getSkin()->getSampleSet();
 
         } else {
 
             m_beatmap->getSkin()->stopSliderSlideSound(m_iPrevSliderSlideSoundSampleSet);
@@ -971,15 +969,14 @@ void OsuSlider::update(long curPos) {
 
     }
 
 }
 
 
 
-void OsuSlider::updateAnimations(long curPos) {
 
+void Slider::updateAnimations(long curPos) {
 
     Osu *osu = m_beatmap->getOsu();
 
     float animation_multiplier = osu->getSpeedMultiplier() / osu->getAnimationSpeedMultiplier();
 
 
 
-    float fadein_fade_time = OsuGameRules::osu_slider_followcircle_fadein_fade_time.getFloat() * animation_multiplier;
 
-    float fadeout_fade_time = OsuGameRules::osu_slider_followcircle_fadeout_fade_time.getFloat() * animation_multiplier;
 
-    float fadein_scale_time = OsuGameRules::osu_slider_followcircle_fadein_scale_time.getFloat() * animation_multiplier;
 
-    float fadeout_scale_time =
 
-        OsuGameRules::osu_slider_followcircle_fadeout_scale_time.getFloat() * animation_multiplier;
 
+    float fadein_fade_time = GameRules::osu_slider_followcircle_fadein_fade_time.getFloat() * animation_multiplier;
 
+    float fadeout_fade_time = GameRules::osu_slider_followcircle_fadeout_fade_time.getFloat() * animation_multiplier;
 
+    float fadein_scale_time = GameRules::osu_slider_followcircle_fadein_scale_time.getFloat() * animation_multiplier;
 
+    float fadeout_scale_time = GameRules::osu_slider_followcircle_fadeout_scale_time.getFloat() * animation_multiplier;
 
 
 
     // handle followcircle animations
 
     m_fFollowCircleAnimationAlpha = clamp<float>(
@@ -1004,25 +1001,25 @@ void OsuSlider::updateAnimations(long curPos) {
 
 
 
     if(!m_bFinished)
 
         m_fFollowCircleAnimationScale =
 
-            OsuGameRules::osu_slider_followcircle_fadein_scale.getFloat() +
 
-            (1.0f - OsuGameRules::osu_slider_followcircle_fadein_scale.getFloat()) * m_fFollowCircleAnimationScale;
 
+            GameRules::osu_slider_followcircle_fadein_scale.getFloat() +
 
+            (1.0f - GameRules::osu_slider_followcircle_fadein_scale.getFloat()) * m_fFollowCircleAnimationScale;
 
     else
 
-        m_fFollowCircleAnimationScale = 1.0f - (1.0f - OsuGameRules::osu_slider_followcircle_fadeout_scale.getFloat()) *
 
-                                                   m_fFollowCircleAnimationScale;
 
+        m_fFollowCircleAnimationScale =
 
+            1.0f - (1.0f - GameRules::osu_slider_followcircle_fadeout_scale.getFloat()) * m_fFollowCircleAnimationScale;
 
 }
 
 
 
-void OsuSlider::updateStackPosition(float stackOffset) {
 
+void Slider::updateStackPosition(float stackOffset) {
 
     if(m_curve != NULL) m_curve->updateStackPosition(m_iStack * stackOffset, m_beatmap->getOsu()->getModHR());
 
 }
 
 
 
-void OsuSlider::miss(long curPos) {
 
+void Slider::miss(long curPos) {
 
     if(m_bFinished) return;
 
 
 
     const long delta = curPos - m_iTime;
 
 
 
     // startcircle
 
     if(!m_bStartFinished) {
 
-        m_startResult = OsuScore::HIT::HIT_MISS;
 
+        m_startResult = LiveScore::HIT::HIT_MISS;
 
         onHit(m_startResult, delta, false);
 
         bancho.osu->holding_slider = false;
 
     }
@@ -1050,14 +1047,14 @@ void OsuSlider::miss(long curPos) {
 
 
 
             if(!m_bHeldTillEnd && osu_slider_end_miss_breaks_combo.getBool()) onSliderBreak();
 
 
 
-            m_endResult = OsuScore::HIT::HIT_MISS;
 
+            m_endResult = LiveScore::HIT::HIT_MISS;
 
             onHit(m_endResult, 0, true);
 
             bancho.osu->holding_slider = false;
 
         }
 
     }
 
 }
 
 
 
-Vector2 OsuSlider::getRawPosAt(long pos) {
 
+Vector2 Slider::getRawPosAt(long pos) {
 
     if(m_curve == NULL) return Vector2(0, 0);
 
 
 
     if(pos <= m_iTime)
@@ -1071,7 +1068,7 @@ Vector2 OsuSlider::getRawPosAt(long pos) {
 
         return m_curve->pointAt(getT(pos, false));
 
 }
 
 
 
-Vector2 OsuSlider::getOriginalRawPosAt(long pos) {
 
+Vector2 Slider::getOriginalRawPosAt(long pos) {
 
     if(m_curve == NULL) return Vector2(0, 0);
 
 
 
     if(pos <= m_iTime)
@@ -1085,7 +1082,7 @@ Vector2 OsuSlider::getOriginalRawPosAt(long pos) {
 
         return m_curve->originalPointAt(getT(pos, false));
 
 }
 
 
 
-float OsuSlider::getT(long pos, bool raw) {
 
+float Slider::getT(long pos, bool raw) {
 
     float t = (float)((long)pos - (long)m_iTime) / m_fSliderTimeWithoutRepeats;
 
     if(raw)
 
         return t;
@@ -1095,7 +1092,7 @@ float OsuSlider::getT(long pos, bool raw) {
 
     }
 
 }
 
 
 
-void OsuSlider::onClickEvent(std::vector<Click> &clicks) {
 
+void Slider::onClickEvent(std::vector<Click> &clicks) {
 
     if(m_points.size() == 0 || m_bBlocked)
 
         return;  // also handle note blocking here (doesn't need fancy shake logic, since sliders don't shake in
 
                  // osu!stable)
@@ -1108,8 +1105,8 @@ void OsuSlider::onClickEvent(std::vector<Click> &clicks) {
 
         if(cursorDelta < m_beatmap->getHitcircleDiameter() / 2.0f) {
 
             const long delta = clicks[0].tms - (long)m_iTime;
 
 
 
-            OsuScore::HIT result = OsuGameRules::getHitResult(delta, m_beatmap);
 
-            if(result != OsuScore::HIT::HIT_NULL) {
 
+            LiveScore::HIT result = GameRules::getHitResult(delta, m_beatmap);
 
+            if(result != LiveScore::HIT::HIT_NULL) {
 
                 const float targetDelta = cursorDelta / (m_beatmap->getHitcircleDiameter() / 2.0f);
 
                 const float targetAngle = rad2deg(atan2(cursorPos.y - pos.y, cursorPos.x - pos.x));
 
 
@@ -1122,8 +1119,8 @@ void OsuSlider::onClickEvent(std::vector<Click> &clicks) {
 
     }
 
 }
 
 
 
-void OsuSlider::onHit(OsuScore::HIT result, long delta, bool startOrEnd, float targetDelta, float targetAngle,
 
-                      bool isEndResultFromStrictTrackingMod) {
 
+void Slider::onHit(LiveScore::HIT result, long delta, bool startOrEnd, float targetDelta, float targetAngle,
 
+                   bool isEndResultFromStrictTrackingMod) {
 
     if(m_points.size() == 0) return;
 
 
 
     // start + end of a slider add +30 points, if successful
@@ -1132,7 +1129,7 @@ void OsuSlider::onHit(OsuScore::HIT result, long delta, bool startOrEnd, float t
 
 
 
     // sound and hit animation and also sliderbreak combo drop
 
     {
 
-        if(result == OsuScore::HIT::HIT_MISS) {
 
+        if(result == LiveScore::HIT::HIT_MISS) {
 
             if(!isEndResultFromStrictTrackingMod) onSliderBreak();
 
         } else {
 
             if(m_osu_timingpoints_force->getBool())
@@ -1143,18 +1140,18 @@ void OsuSlider::onHit(OsuScore::HIT result, long delta, bool startOrEnd, float t
 
             m_beatmap->getSkin()->playHitCircleSound(m_iCurRepeatCounterForHitSounds < m_hitSounds.size()
 
                                                          ? m_hitSounds[m_iCurRepeatCounterForHitSounds]
 
                                                          : m_iSampleType,
 
-                                                     OsuGameRules::osuCoords2Pan(osuCoords.x));
 
+                                                     GameRules::osuCoords2Pan(osuCoords.x));
 
 
 
             if(!startOrEnd) {
 
                 m_fStartHitAnimation = 0.001f;  // quickfix for 1 frame missing images
 
-                anim->moveQuadOut(&m_fStartHitAnimation, 1.0f, OsuGameRules::getFadeOutTime(m_beatmap), true);
 
+                anim->moveQuadOut(&m_fStartHitAnimation, 1.0f, GameRules::getFadeOutTime(m_beatmap), true);
 
             } else {
 
                 if(m_iRepeat % 2 != 0) {
 
                     m_fEndHitAnimation = 0.001f;  // quickfix for 1 frame missing images
 
-                    anim->moveQuadOut(&m_fEndHitAnimation, 1.0f, OsuGameRules::getFadeOutTime(m_beatmap), true);
 
+                    anim->moveQuadOut(&m_fEndHitAnimation, 1.0f, GameRules::getFadeOutTime(m_beatmap), true);
 
                 } else {
 
                     m_fStartHitAnimation = 0.001f;  // quickfix for 1 frame missing images
 
-                    anim->moveQuadOut(&m_fStartHitAnimation, 1.0f, OsuGameRules::getFadeOutTime(m_beatmap), true);
 
+                    anim->moveQuadOut(&m_fStartHitAnimation, 1.0f, GameRules::getFadeOutTime(m_beatmap), true);
 
                 }
 
             }
 
         }
@@ -1164,7 +1161,7 @@ void OsuSlider::onHit(OsuScore::HIT result, long delta, bool startOrEnd, float t
 
             m_fEndSliderBodyFadeAnimation = 0.001f;  // quickfix for 1 frame missing images
 
             anim->moveQuadOut(
 
                 &m_fEndSliderBodyFadeAnimation, 1.0f,
 
-                OsuGameRules::getFadeOutTime(m_beatmap) * osu_slider_body_fade_out_time_multiplier.getFloat(), true);
 
+                GameRules::getFadeOutTime(m_beatmap) * osu_slider_body_fade_out_time_multiplier.getFloat(), true);
 
 
 
             m_beatmap->getSkin()->stopSliderSlideSound();
 
         }
@@ -1198,15 +1195,15 @@ void OsuSlider::onHit(OsuScore::HIT result, long delta, bool startOrEnd, float t
 
                                   // score, ignore for health, don't add object duration to result anim
 
 
 
         // add bonus score + health manually
 
-        if(result != OsuScore::HIT::HIT_MISS) {
 
-            OsuScore::HIT resultForHealth = OsuScore::HIT::HIT_SLIDER30;
 
+        if(result != LiveScore::HIT::HIT_MISS) {
 
+            LiveScore::HIT resultForHealth = LiveScore::HIT::HIT_SLIDER30;
 
 
 
             m_beatmap->addHitResult(this, resultForHealth, 0, false, true, true, true, true,
 
                                     false);  // only increase health
 
             m_beatmap->addScorePoints(30);
 
         } else {
 
             // special case: missing the startcircle drains HIT_MISS_SLIDERBREAK health (and not HIT_MISS health)
 
-            m_beatmap->addHitResult(this, OsuScore::HIT::HIT_MISS_SLIDERBREAK, 0, false, true, true, true, true,
 
+            m_beatmap->addHitResult(this, LiveScore::HIT::HIT_MISS_SLIDERBREAK, 0, false, true, true, true, true,
 
                                     false);  // only decrease health
 
         }
 
     } else {
@@ -1229,14 +1226,14 @@ void OsuSlider::onHit(OsuScore::HIT result, long delta, bool startOrEnd, float t
 
 
 
             // add bonus score + extra health manually
 
             if(m_bHeldTillEnd) {
 
-                m_beatmap->addHitResult(this, OsuScore::HIT::HIT_SLIDER30, 0, false, true, true, true, true,
 
+                m_beatmap->addHitResult(this, LiveScore::HIT::HIT_SLIDER30, 0, false, true, true, true, true,
 
                                         false);  // only increase health
 
                 m_beatmap->addScorePoints(30);
 
             } else {
 
                 // special case: missing the endcircle drains HIT_MISS_SLIDERBREAK health (and not HIT_MISS health)
 
                 // NOTE: yes, this will drain twice for the end of a slider (once for the judgement of the whole slider
 
                 // above, and once for the endcircle here)
 
-                m_beatmap->addHitResult(this, OsuScore::HIT::HIT_MISS_SLIDERBREAK, 0, false, true, true, true, true,
 
+                m_beatmap->addHitResult(this, LiveScore::HIT::HIT_MISS_SLIDERBREAK, 0, false, true, true, true, true,
 
                                         false);  // only decrease health
 
             }
 
         }
@@ -1245,7 +1242,7 @@ void OsuSlider::onHit(OsuScore::HIT result, long delta, bool startOrEnd, float t
 
     m_iCurRepeatCounterForHitSounds++;
 
 }
 
 
 
-void OsuSlider::onRepeatHit(bool successful, bool sliderend) {
 
+void Slider::onRepeatHit(bool successful, bool sliderend) {
 
     if(m_points.size() == 0) return;
 
 
 
     // repeat hit of a slider adds +30 points, if successful
@@ -1262,21 +1259,21 @@ void OsuSlider::onRepeatHit(bool successful, bool sliderend) {
 
         m_beatmap->getSkin()->playHitCircleSound(m_iCurRepeatCounterForHitSounds < m_hitSounds.size()
 
                                                      ? m_hitSounds[m_iCurRepeatCounterForHitSounds]
 
                                                      : m_iSampleType,
 
-                                                 OsuGameRules::osuCoords2Pan(osuCoords.x));
 
+                                                 GameRules::osuCoords2Pan(osuCoords.x));
 
 
 
         Osu *osu = m_beatmap->getOsu();
 
         float animation_multiplier = osu->getSpeedMultiplier() / osu->getAnimationSpeedMultiplier();
 
-        float tick_pulse_time = OsuGameRules::osu_slider_followcircle_tick_pulse_time.getFloat() * animation_multiplier;
 
+        float tick_pulse_time = GameRules::osu_slider_followcircle_tick_pulse_time.getFloat() * animation_multiplier;
 
 
 
         m_fFollowCircleTickAnimationScale = 0.0f;
 
         anim->moveLinear(&m_fFollowCircleTickAnimationScale, 1.0f, tick_pulse_time, true);
 
 
 
         if(sliderend) {
 
             m_fEndHitAnimation = 0.001f;  // quickfix for 1 frame missing images
 
-            anim->moveQuadOut(&m_fEndHitAnimation, 1.0f, OsuGameRules::getFadeOutTime(m_beatmap), true);
 
+            anim->moveQuadOut(&m_fEndHitAnimation, 1.0f, GameRules::getFadeOutTime(m_beatmap), true);
 
         } else {
 
             m_fStartHitAnimation = 0.001f;  // quickfix for 1 frame missing images
 
-            anim->moveQuadOut(&m_fStartHitAnimation, 1.0f, OsuGameRules::getFadeOutTime(m_beatmap), true);
 
+            anim->moveQuadOut(&m_fStartHitAnimation, 1.0f, GameRules::getFadeOutTime(m_beatmap), true);
 
         }
 
     }
 
 
@@ -1284,10 +1281,10 @@ void OsuSlider::onRepeatHit(bool successful, bool sliderend) {
 
     if(!successful) {
 
         // add health manually
 
         // special case: missing a repeat drains HIT_MISS_SLIDERBREAK health (and not HIT_MISS health)
 
-        m_beatmap->addHitResult(this, OsuScore::HIT::HIT_MISS_SLIDERBREAK, 0, false, true, true, true, true,
 
+        m_beatmap->addHitResult(this, LiveScore::HIT::HIT_MISS_SLIDERBREAK, 0, false, true, true, true, true,
 
                                 false);  // only decrease health
 
     } else {
 
-        m_beatmap->addHitResult(this, OsuScore::HIT::HIT_SLIDER30, 0, false, true, true, false, true,
 
+        m_beatmap->addHitResult(this, LiveScore::HIT::HIT_SLIDER30, 0, false, true, true, false, true,
 
                                 false);  // not end of combo, ignore in hiterrorbar, ignore for accuracy, increase
 
                                          // combo, don't count towards score, increase health
 
 
@@ -1298,7 +1295,7 @@ void OsuSlider::onRepeatHit(bool successful, bool sliderend) {
 
     m_iCurRepeatCounterForHitSounds++;
 
 }
 
 
 
-void OsuSlider::onTickHit(bool successful, int tickIndex) {
 
+void Slider::onTickHit(bool successful, int tickIndex) {
 
     if(m_points.size() == 0) return;
 
 
 
     // tick hit of a slider adds +10 points, if successful
@@ -1319,11 +1316,11 @@ void OsuSlider::onTickHit(bool successful, int tickIndex) {
 
 
 
         const Vector2 osuCoords = m_beatmap->pixels2OsuCoords(m_beatmap->osuCoords2Pixels(m_vCurPointRaw));
 
 
 
-        m_beatmap->getSkin()->playSliderTickSound(OsuGameRules::osuCoords2Pan(osuCoords.x));
 
+        m_beatmap->getSkin()->playSliderTickSound(GameRules::osuCoords2Pan(osuCoords.x));
 
 
 
         Osu *osu = m_beatmap->getOsu();
 
         float animation_multiplier = osu->getSpeedMultiplier() / osu->getAnimationSpeedMultiplier();
 
-        float tick_pulse_time = OsuGameRules::osu_slider_followcircle_tick_pulse_time.getFloat() * animation_multiplier;
 
+        float tick_pulse_time = GameRules::osu_slider_followcircle_tick_pulse_time.getFloat() * animation_multiplier;
 
 
 
         m_fFollowCircleTickAnimationScale = 0.0f;
 
         anim->moveLinear(&m_fFollowCircleTickAnimationScale, 1.0f, tick_pulse_time, true);
@@ -1333,10 +1330,10 @@ void OsuSlider::onTickHit(bool successful, int tickIndex) {
 
     if(!successful) {
 
         // add health manually
 
         // special case: missing a tick drains HIT_MISS_SLIDERBREAK health (and not HIT_MISS health)
 
-        m_beatmap->addHitResult(this, OsuScore::HIT::HIT_MISS_SLIDERBREAK, 0, false, true, true, true, true,
 
+        m_beatmap->addHitResult(this, LiveScore::HIT::HIT_MISS_SLIDERBREAK, 0, false, true, true, true, true,
 
                                 false);  // only decrease health
 
     } else {
 
-        m_beatmap->addHitResult(this, OsuScore::HIT::HIT_SLIDER10, 0, false, true, true, false, true,
 
+        m_beatmap->addHitResult(this, LiveScore::HIT::HIT_SLIDER10, 0, false, true, true, false, true,
 
                                 false);  // not end of combo, ignore in hiterrorbar, ignore for accuracy, increase
 
                                          // combo, don't count towards score, increase health
 
 
@@ -1345,7 +1342,7 @@ void OsuSlider::onTickHit(bool successful, int tickIndex) {
 
     }
 
 }
 
 
 
-void OsuSlider::onSliderBreak() {
 
+void Slider::onSliderBreak() {
 
     m_beatmap->addSliderBreak();
 
 
 
     if(osu_slider_break_epilepsy.getBool()) {
@@ -1354,8 +1351,8 @@ void OsuSlider::onSliderBreak() {
 
     }
 
 }
 
 
 
-void OsuSlider::onReset(long curPos) {
 
-    OsuHitObject::onReset(curPos);
 
+void Slider::onReset(long curPos) {
 
+    HitObject::onReset(curPos);
 
 
 
     m_beatmap->getSkin()->stopSliderSlideSound();
 
 
@@ -1366,8 +1363,8 @@ void OsuSlider::onReset(long curPos) {
 
     m_bHeldTillEnd = false;
 
     m_bHeldTillEndForLenienceHack = false;
 
     m_bHeldTillEndForLenienceHackCheck = false;
 
-    m_startResult = OsuScore::HIT::HIT_NULL;
 
-    m_endResult = OsuScore::HIT::HIT_NULL;
 
+    m_startResult = LiveScore::HIT::HIT_NULL;
 
+    m_endResult = LiveScore::HIT::HIT_NULL;
 
 
 
     m_iCurRepeatCounterForHitSounds = 0;
 
 
@@ -1422,7 +1419,7 @@ void OsuSlider::onReset(long curPos) {
 
     m_epilepsy_ref->setValue(0.0f);
 
 }
 
 
 
-void OsuSlider::rebuildVertexBuffer(bool useRawCoords) {
 
+void Slider::rebuildVertexBuffer(bool useRawCoords) {
 
     // base mesh (background) (raw unscaled, size in raw osu coordinates centered at (0, 0, 0))
 
     // this mesh needs to be scaled and translated appropriately since we are not 1:1 with the playfield
 
     std::vector<Vector2> osuCoordPoints = m_curve->getPoints();
@@ -1432,10 +1429,10 @@ void OsuSlider::rebuildVertexBuffer(bool useRawCoords) {
 
         }
 
     }
 
     SAFE_DELETE(m_vao);
 
-    m_vao = OsuSliderRenderer::generateVAO(m_beatmap->getOsu(), osuCoordPoints, m_beatmap->getRawHitcircleDiameter());
 
+    m_vao = SliderRenderer::generateVAO(m_beatmap->getOsu(), osuCoordPoints, m_beatmap->getRawHitcircleDiameter());
 
 }
 
 
 
-bool OsuSlider::isClickHeldSlider() {
 
+bool Slider::isClickHeldSlider() {
 
     // osu! has a weird slider quirk, that I'll explain in detail here.
 
     // When holding K1 before the slider, tapping K2 on slider head, and releasing K2 later,
 
     // the slider is no longer considered being "held" until K2 is pressed again, or K1 is released and pressed again.
--- a/src/App/Osu/OsuSlider.h
+++ b/src/App/Osu/OsuSlider.h
@@ -8,13 +8,13 @@
 
 #ifndef OSUSLIDER_H
 
 #define OSUSLIDER_H
 
 
 
-#include "OsuHitObject.h"
 
+#include "HitObject.h"
 
 
 
-class OsuSliderCurve;
 
+class SliderCurve;
 
 
 
 class VertexArrayObject;
 
 
 
-class OsuSlider : public OsuHitObject {
 
+class Slider : public HitObject {
 
    public:
 
     struct SLIDERCLICK {
 
         long time;
@@ -26,10 +26,10 @@ class OsuSlider : public OsuHitObject {
 
     };
 
 
 
    public:
 
-    OsuSlider(char type, int repeat, float pixelLength, std::vector<Vector2> points, std::vector<int> hitSounds,
 
-              std::vector<float> ticks, float sliderTime, float sliderTimeWithoutRepeats, long time, int sampleType,
 
-              int comboNumber, bool isEndOfCombo, int colorCounter, int colorOffset, OsuBeatmap *beatmap);
 
-    virtual ~OsuSlider();
 
+    Slider(char type, int repeat, float pixelLength, std::vector<Vector2> points, std::vector<int> hitSounds,
 
+           std::vector<float> ticks, float sliderTime, float sliderTimeWithoutRepeats, long time, int sampleType,
 
+           int comboNumber, bool isEndOfCombo, int colorCounter, int colorOffset, Beatmap *beatmap);
 
+    virtual ~Slider();
 
 
 
     virtual void draw(Graphics *g);
 
     virtual void draw2(Graphics *g);
@@ -61,7 +61,7 @@ class OsuSlider : public OsuHitObject {
 
 
 
     // ILLEGAL:
 
     inline VertexArrayObject *getVAO() const { return m_vao; }
 
-    inline OsuSliderCurve *getCurve() const { return m_curve; }
 
+    inline SliderCurve *getCurve() const { return m_curve; }
 
 
 
    private:
 
     static ConVar *m_osu_playfield_mirror_horizontal_ref;
@@ -80,7 +80,7 @@ class OsuSlider : public OsuHitObject {
 
 
 
     void updateAnimations(long curPos);
 
 
 
-    void onHit(OsuScore::HIT result, long delta, bool startOrEnd, float targetDelta = 0.0f, float targetAngle = 0.0f,
 
+    void onHit(LiveScore::HIT result, long delta, bool startOrEnd, float targetDelta = 0.0f, float targetAngle = 0.0f,
 
                bool isEndResultFromStrictTrackingMod = false);
 
     void onRepeatHit(bool successful, bool sliderend);
 
     void onTickHit(bool successful, int tickIndex);
@@ -90,9 +90,9 @@ class OsuSlider : public OsuHitObject {
 
 
 
     bool isClickHeldSlider();  // special logic to disallow hold tapping
 
 
 
-    OsuBeatmap *m_beatmap;
 
+    Beatmap *m_beatmap;
 
 
 
-    OsuSliderCurve *m_curve;
 
+    SliderCurve *m_curve;
 
 
 
     char m_cType;
 
     int m_iRepeat;
@@ -120,8 +120,8 @@ class OsuSlider : public OsuHitObject {
 
     Vector2 m_vCurPoint;
 
     Vector2 m_vCurPointRaw;
 
 
 
-    OsuScore::HIT m_startResult;
 
-    OsuScore::HIT m_endResult;
 
+    LiveScore::HIT m_startResult;
 
+    LiveScore::HIT m_endResult;
 
     bool m_bStartFinished;
 
     float m_fStartHitAnimation;
 
     bool m_bEndFinished;
--- a/src/App/Osu/OsuSliderCurves.cpp
+++ b/src/App/Osu/OsuSliderCurves.cpp
@@ -6,7 +6,7 @@
 
 // $NoKeywords: $slidercurves
 
 //=====================================================================================================//
 
 
 
-#include "OsuSliderCurves.h"
 
+#include "SliderCurves.h"
 
 
 
 #include "ConVar.h"
 
 #include "Engine.h"
@@ -25,14 +25,13 @@ ConVar osu_slider_curve_max_length("osu_slider_curve_max_length", 65536 / 2, FCV
 
 //	 Curve Base Class	//
 
 //**********************//
 
 
 
-OsuSliderCurve *OsuSliderCurve::createCurve(char osuSliderCurveType, std::vector<Vector2> controlPoints,
 
-                                            float pixelLength) {
 
+SliderCurve *SliderCurve::createCurve(char osuSliderCurveType, std::vector<Vector2> controlPoints, float pixelLength) {
 
     const float points_separation = osu_slider_curve_points_separation.getFloat();
 
     return createCurve(osuSliderCurveType, controlPoints, pixelLength, points_separation);
 
 }
 
 
 
-OsuSliderCurve *OsuSliderCurve::createCurve(char osuSliderCurveType, std::vector<Vector2> controlPoints,
 
-                                            float pixelLength, float curvePointsSeparation) {
 
+SliderCurve *SliderCurve::createCurve(char osuSliderCurveType, std::vector<Vector2> controlPoints, float pixelLength,
 
+                                      float curvePointsSeparation) {
 
     if(osuSliderCurveType == OSUSLIDERCURVETYPE_PASSTHROUGH && controlPoints.size() == 3) {
 
         Vector2 nora = controlPoints[1] - controlPoints[0];
 
         Vector2 norb = controlPoints[1] - controlPoints[2];
@@ -48,19 +47,18 @@ OsuSliderCurve *OsuSliderCurve::createCurve(char osuSliderCurveType, std::vector
 
         // segments if they are too big
 
 
 
         if(std::abs(norb.x * nora.y - norb.y * nora.x) < 0.00001f)
 
-            return new OsuSliderCurveLinearBezier(
 
-                controlPoints, pixelLength, false,
 
-                curvePointsSeparation);  // vectors parallel, use linear bezier instead
 
+            return new SliderCurveLinearBezier(controlPoints, pixelLength, false,
 
+                                               curvePointsSeparation);  // vectors parallel, use linear bezier instead
 
         else
 
-            return new OsuSliderCurveCircumscribedCircle(controlPoints, pixelLength, curvePointsSeparation);
 
+            return new SliderCurveCircumscribedCircle(controlPoints, pixelLength, curvePointsSeparation);
 
     } else if(osuSliderCurveType == OSUSLIDERCURVETYPE_CATMULL)
 
-        return new OsuSliderCurveCatmull(controlPoints, pixelLength, curvePointsSeparation);
 
+        return new SliderCurveCatmull(controlPoints, pixelLength, curvePointsSeparation);
 
     else
 
-        return new OsuSliderCurveLinearBezier(controlPoints, pixelLength,
 
-                                              (osuSliderCurveType == OSUSLIDERCURVETYPE_LINEAR), curvePointsSeparation);
 
+        return new SliderCurveLinearBezier(controlPoints, pixelLength,
 
+                                           (osuSliderCurveType == OSUSLIDERCURVETYPE_LINEAR), curvePointsSeparation);
 
 }
 
 
 
-OsuSliderCurve::OsuSliderCurve(std::vector<Vector2> controlPoints, float pixelLength) {
 
+SliderCurve::SliderCurve(std::vector<Vector2> controlPoints, float pixelLength) {
 
     m_controlPoints = controlPoints;
 
     m_fPixelLength = pixelLength;
 
 
@@ -68,7 +66,7 @@ OsuSliderCurve::OsuSliderCurve(std::vector<Vector2> controlPoints, float pixelLe
 
     m_fEndAngle = 0.0f;
 
 }
 
 
 
-void OsuSliderCurve::updateStackPosition(float stackMulStackOffset, bool HR) {
 
+void SliderCurve::updateStackPosition(float stackMulStackOffset, bool HR) {
 
     for(int i = 0; i < m_originalCurvePoints.size() && i < m_curvePoints.size(); i++) {
 
         m_curvePoints[i] =
 
             m_originalCurvePoints[i] - Vector2(stackMulStackOffset, stackMulStackOffset * (HR ? -1.0f : 1.0f));
@@ -86,19 +84,19 @@ void OsuSliderCurve::updateStackPosition(float stackMulStackOffset, bool HR) {
 
 //	 Curve Type Base Class & Curve Types	//
 
 //******************************************//
 
 
 
-OsuSliderCurveType::OsuSliderCurveType() { m_fTotalDistance = 0.0f; }
 
+SliderCurveType::SliderCurveType() { m_fTotalDistance = 0.0f; }
 
 
 
-void OsuSliderCurveType::init(float approxLength) {
 
+void SliderCurveType::init(float approxLength) {
 
     calculateIntermediaryPoints(approxLength);
 
     calculateCurveDistances();
 
 }
 
 
 
-void OsuSliderCurveType::initCustom(std::vector<Vector2> points) {
 
+void SliderCurveType::initCustom(std::vector<Vector2> points) {
 
     m_points = std::move(points);
 
     calculateCurveDistances();
 
 }
 
 
 
-void OsuSliderCurveType::calculateIntermediaryPoints(float approxLength) {
 
+void SliderCurveType::calculateIntermediaryPoints(float approxLength) {
 
     // subdivide the curve, calculate all intermediary points
 
     const int numPoints = (int)(approxLength / 4.0f) + 2;
 
     m_points.reserve(numPoints);
@@ -107,7 +105,7 @@ void OsuSliderCurveType::calculateIntermediaryPoints(float approxLength) {
 
     }
 
 }
 
 
 
-void OsuSliderCurveType::calculateCurveDistances() {
 
+void SliderCurveType::calculateCurveDistances() {
 
     // reset
 
     m_fTotalDistance = 0.0f;
 
     m_curveDistances.clear();
@@ -122,14 +120,14 @@ void OsuSliderCurveType::calculateCurveDistances() {
 
     }
 
 }
 
 
 
-OsuSliderCurveTypeBezier2::OsuSliderCurveTypeBezier2(const std::vector<Vector2> &points) : OsuSliderCurveType() {
 
-    initCustom(OsuSliderBezierApproximator().createBezier(points));
 
+SliderCurveTypeBezier2::SliderCurveTypeBezier2(const std::vector<Vector2> &points) : SliderCurveType() {
 
+    initCustom(SliderBezierApproximator().createBezier(points));
 
 }
 
 
 
-OsuSliderCurveTypeCentripetalCatmullRom::OsuSliderCurveTypeCentripetalCatmullRom(const std::vector<Vector2> &points)
 
-    : OsuSliderCurveType() {
 
+SliderCurveTypeCentripetalCatmullRom::SliderCurveTypeCentripetalCatmullRom(const std::vector<Vector2> &points)
 
+    : SliderCurveType() {
 
     if(points.size() != 4) {
 
-        debugLog("OsuSliderCurveTypeCentripetalCatmullRom() Error: points.size() != 4!!!\n");
 
+        debugLog("SliderCurveTypeCentripetalCatmullRom() Error: points.size() != 4!!!\n");
 
         return;
 
     }
 
 
@@ -153,7 +151,7 @@ OsuSliderCurveTypeCentripetalCatmullRom::OsuSliderCurveTypeCentripetalCatmullRom
 
     init(approxLength / 2.0f);
 
 }
 
 
 
-Vector2 OsuSliderCurveTypeCentripetalCatmullRom::pointAt(float t) {
 
+Vector2 SliderCurveTypeCentripetalCatmullRom::pointAt(float t) {
 
     t = t * (m_time[2] - m_time[1]) + m_time[1];
 
 
 
     const Vector2 A1 = m_points[0] * ((m_time[1] - t) / (m_time[1] - m_time[0])) +
@@ -178,16 +176,16 @@ Vector2 OsuSliderCurveTypeCentripetalCatmullRom::pointAt(float t) {
 
 //	 Curve Classes	 //
 
 //*******************//
 
 
 
-OsuSliderCurveEqualDistanceMulti::OsuSliderCurveEqualDistanceMulti(std::vector<Vector2> controlPoints,
 
-                                                                   float pixelLength, float curvePointsSeparation)
 
-    : OsuSliderCurve(controlPoints, pixelLength) {
 
+SliderCurveEqualDistanceMulti::SliderCurveEqualDistanceMulti(std::vector<Vector2> controlPoints, float pixelLength,
 
+                                                             float curvePointsSeparation)
 
+    : SliderCurve(controlPoints, pixelLength) {
 
     const int max_points = osu_slider_curve_max_points.getInt();
 
     m_iNCurve = std::min((int)(m_fPixelLength / clamp<float>(curvePointsSeparation, 1.0f, 100.0f)), max_points);
 
 }
 
 
 
-void OsuSliderCurveEqualDistanceMulti::init(const std::vector<OsuSliderCurveType *> &curvesList) {
 
+void SliderCurveEqualDistanceMulti::init(const std::vector<SliderCurveType *> &curvesList) {
 
     if(curvesList.size() < 1) {
 
-        debugLog("OsuSliderCurveEqualDistanceMulti::init() Error: curvesList.size() == 0!!!\n");
 
+        debugLog("SliderCurveEqualDistanceMulti::init() Error: curvesList.size() == 0!!!\n");
 
         return;
 
     }
 
 
@@ -197,10 +195,10 @@ void OsuSliderCurveEqualDistanceMulti::init(const std::vector<OsuSliderCurveType
 
     float distanceAt = 0.0f;
 
     float lastDistanceAt = 0.0f;
 
 
 
-    OsuSliderCurveType *curCurve = curvesList[curCurveIndex];
 
+    SliderCurveType *curCurve = curvesList[curCurveIndex];
 
     {
 
         if(curCurve->getCurvePoints().size() < 1) {
 
-            debugLog("OsuSliderCurveEqualDistanceMulti::init() Error: curCurve->getCurvePoints().size() == 0!!!\n");
 
+            debugLog("SliderCurveEqualDistanceMulti::init() Error: curCurve->getCurvePoints().size() == 0!!!\n");
 
 
 
             // cleanup
 
             for(size_t i = 0; i < curvesList.size(); i++) {
@@ -286,7 +284,7 @@ void OsuSliderCurveEqualDistanceMulti::init(const std::vector<OsuSliderCurveType
 
 
 
     // sanity check
 
     if(m_curvePoints.size() == 0) {
 
-        debugLog("OsuSliderCurveEqualDistanceMulti::init() Error: m_curvePoints.size() == 0!!!\n");
 
+        debugLog("SliderCurveEqualDistanceMulti::init() Error: m_curvePoints.size() == 0!!!\n");
 
 
 
         // cleanup
 
         for(size_t i = 0; i < curvesList.size(); i++) {
@@ -362,7 +360,7 @@ void OsuSliderCurveEqualDistanceMulti::init(const std::vector<OsuSliderCurveType
 
     }
 
 }
 
 
 
-Vector2 OsuSliderCurveEqualDistanceMulti::pointAt(float t) {
 
+Vector2 SliderCurveEqualDistanceMulti::pointAt(float t) {
 
     if(m_curvePoints.size() < 1) return Vector2(0, 0);
 
 
 
     const float indexF = t * m_iNCurve;
@@ -371,12 +369,12 @@ Vector2 OsuSliderCurveEqualDistanceMulti::pointAt(float t) {
 
         if(m_iNCurve > -1 && m_iNCurve < m_curvePoints.size())
 
             return m_curvePoints[m_iNCurve];
 
         else {
 
-            debugLog("OsuSliderCurveEqualDistanceMulti::pointAt() Error: Illegal index %i!!!\n", m_iNCurve);
 
+            debugLog("SliderCurveEqualDistanceMulti::pointAt() Error: Illegal index %i!!!\n", m_iNCurve);
 
             return Vector2(0, 0);
 
         }
 
     } else {
 
         if(index < 0 || index + 1 >= m_curvePoints.size()) {
 
-            debugLog("OsuSliderCurveEqualDistanceMulti::pointAt() Error: Illegal index %i!!!\n", index);
 
+            debugLog("SliderCurveEqualDistanceMulti::pointAt() Error: Illegal index %i!!!\n", index);
 
             return Vector2(0, 0);
 
         }
 
 
@@ -389,7 +387,7 @@ Vector2 OsuSliderCurveEqualDistanceMulti::pointAt(float t) {
 
     }
 
 }
 
 
 
-Vector2 OsuSliderCurveEqualDistanceMulti::originalPointAt(float t) {
 
+Vector2 SliderCurveEqualDistanceMulti::originalPointAt(float t) {
 
     if(m_originalCurvePoints.size() < 1) return Vector2(0, 0);
 
 
 
     const float indexF = t * m_iNCurve;
@@ -398,12 +396,12 @@ Vector2 OsuSliderCurveEqualDistanceMulti::originalPointAt(float t) {
 
         if(m_iNCurve > -1 && m_iNCurve < m_originalCurvePoints.size())
 
             return m_originalCurvePoints[m_iNCurve];
 
         else {
 
-            debugLog("OsuSliderCurveEqualDistanceMulti::originalPointAt() Error: Illegal index %i!!!\n", m_iNCurve);
 
+            debugLog("SliderCurveEqualDistanceMulti::originalPointAt() Error: Illegal index %i!!!\n", m_iNCurve);
 
             return Vector2(0, 0);
 
         }
 
     } else {
 
         if(index < 0 || index + 1 >= m_originalCurvePoints.size()) {
 
-            debugLog("OsuSliderCurveEqualDistanceMulti::originalPointAt() Error: Illegal index %i!!!\n", index);
 
+            debugLog("SliderCurveEqualDistanceMulti::originalPointAt() Error: Illegal index %i!!!\n", index);
 
             return Vector2(0, 0);
 
         }
 
 
@@ -416,12 +414,12 @@ Vector2 OsuSliderCurveEqualDistanceMulti::originalPointAt(float t) {
 
     }
 
 }
 
 
 
-OsuSliderCurveLinearBezier::OsuSliderCurveLinearBezier(std::vector<Vector2> controlPoints, float pixelLength, bool line,
 
-                                                       float curvePointsSeparation)
 
-    : OsuSliderCurveEqualDistanceMulti(controlPoints, pixelLength, curvePointsSeparation) {
 
+SliderCurveLinearBezier::SliderCurveLinearBezier(std::vector<Vector2> controlPoints, float pixelLength, bool line,
 
+                                                 float curvePointsSeparation)
 
+    : SliderCurveEqualDistanceMulti(controlPoints, pixelLength, curvePointsSeparation) {
 
     const int numControlPoints = m_controlPoints.size();
 
 
 
-    std::vector<OsuSliderCurveType *> beziers;
 
+    std::vector<SliderCurveType *> beziers;
 
 
 
     std::vector<Vector2> points;  // temporary list of points to separate different bezier curves
 
 
@@ -437,14 +435,14 @@ OsuSliderCurveLinearBezier::OsuSliderCurveLinearBezier(std::vector<Vector2> cont
 
             if(i > 0) {
 
                 points.push_back(currentPoint);
 
 
 
-                beziers.push_back(new OsuSliderCurveTypeBezier2(points));
 
+                beziers.push_back(new SliderCurveTypeBezier2(points));
 
 
 
                 points.clear();
 
             }
 
         } else if(i > 0) {
 
             if(currentPoint == lastPoint) {
 
                 if(points.size() >= 2) {
 
-                    beziers.push_back(new OsuSliderCurveTypeBezier2(points));
 
+                    beziers.push_back(new SliderCurveTypeBezier2(points));
 
                 }
 
 
 
                 points.clear();
@@ -459,21 +457,21 @@ OsuSliderCurveLinearBezier::OsuSliderCurveLinearBezier(std::vector<Vector2> cont
 
         // trying to continue Bezier with less than 2 points
 
         // probably ending on a red point, just ignore it
 
     } else {
 
-        beziers.push_back(new OsuSliderCurveTypeBezier2(points));
 
+        beziers.push_back(new SliderCurveTypeBezier2(points));
 
 
 
         points.clear();
 
     }
 
 
 
     // build curve
 
-    OsuSliderCurveEqualDistanceMulti::init(beziers);
 
+    SliderCurveEqualDistanceMulti::init(beziers);
 
 }
 
 
 
-OsuSliderCurveCatmull::OsuSliderCurveCatmull(std::vector<Vector2> controlPoints, float pixelLength,
 
-                                             float curvePointsSeparation)
 
-    : OsuSliderCurveEqualDistanceMulti(controlPoints, pixelLength, curvePointsSeparation) {
 
+SliderCurveCatmull::SliderCurveCatmull(std::vector<Vector2> controlPoints, float pixelLength,
 
+                                       float curvePointsSeparation)
 
+    : SliderCurveEqualDistanceMulti(controlPoints, pixelLength, curvePointsSeparation) {
 
     const int numControlPoints = m_controlPoints.size();
 
 
 
-    std::vector<OsuSliderCurveType *> catmulls;
 
+    std::vector<SliderCurveType *> catmulls;
 
 
 
     std::vector<Vector2> points;  // temporary list of points to separate different curves
 
 
@@ -488,7 +486,7 @@ OsuSliderCurveCatmull::OsuSliderCurveCatmull(std::vector<Vector2> controlPoints,
 
     for(int i = 0; i < numControlPoints; i++) {
 
         points.push_back(m_controlPoints[i]);
 
         if(points.size() >= 4) {
 
-            catmulls.push_back(new OsuSliderCurveTypeCentripetalCatmullRom(points));
 
+            catmulls.push_back(new SliderCurveTypeCentripetalCatmullRom(points));
 
 
 
             points.erase(points.begin());
 
         }
@@ -499,18 +497,18 @@ OsuSliderCurveCatmull::OsuSliderCurveCatmull(std::vector<Vector2> controlPoints,
 
         points.push_back(m_controlPoints[numControlPoints - 1]);
 
 
 
     if(points.size() >= 4) {
 
-        catmulls.push_back(new OsuSliderCurveTypeCentripetalCatmullRom(points));
 
+        catmulls.push_back(new SliderCurveTypeCentripetalCatmullRom(points));
 
     }
 
 
 
     // build curve
 
-    OsuSliderCurveEqualDistanceMulti::init(catmulls);
 
+    SliderCurveEqualDistanceMulti::init(catmulls);
 
 }
 
 
 
-OsuSliderCurveCircumscribedCircle::OsuSliderCurveCircumscribedCircle(std::vector<Vector2> controlPoints,
 
-                                                                     float pixelLength, float curvePointsSeparation)
 
-    : OsuSliderCurve(controlPoints, pixelLength) {
 
+SliderCurveCircumscribedCircle::SliderCurveCircumscribedCircle(std::vector<Vector2> controlPoints, float pixelLength,
 
+                                                               float curvePointsSeparation)
 
+    : SliderCurve(controlPoints, pixelLength) {
 
     if(controlPoints.size() != 3) {
 
-        debugLog("OsuSliderCurveCircumscribedCircle() Error: controlPoints.size() != 3\n");
 
+        debugLog("SliderCurveCircumscribedCircle() Error: controlPoints.size() != 3\n");
 
         return;
 
     }
 
 
@@ -559,7 +557,7 @@ OsuSliderCurveCircumscribedCircle::OsuSliderCurveCircumscribedCircle(std::vector
 
                 isIn(m_fCalculationStartAngle, midAng, m_fCalculationEndAngle - (2 * PI)))
 
             m_fCalculationEndAngle -= 2 * PI;
 
         else {
 
-            debugLog("OsuSliderCurveCircumscribedCircle() Error: Cannot find angles between midAng (%.3f %.3f %.3f)\n",
 
+            debugLog("SliderCurveCircumscribedCircle() Error: Cannot find angles between midAng (%.3f %.3f %.3f)\n",
 
                      m_fCalculationStartAngle, midAng, m_fCalculationEndAngle);
 
             return;
 
         }
@@ -601,13 +599,13 @@ OsuSliderCurveCircumscribedCircle::OsuSliderCurveCircumscribedCircle(std::vector
 
     m_originalCurvePointSegments = std::vector<std::vector<Vector2>>(m_curvePointSegments);  // copy
 
 }
 
 
 
-void OsuSliderCurveCircumscribedCircle::updateStackPosition(float stackMulStackOffset, bool HR) {
 
-    OsuSliderCurve::updateStackPosition(stackMulStackOffset, HR);
 
+void SliderCurveCircumscribedCircle::updateStackPosition(float stackMulStackOffset, bool HR) {
 
+    SliderCurve::updateStackPosition(stackMulStackOffset, HR);
 
 
 
     m_vCircleCenter = m_vOriginalCircleCenter - Vector2(stackMulStackOffset, stackMulStackOffset * (HR ? -1.0f : 1.0f));
 
 }
 
 
 
-Vector2 OsuSliderCurveCircumscribedCircle::pointAt(float t) {
 
+Vector2 SliderCurveCircumscribedCircle::pointAt(float t) {
 
     const float sanityRange =
 
         osu_slider_curve_max_length
 
             .getFloat();  // NOTE: added to fix some aspire problems (endless drawFollowPoints and star calc etc.)
@@ -617,7 +615,7 @@ Vector2 OsuSliderCurveCircumscribedCircle::pointAt(float t) {
 
                    clamp<float>(std::sin(ang) * m_fRadius + m_vCircleCenter.y, -sanityRange, sanityRange));
 
 }
 
 
 
-Vector2 OsuSliderCurveCircumscribedCircle::originalPointAt(float t) {
 
+Vector2 SliderCurveCircumscribedCircle::originalPointAt(float t) {
 
     const float sanityRange =
 
         osu_slider_curve_max_length
 
             .getFloat();  // NOTE: added to fix some aspire problems (endless drawFollowPoints and star calc etc.)
@@ -627,10 +625,10 @@ Vector2 OsuSliderCurveCircumscribedCircle::originalPointAt(float t) {
 
                    clamp<float>(std::sin(ang) * m_fRadius + m_vOriginalCircleCenter.y, -sanityRange, sanityRange));
 
 }
 
 
 
-Vector2 OsuSliderCurveCircumscribedCircle::intersect(Vector2 a, Vector2 ta, Vector2 b, Vector2 tb) {
 
+Vector2 SliderCurveCircumscribedCircle::intersect(Vector2 a, Vector2 ta, Vector2 b, Vector2 tb) {
 
     const float des = (tb.x * ta.y - tb.y * ta.x);
 
     if(std::abs(des) < 0.0001f) {
 
-        debugLog("OsuSliderCurveCircumscribedCircle::intersect() Error: Vectors are parallel!!!\n");
 
+        debugLog("SliderCurveCircumscribedCircle::intersect() Error: Vectors are parallel!!!\n");
 
         return Vector2(0, 0);
 
     }
 
 
@@ -646,11 +644,11 @@ Vector2 OsuSliderCurveCircumscribedCircle::intersect(Vector2 a, Vector2 ta, Vect
 
 // https://github.com/ppy/osu-framework/blob/master/osu.Framework/MathUtils/PathApproximator.cs
 
 // Copyright (c) ppy Pty Ltd <[email protected]>. Licensed under the MIT Licence.
 
 
 
-double OsuSliderBezierApproximator::TOLERANCE_SQ = 0.25 * 0.25;
 
+double SliderBezierApproximator::TOLERANCE_SQ = 0.25 * 0.25;
 
 
 
-OsuSliderBezierApproximator::OsuSliderBezierApproximator() { m_iCount = 0; }
 
+SliderBezierApproximator::SliderBezierApproximator() { m_iCount = 0; }
 
 
 
-std::vector<Vector2> OsuSliderBezierApproximator::createBezier(const std::vector<Vector2> &controlPoints) {
 
+std::vector<Vector2> SliderBezierApproximator::createBezier(const std::vector<Vector2> &controlPoints) {
 
     m_iCount = controlPoints.size();
 
 
 
     std::vector<Vector2> output;
@@ -697,7 +695,7 @@ std::vector<Vector2> OsuSliderBezierApproximator::createBezier(const std::vector
 
     return output;
 
 }
 
 
 
-bool OsuSliderBezierApproximator::isFlatEnough(const std::vector<Vector2> &controlPoints) {
 
+bool SliderBezierApproximator::isFlatEnough(const std::vector<Vector2> &controlPoints) {
 
     if(controlPoints.size() < 1) return true;
 
 
 
     for(int i = 1; i < (int)(controlPoints.size() - 1); i++) {
@@ -709,8 +707,8 @@ bool OsuSliderBezierApproximator::isFlatEnough(const std::vector<Vector2> &contr
 
     return true;
 
 }
 
 
 
-void OsuSliderBezierApproximator::subdivide(std::vector<Vector2> &controlPoints, std::vector<Vector2> &l,
 
-                                            std::vector<Vector2> &r) {
 
+void SliderBezierApproximator::subdivide(std::vector<Vector2> &controlPoints, std::vector<Vector2> &l,
 
+                                         std::vector<Vector2> &r) {
 
     std::vector<Vector2> &midpoints = m_subdivisionBuffer1;
 
 
 
     for(int i = 0; i < m_iCount; ++i) {
@@ -727,7 +725,7 @@ void OsuSliderBezierApproximator::subdivide(std::vector<Vector2> &controlPoints,
 
     }
 
 }
 
 
 
-void OsuSliderBezierApproximator::approximate(std::vector<Vector2> &controlPoints, std::vector<Vector2> &output) {
 
+void SliderBezierApproximator::approximate(std::vector<Vector2> &controlPoints, std::vector<Vector2> &output) {
 
     std::vector<Vector2> &l = m_subdivisionBuffer2;
 
     std::vector<Vector2> &r = m_subdivisionBuffer1;
 
 
--- a/src/App/Osu/OsuSliderCurves.h
+++ b/src/App/Osu/OsuSliderCurves.h
@@ -15,7 +15,7 @@
 
 //	 Curve Base Class	//
 
 //**********************//
 
 
 
-class OsuSliderCurve {
 
+class SliderCurve {
 
    public:
 
     enum OSUSLIDERCURVETYPE {
 
         OSUSLIDERCURVETYPE_CATMULL = 'C',
@@ -24,13 +24,13 @@ class OsuSliderCurve {
 
         OSUSLIDERCURVETYPE_PASSTHROUGH = 'P'
 
     };
 
 
 
-    static OsuSliderCurve *createCurve(char osuSliderCurveType, std::vector<Vector2> controlPoints, float pixelLength);
 
-    static OsuSliderCurve *createCurve(char osuSliderCurveType, std::vector<Vector2> controlPoints, float pixelLength,
 
-                                       float curvePointsSeparation);
 
+    static SliderCurve *createCurve(char osuSliderCurveType, std::vector<Vector2> controlPoints, float pixelLength);
 
+    static SliderCurve *createCurve(char osuSliderCurveType, std::vector<Vector2> controlPoints, float pixelLength,
 
+                                    float curvePointsSeparation);
 
 
 
    public:
 
-    OsuSliderCurve(std::vector<Vector2> controlPoints, float pixelLength);
 
-    virtual ~OsuSliderCurve() { ; }
 
+    SliderCurve(std::vector<Vector2> controlPoints, float pixelLength);
 
+    virtual ~SliderCurve() { ; }
 
 
 
     virtual void updateStackPosition(float stackMulStackOffset, bool HR);
 
 
@@ -61,10 +61,10 @@ class OsuSliderCurve {
 
 //	 Curve Type Base Class & Curve Types	//
 
 //******************************************//
 
 
 
-class OsuSliderCurveType {
 
+class SliderCurveType {
 
    public:
 
-    OsuSliderCurveType();
 
-    virtual ~OsuSliderCurveType() { ; }
 
+    SliderCurveType();
 
+    virtual ~SliderCurveType() { ; }
 
 
 
     virtual Vector2 pointAt(float t) = 0;
 
 
@@ -90,18 +90,18 @@ class OsuSliderCurveType {
 
     std::vector<float> m_curveDistances;
 
 };
 
 
 
-class OsuSliderCurveTypeBezier2 : public OsuSliderCurveType {
 
+class SliderCurveTypeBezier2 : public SliderCurveType {
 
    public:
 
-    OsuSliderCurveTypeBezier2(const std::vector<Vector2> &points);
 
-    virtual ~OsuSliderCurveTypeBezier2() { ; }
 
+    SliderCurveTypeBezier2(const std::vector<Vector2> &points);
 
+    virtual ~SliderCurveTypeBezier2() { ; }
 
 
 
     virtual Vector2 pointAt(float t) { return Vector2(); }  // unused
 
 };
 
 
 
-class OsuSliderCurveTypeCentripetalCatmullRom : public OsuSliderCurveType {
 
+class SliderCurveTypeCentripetalCatmullRom : public SliderCurveType {
 
    public:
 
-    OsuSliderCurveTypeCentripetalCatmullRom(const std::vector<Vector2> &points);
 
-    virtual ~OsuSliderCurveTypeCentripetalCatmullRom() { ; }
 
+    SliderCurveTypeCentripetalCatmullRom(const std::vector<Vector2> &points);
 
+    virtual ~SliderCurveTypeCentripetalCatmullRom() { ; }
 
 
 
     virtual Vector2 pointAt(float t);
 
 
@@ -114,14 +114,13 @@ class OsuSliderCurveTypeCentripetalCatmullRom : public OsuSliderCurveType {
 
 //	 Curve Classes	 //
 
 //*******************//
 
 
 
-class OsuSliderCurveEqualDistanceMulti : public OsuSliderCurve {
 
+class SliderCurveEqualDistanceMulti : public SliderCurve {
 
    public:
 
-    OsuSliderCurveEqualDistanceMulti(std::vector<Vector2> controlPoints, float pixelLength,
 
-                                     float curvePointsSeparation);
 
-    virtual ~OsuSliderCurveEqualDistanceMulti() { ; }
 
+    SliderCurveEqualDistanceMulti(std::vector<Vector2> controlPoints, float pixelLength, float curvePointsSeparation);
 
+    virtual ~SliderCurveEqualDistanceMulti() { ; }
 
 
 
     // must be called from one of the subclasses
 
-    void init(const std::vector<OsuSliderCurveType *> &curvesList);
 
+    void init(const std::vector<SliderCurveType *> &curvesList);
 
 
 
     virtual Vector2 pointAt(float t);
 
     virtual Vector2 originalPointAt(float t);
@@ -130,24 +129,23 @@ class OsuSliderCurveEqualDistanceMulti : public OsuSliderCurve {
 
     int m_iNCurve;
 
 };
 
 
 
-class OsuSliderCurveLinearBezier : public OsuSliderCurveEqualDistanceMulti {
 
+class SliderCurveLinearBezier : public SliderCurveEqualDistanceMulti {
 
    public:
 
-    OsuSliderCurveLinearBezier(std::vector<Vector2> controlPoints, float pixelLength, bool line,
 
-                               float curvePointsSeparation);
 
-    virtual ~OsuSliderCurveLinearBezier() { ; }
 
+    SliderCurveLinearBezier(std::vector<Vector2> controlPoints, float pixelLength, bool line,
 
+                            float curvePointsSeparation);
 
+    virtual ~SliderCurveLinearBezier() { ; }
 
 };
 
 
 
-class OsuSliderCurveCatmull : public OsuSliderCurveEqualDistanceMulti {
 
+class SliderCurveCatmull : public SliderCurveEqualDistanceMulti {
 
    public:
 
-    OsuSliderCurveCatmull(std::vector<Vector2> controlPoints, float pixelLength, float curvePointsSeparation);
 
-    virtual ~OsuSliderCurveCatmull() { ; }
 
+    SliderCurveCatmull(std::vector<Vector2> controlPoints, float pixelLength, float curvePointsSeparation);
 
+    virtual ~SliderCurveCatmull() { ; }
 
 };
 
 
 
-class OsuSliderCurveCircumscribedCircle : public OsuSliderCurve {
 
+class SliderCurveCircumscribedCircle : public SliderCurve {
 
    public:
 
-    OsuSliderCurveCircumscribedCircle(std::vector<Vector2> controlPoints, float pixelLength,
 
-                                      float curvePointsSeparation);
 
-    virtual ~OsuSliderCurveCircumscribedCircle() { ; }
 
+    SliderCurveCircumscribedCircle(std::vector<Vector2> controlPoints, float pixelLength, float curvePointsSeparation);
 
+    virtual ~SliderCurveCircumscribedCircle() { ; }
 
 
 
     virtual Vector2 pointAt(float t);
 
     virtual Vector2 originalPointAt(float t);
@@ -175,9 +173,9 @@ class OsuSliderCurveCircumscribedCircle : public OsuSliderCurve {
 
 // https://github.com/ppy/osu-framework/blob/master/osu.Framework/MathUtils/PathApproximator.cs
 
 // Copyright (c) ppy Pty Ltd <[email protected]>. Licensed under the MIT Licence.
 
 
 
-class OsuSliderBezierApproximator {
 
+class SliderBezierApproximator {
 
    public:
 
-    OsuSliderBezierApproximator();
 
+    SliderBezierApproximator();
 
 
 
     std::vector<Vector2> createBezier(const std::vector<Vector2> &controlPoints);
 
 
--- a/src/App/Osu/OsuSliderRenderer.cpp
+++ b/src/App/Osu/OsuSliderRenderer.cpp
@@ -1,42 +1,42 @@
 
 //================ Copyright (c) 2016, PG, All rights reserved. =================//
 
 //
 
-// Purpose:		static renderer class, so it can be used outside of OsuSlider
 
+// Purpose:		static renderer class, so it can be used outside of Slider
 
 //
 
 // $NoKeywords: $sliderrender
 
 //===============================================================================//
 
 
 
-#include "OsuSliderRenderer.h"
 
+#include "SliderRenderer.h"
 
 
 
 #include "ConVar.h"
 
 #include "Engine.h"
 
 #include "Environment.h"
 
+#include "GameRules.h"
 
 #include "OpenGL3Interface.h"
 
 #include "OpenGLES2Interface.h"
 
 #include "OpenGLHeaders.h"
 
 #include "OpenGLLegacyInterface.h"
 
 #include "Osu.h"
 
-#include "OsuGameRules.h"
 
-#include "OsuSkin.h"
 
 #include "RenderTarget.h"
 
 #include "ResourceManager.h"
 
 #include "Shader.h"
 
+#include "Skin.h"
 
 #include "VertexArrayObject.h"
 
 
 
-Shader *OsuSliderRenderer::BLEND_SHADER = NULL;
 
+Shader *SliderRenderer::BLEND_SHADER = NULL;
 
 
 
-float OsuSliderRenderer::MESH_CENTER_HEIGHT =
 
+float SliderRenderer::MESH_CENTER_HEIGHT =
 
     0.5f;  // Camera::buildMatrixOrtho2D() uses -1 to 1 for zn/zf, so don't make this too high
 
-int OsuSliderRenderer::UNIT_CIRCLE_SUBDIVISIONS = 0;  // see osu_slider_body_unit_circle_subdivisions now
 
-std::vector<float> OsuSliderRenderer::UNIT_CIRCLE;
 
-VertexArrayObject *OsuSliderRenderer::UNIT_CIRCLE_VAO = NULL;
 
-VertexArrayObject *OsuSliderRenderer::UNIT_CIRCLE_VAO_BAKED = NULL;
 
-VertexArrayObject *OsuSliderRenderer::UNIT_CIRCLE_VAO_TRIANGLES = NULL;
 
-float OsuSliderRenderer::UNIT_CIRCLE_VAO_DIAMETER = 0.0f;
 
-
 
-float OsuSliderRenderer::m_fBoundingBoxMinX = std::numeric_limits<float>::max();
 
-float OsuSliderRenderer::m_fBoundingBoxMaxX = 0.0f;
 
-float OsuSliderRenderer::m_fBoundingBoxMinY = std::numeric_limits<float>::max();
 
-float OsuSliderRenderer::m_fBoundingBoxMaxY = 0.0f;
 
+int SliderRenderer::UNIT_CIRCLE_SUBDIVISIONS = 0;  // see osu_slider_body_unit_circle_subdivisions now
 
+std::vector<float> SliderRenderer::UNIT_CIRCLE;
 
+VertexArrayObject *SliderRenderer::UNIT_CIRCLE_VAO = NULL;
 
+VertexArrayObject *SliderRenderer::UNIT_CIRCLE_VAO_BAKED = NULL;
 
+VertexArrayObject *SliderRenderer::UNIT_CIRCLE_VAO_TRIANGLES = NULL;
 
+float SliderRenderer::UNIT_CIRCLE_VAO_DIAMETER = 0.0f;
 
+
 
+float SliderRenderer::m_fBoundingBoxMinX = std::numeric_limits<float>::max();
 
+float SliderRenderer::m_fBoundingBoxMaxX = 0.0f;
 
+float SliderRenderer::m_fBoundingBoxMinY = std::numeric_limits<float>::max();
 
+float SliderRenderer::m_fBoundingBoxMaxY = 0.0f;
 
 
 
 ConVar osu_slider_debug_draw("osu_slider_debug_draw", false, FCVAR_NONE,
 
                              "draw hitcircle at every curve point and nothing else (no vao, no rt, no shader, nothing) "
@@ -62,8 +62,8 @@ ConVar osu_slider_legacy_use_baked_vao(
 
     "use baked cone mesh instead of raw mesh for legacy slider renderer (disabled by default because usually slower on "
 
     "very old gpus even though it should not be)");
 
 
 
-VertexArrayObject *OsuSliderRenderer::generateVAO(Osu *osu, const std::vector<Vector2> &points, float hitcircleDiameter,
 
-                                                  Vector3 translation, bool skipOOBPoints) {
 
+VertexArrayObject *SliderRenderer::generateVAO(Osu *osu, const std::vector<Vector2> &points, float hitcircleDiameter,
 
+                                               Vector3 translation, bool skipOOBPoints) {
 
     engine->getResourceManager()->requestNextLoadUnmanaged();
 
     VertexArrayObject *vao = engine->getResourceManager()->createVertexArrayObject();
 
 
@@ -77,10 +77,10 @@ VertexArrayObject *OsuSliderRenderer::generateVAO(Osu *osu, const std::vector<Ve
 
     for(int i = 0; i < points.size(); i++) {
 
         // fuck oob sliders
 
         if(skipOOBPoints) {
 
-            if(points[i].x < -hitcircleDiameter - OsuGameRules::OSU_COORD_WIDTH * 2 ||
 
-               points[i].x > osu->getScreenWidth() + hitcircleDiameter + OsuGameRules::OSU_COORD_WIDTH * 2 ||
 
-               points[i].y < -hitcircleDiameter - OsuGameRules::OSU_COORD_HEIGHT * 2 ||
 
-               points[i].y > osu->getScreenHeight() + hitcircleDiameter + OsuGameRules::OSU_COORD_HEIGHT * 2)
 
+            if(points[i].x < -hitcircleDiameter - GameRules::OSU_COORD_WIDTH * 2 ||
 
+               points[i].x > osu->getScreenWidth() + hitcircleDiameter + GameRules::OSU_COORD_WIDTH * 2 ||
 
+               points[i].y < -hitcircleDiameter - GameRules::OSU_COORD_HEIGHT * 2 ||
 
+               points[i].y > osu->getScreenHeight() + hitcircleDiameter + GameRules::OSU_COORD_HEIGHT * 2)
 
                 continue;
 
         }
 
 
@@ -121,14 +121,14 @@ VertexArrayObject *OsuSliderRenderer::generateVAO(Osu *osu, const std::vector<Ve
 
     if(vao->getNumVertices() > 0)
 
         engine->getResourceManager()->loadResource(vao);
 
     else
 
-        debugLog("OsuSliderRenderer::generateSliderVAO() ERROR: Zero triangles!\n");
 
+        debugLog("SliderRenderer::generateSliderVAO() ERROR: Zero triangles!\n");
 
 
 
     return vao;
 
 }
 
 
 
-void OsuSliderRenderer::draw(Graphics *g, Osu *osu, const std::vector<Vector2> &points,
 
-                             const std::vector<Vector2> &alwaysPoints, float hitcircleDiameter, float from, float to,
 
-                             Color undimmedColor, float colorRGBMultiplier, float alpha, long sliderTimeForRainbow) {
 
+void SliderRenderer::draw(Graphics *g, Osu *osu, const std::vector<Vector2> &points,
 
+                          const std::vector<Vector2> &alwaysPoints, float hitcircleDiameter, float from, float to,
 
+                          Color undimmedColor, float colorRGBMultiplier, float alpha, long sliderTimeForRainbow) {
 
     if(osu_slider_alpha_multiplier.getFloat() <= 0.0f || alpha <= 0.0f) return;
 
 
 
     checkUpdateVars(osu, hitcircleDiameter);
@@ -276,11 +276,10 @@ void OsuSliderRenderer::draw(Graphics *g, Osu *osu, const std::vector<Vector2> &
 
                                           m_fBoundingBoxMaxY - m_fBoundingBoxMinY);
 
 }
 
 
 
-void OsuSliderRenderer::draw(Graphics *g, Osu *osu, VertexArrayObject *vao, const std::vector<Vector2> &alwaysPoints,
 
-                             Vector2 translation, float scale, float hitcircleDiameter, float from, float to,
 
-                             Color undimmedColor, float colorRGBMultiplier, float alpha, long sliderTimeForRainbow,
 
-                             bool doEnableRenderTarget, bool doDisableRenderTarget,
 
-                             bool doDrawSliderFrameBufferToScreen) {
 
+void SliderRenderer::draw(Graphics *g, Osu *osu, VertexArrayObject *vao, const std::vector<Vector2> &alwaysPoints,
 
+                          Vector2 translation, float scale, float hitcircleDiameter, float from, float to,
 
+                          Color undimmedColor, float colorRGBMultiplier, float alpha, long sliderTimeForRainbow,
 
+                          bool doEnableRenderTarget, bool doDisableRenderTarget, bool doDrawSliderFrameBufferToScreen) {
 
     if((osu_slider_alpha_multiplier.getFloat() <= 0.0f && doDrawSliderFrameBufferToScreen) ||
 
        (alpha <= 0.0f && doDrawSliderFrameBufferToScreen) || vao == NULL)
 
         return;
@@ -455,9 +454,9 @@ void OsuSliderRenderer::draw(Graphics *g, Osu *osu, VertexArrayObject *vao, cons
 
     }
 
 }
 
 
 
-void OsuSliderRenderer::drawMM(Graphics *g, Osu *osu, const std::vector<Vector2> &points, float hitcircleDiameter,
 
-                               float from, float to, Color undimmedColor, float colorRGBMultiplier, float alpha,
 
-                               long sliderTimeForRainbow) {
 
+void SliderRenderer::drawMM(Graphics *g, Osu *osu, const std::vector<Vector2> &points, float hitcircleDiameter,
 
+                            float from, float to, Color undimmedColor, float colorRGBMultiplier, float alpha,
 
+                            long sliderTimeForRainbow) {
 
     if(osu_slider_alpha_multiplier.getFloat() <= 0.0f || alpha <= 0.0f) return;
 
 
 
     checkUpdateVars(osu, hitcircleDiameter);
@@ -550,9 +549,9 @@ void OsuSliderRenderer::drawMM(Graphics *g, Osu *osu, const std::vector<Vector2>
 
     osu->getSliderFrameBuffer()->draw(g, 0, 0);
 
 }
 
 
 
-void OsuSliderRenderer::drawFillSliderBodyPeppy(Graphics *g, Osu *osu, const std::vector<Vector2> &points,
 
-                                                VertexArrayObject *circleMesh, float radius, int drawFromIndex,
 
-                                                int drawUpToIndex, Shader *shader) {
 
+void SliderRenderer::drawFillSliderBodyPeppy(Graphics *g, Osu *osu, const std::vector<Vector2> &points,
 
+                                             VertexArrayObject *circleMesh, float radius, int drawFromIndex,
 
+                                             int drawUpToIndex, Shader *shader) {
 
     if(drawFromIndex < 0) drawFromIndex = 0;
 
     if(drawUpToIndex < 0) drawUpToIndex = points.size();
 
 
@@ -602,8 +601,8 @@ void OsuSliderRenderer::drawFillSliderBodyPeppy(Graphics *g, Osu *osu, const std
 
     g->popTransform();
 
 }
 
 
 
-void OsuSliderRenderer::drawFillSliderBodyMM(Graphics *g, const std::vector<Vector2> &points, float radius,
 
-                                             int drawFromIndex, int drawUpToIndex) {
 
+void SliderRenderer::drawFillSliderBodyMM(Graphics *g, const std::vector<Vector2> &points, float radius,
 
+                                          int drawFromIndex, int drawUpToIndex) {
 
     // modified version of
 
     // https://github.com/ppy/osu-framework/blob/master/osu.Framework/Graphics/Lines/Path_DrawNode.cs
 
 
@@ -745,7 +744,7 @@ void OsuSliderRenderer::drawFillSliderBodyMM(Graphics *g, const std::vector<Vect
 
     }
 
 }
 
 
 
-void OsuSliderRenderer::checkUpdateVars(Osu *osu, float hitcircleDiameter) {
 
+void SliderRenderer::checkUpdateVars(Osu *osu, float hitcircleDiameter) {
 
     // static globals
 
 
 
     // build shaders and circle mesh
@@ -855,9 +854,9 @@ void OsuSliderRenderer::checkUpdateVars(Osu *osu, float hitcircleDiameter) {
 
     }
 
 }
 
 
 
-void OsuSliderRenderer::resetRenderTargetBoundingBox() {
 
-    OsuSliderRenderer::m_fBoundingBoxMinX = std::numeric_limits<float>::max();
 
-    OsuSliderRenderer::m_fBoundingBoxMaxX = 0.0f;
 
-    OsuSliderRenderer::m_fBoundingBoxMinY = std::numeric_limits<float>::max();
 
-    OsuSliderRenderer::m_fBoundingBoxMaxY = 0.0f;
 
+void SliderRenderer::resetRenderTargetBoundingBox() {
 
+    SliderRenderer::m_fBoundingBoxMinX = std::numeric_limits<float>::max();
 
+    SliderRenderer::m_fBoundingBoxMaxX = 0.0f;
 
+    SliderRenderer::m_fBoundingBoxMinY = std::numeric_limits<float>::max();
 
+    SliderRenderer::m_fBoundingBoxMaxY = 0.0f;
 
 }
--- a/src/App/Osu/OsuSliderRenderer.h
+++ b/src/App/Osu/OsuSliderRenderer.h
@@ -1,6 +1,6 @@
 
 //================ Copyright (c) 2016, PG, All rights reserved. =================//
 
 //
 
-// Purpose:		static renderer class, so it can be used outside of OsuSlider
 
+// Purpose:		static renderer class, so it can be used outside of Slider
 
 //
 
 // $NoKeywords: $sliderrender
 
 //===============================================================================//
@@ -15,7 +15,7 @@ class VertexArrayObject;
 
 
 
 class Osu;
 
 
 
-class OsuSliderRenderer {
 
+class SliderRenderer {
 
    public:
 
     static Shader *BLEND_SHADER;
 
 
--- a/src/App/Osu/SongBrowser.cpp
+++ b/src/App/Osu/SongBrowser.cpp
--- a/src/App/Osu/OsuSongBrowser.h
+++ b/src/App/Osu/OsuSongBrowser.h
@@ -1,25 +1,25 @@
 
 #pragma once
 
 #include "MouseListener.h"
 
-#include "OsuScreenBackable.h"
 
+#include "ScreenBackable.h"
 
 
 
 class Osu;
 
-class OsuBeatmap;
 
-class OsuDatabase;
 
-class OsuDatabaseBeatmap;
 
-class OsuDatabaseBeatmapStarCalculator;
 
-class OsuSkinImage;
 
-
 
-class OsuUIContextMenu;
 
-class OsuUISearchOverlay;
 
-class OsuUISelectionButton;
 
-class OsuUISongBrowserInfoLabel;
 
-class OsuUISongBrowserUserButton;
 
-class OsuUISongBrowserScoreButton;
 
-class OsuUISongBrowserButton;
 
-class OsuUISongBrowserSongButton;
 
-class OsuUISongBrowserSongDifficultyButton;
 
-class OsuUISongBrowserCollectionButton;
 
-class OsuUIUserStatsScreenLabel;
 
+class Beatmap;
 
+class Database;
 
+class DatabaseBeatmap;
 
+class DatabaseBeatmapStarCalculator;
 
+class SkinImage;
 
+
 
+class UIContextMenu;
 
+class UISearchOverlay;
 
+class UISelectionButton;
 
+class UISongBrowserInfoLabel;
 
+class UISongBrowserUserButton;
 
+class UISongBrowserScoreButton;
 
+class UISongBrowserButton;
 
+class UISongBrowserSongButton;
 
+class UISongBrowserSongDifficultyButton;
 
+class UISongBrowserCollectionButton;
 
+class UIUserStatsScreenLabel;
 
 
 
 class CBaseUIContainer;
 
 class CBaseUIImageButton;
@@ -30,50 +30,50 @@ class CBaseUILabel;
 
 class McFont;
 
 class ConVar;
 
 
 
-class OsuSongBrowserBackgroundSearchMatcher;
 
+class SongBrowserBackgroundSearchMatcher;
 
 
 
-class OsuSongBrowser : public OsuScreenBackable {
 
+class SongBrowser : public ScreenBackable {
 
    public:
 
     static void drawSelectedBeatmapBackgroundImage(Graphics *g, Osu *osu, float alpha = 1.0f);
 
 
 
     struct SORTING_COMPARATOR {
 
         virtual ~SORTING_COMPARATOR() { ; }
 
-        virtual bool operator()(OsuUISongBrowserButton const *a, OsuUISongBrowserButton const *b) const = 0;
 
+        virtual bool operator()(UISongBrowserButton const *a, UISongBrowserButton const *b) const = 0;
 
     };
 
 
 
     struct SortByArtist : public SORTING_COMPARATOR {
 
         virtual ~SortByArtist() { ; }
 
-        virtual bool operator()(OsuUISongBrowserButton const *a, OsuUISongBrowserButton const *b) const;
 
+        virtual bool operator()(UISongBrowserButton const *a, UISongBrowserButton const *b) const;
 
     };
 
 
 
     struct SortByBPM : public SORTING_COMPARATOR {
 
         virtual ~SortByBPM() { ; }
 
-        virtual bool operator()(OsuUISongBrowserButton const *a, OsuUISongBrowserButton const *b) const;
 
+        virtual bool operator()(UISongBrowserButton const *a, UISongBrowserButton const *b) const;
 
     };
 
 
 
     struct SortByCreator : public SORTING_COMPARATOR {
 
         virtual ~SortByCreator() { ; }
 
-        virtual bool operator()(OsuUISongBrowserButton const *a, OsuUISongBrowserButton const *b) const;
 
+        virtual bool operator()(UISongBrowserButton const *a, UISongBrowserButton const *b) const;
 
     };
 
 
 
     struct SortByDateAdded : public SORTING_COMPARATOR {
 
         virtual ~SortByDateAdded() { ; }
 
-        virtual bool operator()(OsuUISongBrowserButton const *a, OsuUISongBrowserButton const *b) const;
 
+        virtual bool operator()(UISongBrowserButton const *a, UISongBrowserButton const *b) const;
 
     };
 
 
 
     struct SortByDifficulty : public SORTING_COMPARATOR {
 
         virtual ~SortByDifficulty() { ; }
 
-        virtual bool operator()(OsuUISongBrowserButton const *a, OsuUISongBrowserButton const *b) const;
 
+        virtual bool operator()(UISongBrowserButton const *a, UISongBrowserButton const *b) const;
 
     };
 
 
 
     struct SortByLength : public SORTING_COMPARATOR {
 
         virtual ~SortByLength() { ; }
 
-        bool operator()(OsuUISongBrowserButton const *a, OsuUISongBrowserButton const *b) const;
 
+        bool operator()(UISongBrowserButton const *a, UISongBrowserButton const *b) const;
 
     };
 
 
 
     struct SortByTitle : public SORTING_COMPARATOR {
 
         virtual ~SortByTitle() { ; }
 
-        bool operator()(OsuUISongBrowserButton const *a, OsuUISongBrowserButton const *b) const;
 
+        bool operator()(UISongBrowserButton const *a, UISongBrowserButton const *b) const;
 
     };
 
 
 
     enum class GROUP {
@@ -88,10 +88,10 @@ class OsuSongBrowser : public OsuScreenBackable {
 
         GROUP_COLLECTIONS
 
     };
 
 
 
-    friend class OsuSongBrowserBackgroundSearchMatcher;
 
+    friend class SongBrowserBackgroundSearchMatcher;
 
 
 
-    OsuSongBrowser(Osu *osu);
 
-    virtual ~OsuSongBrowser();
 
+    SongBrowser(Osu *osu);
 
+    virtual ~SongBrowser();
 
 
 
     virtual void draw(Graphics *g);
 
     virtual void mouse_update(bool *propagate_clicks);
@@ -107,14 +107,14 @@ class OsuSongBrowser : public OsuScreenBackable {
 
     void selectSelectedBeatmapSongButton();
 
     void onPlayEnd(bool quit = true);  // called when a beatmap is finished playing (or the player quit)
 
 
 
-    void onSelectionChange(OsuUISongBrowserButton *button, bool rebuild);
 
-    void onDifficultySelected(OsuDatabaseBeatmap *diff2, bool play = false);
 
+    void onSelectionChange(UISongBrowserButton *button, bool rebuild);
 
+    void onDifficultySelected(DatabaseBeatmap *diff2, bool play = false);
 
 
 
-    void onScoreContextMenu(OsuUISongBrowserScoreButton *scoreButton, int id);
 
-    void onSongButtonContextMenu(OsuUISongBrowserSongButton *songButton, UString text, int id);
 
-    void onCollectionButtonContextMenu(OsuUISongBrowserCollectionButton *collectionButton, UString text, int id);
 
+    void onScoreContextMenu(UISongBrowserScoreButton *scoreButton, int id);
 
+    void onSongButtonContextMenu(UISongBrowserSongButton *songButton, UString text, int id);
 
+    void onCollectionButtonContextMenu(UISongBrowserCollectionButton *collectionButton, UString text, int id);
 
 
 
-    void highlightScore(uint64_t unixTimestamp);
 
+    void highlightScore(u64 unixTimestamp);
 
     void selectRandomBeatmap();
 
     void playNextRandomBeatmap() {
 
         selectRandomBeatmap();
@@ -123,11 +123,11 @@ class OsuSongBrowser : public OsuScreenBackable {
 
     void recalculateStarsForSelectedBeatmap(bool force = false);
 
 
 
     void refreshBeatmaps();
 
-    void addBeatmap(OsuDatabaseBeatmap *beatmap);
 
-    void readdBeatmap(OsuDatabaseBeatmap *diff2);
 
+    void addBeatmap(DatabaseBeatmap *beatmap);
 
+    void readdBeatmap(DatabaseBeatmap *diff2);
 
 
 
-    void requestNextScrollToSongButtonJumpFix(OsuUISongBrowserSongDifficultyButton *diffButton);
 
-    void scrollToSongButton(OsuUISongBrowserButton *songButton, bool alignOnTop = false);
 
+    void requestNextScrollToSongButtonJumpFix(UISongBrowserSongDifficultyButton *diffButton);
 
+    void scrollToSongButton(UISongBrowserButton *songButton, bool alignOnTop = false);
 
     void scrollToSelectedSongButton();
 
     void rebuildSongButtons();
 
     void recreateCollectionsButtons();
@@ -135,8 +135,8 @@ class OsuSongBrowser : public OsuScreenBackable {
 
     void updateSongButtonLayout();
 
     void updateSongButtonSorting();
 
 
 
-    OsuUISongBrowserButton *findCurrentlySelectedSongButton() const;
 
-    inline const std::vector<OsuUISongBrowserCollectionButton *> &getCollectionButtons() const {
 
+    UISongBrowserButton *findCurrentlySelectedSongButton() const;
 
+    inline const std::vector<UISongBrowserCollectionButton *> &getCollectionButtons() const {
 
         return m_collectionButtons;
 
     }
 
 
@@ -144,11 +144,11 @@ class OsuSongBrowser : public OsuScreenBackable {
 
     inline bool isInSearch() const { return m_bInSearch; }
 
     inline bool isRightClickScrolling() const { return m_bSongBrowserRightClickScrolling; }
 
 
 
-    inline OsuDatabase *getDatabase() const { return m_db; }
 
-    inline OsuBeatmap *getSelectedBeatmap() const { return m_selectedBeatmap; }
 
-    inline const OsuDatabaseBeatmapStarCalculator *getDynamicStarCalculator() const { return m_dynamicStarCalculator; }
 
+    inline Database *getDatabase() const { return m_db; }
 
+    inline Beatmap *getSelectedBeatmap() const { return m_selectedBeatmap; }
 
+    inline const DatabaseBeatmapStarCalculator *getDynamicStarCalculator() const { return m_dynamicStarCalculator; }
 
 
 
-    inline OsuUISongBrowserInfoLabel *getInfoLabel() { return m_songInfo; }
 
+    inline UISongBrowserInfoLabel *getInfoLabel() { return m_songInfo; }
 
 
 
     inline GROUP getGroupingMode() const { return m_group; }
 
 
@@ -175,9 +175,8 @@ class OsuSongBrowser : public OsuScreenBackable {
 
         int id;
 
     };
 
 
 
-    static bool searchMatcher(const OsuDatabaseBeatmap *databaseBeatmap,
 
-                              const std::vector<UString> &searchStringTokens);
 
-    static bool findSubstringInDifficulty(const OsuDatabaseBeatmap *diff, const UString &searchString);
 
+    static bool searchMatcher(const DatabaseBeatmap *databaseBeatmap, const std::vector<UString> &searchStringTokens);
 
+    static bool findSubstringInDifficulty(const DatabaseBeatmap *diff, const UString &searchString);
 
 
 
     virtual void updateLayout();
 
     virtual void onBack();
@@ -190,8 +189,8 @@ class OsuSongBrowser : public OsuScreenBackable {
 
     bool checkHandleKillDynamicStarCalculator(bool timeout);
 
     void checkHandleKillBackgroundSearchMatcher();
 
 
 
-    OsuUISelectionButton *addBottombarNavButton(std::function<OsuSkinImage *()> getImageFunc,
 
-                                                std::function<OsuSkinImage *()> getImageOverFunc);
 
+    UISelectionButton *addBottombarNavButton(std::function<SkinImage *()> getImageFunc,
 
+                                             std::function<SkinImage *()> getImageOverFunc);
 
     CBaseUIButton *addTopBarRightTabButton(UString text);
 
     CBaseUIButton *addTopBarRightGroupButton(UString text);
 
     CBaseUIButton *addTopBarRightSortButton(UString text);
@@ -242,7 +241,7 @@ class OsuSongBrowser : public OsuScreenBackable {
 
 
 
     void onScoreClicked(CBaseUIButton *button);
 
 
 
-    void selectSongButton(OsuUISongBrowserButton *songButton);
 
+    void selectSongButton(UISongBrowserButton *songButton);
 
     void selectPreviousRandomBeatmap();
 
     void playSelectedDifficulty();
 
 
@@ -276,7 +275,7 @@ class OsuSongBrowser : public OsuScreenBackable {
 
 
 
     // top bar left
 
     CBaseUIContainer *m_topbarLeft;
 
-    OsuUISongBrowserInfoLabel *m_songInfo;
 
+    UISongBrowserInfoLabel *m_songInfo;
 
     std::vector<CBaseUIButton *> m_topbarLeftTabButtons;
 
     std::vector<CBaseUIButton *> m_topbarLeftButtons;
 
     CBaseUIButton *m_scoreSortButton;
@@ -295,22 +294,22 @@ class OsuSongBrowser : public OsuScreenBackable {
 
     CBaseUIButton *m_difficultiesButton;
 
     CBaseUILabel *m_sortLabel;
 
     CBaseUIButton *m_sortButton;
 
-    OsuUIContextMenu *m_contextMenu;
 
+    UIContextMenu *m_contextMenu;
 
 
 
     // bottom bar
 
     CBaseUIContainer *m_bottombar;
 
-    std::vector<OsuUISelectionButton *> m_bottombarNavButtons;
 
-    OsuUISongBrowserUserButton *m_userButton;
 
-    OsuUIUserStatsScreenLabel *m_ppVersionInfoLabel;
 
+    std::vector<UISelectionButton *> m_bottombarNavButtons;
 
+    UISongBrowserUserButton *m_userButton;
 
+    UIUserStatsScreenLabel *m_ppVersionInfoLabel;
 
 
 
     // score browser
 
-    std::vector<OsuUISongBrowserScoreButton *> m_scoreButtonCache;
 
+    std::vector<UISongBrowserScoreButton *> m_scoreButtonCache;
 
     CBaseUIScrollView *m_scoreBrowser;
 
     CBaseUIElement *m_scoreBrowserScoresStillLoadingElement;
 
     CBaseUIElement *m_scoreBrowserNoRecordsYetElement;
 
     CBaseUIContainer *m_localBestContainer;
 
     CBaseUILabel *m_localBestLabel;
 
-    OsuUISongBrowserScoreButton *m_localBestButton = nullptr;
 
+    UISongBrowserScoreButton *m_localBestButton = nullptr;
 
 
 
     // song browser
 
     CBaseUIScrollView *m_songBrowser;
@@ -322,24 +321,24 @@ class OsuSongBrowser : public OsuScreenBackable {
 
     float m_fNextScrollToSongButtonJumpFixOldScrollSizeY;
 
 
 
     // song browser selection state logic
 
-    OsuUISongBrowserSongButton *m_selectionPreviousSongButton;
 
-    OsuUISongBrowserSongDifficultyButton *m_selectionPreviousSongDiffButton;
 
-    OsuUISongBrowserCollectionButton *m_selectionPreviousCollectionButton;
 
+    UISongBrowserSongButton *m_selectionPreviousSongButton;
 
+    UISongBrowserSongDifficultyButton *m_selectionPreviousSongDiffButton;
 
+    UISongBrowserCollectionButton *m_selectionPreviousCollectionButton;
 
 
 
     // beatmap database
 
-    OsuDatabase *m_db;
 
-    std::vector<OsuDatabaseBeatmap *> m_beatmaps;
 
-    std::vector<OsuUISongBrowserSongButton *> m_songButtons;
 
-    std::vector<OsuUISongBrowserButton *> m_visibleSongButtons;
 
-    std::vector<OsuUISongBrowserCollectionButton *> m_collectionButtons;
 
-    std::vector<OsuUISongBrowserCollectionButton *> m_artistCollectionButtons;
 
-    std::vector<OsuUISongBrowserCollectionButton *> m_difficultyCollectionButtons;
 
-    std::vector<OsuUISongBrowserCollectionButton *> m_bpmCollectionButtons;
 
-    std::vector<OsuUISongBrowserCollectionButton *> m_creatorCollectionButtons;
 
-    std::vector<OsuUISongBrowserCollectionButton *> m_dateaddedCollectionButtons;
 
-    std::vector<OsuUISongBrowserCollectionButton *> m_lengthCollectionButtons;
 
-    std::vector<OsuUISongBrowserCollectionButton *> m_titleCollectionButtons;
 
-    std::unordered_map<MD5Hash, OsuUISongBrowserSongButton *> hashToSongButton;
 
+    Database *m_db;
 
+    std::vector<DatabaseBeatmap *> m_beatmaps;
 
+    std::vector<UISongBrowserSongButton *> m_songButtons;
 
+    std::vector<UISongBrowserButton *> m_visibleSongButtons;
 
+    std::vector<UISongBrowserCollectionButton *> m_collectionButtons;
 
+    std::vector<UISongBrowserCollectionButton *> m_artistCollectionButtons;
 
+    std::vector<UISongBrowserCollectionButton *> m_difficultyCollectionButtons;
 
+    std::vector<UISongBrowserCollectionButton *> m_bpmCollectionButtons;
 
+    std::vector<UISongBrowserCollectionButton *> m_creatorCollectionButtons;
 
+    std::vector<UISongBrowserCollectionButton *> m_dateaddedCollectionButtons;
 
+    std::vector<UISongBrowserCollectionButton *> m_lengthCollectionButtons;
 
+    std::vector<UISongBrowserCollectionButton *> m_titleCollectionButtons;
 
+    std::unordered_map<MD5Hash, UISongBrowserSongButton *> hashToSongButton;
 
     bool m_bBeatmapRefreshScheduled;
 
     UString m_sLastOsuFolder;
 
 
@@ -354,33 +353,33 @@ class OsuSongBrowser : public OsuScreenBackable {
 
     bool m_bPreviousRandomBeatmapScheduled;
 
 
 
     // behaviour
 
-    OsuDatabaseBeatmap *m_lastSelectedBeatmap = nullptr;
 
-    OsuBeatmap *m_selectedBeatmap;
 
+    DatabaseBeatmap *m_lastSelectedBeatmap = nullptr;
 
+    Beatmap *m_selectedBeatmap;
 
     bool m_bHasSelectedAndIsPlaying;
 
     float m_fPulseAnimation;
 
     float m_fBackgroundFadeInTime;
 
-    std::vector<OsuDatabaseBeatmap *> m_previousRandomBeatmaps;
 
+    std::vector<DatabaseBeatmap *> m_previousRandomBeatmaps;
 
 
 
     // search
 
-    OsuUISearchOverlay *m_search;
 
+    UISearchOverlay *m_search;
 
     UString m_sSearchString;
 
     UString m_sPrevSearchString;
 
     UString m_sPrevHardcodedSearchString;
 
     float m_fSearchWaitTime;
 
     bool m_bInSearch;
 
     GROUP m_searchPrevGroup;
 
-    OsuSongBrowserBackgroundSearchMatcher *m_backgroundSearchMatcher;
 
+    SongBrowserBackgroundSearchMatcher *m_backgroundSearchMatcher;
 
     bool m_bOnAfterSortingOrGroupChangeUpdateScheduled;
 
     bool m_bOnAfterSortingOrGroupChangeUpdateScheduledAutoScroll;
 
 
 
     // background star calculation (entire database)
 
     float m_fBackgroundStarCalculationWorkNotificationTime;
 
     int m_iBackgroundStarCalculationIndex;
 
-    OsuDatabaseBeatmapStarCalculator *m_backgroundStarCalculator;
 
-    OsuDatabaseBeatmap *m_backgroundStarCalcTempParent;
 
+    DatabaseBeatmapStarCalculator *m_backgroundStarCalculator;
 
+    DatabaseBeatmap *m_backgroundStarCalcTempParent;
 
 
 
     // background star calculation (currently selected beatmap)
 
     bool m_bBackgroundStarCalcScheduled;
 
     bool m_bBackgroundStarCalcScheduledForce;
 
-    OsuDatabaseBeatmapStarCalculator *m_dynamicStarCalculator;
 
+    DatabaseBeatmapStarCalculator *m_dynamicStarCalculator;
 
 };
--- a/src/App/Osu/OsuSpinner.cpp
+++ b/src/App/Osu/OsuSpinner.cpp
@@ -5,25 +5,25 @@
 
 // $NoKeywords: $spin
 
 //=====================================================================================================//
 
 
 
-#include "OsuSpinner.h"
 
+#include "Spinner.h"
 
 
 
 #include "AnimationHandler.h"
 
+#include "Beatmap.h"
 
 #include "ConVar.h"
 
 #include "Engine.h"
 
+#include "GameRules.h"
 
 #include "Mouse.h"
 
 #include "Osu.h"
 
-#include "OsuBeatmap.h"
 
-#include "OsuGameRules.h"
 
-#include "OsuSkin.h"
 
 #include "ResourceManager.h"
 
+#include "Skin.h"
 
 #include "SoundEngine.h"
 
 
 
 ConVar osu_spinner_use_ar_fadein(
 
     "osu_spinner_use_ar_fadein", false, FCVAR_NONE,
 
     "whether spinners should fade in with AR (same as circles), or with hardcoded 400 ms fadein time (osu!default)");
 
 
 
-OsuSpinner::OsuSpinner(int x, int y, long time, int sampleType, bool isEndOfCombo, long endTime, OsuBeatmap *beatmap)
 
-    : OsuHitObject(time, sampleType, -1, isEndOfCombo, -1, -1, beatmap) {
 
+Spinner::Spinner(int x, int y, long time, int sampleType, bool isEndOfCombo, long endTime, Beatmap *beatmap)
 
+    : HitObject(time, sampleType, -1, isEndOfCombo, -1, -1, beatmap) {
 
     m_vOriginalRawPos = Vector2(x, y);
 
     m_vRawPos = m_vOriginalRawPos;
 
 
@@ -60,25 +60,25 @@ OsuSpinner::OsuSpinner(int x, int y, long time, int sampleType, bool isEndOfComb
 
     m_bMisAim = true;
 
 
 
     // spinners don't use AR-dependent fadein, instead they always fade in with hardcoded 400 ms (see
 
-    // OsuGameRules::getFadeInTime())
 
+    // GameRules::getFadeInTime())
 
     m_bUseFadeInTimeAsApproachTime = !osu_spinner_use_ar_fadein.getBool();
 
 }
 
 
 
-OsuSpinner::~OsuSpinner() {
 
+Spinner::~Spinner() {
 
     onReset(0);
 
 
 
     delete[] m_storedDeltaAngles;
 
     m_storedDeltaAngles = NULL;
 
 }
 
 
 
-void OsuSpinner::draw(Graphics *g) {
 
-    OsuHitObject::draw(g);
 
-    const float fadeOutMultiplier = OsuGameRules::osu_spinner_fade_out_time_multiplier.getFloat();
 
-    const long fadeOutTimeMS = (long)(OsuGameRules::getFadeOutTime(m_beatmap) * 1000.0f * fadeOutMultiplier);
 
+void Spinner::draw(Graphics *g) {
 
+    HitObject::draw(g);
 
+    const float fadeOutMultiplier = GameRules::osu_spinner_fade_out_time_multiplier.getFloat();
 
+    const long fadeOutTimeMS = (long)(GameRules::getFadeOutTime(m_beatmap) * 1000.0f * fadeOutMultiplier);
 
     const long deltaEnd = m_iDelta + m_iObjectDuration;
 
     if((m_bFinished || !m_bVisible) && (deltaEnd > 0 || (deltaEnd < -fadeOutTimeMS))) return;
 
 
 
-    OsuSkin *skin = m_beatmap->getSkin();
 
+    Skin *skin = m_beatmap->getSkin();
 
     Vector2 center = m_beatmap->osuCoords2Pixels(m_vRawPos);
 
 
 
     const float alphaMultiplier =
@@ -269,8 +269,8 @@ void OsuSpinner::draw(Graphics *g) {
 
     }
 
 }
 
 
 
-void OsuSpinner::update(long curPos) {
 
-    OsuHitObject::update(curPos);
 
+void Spinner::update(long curPos) {
 
+    HitObject::update(curPos);
 
 
 
     // stop spinner sound and don't update() while paused
 
     if(m_beatmap->isPaused() || !m_beatmap->isPlaying() || m_beatmap->hasFailed()) {
@@ -287,7 +287,7 @@ void OsuSpinner::update(long curPos) {
 
             return;
 
         }
 
 
 
-        m_fRotationsNeeded = OsuGameRules::getSpinnerRotationsForSpeedMultiplier(m_beatmap, m_iObjectDuration);
 
+        m_fRotationsNeeded = GameRules::getSpinnerRotationsForSpeedMultiplier(m_beatmap, m_iObjectDuration);
 
 
 
         const float fixedRate = /*(1.0f / convar->getConVarByName("fps_max")->getFloat())*/ engine->getFrameTime();
 
 
@@ -374,7 +374,7 @@ void OsuSpinner::update(long curPos) {
 
     }
 
 }
 
 
 
-void OsuSpinner::onClickEvent(std::vector<Click> &clicks) {
 
+void Spinner::onClickEvent(std::vector<Click> &clicks) {
 
     if(m_bFinished) return;
 
 
 
     // needed for nightmare mod
@@ -384,8 +384,8 @@ void OsuSpinner::onClickEvent(std::vector<Click> &clicks) {
 
     }
 
 }
 
 
 
-void OsuSpinner::onReset(long curPos) {
 
-    OsuHitObject::onReset(curPos);
 
+void Spinner::onReset(long curPos) {
 
+    HitObject::onReset(curPos);
 
 
 
     m_beatmap->getSkin()->stopSpinnerSpinSound();
 
 
@@ -413,28 +413,28 @@ void OsuSpinner::onReset(long curPos) {
 
         m_bFinished = false;
 
 }
 
 
 
-void OsuSpinner::onHit() {
 
+void Spinner::onHit() {
 
     /// debugLog("ratio = %f\n", m_fRatio);
 
     // m_bDrawRPM = false;
 
 
 
     // calculate hit result
 
-    OsuScore::HIT result = OsuScore::HIT::HIT_NULL;
 
+    LiveScore::HIT result = LiveScore::HIT::HIT_NULL;
 
     if(m_fRatio >= 1.0f || m_beatmap->getOsu()->getModAuto())
 
-        result = OsuScore::HIT::HIT_300;
 
-    else if(m_fRatio >= 0.9f && !OsuGameRules::osu_mod_ming3012.getBool() && !OsuGameRules::osu_mod_no100s.getBool())
 
-        result = OsuScore::HIT::HIT_100;
 
-    else if(m_fRatio >= 0.75f && !OsuGameRules::osu_mod_no100s.getBool() && !OsuGameRules::osu_mod_no50s.getBool())
 
-        result = OsuScore::HIT::HIT_50;
 
+        result = LiveScore::HIT::HIT_300;
 
+    else if(m_fRatio >= 0.9f && !GameRules::osu_mod_ming3012.getBool() && !GameRules::osu_mod_no100s.getBool())
 
+        result = LiveScore::HIT::HIT_100;
 
+    else if(m_fRatio >= 0.75f && !GameRules::osu_mod_no100s.getBool() && !GameRules::osu_mod_no50s.getBool())
 
+        result = LiveScore::HIT::HIT_50;
 
     else
 
-        result = OsuScore::HIT::HIT_MISS;
 
+        result = LiveScore::HIT::HIT_MISS;
 
 
 
     // sound
 
-    if(result != OsuScore::HIT::HIT_MISS) {
 
+    if(result != LiveScore::HIT::HIT_MISS) {
 
         if(m_osu_timingpoints_force->getBool()) m_beatmap->updateTimingPoints(m_iTime + m_iObjectDuration);
 
 
 
         const Vector2 osuCoords = m_beatmap->pixels2OsuCoords(m_beatmap->osuCoords2Pixels(m_vRawPos));
 
 
 
-        m_beatmap->getSkin()->playHitCircleSound(m_iSampleType, OsuGameRules::osuCoords2Pan(osuCoords.x));
 
+        m_beatmap->getSkin()->playHitCircleSound(m_iSampleType, GameRules::osuCoords2Pan(osuCoords.x));
 
     }
 
 
 
     // add it, and we are finished
@@ -444,7 +444,7 @@ void OsuSpinner::onHit() {
 
     m_beatmap->getSkin()->stopSpinnerSpinSound();
 
 }
 
 
 
-void OsuSpinner::rotate(float rad) {
 
+void Spinner::rotate(float rad) {
 
     m_fDrawRot += rad2deg(rad);
 
 
 
     rad = std::abs(rad);
@@ -455,16 +455,16 @@ void OsuSpinner::rotate(float rad) {
 
         if((int)(newRotations / 360.0f) > (int)(m_fRotationsNeeded) + 1) {
 
             // extra rotations and bonus sound
 
             m_beatmap->getSkin()->playSpinnerBonusSound();
 
-            m_beatmap->addHitResult(this, OsuScore::HIT::HIT_SPINNERBONUS, 0, false, true, true, true, true,
 
+            m_beatmap->addHitResult(this, LiveScore::HIT::HIT_SPINNERBONUS, 0, false, true, true, true, true,
 
                                     false);  // only increase health
 
-            m_beatmap->addHitResult(this, OsuScore::HIT::HIT_SPINNERBONUS, 0, false, true, true, true, true,
 
+            m_beatmap->addHitResult(this, LiveScore::HIT::HIT_SPINNERBONUS, 0, false, true, true, true, true,
 
                                     false);  // HACKHACK: compensating for rotation logic differences
 
             m_beatmap->addScorePoints(1100, true);
 
         } else {
 
             // normal whole rotation
 
-            m_beatmap->addHitResult(this, OsuScore::HIT::HIT_SPINNERSPIN, 0, false, true, true, true, true,
 
+            m_beatmap->addHitResult(this, LiveScore::HIT::HIT_SPINNERSPIN, 0, false, true, true, true, true,
 
                                     false);  // only increase health
 
-            m_beatmap->addHitResult(this, OsuScore::HIT::HIT_SPINNERSPIN, 0, false, true, true, true, true,
 
+            m_beatmap->addHitResult(this, LiveScore::HIT::HIT_SPINNERSPIN, 0, false, true, true, true, true,
 
                                     false);  // HACKHACK: compensating for rotation logic differences
 
             m_beatmap->addScorePoints(100, true);
 
         }
@@ -481,7 +481,7 @@ void OsuSpinner::rotate(float rad) {
 
     m_fRotations = newRotations;
 
 }
 
 
 
-Vector2 OsuSpinner::getAutoCursorPos(long curPos) {
 
+Vector2 Spinner::getAutoCursorPos(long curPos) {
 
     // calculate point
 
     long delta = 0;
 
     if(curPos <= m_iTime)
--- a/src/App/Osu/OsuSpinner.h
+++ b/src/App/Osu/OsuSpinner.h
@@ -8,12 +8,12 @@
 
 #ifndef OSUSPINNER_H
 
 #define OSUSPINNER_H
 
 
 
-#include "OsuHitObject.h"
 
+#include "HitObject.h"
 
 
 
-class OsuSpinner : public OsuHitObject {
 
+class Spinner : public HitObject {
 
    public:
 
-    OsuSpinner(int x, int y, long time, int sampleType, bool isEndOfCombo, long endTime, OsuBeatmap *beatmap);
 
-    virtual ~OsuSpinner();
 
+    Spinner(int x, int y, long time, int sampleType, bool isEndOfCombo, long endTime, Beatmap *beatmap);
 
+    virtual ~Spinner();
 
 
 
     virtual void draw(Graphics *g);
 
     virtual void update(long curPos);
@@ -34,7 +34,7 @@ class OsuSpinner : public OsuHitObject {
 
     void onHit();
 
     void rotate(float rad);
 
 
 
-    OsuBeatmap *m_beatmap;
 
+    Beatmap *m_beatmap;
 
 
 
     Vector2 m_vRawPos;
 
     Vector2 m_vOriginalRawPos;
Upphovsman	SHA1 Meddelande	Datum
Clément Wolf	d9c3e70e06 Fix linux build instructions	2 veckor sedan
Clément Wolf	78f70b4eef Disable auto updater on linux	2 veckor sedan
Clément Wolf	a05d2daf94 Fix race conditions	2 veckor sedan
Clément Wolf	9fbc8d56a4 Cache BPM	2 veckor sedan
Clément Wolf	a36fb3591d Optimize beatmap list loading some more	2 veckor sedan
Clément Wolf	e57dedcb2c Use simpler type names	2 veckor sedan
Clément Wolf	f8e4d1f183 Remove redundant "Osu" naming	2 veckor sedan