Various changed to make server easier to be split out for gui handling.

Various small additions to encounters in preparation of more elaborate encounter handling.

Author: SapphireMordred

src/common/Logging/Logger.cpp

@@ -11,6 +11,8 @@
 #include <filesystem>
 namespace fs = std::filesystem;
 
+std::shared_ptr< Sapphire::buffer_sink_mt > Sapphire::Logger::m_bufferSink;
+
 
 void Sapphire::Logger::init( const std::string& logPath )
 {
@@ -27,7 +29,9 @@ void Sapphire::Logger::init( const std::string& logPath )
   auto stdout_sink = std::make_shared< spdlog::sinks::stdout_color_sink_mt >();
   auto daily_sink = std::make_shared< spdlog::sinks::daily_file_sink_mt >( logPath + ".log", 0, 0 );
 
-  std::vector< spdlog::sink_ptr > sinks { stdout_sink, daily_sink };
+  m_bufferSink = std::make_shared< buffer_sink_mt >();
+
+  std::vector< spdlog::sink_ptr > sinks{ stdout_sink, daily_sink, m_bufferSink };
 
   auto logger = std::make_shared< spdlog::async_logger >( "logger", sinks.begin(), sinks.end(),
                                                           spdlog::thread_pool(), spdlog::async_overflow_policy::block );
@@ -47,6 +51,11 @@ void Sapphire::Logger::setLogLevel( uint8_t logLevel )
   spdlog::set_level( static_cast< spdlog::level::level_enum >( logLevel ) );
 }
 
+std::shared_ptr< Sapphire::buffer_sink_mt > Sapphire::Logger::getBufferSink()
+{
+  return m_bufferSink;
+}
+
 void Sapphire::Logger::error( const std::string& text )
 {
   spdlog::get( "logger" )->error( text );
@@ -76,4 +85,3 @@ void Sapphire::Logger::trace( const std::string& text )
 {
   spdlog::get( "logger" )->trace( text );
 }
-

src/common/Logging/Logger.h

@@ -1,34 +1,120 @@
 #pragma once
 
 #include <string>
+#include <vector>
 #include <spdlog/fmt/fmt.h>
 
+#include "spdlog/sinks/base_sink.h"
+
 namespace Sapphire
 {
+  // Custom sink class
+  // Simplified custom sink class that avoids formatter conflicts
+  template< typename Mutex >
+  class buffer_sink : public spdlog::sinks::base_sink< Mutex >
+  {
+  public:
+    buffer_sink() = default;
+
+    std::vector< std::string > getMessages() const
+    {
+      std::lock_guard< Mutex > lock( this->mutex_ );
+      return messages_;
+    }
+
+    void clearMessages()
+    {
+      std::lock_guard< Mutex > lock( this->mutex_ );
+      messages_.clear();
+    }
+
+    size_t getMessageCount() const
+    {
+      std::lock_guard< Mutex > lock( this->mutex_ );
+      return messages_.size();
+    }
+
+  protected:
+    void sink_it_( const spdlog::details::log_msg& msg ) override
+    {
+      // Simple approach: extract the raw message and add basic formatting
+      std::string raw_message( msg.payload.data(), msg.payload.size() );
+
+      // Create a simple timestamp (you can improve this)
+      auto time_t = std::chrono::system_clock::to_time_t( msg.time );
+      auto tm = *std::localtime( &time_t );
+
+      // Format: [HH:MM:SS] [LEVEL] message
+      char time_buf[32];
+      std::strftime( time_buf, sizeof( time_buf ), "%H:%M:%S", &tm );
+
+      std::string level_str;
+      switch( msg.level )
+      {
+        case spdlog::level::trace: level_str = "trace"; break;
+        case spdlog::level::debug: level_str = "debug"; break;
+        case spdlog::level::info: level_str = "info"; break;
+        case spdlog::level::warn: level_str = "warn"; break;
+        case spdlog::level::err: level_str = "error"; break;
+        case spdlog::level::critical: level_str = "fatal"; break;
+        default: level_str = "unknown"; break;
+      }
+
+      std::string formatted_message = fmt::format( "[{}] [{}] {}", time_buf, level_str, raw_message );
+
+      messages_.push_back( std::move( formatted_message ) );
+
+      // Limit buffer size
+      if( messages_.size() > max_messages_ )
+      {
+        messages_.erase( messages_.begin() );
+      }
+    }
+
+    void flush_() override
+    {
+      // Nothing to flush for this sink
+    }
+
+  private:
+    std::vector< std::string > messages_;
+    static const size_t max_messages_ = 1000;
+  };
+
+  using buffer_sink_mt = buffer_sink< std::mutex >;
+  using buffer_sink_st = buffer_sink< spdlog::details::null_mutex >;
+
+
 
   class Logger
   {
-
   private:
     std::string m_logFile;
+    static std::shared_ptr< buffer_sink_mt > m_bufferSink;
+
     Logger() = default;
+
     ~Logger() = default;
 
   public:
-
     static void init( const std::string& logPath );
+
     static void setLogLevel( uint8_t logLevel );
 
+    static std::shared_ptr< buffer_sink_mt > getBufferSink();
+
     // todo: this is a minor increase in build time because of fmtlib, but much less than including spdlog directly
 
     static void error( const std::string& text );
+
     template< typename... Args >
     static void error( const std::string& text, const Args&... args )
     {
       error( fmt::format( text, args... ) );
     }
 
     static void warn( const std::string& text );
+
     template< typename... Args >
     static void warn( const std::string& text, const Args&... args )
     {
@@ -37,6 +123,7 @@ namespace Sapphire
 
 
     static void info( const std::string& text );
+
     template< typename... Args >
     static void info( const std::string& text, const Args&... args )
     {
@@ -45,6 +132,7 @@ namespace Sapphire
 
 
     static void debug( const std::string& text );
+
     template< typename... Args >
     static void debug( const std::string& text, const Args&... args )
     {
@@ -53,6 +141,7 @@ namespace Sapphire
 
 
     static void fatal( const std::string& text );
+
     template< typename... Args >
     static void fatal( const std::string& text, const Args&... args )
     {
@@ -61,14 +150,11 @@ namespace Sapphire
 
 
     static void trace( const std::string& text );
+
     template< typename... Args >
     static void trace( const std::string& text, const Args&... args )
     {
       trace( fmt::format( text, args... ) );
     }
-
-
   };
-
 }
-

src/common/Util/Util.cpp

@@ -3,6 +3,7 @@
 #include <sstream>
 #include <iomanip>
 #include <algorithm>
+#include <fstream>
 #include <string>
 
 using namespace Sapphire::Common;
@@ -147,6 +148,34 @@ void Util::valueToFlagByteIndexValue( uint32_t inVal, uint8_t& outVal, uint16_t&
   outVal = 1 << bitIndex;
 }
 
+std::string Util::readFileToString( const std::string& filename )
+{
+  // Open the file for reading
+  std::ifstream file( filename );
+
+  // Check if the file was opened successfully
+  if( !file )
+  {
+    throw std::runtime_error( "Failed to open file" );
+  }
+
+  // Read the contents of the file into a string
+  std::string fileContents( ( std::istreambuf_iterator< char >( file ) ),
+                              std::istreambuf_iterator< char >() );
+
+  // Close the file
+  file.close();
+
+  // Remove all newlines from the file contents
+  fileContents.erase( std::remove( fileContents.begin(), fileContents.end(), '\n' ), fileContents.end() );
+  fileContents.erase( std::remove( fileContents.begin(), fileContents.end(), '\r' ), fileContents.end() );
+
+
+  // Return the file contents as a string
+  return fileContents;
+
+}
+
 
 std::string Util::fmtUtcTime( const std::string& fmt )
 {

src/common/Util/Util.h

@@ -44,6 +44,8 @@ namespace Sapphire::Common::Util
     seed ^= hasher( v ) + 0x9e3779b9 + ( seed << 6 ) + ( seed >> 2 );
   }
 
+  std::string readFileToString( const std::string& filename );
+
 }
 
 #endif

src/world/Encounter/Encounter.cpp

@@ -4,22 +4,23 @@
 
 namespace Sapphire
 {
-  Encounter::Encounter( TerritoryPtr pInstance, std::shared_ptr< Event::Director > pDirector, const std::string& timelineName ) :
+  Encounter::Encounter( TerritoryPtr pInstance, std::shared_ptr< Event::Director > pDirector,
+                        const std::string& timelineName ) :
     m_pTeri( pInstance ),
     m_pDirector( pDirector ),
-    m_timelineName( timelineName ),
     m_status( EncounterStatus::UNINITIALIZED )
   {
+    m_setup.timelineName = timelineName;
   }
 
   void Encounter::init()
   {
-    m_pTimeline = TimelinePack::createTimelinePack( m_timelineName );
+    m_pTimeline = TimelinePack::createTimelinePack( m_setup.timelineName );
     m_pTimeline->setEncounter( shared_from_this() );
     m_status = EncounterStatus::IDLE;
     m_startTime = 0;
 
-    for( const auto& actor : m_actorSetupList )
+    for( const auto& actor : m_setup.actorSetupList )
     {
       auto entry = m_pTeri->createBNpcFromLayoutId( actor.layoutId, actor.hp, actor.type );
       entry->init();
@@ -97,8 +98,13 @@ namespace Sapphire
     return m_pDirector;
   }
 
-  void Encounter::setInitialActorSetup( const std::vector<EncounterActor>& actorSetupList )
+  void Encounter::setInitialActorSetup( const std::vector< EncounterActor >& actorSetupList )
   {
-    m_actorSetupList = actorSetupList;
+    m_setup.actorSetupList = actorSetupList;
+  }
+
+  EncounterSetup& Encounter::getSetup()
+  {
+    return m_setup;
   }
 }

src/world/Encounter/Encounter.h

@@ -20,6 +20,12 @@ namespace Sapphire
     SUCCESS
   };
 
+  enum class EncounterShape
+  {
+    BOX,
+    CYLINDER
+  };
+
   struct EncounterActor
   {
     uint32_t layoutId;
@@ -28,6 +34,18 @@ namespace Sapphire
     uint32_t flags;
   };
 
+  struct EncounterSetup
+  {
+    std::string timelineName;
+    std::vector< EncounterActor > actorSetupList;
+    EncounterShape encounterShape;
+    // for BOX shape, this would be m_position = min, m_position2 = max
+    // for CYLINDER m_position = center, m_position2.x radius, position2.y height
+    Common::FFXIVARR_POSITION3 position;
+    Common::FFXIVARR_POSITION3 position2;
+    bool hasLockout{false};
+  };
+
   class Encounter : public std::enable_shared_from_this< Encounter >
   {
   public:
@@ -65,19 +83,21 @@ namespace Sapphire
 
     void setInitialActorSetup( const std::vector< EncounterActor >& actorSetupList );
 
+    EncounterSetup& getSetup();
+
   protected:
     uint64_t m_startTime{ 0 };
-    std::string m_timelineName;
+
     std::set< Entity::PlayerPtr > m_playerList;
     std::unordered_map< uint32_t, Entity::BNpcPtr > m_bnpcs;
-
     EncounterStatus m_status{ EncounterStatus::IDLE };
-
     Event::DirectorPtr m_pDirector;
     TerritoryPtr m_pTeri;
-
-    std::vector< EncounterActor > m_actorSetupList;
     std::shared_ptr< TimelinePack > m_pTimeline;
+
+    // encountersetup
+    EncounterSetup m_setup;
+
   };