feat: add server start time measurement

src/ll/api/LoggerAPI.cpp

@@ -86,42 +86,42 @@ bool checkLogLevel(int level, int outLevel) {
 fmt::text_style getModeColor(std::string const& a1) {
     if (!ll::globalConfig.colorLog) return {};
     switch (do_hash(a1)) {
-    case do_hash("INFO"):
+    case "INFO"_h:
         return fmt::fg(fmt::color::light_sea_green);
-    case do_hash("WARN"):
+    case "WARN"_h:
         return fmt::fg(fmt::color::yellow);
-    case do_hash("DEBUG"):
+    case "DEBUG"_h:
         return fmt::fg(fmt::color::white);
-    case do_hash("ERROR"):
+    case "ERROR"_h:
         return fmt::fg(fmt::terminal_color::bright_red);
-    case do_hash("FATAL"):
+    case "FATAL"_h:
         return fmt::fg(fmt::color::red);
     }
     return fmt::fg(fmt::color::white);
 }
 
 template <typename S, typename Char>
-std::string applyTextStyle(fmt::v9::text_style const& ts, S const& format_str, bool reset) {
-    fmt::v9::basic_memory_buffer<Char> buf;
-    auto                               fmt       = fmt::detail::to_string_view(format_str);
-    bool                               has_style = false;
+std::string applyTextStyle(fmt::text_style const& ts, S const& format_str, bool reset) {
+    fmt::basic_memory_buffer<Char> buf;
+    auto                           fmt       = fmt::detail::to_string_view(format_str);
+    bool                           has_style = false;
     if (ts.has_emphasis()) {
         has_style     = true;
-        auto emphasis = fmt::v9::detail::make_emphasis<Char>(ts.get_emphasis());
+        auto emphasis = fmt::detail::make_emphasis<Char>(ts.get_emphasis());
         buf.append(emphasis.begin(), emphasis.end());
     }
     if (ts.has_foreground()) {
         has_style       = true;
-        auto foreground = fmt::v9::detail::make_foreground_color<Char>(ts.get_foreground());
+        auto foreground = fmt::detail::make_foreground_color<Char>(ts.get_foreground());
         buf.append(foreground.begin(), foreground.end());
     }
     if (ts.has_background()) {
         has_style       = true;
-        auto background = fmt::v9::detail::make_background_color<Char>(ts.get_background());
+        auto background = fmt::detail::make_background_color<Char>(ts.get_background());
         buf.append(background.begin(), background.end());
     }
     buf.append(fmt.begin(), fmt.end());
-    if (has_style && reset) fmt::v9::detail::reset_color<Char>(buf);
+    if (has_style && reset) fmt::detail::reset_color<Char>(buf);
     return fmt::to_string(buf);
 }
 

src/ll/api/LoggerAPI.h

@@ -167,5 +167,5 @@ class Logger {
     LLAPI static std::mutex& getLocker();
 };
 
-template <typename S, typename Char = fmt::v9::char_t<S>>
-std::string applyTextStyle(fmt::v9::text_style const& ts, S const& format_str, bool reset = true);
+template <typename S, typename Char = fmt::char_t<S>>
+std::string applyTextStyle(fmt::text_style const& ts, S const& format_str, bool reset = true);

src/ll/api/ScheduleAPI.cpp

@@ -167,7 +167,7 @@ ScheduleTaskQueueType taskQueue;
 
 namespace Schedule {
 ScheduleTask delay(std::function<void(void)> task, uint64 tickDelay, HMODULE handle) {
-    if (ll::globalRuntimeConfig.serverStatus >= ll::LLServerStatus::Stopping) return {(uint)-1};
+    if (ll::globalRuntimeConfig.serverStatus >= ll::ServerStatus::Stopping) return {(uint)-1};
     ScheduleTaskData sche(ScheduleTaskData::TaskType::Delay, std::move(task), tickDelay, -1, -1, handle);
     locker.lock();
     pendingTaskList.push_back(sche);
@@ -176,7 +176,7 @@ ScheduleTask delay(std::function<void(void)> task, uint64 tickDelay, HMODULE han
 }
 
 ScheduleTask repeat(std::function<void(void)> task, uint64 tickRepeat, int maxCount, HMODULE handle) {
-    if (ll::globalRuntimeConfig.serverStatus >= ll::LLServerStatus::Stopping) return {(uint)-1};
+    if (ll::globalRuntimeConfig.serverStatus >= ll::ServerStatus::Stopping) return {(uint)-1};
     ScheduleTaskData::TaskType type =
         maxCount < 0 ? ScheduleTaskData::TaskType::InfiniteRepeat : ScheduleTaskData::TaskType::Repeat;
     ScheduleTaskData
@@ -189,7 +189,7 @@ ScheduleTask repeat(std::function<void(void)> task, uint64 tickRepeat, int maxCo
 
 ScheduleTask
 delayRepeat(std::function<void(void)> task, uint64 tickDelay, uint64 tickRepeat, int maxCount, HMODULE handle) {
-    if (ll::globalRuntimeConfig.serverStatus >= ll::LLServerStatus::Stopping) return {(uint)-1};
+    if (ll::globalRuntimeConfig.serverStatus >= ll::ServerStatus::Stopping) return {(uint)-1};
     ScheduleTaskData::TaskType type =
         maxCount < 0 ? ScheduleTaskData::TaskType::InfiniteRepeat : ScheduleTaskData::TaskType::Repeat;
     ScheduleTaskData sche(type, std::move(task), tickDelay, std::max(tickRepeat, 1ull), maxCount, handle);
@@ -200,7 +200,7 @@ delayRepeat(std::function<void(void)> task, uint64 tickDelay, uint64 tickRepeat,
 }
 
 ScheduleTask nextTick(std::function<void(void)> task, HMODULE handle) {
-    if (ll::globalRuntimeConfig.serverStatus >= ll::LLServerStatus::Stopping) return {(uint)-1};
+    if (ll::globalRuntimeConfig.serverStatus >= ll::ServerStatus::Stopping) return {(uint)-1};
     ScheduleTaskData sche(ScheduleTaskData::TaskType::Delay, std::move(task), 1, -1, -1, handle);
     locker.lock();
     pendingTaskList.push_back(sche);

src/ll/api/command/DynamicCommandAPI.cpp

@@ -704,9 +704,8 @@ DynamicCommandInstance const* DynamicCommand::setup(std::unique_ptr<class Dynami
     auto ptr = commandInstance.get();
     if (!ptr) throw std::runtime_error("DynamicCommand::setup - commandInstance is null");
     if (!serverCommandsRegistered) {
-        delaySetupLock.lock();
-        auto& uptr = delaySetupCommandInstances.emplace_back(std::move(commandInstance));
-        delaySetupLock.unlock();
+        SRWLockHolder locker(delaySetupLock);
+        auto&         uptr = delaySetupCommandInstances.emplace_back(std::move(commandInstance));
         return uptr.get();
     }
     Schedule::nextTick([instance{commandInstance.release()}]() {
@@ -798,7 +797,7 @@ inline std::unique_ptr<DynamicCommandInstance> DynamicCommandInstance::create(
     CommandFlag            flag,
     HMODULE                handle
 ) {
-    if (ll::globalRuntimeConfig.serverStatus != ll::LLServerStatus::Running) {
+    if (ll::globalRuntimeConfig.serverStatus != ll::ServerStatus::Running) {
         for (auto& cmd : delaySetupCommandInstances) {
             if (cmd->name_ == name) {
                 logger.error("Command \"{}\" already exists", name);

src/ll/api/command/DynamicCommandAPI.h

@@ -111,19 +111,19 @@ class DynamicCommandInstance;
  *     auto& action = results["testEnum"].get<std::string>();
  *     switch (do_hash(action.c_str()))
  *     {
- *       case do_hash("add"):
+ *       case "add"_h:
  *         if (results["testInt"].isSet)
  *           output.success(fmt::format("add {}", results["testInt"].getRaw<int>()));
  *         else
  *           output.success("add nothing");
  *         break;
- *       case do_hash("remove"):
+ *       case "remove"_h:
  *         if (results["testInt"].isSet)
  *           output.success(fmt::format("remove {}", results["testInt"].getRaw<int>()));
  *         else
  *           output.success("remove nothing");
  *         break;
- *       case do_hash("list"):
+ *       case "list"_h:
  *         output.success("list");
  *         break;
  *       default:
@@ -734,11 +734,11 @@ class DynamicCommandInstance {
     LLAPI static std::vector<std::string> getSoftEnumNames();
 
     template <typename T>
-    inline std::enable_if_t<fmt::v9::detail::is_string<T>::value, ParameterIndex> toIndex(T const& arg) {
+    inline std::enable_if_t<fmt::detail::is_string<T>::value, ParameterIndex> toIndex(T const& arg) {
         return findParameterIndex(arg);
     }
     template <typename T>
-    inline std::enable_if_t<!fmt::v9::detail::is_string<T>::value, ParameterIndex> toIndex(T const& arg) = delete;
+    inline std::enable_if_t<!fmt::detail::is_string<T>::value, ParameterIndex> toIndex(T const& arg) = delete;
     template <>
     inline ParameterIndex toIndex(ParameterIndex const& arg) {
         return arg;

src/ll/api/service/GlobalService.h

@@ -42,16 +42,16 @@ class GlobalService {
     LLAPI GlobalService();
     void  init(T* ptr);
 
-    T* get() { return value; }
-    T* operator->() { return value; }
-    T& operator*() { return *value; }
-    operator T*() { return value; } // NOLINT(google-explicit-constructor)
+    constexpr T* get() { return value; }
+    constexpr T* operator->() { return value; }
+    constexpr T& operator*() { return *value; }
+    constexpr    operator T*() { return value; } // NOLINT(google-explicit-constructor)
     template <typename U>
-    explicit operator U*() {
+    constexpr explicit operator U*() {
         return static_cast<U*>(value);
     }
-    explicit operator bool() { return value != nullptr; }
-    bool has_value() { return value != nullptr; }
+    constexpr explicit operator bool() { return value != nullptr; }
+    constexpr bool has_value() { return value != nullptr; }
 };
 
 template <IsGlobalService T>

src/ll/api/utils/Base64.h

@@ -15,8 +15,8 @@ inline size_t getEncodeLength(size_t len) { return (len + 2 - ((len + 2) % 3)) /
 inline size_t getEncodeLength(std::string const& str) { return getEncodeLength(str.length()); }
 
 inline size_t getDecodeLength(std::string const& in) {
-    unsigned char count      = 0;
-    size_t        input_size = in.size();
+    uchar  count      = 0;
+    size_t input_size = in.size();
     for (auto it = in.rbegin(); *it == '='; ++it) { ++count; }
     input_size -= count;     // remove padding size
     count       = 0;         // reset padding counter

src/ll/api/utils/FileHelper.cpp

@@ -2,6 +2,7 @@
 
 #include <filesystem>
 
+#include "ll/api/LoggerAPI.h"
 #include "ll/api/utils/StringUtils.h"
 #include "ll/api/utils/WinHelper.h"
 #include "ll/core/Config.h"

src/ll/api/utils/FileHelper.h

@@ -1,5 +1,4 @@
 #pragma once
-#include "ll/api/LoggerAPI.h"
 #include "ll/api/base/Global.h"
 #include <fstream>
 #include <optional>

src/ll/api/utils/Hash.h

@@ -47,6 +47,8 @@ constexpr uint64 do_hash(const char* x, size_t len) {
     return rval;
 }
 
+constexpr uint64 operator""_h(const char* x, size_t len) { return do_hash(x, len); }
+
 constexpr uint64 do_hash2(std::string_view x) {
     // ap hash
     uint64 rval = 0;

src/ll/core/Config.h

@@ -14,7 +14,6 @@ namespace ll {
 struct CommandLineOption {
     bool noColorOption = false;
 };
-enum class LLServerStatus { Starting, Running, Stopping };
 struct LLConfig {
     bool        debugMode = false;
     bool        colorLog  = true;
@@ -54,7 +53,7 @@ struct LLConfig {
 };
 
 struct LLRuntimeConfig {
-    LLServerStatus  serverStatus = LLServerStatus::Starting;
+    ServerStatus    serverStatus = ServerStatus::Starting;
     std::thread::id tickThreadId;
 };
 

src/ll/core/LeviLamina.cpp

@@ -28,9 +28,9 @@
 #include "windows.h"
 
 
-Logger ll::logger("LeviLamina");
-time_t ll::startTime;
-time_t ll::endTime;
+Logger                                ll::logger("LeviLamina");
+std::chrono::steady_clock::time_point ll::SeverStartBeginTime;
+std::chrono::steady_clock::time_point ll::SeverStartEndTime;
 
 using namespace ll;
 
@@ -334,18 +334,28 @@ void leviLaminaMain() {
 
 using namespace ll::memory;
 
-// int main(int argc, char* argv[]);
-
 LL_AUTO_STATIC_HOOK(LeviLaminaMainHook, HookPriority::Normal, "main", int, int argc, char* argv[]) {
-    startTime = clock();
+
+    SeverStartBeginTime = std::chrono::steady_clock::now();
+
     for (int i = 0; i < argc; ++i) {
-        if (strcmp(argv[i], "--noColor") == 0) {
+        switch (do_hash(argv[i])) {
+        case "--noColor"_h:
             ll::commandLineOption.noColorOption = true;
             break;
+        case "-v"_h:
+        case "--version"_h:
+            fmt::print("{}", ll::getBdsVersion());
+            return 0;
+        case "--protocolversion"_h:
+            fmt::print("{}", ll::getServerProtocolVersion());
+            return 0;
+        default:
+            break;
         }
     }
     leviLaminaMain();
     return origin(argc, argv);
 }
 
-[[maybe_unused]] BOOL WINAPI DllMain(HMODULE, DWORD , LPVOID) { return TRUE; }
+[[maybe_unused]] BOOL WINAPI DllMain(HMODULE, DWORD, LPVOID) { return TRUE; }

src/ll/core/LeviLamina.h

@@ -3,6 +3,6 @@
 #include "ll/api/LoggerAPI.h"
 namespace ll {
 extern Logger logger;
-extern time_t startTime;
-extern time_t endTime;
+extern std::chrono::steady_clock::time_point SeverStartBeginTime;
+extern std::chrono::steady_clock::time_point SeverStartEndTime;
 } // namespace ll

src/ll/core/ModifyInfomation.cpp

@@ -1,47 +1,45 @@
-#include "ll/api/LoggerAPI.h"
 #include "ll/api/memory/Hook.h"
+#include "ll/core/LeviLamina.h"
 #include "mc/common/Common.h"
 
 #include "mc/deps/core/common/debug/LogDetails.h"
 
 Logger serverLogger("Server");
 
-std::unordered_map<unsigned int, decltype(serverLogger.debug)&> loggerMap = {
+static std::unordered_map<uint, decltype(serverLogger.debug)&> loggerMap = {
     {1u, serverLogger.debug},
     {2u, serverLogger.info },
     {4u, serverLogger.warn },
     {8u, serverLogger.error}
 };
 
-// Block BDS from adding LOG metadata
+static bool serverStarted = false;
 
-LL_AUTO_TYPED_INSTANCE_HOOK(
-    AppendLogEntryMetadataHook,
-    HookPriority::Normal,
-    ::BedrockLog::LogDetails,
-    &::BedrockLog::LogDetails::_appendLogEntryMetadata,
-    void,
-    std::string&,
-    std::string, // NOLINT
-    ::LogAreaID,
-    uint,
-    std::string, // NOLINT
-    int,
-    int
-) {}
+void tryLogServerStarted(std::string& s) {
+    if (s != "Server started.") return;
+    serverStarted = true;
 
-MCAPI void BedrockLogOut(unsigned int priority, const char* pszFormat, ...);
+    ll::SeverStartEndTime = std::chrono::steady_clock::now();
+
+    s = std::format(
+        R"(Server started in ({:.1f}s)! For help, type "help" or "?")",
+        std::chrono::duration_cast<std::chrono::duration<double>>(ll::SeverStartEndTime - ll::SeverStartBeginTime)
+            .count()
+    );
+}
+
+MCAPI void BedrockLogOut(uint priority, const char* pszFormat, ...);
 
 LL_AUTO_STATIC_HOOK(
     BedrockLogOutHook,
     HookPriority::Normal,
     BedrockLogOut,
     void,
-    unsigned int priority,
-    const char*  pszFormat,
+    uint        priority,
+    const char* pszFormat,
     ...
 ) {
-    constexpr const int BUFFER_SIZE = 4096;
+    constexpr const int BUFFER_SIZE = 4096; // from ida
     char                Buffer[BUFFER_SIZE];
     va_list             va;
     va_start(va, pszFormat);
@@ -52,10 +50,29 @@ LL_AUTO_STATIC_HOOK(
     std::istringstream iss(Buffer);
     std::string        line;
 
+    auto& logger = loggerMap.contains(priority) ? loggerMap.at(priority) : serverLogger.info;
+
     while (std::getline(iss, line)) {
         if (!line.empty() && line.back() == '\n') { line.pop_back(); }
-        auto  loggerIter = loggerMap.find(priority);
-        auto& logger     = (loggerIter != loggerMap.end()) ? loggerIter->second : serverLogger.info;
+        if (!serverStarted) tryLogServerStarted(line);
         logger << line << Logger::endl;
     }
 }
+
+
+// Block BDS from adding LOG metadata
+
+LL_AUTO_TYPED_INSTANCE_HOOK(
+    AppendLogEntryMetadataHook,
+    HookPriority::Normal,
+    ::BedrockLog::LogDetails,
+    &::BedrockLog::LogDetails::_appendLogEntryMetadata,
+    void,
+    std::string&,
+    std::string, // NOLINT
+    ::LogAreaID,
+    uint,
+    std::string, // NOLINT
+    int,
+    int
+) {}