Config and linux fixes, refactoringfix-timer

5 files changed, 42 insertions, 43 deletions

diff --git a/src/SSVOpenHexagon/Components/CWall.cpp b/src/SSVOpenHexagon/Components/CWall.cpp
index 25753af9..e962bfad 100644
--- a/src/SSVOpenHexagon/Components/CWall.cpp
+++ b/src/SSVOpenHexagon/Components/CWall.cpp
@@ -3,13 +3,9 @@
 // AFL License page: http://opensource.org/licenses/AFL-3.0
 
 #include "SSVOpenHexagon/Core/HexagonGame.hpp"
-#include "SSVOpenHexagon/Components/CPlayer.hpp"
 #include "SSVOpenHexagon/Components/CWall.hpp"
 #include "SSVOpenHexagon/Utils/Utils.hpp"
 
-using namespace sf;
-using namespace ssvs;
-
 namespace hg
 {
 
@@ -21,19 +17,19 @@ CWall::CWall(HexagonGame& mHexagonGame, const sf::Vector2f& mCenterPos,
     const float div{ssvu::tau / mHexagonGame.getSides() * 0.5f};
     const float angle{div * 2.f * mSide};
 
-    vertexPositions[0] = getOrbitRad(mCenterPos, angle - div, mDistance);
-    vertexPositions[1] = getOrbitRad(mCenterPos, angle + div, mDistance);
-    vertexPositions[2] =
-        getOrbitRad(mCenterPos, angle + div + mHexagonGame.getWallAngleLeft(),
-            mDistance + mThickness + mHexagonGame.getWallSkewLeft());
-    vertexPositions[3] =
-        getOrbitRad(mCenterPos, angle - div + mHexagonGame.getWallAngleRight(),
-            mDistance + mThickness + mHexagonGame.getWallSkewRight());
+    vertexPositions[0] = ssvs::getOrbitRad(mCenterPos, angle - div, mDistance);
+    vertexPositions[1] = ssvs::getOrbitRad(mCenterPos, angle + div, mDistance);
+    vertexPositions[2] = ssvs::getOrbitRad(mCenterPos,
+        angle + div + mHexagonGame.getWallAngleLeft(),
+        mDistance + mThickness + mHexagonGame.getWallSkewLeft());
+    vertexPositions[3] = ssvs::getOrbitRad(mCenterPos,
+        angle - div + mHexagonGame.getWallAngleRight(),
+        mDistance + mThickness + mHexagonGame.getWallSkewRight());
 }
 
 void CWall::draw(HexagonGame& mHexagonGame)
 {
-    Color colorMain(mHexagonGame.getColorMain());
+    sf::Color colorMain(mHexagonGame.getColorMain());
 
     if(hueMod != 0)
     {
@@ -47,7 +43,7 @@ void CWall::draw(HexagonGame& mHexagonGame)
 }
 
 void CWall::update(
-    HexagonGame& mHexagonGame, const sf::Vector2f& mCenterPos, FT mFT)
+    HexagonGame& mHexagonGame, const sf::Vector2f& mCenterPos, ssvu::FT mFT)
 {
     speed.update(mFT);
     curve.update(mFT);
@@ -64,8 +60,8 @@ void CWall::update(
         }
         else
         {
-            moveTowards(vp, mCenterPos, speed.speed * 5.f * mFT);
-            rotateRadAround(vp, mCenterPos, curve.speed / 60.f * mFT);
+            ssvs::moveTowards(vp, mCenterPos, speed.speed * 5.f * mFT);
+            ssvs::rotateRadAround(vp, mCenterPos, curve.speed / 60.f * mFT);
         }
     }
 
diff --git a/src/SSVOpenHexagon/Core/HexagonGame.cpp b/src/SSVOpenHexagon/Core/HexagonGame.cpp
index d38a3d4c..2f02317a 100644
--- a/src/SSVOpenHexagon/Core/HexagonGame.cpp
+++ b/src/SSVOpenHexagon/Core/HexagonGame.cpp
@@ -13,10 +13,6 @@
 #include "SSVOpenHexagon/Utils/Utils.hpp"
 #include "SSVOpenHexagon/Utils/LuaWrapper.hpp"
 
-using namespace std;
-using namespace sf;
-using namespace ssvu;
-using namespace ssvs;
 using namespace hg::Utils;
 
 namespace hg
@@ -33,7 +29,7 @@ void HexagonGame::createWall(int mSide, float mThickness,
 
 HexagonGame::HexagonGame(Steam::steam_manager& mSteamManager,
     Discord::discord_manager& mDiscordManager, HGAssets& mAssets,
-    GameWindow& mGameWindow)
+    ssvs::GameWindow& mGameWindow)
     : steamManager(mSteamManager), discordManager(mDiscordManager),
       assets(mAssets), window(mGameWindow), player{ssvs::zeroVec2f},
       fpsWatcher(window)
@@ -55,7 +51,7 @@ HexagonGame::HexagonGame(Steam::steam_manager& mSteamManager,
     game.addInput(
         Config::getTriggerForceRestart(),
         [this](FT /*unused*/) { status.mustRestart = true; },
-        Input::Type::Once);
+        ssvs::Input::Type::Once);
     game.addInput(
         Config::getTriggerRestart(),
         [this](FT /*unused*/) {
@@ -64,15 +60,15 @@ HexagonGame::HexagonGame(Steam::steam_manager& mSteamManager,
                 status.mustRestart = true;
             }
         },
-        Input::Type::Once);
+        ssvs::Input::Type::Once);
     game.addInput(
         Config::getTriggerScreenshot(),
         [this](FT /*unused*/) { mustTakeScreenshot = true; },
-        Input::Type::Once);
+        ssvs::Input::Type::Once);
 }
 
 void HexagonGame::newGame(
-    const string& mId, bool mFirstPlay, float mDifficultyMult)
+    const std::string& mId, bool mFirstPlay, float mDifficultyMult)
 {
     initFlashEffect();
 
@@ -150,13 +146,13 @@ void HexagonGame::newGame(
 void HexagonGame::death(bool mForce)
 {
     fpsWatcher.disable();
-    assets.playSound("death.ogg", SoundPlayer::Mode::Abort);
+    assets.playSound("death.ogg", ssvs::SoundPlayer::Mode::Abort);
 
     if(!mForce && (Config::getInvincible() || levelStatus.tutorialMode))
     {
         return;
     }
-    assets.playSound("gameOver.ogg", SoundPlayer::Mode::Abort);
+    assets.playSound("gameOver.ogg", ssvs::SoundPlayer::Mode::Abort);
 
     if(!assets.pIsLocal() && Config::isEligibleForScore())
     {
@@ -187,8 +183,8 @@ void HexagonGame::incrementDifficulty()
 
     if(levelStatus.shouldIncrement())
     {
-        levelStatus.rotationSpeed +=
-            levelStatus.rotationSpeedInc * getSign(levelStatus.rotationSpeed);
+        levelStatus.rotationSpeed += levelStatus.rotationSpeedInc *
+                                     ssvu::getSign(levelStatus.rotationSpeed);
     }
 
     levelStatus.rotationSpeed *= -1.f;
@@ -197,7 +193,7 @@ void HexagonGame::incrementDifficulty()
     if(status.fastSpin < 0 && abs(levelStatus.rotationSpeed) > rotationSpeedMax)
     {
         levelStatus.rotationSpeed =
-            rotationSpeedMax * getSign(levelStatus.rotationSpeed);
+            rotationSpeedMax * ssvu::getSign(levelStatus.rotationSpeed);
     }
 
     status.fastSpin = levelStatus.fastSpin;
@@ -226,14 +222,15 @@ void HexagonGame::checkAndSaveScore()
 
     if(Config::getInvincible())
     {
-        lo("hg::HexagonGame::checkAndSaveScore()")
+        ssvu::lo("hg::HexagonGame::checkAndSaveScore()")
             << "Not saving score - invincibility on\n";
         return;
     }
 
     if(assets.pIsLocal())
     {
-        string localValidator{getLocalValidator(levelData->id, difficultyMult)};
+        std::string localValidator{
+            getLocalValidator(levelData->id, difficultyMult)};
         if(assets.getLocalScore(localValidator) < time)
         {
             assets.setLocalScore(localValidator, time);
@@ -244,14 +241,14 @@ void HexagonGame::checkAndSaveScore()
     {
         if(status.scoreInvalid || !Config::isEligibleForScore())
         {
-            lo("hg::HexagonGame::checkAndSaveScore()")
+            ssvu::lo("hg::HexagonGame::checkAndSaveScore()")
                 << "Not sending/saving score - not eligible\n"
                 << Config::getUneligibilityReason() << "\n";
             return;
         }
         if(time < 8)
         {
-            lo("hg::HexagonGame::checkAndSaveScore()")
+            ssvu::lo("hg::HexagonGame::checkAndSaveScore()")
                 << "Not sending score - less than 8 seconds\n";
             return;
         }
@@ -274,7 +271,7 @@ void HexagonGame::goToMenu(bool mSendScores)
     mgPtr->init();
 }
 
-void HexagonGame::changeLevel(const string& mId, bool mFirstTime)
+void HexagonGame::changeLevel(const std::string& mId, bool mFirstTime)
 {
     newGame(mId, mFirstTime, difficultyMult);
 }
@@ -284,15 +281,15 @@ void HexagonGame::addMessage(
 {
     Utils::uppercasify(mMessage);
 
-    messageTimeline.append<Do>([this, mSoundToggle, mMessage] {
+    messageTimeline.append<ssvu::Do>([this, mSoundToggle, mMessage] {
         if(mSoundToggle)
         {
             assets.playSound("beep.ogg");
         }
         messageText.setString(mMessage);
     });
-    messageTimeline.append<Wait>(mDuration);
-    messageTimeline.append<Do>([this] { messageText.setString(""); });
+    messageTimeline.append<ssvu::Wait>(mDuration);
+    messageTimeline.append<ssvu::Do>([this] { messageText.setString(""); });
 }
 
 void HexagonGame::clearMessages()
@@ -337,17 +334,17 @@ void HexagonGame::stopLevelMusic()
 void HexagonGame::invalidateScore()
 {
     status.scoreInvalid = true;
-    lo("HexagonGame::invalidateScore")
+    ssvu::lo("HexagonGame::invalidateScore")
         << "Too much slowdown, invalidating official game\n";
 }
 
-auto HexagonGame::getColorMain() const -> Color
+auto HexagonGame::getColorMain() const -> sf::Color
 {
     if(Config::getBlackAndWhite())
     {
         //			if(status.drawing3D) return Color{255, 255, 255,
         // status.overrideColor.a};
-        return Color(255, 255, 255, styleData.getMainColor().a);
+        return sf::Color(255, 255, 255, styleData.getMainColor().a);
     }
     //	else if(status.drawing3D) return status.overrideColor;
     {
diff --git a/src/SSVOpenHexagon/Core/main.cpp b/src/SSVOpenHexagon/Core/main.cpp
index f3a28c5c..2b8ae1df 100644
--- a/src/SSVOpenHexagon/Core/main.cpp
+++ b/src/SSVOpenHexagon/Core/main.cpp
@@ -37,8 +37,8 @@ int main(int argc, char* argv[])
     // Discord integration
     hg::Discord::discord_manager discordManager;
 
-    auto gtm = std::make_unique<hg::Online::GlobalThreadManager>();
-    hg::Online::setCurrentGtm(std::move(gtm));
+    hg::Online::setCurrentGtm(
+        std::make_unique<hg::Online::GlobalThreadManager>());
 
     const auto overrideIds = [&] {
         std::vector<std::string> result;
diff --git a/src/SSVOpenHexagon/Global/Config.cpp b/src/SSVOpenHexagon/Global/Config.cpp
index 946adef3..b920dcc1 100644
--- a/src/SSVOpenHexagon/Global/Config.cpp
+++ b/src/SSVOpenHexagon/Global/Config.cpp
@@ -158,6 +158,7 @@ void loadConfig(const vector<string>& mOverridesIds)
 
     recalculateSizes();
 }
+
 void saveConfig()
 {
     lo("::saveConfig") << "saving config\n";
diff --git a/src/SSVOpenHexagon/Online/Online.cpp b/src/SSVOpenHexagon/Online/Online.cpp
index 42b350e6..5a26a235 100644
--- a/src/SSVOpenHexagon/Online/Online.cpp
+++ b/src/SSVOpenHexagon/Online/Online.cpp
@@ -484,6 +484,11 @@ string getMD5Hash(const string& mStr)
 
 void initializeValidators(HGAssets& mAssets)
 {
+    if(!Config::getOnline())
+    {
+        return;
+    }
+
     HG_LO_VERBOSE("hg::Online::initializeValidators")
         << "Initializing validators...\n";