Refactoring

23 files changed, 109 insertions, 111 deletions

diff --git a/_RELEASE/config.json b/_RELEASE/config.json
index c1050dbf..1140f0d1 100644
--- a/_RELEASE/config.json
+++ b/_RELEASE/config.json
@@ -50,16 +50,16 @@
 	"player_focus_speed" : 4.6250,

 	"player_size" : 7.300000190734863,

 	"player_speed" : 9.449999809265137,

-	"player_trail_alpha" : 255,

-	"player_trail_decay" : 0.50,

+	"player_trail_alpha" : 125,

+	"player_trail_decay" : 5.50,

 	"player_trail_has_swap_color" : true,

-	"player_trail_scale" : 1.0,

+	"player_trail_scale" : 0.8499999642372131,

 	"pulse_enabled" : true,

 	"rotate_to_start" : false,

 	"save_last_login_username" : true,

 	"save_local_best_replay_to_file" : true,

 	"server_control_port" : 50506,

-	"server_ip" : "127.0.0.1",

+	"server_ip" : "139.162.199.162",

 	"server_level_whitelist" : 

 	[

 		"ohvrvanilla_vittorio_romeo_cube_1_apeirogon_m_0.35",

diff --git a/include/SSVOpenHexagon/Core/CustomTimelineManager.hpp b/include/SSVOpenHexagon/Core/CustomTimelineManager.hpp
index b0b5243d..99eb4a60 100644
--- a/include/SSVOpenHexagon/Core/CustomTimelineManager.hpp
+++ b/include/SSVOpenHexagon/Core/CustomTimelineManager.hpp
@@ -6,6 +6,8 @@
 
 #include "SSVOpenHexagon/Core/CustomTimelineHandle.hpp"
 
+#include "SSVOpenHexagon/Utils/Clock.hpp"
+
 #include <chrono>
 #include <vector>
 
@@ -15,10 +17,6 @@ struct CustomTimeline;
 
 class CustomTimelineManager
 {
-public:
-    using Clock = std::chrono::high_resolution_clock;
-    using TimePoint = std::chrono::time_point<Clock>;
-
 private:
     std::vector<CustomTimeline> _timelines;
 
@@ -31,7 +29,7 @@ public:
 
     void clear() noexcept;
 
-    void updateAllTimelines(const TimePoint tp);
+    void updateAllTimelines(const HRTimePoint tp);
 
     [[nodiscard]] CustomTimelineHandle create();
 
diff --git a/include/SSVOpenHexagon/Core/HGStatus.hpp b/include/SSVOpenHexagon/Core/HGStatus.hpp
index b5c54f0c..7ee27210 100644
--- a/include/SSVOpenHexagon/Core/HGStatus.hpp
+++ b/include/SSVOpenHexagon/Core/HGStatus.hpp
@@ -4,6 +4,8 @@
 
 #pragma once
 
+#include "SSVOpenHexagon/Utils/Clock.hpp"
+
 #include <SFML/Graphics/Color.hpp>
 
 #include <chrono>
@@ -21,9 +23,6 @@ enum class StateChange
 struct HexagonGameStatus
 {
 public:
-    using Clock = std::chrono::high_resolution_clock;
-    using TimePoint = std::chrono::time_point<Clock>;
-
     struct FlashColor
     {
         int r;
@@ -70,13 +69,13 @@ public:
     [[nodiscard]] double getTimeSeconds() const noexcept;
 
     // Absolute time, as time point
-    [[nodiscard]] TimePoint getCurrentTP() const noexcept;
+    [[nodiscard]] HRTimePoint getCurrentTP() const noexcept;
 
     // Game timer, as time point
-    [[nodiscard]] TimePoint getTimeTP() const noexcept;
+    [[nodiscard]] HRTimePoint getTimeTP() const noexcept;
 
     // Level start, as time point
-    [[nodiscard]] TimePoint getLevelStartTP() const noexcept;
+    [[nodiscard]] HRTimePoint getLevelStartTP() const noexcept;
 
     // `true` if we are currently paused
     [[nodiscard]] bool isTimePaused() const noexcept;
diff --git a/include/SSVOpenHexagon/Core/HexagonClient.hpp b/include/SSVOpenHexagon/Core/HexagonClient.hpp
index aa758d77..4acd5839 100644
--- a/include/SSVOpenHexagon/Core/HexagonClient.hpp
+++ b/include/SSVOpenHexagon/Core/HexagonClient.hpp
@@ -7,6 +7,8 @@
 #include "SSVOpenHexagon/Online/Sodium.hpp"
 #include "SSVOpenHexagon/Online/DatabaseRecords.hpp"
 
+#include "SSVOpenHexagon/Utils/Clock.hpp"
+
 #include <SFML/Network/IpAddress.hpp>
 #include <SFML/Network/TcpSocket.hpp>
 #include <SFML/Network/Packet.hpp>
@@ -81,9 +83,6 @@ public:
         >;
 
 private:
-    using Clock = std::chrono::high_resolution_clock;
-    using TimePoint = std::chrono::time_point<Clock>;
-
     Steam::steam_manager& _steamManager;
 
     std::optional<std::uint64_t> _ticketSteamID;
@@ -97,7 +96,7 @@ private:
     sf::Packet _packetBuffer;
     std::ostringstream _errorOss;
 
-    TimePoint _lastHeartbeatTime;
+    HRTimePoint _lastHeartbeatTime;
 
     bool _verbose;
 
diff --git a/include/SSVOpenHexagon/Core/HexagonServer.hpp b/include/SSVOpenHexagon/Core/HexagonServer.hpp
index f4118189..e9b9dfb8 100644
--- a/include/SSVOpenHexagon/Core/HexagonServer.hpp
+++ b/include/SSVOpenHexagon/Core/HexagonServer.hpp
@@ -6,15 +6,17 @@
 
 #include "SSVOpenHexagon/Global/ProtocolVersion.hpp"
 
+#include "SSVOpenHexagon/Utils/Timestamp.hpp"
+
 #include "SSVOpenHexagon/Online/Sodium.hpp"
 #include "SSVOpenHexagon/Online/DatabaseRecords.hpp"
 
 #include <SFML/Network/IpAddress.hpp>
+#include <SFML/Network/Packet.hpp>
+#include <SFML/Network/SocketSelector.hpp>
 #include <SFML/Network/TcpListener.hpp>
 #include <SFML/Network/TcpSocket.hpp>
 #include <SFML/Network/UdpSocket.hpp>
-#include <SFML/Network/SocketSelector.hpp>
-#include <SFML/Network/Packet.hpp>
 
 #include <chrono>
 #include <list>
@@ -32,10 +34,6 @@ struct replay_file;
 
 class HexagonServer
 {
-public:
-    using Clock = std::chrono::high_resolution_clock;
-    using TimePoint = std::chrono::time_point<Clock>;
-
 private:
     HGAssets& _assets;
     HexagonGame& _hexagonGame;
@@ -67,7 +65,7 @@ private:
         };
 
         sf::TcpSocket _socket;
-        TimePoint _lastActivity;
+        Utils::SCTimePoint _lastActivity;
         int _consecutiveFailures;
         bool _mustDisconnect;
         std::optional<SodiumPublicKeyArray> _clientPublicKey;
@@ -88,13 +86,13 @@ private:
 
         struct GameStatus
         {
-            TimePoint _startTP;
+            Utils::SCTimePoint _startTP;
             std::string _levelValidator;
         };
 
         std::optional<GameStatus> _gameStatus;
 
-        explicit ConnectedClient(const TimePoint lastActivity)
+        explicit ConnectedClient(const Utils::SCTimePoint lastActivity)
             : _socket{},
               _lastActivity{lastActivity},
               _consecutiveFailures{0},
@@ -117,8 +115,8 @@ private:
 
     const SodiumPSKeys _serverPSKeys;
 
-    TimePoint _lastTokenPurge;
-    TimePoint _lastLogsFlush;
+    Utils::SCTimePoint _lastTokenPurge;
+    Utils::SCTimePoint _lastLogsFlush;
 
     [[nodiscard]] bool initializeControlSocket();
     [[nodiscard]] bool initializeTcpListener();
diff --git a/include/SSVOpenHexagon/Core/LeaderboardCache.hpp b/include/SSVOpenHexagon/Core/LeaderboardCache.hpp
index e0f08df2..9d2a66f9 100644
--- a/include/SSVOpenHexagon/Core/LeaderboardCache.hpp
+++ b/include/SSVOpenHexagon/Core/LeaderboardCache.hpp
@@ -6,6 +6,8 @@
 
 #include "SSVOpenHexagon/Online/DatabaseRecords.hpp"
 
+#include "SSVOpenHexagon/Utils/Clock.hpp"
+
 #include <string>
 #include <sstream>
 #include <vector>
@@ -17,16 +19,12 @@ namespace hg {
 
 class LeaderboardCache
 {
-public:
-    using Clock = std::chrono::high_resolution_clock;
-    using TimePoint = std::chrono::time_point<Clock>;
-
 private:
     struct CachedScores
     {
         std::vector<Database::ProcessedScore> _scores;
         std::optional<Database::ProcessedScore> _ownScore;
-        TimePoint _cacheTime;
+        HRTimePoint _cacheTime;
     };
 
     std::unordered_map<std::string, CachedScores> _levelValidatorToScores;
diff --git a/include/SSVOpenHexagon/Core/MenuGame.hpp b/include/SSVOpenHexagon/Core/MenuGame.hpp
index cf720119..2143f0ce 100644
--- a/include/SSVOpenHexagon/Core/MenuGame.hpp
+++ b/include/SSVOpenHexagon/Core/MenuGame.hpp
@@ -10,6 +10,7 @@
 #include "SSVOpenHexagon/Data/LevelData.hpp"
 #include "SSVOpenHexagon/Data/LevelStatus.hpp"
 
+#include "SSVOpenHexagon/Utils/Clock.hpp"
 #include "SSVOpenHexagon/Utils/FastVertexVector.hpp"
 #include "SSVOpenHexagon/Utils/LuaWrapper.hpp"
 #include "SSVOpenHexagon/Utils/UniquePtr.hpp"
@@ -259,10 +260,7 @@ private:
     Utils::FastVertexVectorQuads menuQuads;
 
     // Mouse control
-    using Clock = std::chrono::high_resolution_clock;
-    using TimePoint = Clock::time_point;
-    using Duration = Clock::duration;
-    TimePoint lastMouseClick{};
+    HRTimePoint lastMouseClick{};
     bool mouseHovering{false};
     bool mouseWasPressed{false};
     bool mousePressed{false};
diff --git a/include/SSVOpenHexagon/Data/LevelData.hpp b/include/SSVOpenHexagon/Data/LevelData.hpp
index f103d39a..4fcfe86d 100644
--- a/include/SSVOpenHexagon/Data/LevelData.hpp
+++ b/include/SSVOpenHexagon/Data/LevelData.hpp
@@ -4,9 +4,10 @@
 
 #pragma once
 
-#include <string>
 #include <set>
+#include <string>
 #include <unordered_map>
+#include <vector>
 
 namespace Json {
 class Value;
diff --git a/include/SSVOpenHexagon/Utils/Clock.hpp b/include/SSVOpenHexagon/Utils/Clock.hpp
new file mode 100644
index 00000000..d944625e
--- /dev/null
+++ b/include/SSVOpenHexagon/Utils/Clock.hpp
@@ -0,0 +1,20 @@
+// Copyright (c) 2013-2020 Vittorio Romeo
+// License: Academic Free License ("AFL") v. 3.0
+// AFL License page: https://opensource.org/licenses/AFL-3.0
+
+#pragma once
+
+#include <chrono>
+
+namespace hg {
+
+using HRClock = std::chrono::high_resolution_clock;
+using HRTimePoint = std::chrono::time_point<HRClock>;
+
+[[nodiscard]] inline auto hrSecondsSince(const HRTimePoint tp) noexcept
+{
+    return std::chrono::duration_cast<std::chrono::seconds>(HRClock::now() - tp)
+        .count();
+}
+
+} // namespace hg
diff --git a/include/SSVOpenHexagon/Utils/Timestamp.hpp b/include/SSVOpenHexagon/Utils/Timestamp.hpp
index 1c5cebeb..36def33d 100644
--- a/include/SSVOpenHexagon/Utils/Timestamp.hpp
+++ b/include/SSVOpenHexagon/Utils/Timestamp.hpp
@@ -10,13 +10,16 @@
 
 namespace hg::Utils {
 
-using Clock = std::chrono::high_resolution_clock;
-using TimePoint = std::chrono::time_point<Clock>;
+using SCClock = std::chrono::system_clock;
+using SCTimePoint = std::chrono::time_point<SCClock>;
+
+[[nodiscard]] std::uint64_t timestamp(const SCTimePoint tp);
 
-[[nodiscard]] std::uint64_t timestamp(const TimePoint tp);
 [[nodiscard]] std::uint64_t nowTimestamp();
-[[nodiscard]] TimePoint toTimepoint(const std::uint64_t timestamp);
+
+[[nodiscard]] SCTimePoint toTimepoint(const std::uint64_t timestamp);
+
 [[nodiscard]] std::string formatTimepoint(
-    const TimePoint time, const std::string& format);
+    const SCTimePoint time, const std::string& format);
 
 } // namespace hg::Utils
diff --git a/src/SSVOpenHexagon/Core/CustomTimelineManager.cpp b/src/SSVOpenHexagon/Core/CustomTimelineManager.cpp
index 05ab9c2c..6f43e551 100644
--- a/src/SSVOpenHexagon/Core/CustomTimelineManager.cpp
+++ b/src/SSVOpenHexagon/Core/CustomTimelineManager.cpp
@@ -32,7 +32,7 @@ void CustomTimelineManager::clear() noexcept
     _timelines.clear();
 }
 
-void CustomTimelineManager::updateAllTimelines(const TimePoint tp)
+void CustomTimelineManager::updateAllTimelines(const HRTimePoint tp)
 {
     for(CustomTimeline& t : _timelines)
     {
diff --git a/src/SSVOpenHexagon/Core/HGStatus.cpp b/src/SSVOpenHexagon/Core/HGStatus.cpp
index 6fd422a9..6917d920 100644
--- a/src/SSVOpenHexagon/Core/HGStatus.cpp
+++ b/src/SSVOpenHexagon/Core/HGStatus.cpp
@@ -28,24 +28,21 @@ void HexagonGameStatus::start() noexcept
     return getPlayedAccumulatedFrametimeInSeconds();
 }
 
-[[nodiscard]] HexagonGameStatus::TimePoint
-HexagonGameStatus::getCurrentTP() const noexcept
+[[nodiscard]] HRTimePoint HexagonGameStatus::getCurrentTP() const noexcept
 {
-    return HexagonGameStatus::TimePoint{std::chrono::milliseconds{
+    return HRTimePoint{std::chrono::milliseconds{
         (int64_t)(getTotalAccumulatedFrametimeInSeconds() * 1000.0)}};
 }
 
-[[nodiscard]] HexagonGameStatus::TimePoint
-HexagonGameStatus::getTimeTP() const noexcept
+[[nodiscard]] HRTimePoint HexagonGameStatus::getTimeTP() const noexcept
 {
-    return HexagonGameStatus::TimePoint{std::chrono::milliseconds{
+    return HRTimePoint{std::chrono::milliseconds{
         (int64_t)(getPlayedAccumulatedFrametimeInSeconds() * 1000.0)}};
 }
 
-[[nodiscard]] HexagonGameStatus::TimePoint
-HexagonGameStatus::getLevelStartTP() const noexcept
+[[nodiscard]] HRTimePoint HexagonGameStatus::getLevelStartTP() const noexcept
 {
-    return HexagonGameStatus::TimePoint{};
+    return HRTimePoint{};
 }
 
 [[nodiscard]] bool HexagonGameStatus::isTimePaused() const noexcept
diff --git a/src/SSVOpenHexagon/Core/HGUpdate.cpp b/src/SSVOpenHexagon/Core/HGUpdate.cpp
index 410079af..66789404 100644
--- a/src/SSVOpenHexagon/Core/HGUpdate.cpp
+++ b/src/SSVOpenHexagon/Core/HGUpdate.cpp
@@ -11,6 +11,7 @@
 #include "SSVOpenHexagon/Global/Audio.hpp"
 #include "SSVOpenHexagon/Global/Config.hpp"
 
+#include "SSVOpenHexagon/Utils/Clock.hpp"
 #include "SSVOpenHexagon/Utils/Concat.hpp"
 #include "SSVOpenHexagon/Utils/Easing.hpp"
 #include "SSVOpenHexagon/Utils/LevelValidator.hpp"
@@ -48,18 +49,12 @@ namespace hg {
 
 void HexagonGame::fastForwardTo(const double target)
 {
-    using Clock = std::chrono::high_resolution_clock;
-    using TimePoint = std::chrono::time_point<Clock>;
-
-    const TimePoint tpBegin = Clock::now();
+    const HRTimePoint tpBegin = HRClock::now();
 
     const auto exceededProcessingTime = [&]
     {
         constexpr int maxProcessingSeconds = 3;
-
-        return std::chrono::duration_cast<std::chrono::seconds>(
-                   Clock::now() - tpBegin)
-                   .count() > maxProcessingSeconds;
+        return hrSecondsSince(tpBegin) > maxProcessingSeconds;
     };
 
     while(!status.hasDied && status.getTimeSeconds() < target &&
diff --git a/src/SSVOpenHexagon/Core/HexagonClient.cpp b/src/SSVOpenHexagon/Core/HexagonClient.cpp
index 075dfe3d..448eacc6 100644
--- a/src/SSVOpenHexagon/Core/HexagonClient.cpp
+++ b/src/SSVOpenHexagon/Core/HexagonClient.cpp
@@ -238,7 +238,7 @@ template <typename T>
         return fail();
     }
 
-    _lastHeartbeatTime = Clock::now();
+    _lastHeartbeatTime = HRClock::now();
     return true;
 }
 
@@ -521,7 +521,7 @@ bool HexagonClient::sendHeartbeatIfNecessary()
 
     constexpr std::chrono::duration heatbeatInterval = std::chrono::seconds(45);
 
-    if(Clock::now() - _lastHeartbeatTime > heatbeatInterval)
+    if(HRClock::now() - _lastHeartbeatTime > heatbeatInterval)
     {
         if(!sendHeartbeat())
         {
diff --git a/src/SSVOpenHexagon/Core/HexagonGame.cpp b/src/SSVOpenHexagon/Core/HexagonGame.cpp
index d93d39e6..8c73dedd 100644
--- a/src/SSVOpenHexagon/Core/HexagonGame.cpp
+++ b/src/SSVOpenHexagon/Core/HexagonGame.cpp
@@ -1052,17 +1052,10 @@ void HexagonGame::death_sendAndSaveReplay(const replay_file& rf)
 HexagonGame::executeGameUntilDeath(
     const int maxProcessingSeconds, const float timescale)
 {
-    using Clock = std::chrono::high_resolution_clock;
-    using TimePoint = std::chrono::time_point<Clock>;
-
-    const TimePoint tpBegin = Clock::now();
+    const HRTimePoint tpBegin = HRClock::now();
 
     const auto exceededProcessingTime = [&]
-    {
-        return std::chrono::duration_cast<std::chrono::seconds>(
-                   Clock::now() - tpBegin)
-                   .count() > maxProcessingSeconds;
-    };
+    { return hrSecondsSince(tpBegin) > maxProcessingSeconds; };
 
     while(!status.hasDied)
     {
diff --git a/src/SSVOpenHexagon/Core/HexagonServer.cpp b/src/SSVOpenHexagon/Core/HexagonServer.cpp
index a6bc81cd..64f69db5 100644
--- a/src/SSVOpenHexagon/Core/HexagonServer.cpp
+++ b/src/SSVOpenHexagon/Core/HexagonServer.cpp
@@ -424,7 +424,7 @@ bool HexagonServer::runIteration_TryAcceptingNewClient()
     SSVOH_SLOG_VERBOSE << "Listener is ready\n";
 
     ConnectedClient& potentialClient =
-        _connectedClients.emplace_back(Clock::now());
+        _connectedClients.emplace_back(Utils::SCClock::now());
 
     sf::TcpSocket& potentialSocket = potentialClient._socket;
     potentialSocket.setBlocking(true);
@@ -478,7 +478,7 @@ void HexagonServer::runIteration_LoopOverSockets()
 
             if(processPacket(connectedClient, _packetBuffer))
             {
-                connectedClient._lastActivity = Clock::now();
+                connectedClient._lastActivity = Utils::SCClock::now();
                 connectedClient._consecutiveFailures = 0;
 
                 continue;
@@ -508,7 +508,7 @@ void HexagonServer::runIteration_PurgeClients()
 {
     constexpr std::chrono::duration maxInactivity = std::chrono::seconds(60);
 
-    const TimePoint now = Clock::now();
+    const Utils::SCTimePoint now = Utils::SCClock::now();
 
     for(auto it = _connectedClients.begin(); it != _connectedClients.end();
         ++it)
@@ -538,16 +538,16 @@ void HexagonServer::runIteration_PurgeClients()
     }
 }
 
-template <typename Duration>
+template <typename TDuration>
 [[nodiscard]] static bool checkAndUpdateLastElapsed(
-    HexagonServer::TimePoint& last, const Duration duration)
+    Utils::SCTimePoint& last, const TDuration duration)
 {
-    if(HexagonServer::Clock::now() - last < duration)
+    if(Utils::SCClock::now() - last < duration)
     {
         return false;
     }
 
-    last = HexagonServer::Clock::now();
+    last = Utils::SCClock::now();
     return true;
 }
 
@@ -631,7 +631,7 @@ void HexagonServer::runIteration_FlushLogs()
 {
     const void* clientAddr = static_cast<void*>(&c);
 
-    const TimePoint receiveTime = Clock::now();
+    const Utils::SCTimePoint receiveTime = Utils::SCClock::now();
 
     if(!validateLogin(c, "replay", loginToken))
     {
@@ -1006,8 +1006,6 @@ void HexagonServer::printCTSPDataVerbose(
 
             Database::removeAllLoginTokensForUser(user->id);
 
-            static_assert(std::is_same_v<Clock, Utils::Clock>);
-
             Database::addLoginToken( //
                 Database::LoginToken{
                     .userId = user->id,
@@ -1214,8 +1212,8 @@ void HexagonServer::printCTSPDataVerbose(
                        << "' started game for level '" << lv << "'\n";
 
             c._gameStatus = ConnectedClient::GameStatus{
-                ._startTP = Clock::now(), //
-                ._levelValidator = lv     //
+                ._startTP = Utils::SCClock::now(), //
+                ._levelValidator = lv              //
             };
 
             return true;
@@ -1323,7 +1321,7 @@ HexagonServer::HexagonServer(HGAssets& assets, HexagonGame& hexagonGame,
       _running{true},
       _verbose{false},
       _serverPSKeys{generateSodiumPSKeys()},
-      _lastTokenPurge{Clock::now()}
+      _lastTokenPurge{Utils::SCClock::now()}
 {
     const auto sKeyPublic = sodiumKeyToString(_serverPSKeys.keyPublic);
     const auto sKeySecret = sodiumKeyToString(_serverPSKeys.keySecret);
diff --git a/src/SSVOpenHexagon/Core/LeaderboardCache.cpp b/src/SSVOpenHexagon/Core/LeaderboardCache.cpp
index 82652e67..7a1fba87 100644
--- a/src/SSVOpenHexagon/Core/LeaderboardCache.cpp
+++ b/src/SSVOpenHexagon/Core/LeaderboardCache.cpp
@@ -4,12 +4,14 @@
 
 #include "SSVOpenHexagon/Core/LeaderboardCache.hpp"
 
-#include <string>
-#include <sstream>
-#include <vector>
+#include "SSVOpenHexagon/Global/Assert.hpp"
+
 #include <chrono>
-#include <unordered_map>
 #include <optional>
+#include <sstream>
+#include <string>
+#include <unordered_map>
+#include <vector>
 
 namespace hg {
 
@@ -18,7 +20,7 @@ void LeaderboardCache::receivedScores(const std::string& levelValidator,
 {
     CachedScores& cs = _levelValidatorToScores[levelValidator];
     cs._scores = scores;
-    cs._cacheTime = Clock::now();
+    cs._cacheTime = HRClock::now();
 }
 
 void LeaderboardCache::receivedOwnScore(
@@ -26,12 +28,12 @@ void LeaderboardCache::receivedOwnScore(
 {
     CachedScores& cs = _levelValidatorToScores[levelValidator];
     cs._ownScore = score;
-    cs._cacheTime = Clock::now();
+    cs._cacheTime = HRClock::now();
 }
 
 void LeaderboardCache::requestedScores(const std::string& levelValidator)
 {
-    _levelValidatorToScores[levelValidator]._cacheTime = Clock::now();
+    _levelValidatorToScores[levelValidator]._cacheTime = HRClock::now();
 }
 
 [[nodiscard]] bool LeaderboardCache::shouldRequestScores(
@@ -45,7 +47,7 @@ void LeaderboardCache::requestedScores(const std::string& levelValidator)
 
     const CachedScores& cs = it->second;
 
-    return (Clock::now() - cs._cacheTime) > std::chrono::seconds(6);
+    return (HRClock::now() - cs._cacheTime) > std::chrono::seconds(6);
 }
 
 [[nodiscard]] const std::vector<Database::ProcessedScore>&
diff --git a/src/SSVOpenHexagon/Core/MenuGame.cpp b/src/SSVOpenHexagon/Core/MenuGame.cpp
index 6d618f63..a0917902 100644
--- a/src/SSVOpenHexagon/Core/MenuGame.cpp
+++ b/src/SSVOpenHexagon/Core/MenuGame.cpp
@@ -5001,8 +5001,8 @@ void MenuGame::drawLevelSelectionRightSide(
         // TODO (P2): cleanup mouse control
         if(mouseOverlap && mouseLeftRisingEdge())
         {
-            if(!mustPlay &&
-                Clock::now() - lastMouseClick < std::chrono::milliseconds(160))
+            if(!mustPlay && HRClock::now() - lastMouseClick <
+                                std::chrono::milliseconds(160))
             {
                 mustPlay = true;
             }
@@ -5910,7 +5910,7 @@ void MenuGame::draw()
 
     if(!mouseWasPressed && mousePressed)
     {
-        lastMouseClick = Clock::now();
+        lastMouseClick = HRClock::now();
     }
 }
 
diff --git a/src/SSVOpenHexagon/Core/Replay.cpp b/src/SSVOpenHexagon/Core/Replay.cpp
index b9b57fb3..94ba2023 100644
--- a/src/SSVOpenHexagon/Core/Replay.cpp
+++ b/src/SSVOpenHexagon/Core/Replay.cpp
@@ -417,7 +417,7 @@ static constexpr std::size_t buf_size{2097152}; // 2MB
 
 [[nodiscard]] std::string replay_file::create_filename() const
 {
-    const Utils::TimePoint tp = Utils::toTimepoint(Utils::nowTimestamp());
+    const Utils::SCTimePoint tp = Utils::toTimepoint(Utils::nowTimestamp());
     const std::string tp_str = Utils::formatTimepoint(tp, "%Y%m%d_%H%M%S");
 
     return Utils::concat(_version, '_', tp_str, '_', _player_name, '_',
diff --git a/src/SSVOpenHexagon/Core/Steam.cpp b/src/SSVOpenHexagon/Core/Steam.cpp
index 2533d106..86ccf343 100644
--- a/src/SSVOpenHexagon/Core/Steam.cpp
+++ b/src/SSVOpenHexagon/Core/Steam.cpp
@@ -956,7 +956,8 @@ steam_manager::get_ticket_steam_id() const noexcept
 
 namespace hg::Steam {
 
-class steam_manager::steam_manager_impl { };
+class steam_manager::steam_manager_impl
+{};
 
 steam_manager::steam_manager() : _impl{nullptr}
 {}
diff --git a/src/SSVOpenHexagon/Global/Assets.cpp b/src/SSVOpenHexagon/Global/Assets.cpp
index c003239e..cfb4726c 100644
--- a/src/SSVOpenHexagon/Global/Assets.cpp
+++ b/src/SSVOpenHexagon/Global/Assets.cpp
@@ -16,6 +16,7 @@
 #include "SSVOpenHexagon/SSVUtilsJson/SSVUtilsJson.hpp"
 
 #include "SSVOpenHexagon/Utils/BuildPackId.hpp"
+#include "SSVOpenHexagon/Utils/Clock.hpp"
 #include "SSVOpenHexagon/Utils/Concat.hpp"
 #include "SSVOpenHexagon/Utils/EraseIf.hpp"
 #include "SSVOpenHexagon/Utils/LoadFromJson.hpp"
@@ -122,10 +123,7 @@ HGAssets::HGAssets(
       levelsOnly{mLevelsOnly},
       assetStorage{Utils::makeUnique<AssetStorage>()}
 {
-    using Clock = std::chrono::high_resolution_clock;
-    using TimePoint = std::chrono::time_point<Clock>;
-
-    const TimePoint tpBeforeLoad = Clock::now();
+    const HRTimePoint tpBeforeLoad = HRClock::now();
 
     if(!levelsOnly && !mHeadless)
     {
@@ -195,7 +193,7 @@ HGAssets::HGAssets(
     // so shrink it to fit the actually used size.
     loadInfo.errorMessages.shrink_to_fit();
 
-    const std::chrono::duration durElapsed = Clock::now() - tpBeforeLoad;
+    const std::chrono::duration durElapsed = HRClock::now() - tpBeforeLoad;
 
     ssvu::lo("HGAssets::HGAssets")
         << "Loaded all assets in "
diff --git a/src/SSVOpenHexagon/Online/Database.cpp b/src/SSVOpenHexagon/Online/Database.cpp
index 5ef4133c..e319f3aa 100644
--- a/src/SSVOpenHexagon/Online/Database.cpp
+++ b/src/SSVOpenHexagon/Online/Database.cpp
@@ -205,7 +205,7 @@ constexpr int tokenValiditySeconds = 3600;
 
 [[nodiscard]] static bool isLoginTokenTimestampValid(const LoginToken& lt)
 {
-    const Utils::TimePoint now = Utils::Clock::now();
+    const Utils::SCTimePoint now = Utils::SCClock::now();
 
     return (now - Utils::toTimepoint(lt.timestamp)) <
            std::chrono::seconds(tokenValiditySeconds);
diff --git a/src/SSVOpenHexagon/Utils/Timestamp.cpp b/src/SSVOpenHexagon/Utils/Timestamp.cpp
index 49428c63..cfe79cc7 100644
--- a/src/SSVOpenHexagon/Utils/Timestamp.cpp
+++ b/src/SSVOpenHexagon/Utils/Timestamp.cpp
@@ -9,7 +9,7 @@
 
 namespace hg::Utils {
 
-[[nodiscard]] std::uint64_t timestamp(const TimePoint tp)
+[[nodiscard]] std::uint64_t timestamp(const SCTimePoint tp)
 {
     return std::chrono::duration_cast<std::chrono::seconds>(
         tp.time_since_epoch())
@@ -18,16 +18,16 @@ namespace hg::Utils {
 
 [[nodiscard]] std::uint64_t nowTimestamp()
 {
-    return timestamp(Clock::now());
+    return timestamp(SCClock::now());
 }
 
-[[nodiscard]] TimePoint toTimepoint(const std::uint64_t timestamp)
+[[nodiscard]] SCTimePoint toTimepoint(const std::uint64_t timestamp)
 {
-    return TimePoint{} + std::chrono::seconds(timestamp);
+    return SCTimePoint{} + std::chrono::seconds(timestamp);
 }
 
 [[nodiscard]] std::string formatTimepoint(
-    const TimePoint time, const std::string& format)
+    const SCTimePoint time, const std::string& format)
 {
     const std::time_t tt = std::chrono::system_clock::to_time_t(time);
     const std::tm tm = *std::gmtime(&tt); // GMT (UTC)