Silver-Ore-Team · piotrmacha · Aug 8, 2024 · Jul 31, 2024 · Jul 31, 2024 · Aug 1, 2024
diff --git a/src/Gothic/BassLoader.hpp b/src/Gothic/BassLoader.hpp
@@ -117,7 +117,7 @@ namespace GOTHIC_NAMESPACE
                         std::shared_ptr<NH::Bass::MusicTheme> theme = std::make_shared<NH::Bass::MusicTheme>(input->Name.ToChar());
                         theme->SetAudioEffects(NH::Bass::AudioFile::DEFAULT, [](NH::Bass::AudioEffects& effects){});
                         auto zones = NH::String(input->Zones.ToChar()).Split(",");
-                        for (auto& zone: zones) { theme->AddZone(zone.MakeUpper()); }
+                        for (auto& zone: zones) { theme->AddZone(std::string(zone.MakeUpper().ToChar())); }
                         // input->Type ignored for now
                         NH::Bass::Engine::GetInstance()->GetMusicManager().AddTheme(input->Name.ToChar(), theme);
                     });
@@ -127,8 +127,8 @@ namespace GOTHIC_NAMESPACE
                     [&]() { return m_BassThemeAudioInstances.emplace_back(new BassMusicThemeAudio{}); },
                     [&](BassMusicThemeAudio* input, zCPar_Symbol* symbol) {
                         std::shared_ptr<NH::Bass::MusicTheme> theme = NH::Bass::Engine::GetInstance()->GetMusicManager().GetTheme(input->Theme.ToChar());
-                        NH::String type =  NH::String(input->Type.ToChar());
-                        NH::HashString id = type == "DEFAULT" ? NH::Bass::AudioFile::DEFAULT : NH::HashString(type);
+                        auto type = NH::String(input->Type.ToChar());
+                        const std::string id = type == "DEFAULT" ? NH::Bass::AudioFile::DEFAULT : type.ToChar();
                         theme->SetAudioFile(id, input->Filename.ToChar());
                         theme->SetAudioEffects(id, [&](NH::Bass::AudioEffects& effects) {
                             effects.Loop.Active = input->Loop;
@@ -154,8 +154,8 @@ namespace GOTHIC_NAMESPACE
                         });
                         if (!input->MidiFile.IsEmpty())
                         {
-                            auto midiFile = std::make_shared<NH::Bass::MidiFile>(theme->GetName(), NH::HashString(NH::String(input->MidiFile.ToChar())));
-                            theme->AddMidiFile(NH::HashString(""), midiFile);
+                            auto midiFile = std::make_shared<NH::Bass::MidiFile>(theme->GetName(), NH::String(input->MidiFile.ToChar()));
+                            theme->AddMidiFile("", midiFile);
                         }
                         NH::Bass::Engine::GetInstance()->GetMusicManager().RefreshTheme(theme->GetName());
                     });

diff --git a/src/Gothic/CMusicSys_Bass.hpp b/src/Gothic/CMusicSys_Bass.hpp
@@ -7,8 +7,8 @@ namespace GOTHIC_NAMESPACE
             static NH::Logger* log = NH::CreateLogger("zBassMusic::Event_OnEnd");
 
             NH::Bass::Event::MusicEnd data = std::get<NH::Bass::Event::MusicEnd>(event.Data);
-            zSTRING filename{ data.Theme->GetAudioFile(data.AudioId).Filename.ToChar() };
-            zSTRING name{ data.Theme->GetName() };
+            zSTRING filename{ data.Theme->GetAudioFile(data.AudioId).Filename.c_str() };
+            zSTRING name{ data.Theme->GetName().c_str() };
             log->Trace("{0}, {1}", name.ToChar(), filename.ToChar());
 
             for (int i = 0; i < Globals->Event_OnEnd_Functions.GetNumInList(); i++)
@@ -25,8 +25,8 @@ namespace GOTHIC_NAMESPACE
             static NH::Logger* log = NH::CreateLogger("zBassMusic::Event_OnTransition");
 
             NH::Bass::Event::MusicTransition data = std::get<NH::Bass::Event::MusicTransition>(event.Data);
-            zSTRING filename{ data.Theme->GetAudioFile(data.AudioId).Filename.ToChar() };
-            zSTRING name{ data.Theme->GetName() };
+            zSTRING filename{ data.Theme->GetAudioFile(data.AudioId).Filename.c_str() };
+            zSTRING name{ data.Theme->GetName().c_str() };
             float timeLeft = data.TimeLeft;
             log->Trace("{0}, {1}", name.ToChar(), filename.ToChar());
 
@@ -44,8 +44,8 @@ namespace GOTHIC_NAMESPACE
             static NH::Logger* log = NH::CreateLogger("zBassMusic::Event_OnChange");
 
             NH::Bass::Event::MusicChange data = std::get<NH::Bass::Event::MusicChange>(event.Data);
-            zSTRING filename{ data.Theme->GetAudioFile(data.AudioId).Filename.ToChar() };
-            zSTRING name{ data.Theme->GetName() };
+            zSTRING filename{ data.Theme->GetAudioFile(data.AudioId).Filename.c_str() };
+            zSTRING name{ data.Theme->GetName().c_str() };
             log->Trace("{0}, {1}", name.ToChar(), filename.ToChar());
 
             Globals->BassMusic_ActiveThemeFilename = filename;
@@ -169,7 +169,7 @@ namespace GOTHIC_NAMESPACE
 
             nowPlaying = identifier;
             m_ActiveTheme = nullptr;
-            m_BassEngine->GetCommandQueue().AddCommand(std::make_shared<NH::Bass::ChangeZoneCommand>(NH::String(identifier.ToChar())));
+            m_BassEngine->GetCommandQueue().AddCommand(std::make_shared<NH::Bass::ChangeZoneCommand>(identifier.ToChar()));
 
             if (done)
             {

diff --git a/src/Gothic/Externals.hpp b/src/Gothic/Externals.hpp
@@ -92,14 +92,14 @@ namespace GOTHIC_NAMESPACE
         parser->GetParameter(filter);
         parser->GetParameter(theme);
 
-        auto target = NH::Bass::Engine::GetInstance()->GetMusicManager().GetTheme(NH::String(theme));
+        auto target = NH::Bass::Engine::GetInstance()->GetMusicManager().GetTheme(theme.ToChar());
         if (!target)
         {
             log->Error("Theme {0} not found", theme.ToChar());
             return 0;
         }
 
-        target->AddMidiFile(NH::String(filter), std::make_shared<NH::Bass::MidiFile>(target->GetName(), NH::String(midiFilename.ToChar())));
+        target->AddMidiFile(filter.ToChar(), std::make_shared<NH::Bass::MidiFile>(target->GetName(), NH::String(midiFilename.ToChar())));
         return 0;
     }
 
@@ -120,15 +120,15 @@ namespace GOTHIC_NAMESPACE
         parser->GetParameter(filter);
         parser->GetParameter(theme);
 
-        auto target = NH::Bass::Engine::GetInstance()->GetMusicManager().GetTheme(NH::String(theme.ToChar()));
+        auto target = NH::Bass::Engine::GetInstance()->GetMusicManager().GetTheme(theme.ToChar());
         if (!target)
         {
             log->Error("Theme {0} not found", theme.ToChar());
             return 0;
         }
 
         NH::Bass::Transition::TimePoint tp { start, duration, (NH::Bass::TransitionEffect)effect, nextStart, nextDuration, (NH::Bass::TransitionEffect)nextEffect };
-        target->GetTransitionInfo().AddTimePoint(tp, NH::String(filter.ToChar()));
+        target->GetTransitionInfo().AddTimePoint(tp, filter.ToChar());
 
         return 0;
     }

diff --git a/src/NH/Bass/Channel.cpp b/src/NH/Bass/Channel.cpp
@@ -19,8 +19,8 @@ namespace NH::Bass
         if (!m_Stream)
         {
             int code = BASS_ErrorGetCode();
-            log->Error("Could not create stream: {0}\n  error: {1}\n  at {2}:{3}", audioFile.Filename, Engine::ErrorCodeToString(code), __FILE__, __LINE__);
-            return std::unexpected(Error{ IChannel::ErrorType::INVALID_BUFFER, code, Engine::ErrorCodeToString(code) });
+            log->Error("Could not create stream: {0}\n  error: {1}\n  at {2}:{3}", audioFile.Filename.c_str(), Engine::ErrorCodeToString(code), __FILE__, __LINE__);
+            return std::unexpected(Error{ IChannel::ErrorType::INVALID_BUFFER, code, Engine::ErrorCodeToString(code).ToChar() });
         }
 
         BASS_ChannelStart(m_Stream);

diff --git a/src/NH/Bass/Engine.h b/src/NH/Bass/Engine.h
@@ -1,17 +1,12 @@
 #pragma once
 
-#include <bass.h>
 #include "EventManager.h"
 #include "Channel.h"
 #include "NH/Logger.h"
-#include "NH/HashString.h"
 #include <NH/Bass/IEngine.h>
 #include <NH/Bass/MusicManager.h>
 #include <NH/Bass/Command.h>
 #include <vector>
-#include <mutex>
-#include <chrono>
-#include <unordered_map>
 
 namespace NH::Bass
 {
@@ -23,7 +18,7 @@ namespace NH::Bass
         friend class ChangeZoneCommand;
         friend class ScheduleThemeChangeCommand;
 
-        static NH::Logger* log;
+        static Logger* log;
         static Engine* s_Instance;
         bool m_Initialized = false;
         float m_MasterVolume = 1.0f;

diff --git a/src/NH/Bass/EngineCommands.cpp b/src/NH/Bass/EngineCommands.cpp
@@ -11,11 +11,11 @@ namespace NH::Bass
 
     CommandResult ChangeZoneCommand::Execute(Engine& engine)
     {
-        log->Info("Music zone changed: {0}", m_Zone);
+        log->Info("Music zone changed: {0}", m_Zone.c_str());
         const auto themes = engine.GetMusicManager().GetThemesForZone(m_Zone);
         if (themes.empty())
         {
-            log->Warning("No themes found for zone {0}", m_Zone);
+            log->Warning("No themes found for zone {0}", m_Zone.c_str());
             return CommandResult::DONE;
         }
         engine.GetCommandQueue().AddCommand(std::make_shared<ScheduleThemeChangeCommand>(themes[0].first));
@@ -24,11 +24,11 @@ namespace NH::Bass
 
     CommandResult ScheduleThemeChangeCommand::Execute(Engine& engine)
     {
-        log->Info("Scheduling theme: {0}", m_ThemeId);
+        log->Info("Scheduling theme: {0}", m_ThemeId.c_str());
         auto theme = engine.GetMusicManager().GetTheme(m_ThemeId);
         if (!theme)
         {
-            log->Error("Theme {0} doesn't exist", m_ThemeId);
+            log->Error("Theme {0} doesn't exist", m_ThemeId.c_str());
             return CommandResult::DONE;
         }
 
@@ -48,11 +48,11 @@ namespace NH::Bass
 
     CommandResult PlayThemeInstantCommand::Execute(Engine& engine)
     {
-        log->Info("Playing theme: {0} instantly, because PlayThemeInstantCommand forced it.", m_ThemeId);
+        log->Info("Playing theme: {0} instantly, because PlayThemeInstantCommand forced it.", m_ThemeId.c_str());
         auto theme = engine.GetMusicManager().GetTheme(m_ThemeId);
         if (!theme)
         {
-            log->Error("Theme {0} doesn't exist", m_ThemeId);
+            log->Error("Theme {0} doesn't exist", m_ThemeId.c_str());
             return CommandResult::DONE;
         }
 

diff --git a/src/NH/Bass/EngineCommands.h b/src/NH/Bass/EngineCommands.h
@@ -1,36 +1,37 @@
 #pragma once
 
-#include <NH/HashString.h>
 #include <NH/Logger.h>
 #include <NH/Bass/Command.h>
 #include <NH/Bass/IEngine.h>
 
+#include <utility>
+
 namespace NH::Bass
 {
     class ChangeZoneCommand : public Command
     {
         static Logger* log;
-        String m_Zone;
+        std::string m_Zone;
     public:
-        explicit ChangeZoneCommand(const String& zone) : m_Zone(zone) {};
+        explicit ChangeZoneCommand(std::string zone) : m_Zone(std::move(zone)) {};
         CommandResult Execute(Engine& engine) override;
     };
 
     class ScheduleThemeChangeCommand : public Command
     {
         static Logger* log;
-        HashString m_ThemeId;
+        std::string m_ThemeId;
     public:
-        explicit ScheduleThemeChangeCommand(HashString themeId) : m_ThemeId(themeId) {};
+        explicit ScheduleThemeChangeCommand(std::string themeId) : m_ThemeId(std::move(themeId)) {};
         CommandResult Execute(Engine& engine) override;
     };
 
     class PlayThemeInstantCommand : public Command
     {
         static Logger* log;
-        HashString m_ThemeId;
+        std::string m_ThemeId;
     public:
-        explicit PlayThemeInstantCommand(HashString themeId) : m_ThemeId(themeId) {};
+        explicit PlayThemeInstantCommand(std::string themeId) : m_ThemeId(std::move(themeId)) {};
         CommandResult Execute(Engine& engine) override;
     };
 }
diff --git a/src/NH/Bass/EventManager.h b/src/NH/Bass/EventManager.h
@@ -1,7 +1,6 @@
 #pragma once
 
 #include "NH/Logger.h"
-#include <NH/HashString.h>
 
 #include <utility>
 #include <vector>
@@ -22,16 +21,16 @@ namespace NH::Bass
 
     struct Event
     {
-        struct MusicEnd { MusicTheme const* Theme = nullptr; HashString AudioId; };
-        struct MusicTransition { MusicTheme const* Theme = nullptr; HashString AudioId; float TimeLeft = 0; };
-        struct MusicChange { MusicTheme const* Theme = nullptr; HashString AudioId; };
+        struct MusicEnd { MusicTheme const* Theme = nullptr; std::string AudioId; };
+        struct MusicTransition { MusicTheme const* Theme = nullptr; std::string AudioId; float TimeLeft = 0; };
+        struct MusicChange { MusicTheme const* Theme = nullptr; std::string AudioId; };
         using DataType = std::variant<MusicEnd, MusicTransition, MusicChange>;
 
         EventType Type = EventType::UNKNOWN;
         DataType Data;
 
         Event() = delete;
-        Event(EventType type, DataType data) : Type(type), Data(data) {}
+        Event(EventType type, DataType data) : Type(type), Data(std::move(data)) {}
         virtual ~Event() = default;
     };
 
@@ -78,19 +77,19 @@ namespace NH::Bass
     struct MusicEndEvent : public Event
     {
         MusicEnd Data;
-        MusicEndEvent(MusicTheme* theme, HashString audioId) : Event(EventType::MUSIC_END, MusicEnd{theme, audioId}) {}
+        MusicEndEvent(const MusicTheme* theme, const std::string& audioId) : Event(EventType::MUSIC_END, MusicEnd{theme, audioId}) {}
     };
 
     struct MusicTransitionEvent : public Event
     {
         MusicTransition Data;
-        MusicTransitionEvent(MusicTheme* theme, HashString audioId, float timeLeft)
+        MusicTransitionEvent(const MusicTheme* theme, const std::string& audioId, const float timeLeft)
             : Event(EventType::MUSIC_TRANSITION, MusicTransition{theme, audioId, timeLeft}) {}
     };
 
     struct MusicChangeEvent : public Event
     {
         MusicChange Data;
-        MusicChangeEvent(MusicTheme* theme, HashString audioId) : Event(EventType::MUSIC_CHANGE, MusicChange{theme, audioId}) {}
+        MusicChangeEvent(const MusicTheme* theme, const std::string& audioId) : Event(EventType::MUSIC_CHANGE, MusicChange{theme, audioId}) {}
     };
 }
diff --git a/src/NH/Bass/IChannel.h b/src/NH/Bass/IChannel.h
@@ -1,7 +1,10 @@
 #pragma once
 
+#include "NH/Commons.h"
+
 #include <functional>
 #include <expected>
+#include <stdexcept>
 
 namespace NH::Bass
 {
@@ -16,17 +19,17 @@ namespace NH::Bass
         {
             ErrorType Type;
             int32_t Code;
-            String Details;
+            std::string Details;
         public:
-            Error(ErrorType type, int32_t code, const String& details)
-                    : std::runtime_error(String::Format("{0} error: {1}, message: %s", ErrorTypeStrings[static_cast<int>(type)], code, details)),
+            Error(ErrorType type, const int32_t code, const std::string& details)
+                    : std::runtime_error(String::Format("{0} error: {1}, message: %s", ErrorTypeStrings[static_cast<int>(type)], code, details.c_str()).ToChar()),
                       Type(type), Code(code), Details(details) {};
-            Error(ErrorType type, int32_t code, const String&& details)
-                    : std::runtime_error(String::Format("{0} error: {1}, message: %s", ErrorTypeStrings[static_cast<int>(type)], code, details)),
+            Error(ErrorType type, const int32_t code, const std::string&& details)
+                    : std::runtime_error(String::Format("{0} error: {1}, message: %s", ErrorTypeStrings[static_cast<int>(type)], code, details.c_str()).ToChar()),
                       Type(type), Code(code), Details(details) {};
             [[nodiscard]] ErrorType GetType() const { return Type; }
             [[nodiscard]] int32_t GetCode() const { return Code; }
-            [[nodiscard]] const char* GetDetails() const { return Details; }
+            [[nodiscard]] const char* GetDetails() const { return Details.c_str(); }
         };
 
         template<typename T>

diff --git a/src/NH/Bass/MidiFile.h b/src/NH/Bass/MidiFile.h
@@ -1,7 +1,6 @@
 #pragma once
 
 #include <NH/Logger.h>
-#include <NH/HashString.h>
 #include <NH/Executor.h>
 
 #include <bass.h>
@@ -34,7 +33,7 @@ namespace NH::Bass
 
     private:
         static Logger* log;
-        HashString m_ThemeId;
+        std::string m_ThemeId;
         String m_Filename;
         String m_TargetFilter;
         std::vector<char> m_Buffer{};
@@ -45,12 +44,12 @@ namespace NH::Bass
         std::vector<Tone> m_Tones{};
 
     public:
-        MidiFile(HashString themeId, const String& filename, const String& targetFilter = "")
+        MidiFile(const std::string& themeId, const String& filename, const String& targetFilter = "")
                 : m_ThemeId(themeId), m_Filename(filename), m_TargetFilter(targetFilter) {}
 
         void LoadMidiFile(Executor& executor, const std::function<void(MidiFile&)>& onReady = nullptr);
 
-        [[nodiscard]] HashString GetThemeId() const { return m_ThemeId; }
+        [[nodiscard]] std::string GetThemeId() const { return m_ThemeId; }
 
         [[nodiscard]] const String& GetFilename() const { return m_Filename; }