gewuyou/GFramework
1
0
Fork 0
mirror of https://github.com/GeWuYou/GFramework.git synced 2026-03-22 10:34:30 +08:00
Code Issues Packages Projects Releases Wiki Activity

refactor(architecture): 移除泛型参数并删除拖拽组件

Browse Source 
- 移除 AbstractArchitecture<T> 中的泛型参数 T
- 移除 AbstractGodotModule<T> 中的泛型参数 T
- 删除 AbstractDragDrop2DComponentBase 组件类
- 删除 AbstractDragDropArea2DComponent 组件类
- 修改 InstallGodotModule 方法的泛型约束
- 更新系统中获取系统实例的方式
- 调整命名空间和依赖引用关系
- 添加新的日志抽象基类 AbstractLogger
- 重构控制台日志记录器继承抽象基类
This commit is contained in:
GeWuYou 2025-12-25 13:05:38 +08:00
parent bc2b73b19a
commit 8913f2fb2c
14 changed files with 427 additions and 1045 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

350
GFramework.Core/logging/AbstractLogger.cs Normal file
View File

@ -0,0 +1,350 @@
namespace GFramework.Core.logging;
/// <summary>
/// 日志抽象基类，封装日志级别判断、格式化与异常处理逻辑。
/// 平台日志器只需实现 Write 方法即可。
/// </summary>
public abstract class AbstractLogger(
string? name = null,
LogLevel minLevel = LogLevel.Info) : ILogger
{
private readonly string _name = name ?? ILogger.RootLoggerName;
#region Metadata
/// <summary>
/// 获取日志器的名称
/// </summary>
/// <returns>日志器名称</returns>
public string Name() => _name;
#endregion
#region Level Checks
/// <summary>
/// 判断指定日志级别是否启用
/// </summary>
/// <param name="level">要检查的日志级别</param>
/// <returns>如果指定级别大于等于最小级别则返回true，否则返回false</returns>
protected bool IsEnabled(LogLevel level) => level >= minLevel;
/// <summary>
/// 检查Trace级别日志是否启用
/// </summary>
/// <returns>如果Trace级别启用返回true，否则返回false</returns>
public bool IsTraceEnabled() => IsEnabled(LogLevel.Trace);
/// <summary>
/// 检查Debug级别日志是否启用
/// </summary>
/// <returns>如果Debug级别启用返回true，否则返回false</returns>
public bool IsDebugEnabled() => IsEnabled(LogLevel.Debug);
/// <summary>
/// 检查Info级别日志是否启用
/// </summary>
/// <returns>如果Info级别启用返回true，否则返回false</returns>
public bool IsInfoEnabled() => IsEnabled(LogLevel.Info);
/// <summary>
/// 检查Warning级别日志是否启用
/// </summary>
/// <returns>如果Warning级别启用返回true，否则返回false</returns>
public bool IsWarnEnabled() => IsEnabled(LogLevel.Warning);
/// <summary>
/// 检查Error级别日志是否启用
/// </summary>
/// <returns>如果Error级别启用返回true，否则返回false</returns>
public bool IsErrorEnabled() => IsEnabled(LogLevel.Error);
/// <summary>
/// 检查Fatal级别日志是否启用
/// </summary>
/// <returns>如果Fatal级别启用返回true，否则返回false</returns>
public bool IsFatalEnabled() => IsEnabled(LogLevel.Fatal);
#endregion
#region Trace
/// <summary>
/// 记录Trace级别日志
/// </summary>
/// <param name="msg">日志消息</param>
public void Trace(string msg) => Log(LogLevel.Trace, msg);
/// <summary>
/// 记录Trace级别日志（带格式化参数）
/// </summary>
/// <param name="format">格式化字符串</param>
/// <param name="arg">格式化参数</param>
public void Trace(string format, object arg) => Log(LogLevel.Trace, format, arg);
/// <summary>
/// 记录Trace级别日志（带两个格式化参数）
/// </summary>
/// <param name="format">格式化字符串</param>
/// <param name="arg1">第一个格式化参数</param>
/// <param name="arg2">第二个格式化参数</param>
public void Trace(string format, object arg1, object arg2) => Log(LogLevel.Trace, format, arg1, arg2);
/// <summary>
/// 记录Trace级别日志（带多个格式化参数）
/// </summary>
/// <param name="format">格式化字符串</param>
/// <param name="arguments">格式化参数数组</param>
public void Trace(string format, params object[] arguments) => Log(LogLevel.Trace, format, arguments);
/// <summary>
/// 记录Trace级别日志（带异常信息）
/// </summary>
/// <param name="msg">日志消息</param>
/// <param name="t">异常对象</param>
public void Trace(string msg, Exception t) => Log(LogLevel.Trace, msg, t);
#endregion
#region Debug
/// <summary>
/// 记录Debug级别日志
/// </summary>
/// <param name="msg">日志消息</param>
public void Debug(string msg) => Log(LogLevel.Debug, msg);
/// <summary>
/// 记录Debug级别日志（带格式化参数）
/// </summary>
/// <param name="format">格式化字符串</param>
/// <param name="arg">格式化参数</param>
public void Debug(string format, object arg) => Log(LogLevel.Debug, format, arg);
/// <summary>
/// 记录Debug级别日志（带两个格式化参数）
/// </summary>
/// <param name="format">格式化字符串</param>
/// <param name="arg1">第一个格式化参数</param>
/// <param name="arg2">第二个格式化参数</param>
public void Debug(string format, object arg1, object arg2) => Log(LogLevel.Debug, format, arg1, arg2);
/// <summary>
/// 记录Debug级别日志（带多个格式化参数）
/// </summary>
/// <param name="format">格式化字符串</param>
/// <param name="arguments">格式化参数数组</param>
public void Debug(string format, params object[] arguments) => Log(LogLevel.Debug, format, arguments);
/// <summary>
/// 记录Debug级别日志（带异常信息）
/// </summary>
/// <param name="msg">日志消息</param>
/// <param name="t">异常对象</param>
public void Debug(string msg, Exception t) => Log(LogLevel.Debug, msg, t);
#endregion
#region Info
/// <summary>
/// 记录Info级别日志
/// </summary>
/// <param name="msg">日志消息</param>
public void Info(string msg) => Log(LogLevel.Info, msg);
/// <summary>
/// 记录Info级别日志（带格式化参数）
/// </summary>
/// <param name="format">格式化字符串</param>
/// <param name="arg">格式化参数</param>
public void Info(string format, object arg) => Log(LogLevel.Info, format, arg);
/// <summary>
/// 记录Info级别日志（带两个格式化参数）
/// </summary>
/// <param name="format">格式化字符串</param>
/// <param name="arg1">第一个格式化参数</param>
/// <param name="arg2">第二个格式化参数</param>
public void Info(string format, object arg1, object arg2) => Log(LogLevel.Info, format, arg1, arg2);
/// <summary>
/// 记录Info级别日志（带多个格式化参数）
/// </summary>
/// <param name="format">格式化字符串</param>
/// <param name="arguments">格式化参数数组</param>
public void Info(string format, params object[] arguments) => Log(LogLevel.Info, format, arguments);
/// <summary>
/// 记录Info级别日志（带异常信息）
/// </summary>
/// <param name="msg">日志消息</param>
/// <param name="t">异常对象</param>
public void Info(string msg, Exception t) => Log(LogLevel.Info, msg, t);
#endregion
#region Warn
/// <summary>
/// 记录Warning级别日志
/// </summary>
/// <param name="msg">日志消息</param>
public void Warn(string msg) => Log(LogLevel.Warning, msg);
/// <summary>
/// 记录Warning级别日志（带格式化参数）
/// </summary>
/// <param name="format">格式化字符串</param>
/// <param name="arg">格式化参数</param>
public void Warn(string format, object arg) => Log(LogLevel.Warning, format, arg);
/// <summary>
/// 记录Warning级别日志（带两个格式化参数）
/// </summary>
/// <param name="format">格式化字符串</param>
/// <param name="arg1">第一个格式化参数</param>
/// <param name="arg2">第二个格式化参数</param>
public void Warn(string format, object arg1, object arg2) => Log(LogLevel.Warning, format, arg1, arg2);
/// <summary>
/// 记录Warning级别日志（带多个格式化参数）
/// </summary>
/// <param name="format">格式化字符串</param>
/// <param name="arguments">格式化参数数组</param>
public void Warn(string format, params object[] arguments) => Log(LogLevel.Warning, format, arguments);
/// <summary>
/// 记录Warning级别日志（带异常信息）
/// </summary>
/// <param name="msg">日志消息</param>
/// <param name="t">异常对象</param>
public void Warn(string msg, Exception t) => Log(LogLevel.Warning, msg, t);
#endregion
#region Error
/// <summary>
/// 记录Error级别日志
/// </summary>
/// <param name="msg">日志消息</param>
public void Error(string msg) => Log(LogLevel.Error, msg);
/// <summary>
/// 记录Error级别日志（带格式化参数）
/// </summary>
/// <param name="format">格式化字符串</param>
/// <param name="arg">格式化参数</param>
public void Error(string format, object arg) => Log(LogLevel.Error, format, arg);
/// <summary>
/// 记录Error级别日志（带两个格式化参数）
/// </summary>
/// <param name="format">格式化字符串</param>
/// <param name="arg1">第一个格式化参数</param>
/// <param name="arg2">第二个格式化参数</param>
public void Error(string format, object arg1, object arg2) => Log(LogLevel.Error, format, arg1, arg2);
/// <summary>
/// 记录Error级别日志（带多个格式化参数）
/// </summary>
/// <param name="format">格式化字符串</param>
/// <param name="arguments">格式化参数数组</param>
public void Error(string format, params object[] arguments) => Log(LogLevel.Error, format, arguments);
/// <summary>
/// 记录Error级别日志（带异常信息）
/// </summary>
/// <param name="msg">日志消息</param>
/// <param name="t">异常对象</param>
public void Error(string msg, Exception t) => Log(LogLevel.Error, msg, t);
#endregion
#region Fatal
/// <summary>
/// 记录Fatal级别日志
/// </summary>
/// <param name="msg">日志消息</param>
public void Fatal(string msg) => Log(LogLevel.Fatal, msg);
/// <summary>
/// 记录Fatal级别日志（带格式化参数）
/// </summary>
/// <param name="format">格式化字符串</param>
/// <param name="arg">格式化参数</param>
public void Fatal(string format, object arg) => Log(LogLevel.Fatal, format, arg);
/// <summary>
/// 记录Fatal级别日志（带两个格式化参数）
/// </summary>
/// <param name="format">格式化字符串</param>
/// <param name="arg1">第一个格式化参数</param>
/// <param name="arg2">第二个格式化参数</param>
public void Fatal(string format, object arg1, object arg2) => Log(LogLevel.Fatal, format, arg1, arg2);
/// <summary>
/// 记录Fatal级别日志（带多个格式化参数）
/// </summary>
/// <param name="format">格式化字符串</param>
/// <param name="arguments">格式化参数数组</param>
public void Fatal(string format, params object[] arguments) => Log(LogLevel.Fatal, format, arguments);
/// <summary>
/// 记录Fatal级别日志（带异常信息）
/// </summary>
/// <param name="msg">日志消息</param>
/// <param name="t">异常对象</param>
public void Fatal(string msg, Exception t) => Log(LogLevel.Fatal, msg, t);
#endregion
#region Core Pipeline
/// <summary>
/// 核心日志记录方法（无参数）
/// </summary>
/// <param name="level">日志级别</param>
/// <param name="message">日志消息</param>
private void Log(LogLevel level, string message)
{
if (!IsEnabled(level)) return;
Write(level, message, null);
}
/// <summary>
/// 核心日志记录方法（带参数格式化）
/// </summary>
/// <param name="level">日志级别</param>
/// <param name="format">格式化字符串</param>
/// <param name="args">格式化参数数组</param>
private void Log(LogLevel level, string format, params object[] args)
{
if (!IsEnabled(level)) return;
Write(level, string.Format(format, args), null);
}
/// <summary>
/// 核心日志记录方法（带异常）
/// </summary>
/// <param name="level">日志级别</param>
/// <param name="message">日志消息</param>
/// <param name="exception">异常对象</param>
private void Log(LogLevel level, string message, Exception exception)
{
if (!IsEnabled(level)) return;
Write(level, message, exception);
}
#endregion
/// <summary>
/// 平台输出入口，由具体实现负责真正的日志写入。
/// </summary>
/// <param name="level">日志级别</param>
/// <param name="message">日志消息</param>
/// <param name="exception">异常对象（可为null）</param>
protected abstract void Write(LogLevel level, string message, Exception? exception);
}

372
GFramework.Core/logging/ConsoleLogger.cs
View File

@ -3,371 +3,26 @@ namespace GFramework.Core.logging;
/// <summary>
/// 控制台日志记录器
/// </summary>
public sealed class ConsoleLogger : ILogger
public sealed class ConsoleLogger(
string? name = null,
LogLevel minLevel = LogLevel.Info,
TextWriter? writer = null,
bool useColors = true) : AbstractLogger(name ?? ILogger.RootLoggerName, minLevel)
{
private readonly LogLevel _minLevel;
private readonly string _name;
private readonly TextWriter _writer;
private readonly bool _useColors;
private readonly TextWriter _writer = writer ?? Console.Out;
private readonly bool _useColors = useColors && writer == Console.Out;
/// <summary>
/// 初始化控制台日志记录器实例
/// </summary>
/// <param name="name">日志记录器名称，默认为根日志记录器名称</param>
/// <param name="minLevel">最小日志级别，默认为Info级别</param>
/// <param name="writer">文本写入器，默认为控制台输出</param>
/// <param name="useColors">是否使用颜色输出，默认为true</param>
public ConsoleLogger(
string? name = null,
LogLevel minLevel = LogLevel.Info,
TextWriter? writer = null,
bool useColors = true)
{
_name = name ?? ILogger.RootLoggerName;
_minLevel = minLevel;
_writer = writer ?? Console.Out;
_useColors = useColors && _writer == Console.Out;
}
#region Metadata
/// <summary>
/// 获取日志记录器名称
/// </summary>
/// <returns>日志记录器名称</returns>
public string Name() => _name;
#endregion
#region Level Checks
/// <summary>
/// 检查是否启用Trace级别日志
/// </summary>
/// <returns>如果启用返回true，否则返回false</returns>
public bool IsTraceEnabled() => IsEnabled(LogLevel.Trace);
/// <summary>
/// 检查是否启用Debug级别日志
/// </summary>
/// <returns>如果启用返回true，否则返回false</returns>
public bool IsDebugEnabled() => IsEnabled(LogLevel.Debug);
/// <summary>
/// 检查是否启用Info级别日志
/// </summary>
/// <returns>如果启用返回true，否则返回false</returns>
public bool IsInfoEnabled() => IsEnabled(LogLevel.Info);
/// <summary>
/// 检查是否启用Warn级别日志
/// </summary>
/// <returns>如果启用返回true，否则返回false</returns>
public bool IsWarnEnabled() => IsEnabled(LogLevel.Warning);
/// <summary>
/// 检查是否启用Error级别日志
/// </summary>
/// <returns>如果启用返回true，否则返回false</returns>
public bool IsErrorEnabled() => IsEnabled(LogLevel.Error);
/// <summary>
/// 检查是否启用Fatal级别日志
/// </summary>
/// <returns>如果启用返回true，否则返回false</returns>
public bool IsFatalEnabled() => IsEnabled(LogLevel.Fatal);
/// <summary>
/// 检查指定日志级别是否启用
/// </summary>
/// <param name="level">要检查的日志级别</param>
/// <returns>如果启用返回true，否则返回false</returns>
private bool IsEnabled(LogLevel level) => level >= _minLevel;
#endregion
#region Trace
/// <summary>
/// 记录Trace级别日志消息
/// </summary>
/// <param name="msg">日志消息</param>
public void Trace(string msg) => LogIfEnabled(LogLevel.Trace, msg);
/// <summary>
/// 记录Trace级别日志消息（带格式化参数）
/// </summary>
/// <param name="format">格式化字符串</param>
/// <param name="arg">格式化参数</param>
public void Trace(string format, object arg) => LogIfEnabled(LogLevel.Trace, format, arg);
/// <summary>
/// 记录Trace级别日志消息（带两个格式化参数）
/// </summary>
/// <param name="format">格式化字符串</param>
/// <param name="arg1">第一个格式化参数</param>
/// <param name="arg2">第二个格式化参数</param>
public void Trace(string format, object arg1, object arg2) => LogIfEnabled(LogLevel.Trace, format, arg1, arg2);
/// <summary>
/// 记录Trace级别日志消息（带多个格式化参数）
/// </summary>
/// <param name="format">格式化字符串</param>
/// <param name="arguments">格式化参数数组</param>
public void Trace(string format, params object[] arguments) => LogIfEnabled(LogLevel.Trace, format, arguments);
/// <summary>
/// 记录Trace级别异常日志
/// </summary>
/// <param name="msg">日志消息</param>
/// <param name="t">异常对象</param>
public void Trace(string msg, Exception t) => LogException(LogLevel.Trace, msg, t);
#endregion
#region Debug
/// <summary>
/// 记录Debug级别日志消息
/// </summary>
/// <param name="msg">日志消息</param>
public void Debug(string msg) => LogIfEnabled(LogLevel.Debug, msg);
/// <summary>
/// 记录Debug级别日志消息（带格式化参数）
/// </summary>
/// <param name="format">格式化字符串</param>
/// <param name="arg">格式化参数</param>
public void Debug(string format, object arg) => LogIfEnabled(LogLevel.Debug, format, arg);
/// <summary>
/// 记录Debug级别日志消息（带两个格式化参数）
/// </summary>
/// <param name="format">格式化字符串</param>
/// <param name="arg1">第一个格式化参数</param>
/// <param name="arg2">第二个格式化参数</param>
public void Debug(string format, object arg1, object arg2) => LogIfEnabled(LogLevel.Debug, format, arg1, arg2);
/// <summary>
/// 记录Debug级别日志消息（带多个格式化参数）
/// </summary>
/// <param name="format">格式化字符串</param>
/// <param name="arguments">格式化参数数组</param>
public void Debug(string format, params object[] arguments) => LogIfEnabled(LogLevel.Debug, format, arguments);
/// <summary>
/// 记录Debug级别异常日志
/// </summary>
/// <param name="msg">日志消息</param>
/// <param name="t">异常对象</param>
public void Debug(string msg, Exception t) => LogException(LogLevel.Debug, msg, t);
#endregion
#region Info
/// <summary>
/// 记录Info级别日志消息
/// </summary>
/// <param name="msg">日志消息</param>
public void Info(string msg) => LogIfEnabled(LogLevel.Info, msg);
/// <summary>
/// 记录Info级别日志消息（带格式化参数）
/// </summary>
/// <param name="format">格式化字符串</param>
/// <param name="arg">格式化参数</param>
public void Info(string format, object arg) => LogIfEnabled(LogLevel.Info, format, arg);
/// <summary>
/// 记录Info级别日志消息（带两个格式化参数）
/// </summary>
/// <param name="format">格式化字符串</param>
/// <param name="arg1">第一个格式化参数</param>
/// <param name="arg2">第二个格式化参数</param>
public void Info(string format, object arg1, object arg2) => LogIfEnabled(LogLevel.Info, format, arg1, arg2);
/// <summary>
/// 记录Info级别日志消息（带多个格式化参数）
/// </summary>
/// <param name="format">格式化字符串</param>
/// <param name="arguments">格式化参数数组</param>
public void Info(string format, params object[] arguments) => LogIfEnabled(LogLevel.Info, format, arguments);
/// <summary>
/// 记录Info级别异常日志
/// </summary>
/// <param name="msg">日志消息</param>
/// <param name="t">异常对象</param>
public void Info(string msg, Exception t) => LogException(LogLevel.Info, msg, t);
#endregion
#region Warn
/// <summary>
/// 记录Warn级别日志消息
/// </summary>
/// <param name="msg">日志消息</param>
public void Warn(string msg) => LogIfEnabled(LogLevel.Warning, msg);
/// <summary>
/// 记录Warn级别日志消息（带格式化参数）
/// </summary>
/// <param name="format">格式化字符串</param>
/// <param name="arg">格式化参数</param>
public void Warn(string format, object arg) => LogIfEnabled(LogLevel.Warning, format, arg);
/// <summary>
/// 记录Warn级别日志消息（带两个格式化参数）
/// </summary>
/// <param name="format">格式化字符串</param>
/// <param name="arg1">第一个格式化参数</param>
/// <param name="arg2">第二个格式化参数</param>
public void Warn(string format, object arg1, object arg2) => LogIfEnabled(LogLevel.Warning, format, arg1, arg2);
/// <summary>
/// 记录Warn级别日志消息（带多个格式化参数）
/// </summary>
/// <param name="format">格式化字符串</param>
/// <param name="arguments">格式化参数数组</param>
public void Warn(string format, params object[] arguments) => LogIfEnabled(LogLevel.Warning, format, arguments);
/// <summary>
/// 记录Warn级别异常日志
/// </summary>
/// <param name="msg">日志消息</param>
/// <param name="t">异常对象</param>
public void Warn(string msg, Exception t) => LogException(LogLevel.Warning, msg, t);
#endregion
#region Error
/// <summary>
/// 记录Error级别日志消息
/// </summary>
/// <param name="msg">日志消息</param>
public void Error(string msg) => LogIfEnabled(LogLevel.Error, msg);
/// <summary>
/// 记录Error级别日志消息（带格式化参数）
/// </summary>
/// <param name="format">格式化字符串</param>
/// <param name="arg">格式化参数</param>
public void Error(string format, object arg) => LogIfEnabled(LogLevel.Error, format, arg);
/// <summary>
/// 记录Error级别日志消息（带两个格式化参数）
/// </summary>
/// <param name="format">格式化字符串</param>
/// <param name="arg1">第一个格式化参数</param>
/// <param name="arg2">第二个格式化参数</param>
public void Error(string format, object arg1, object arg2) => LogIfEnabled(LogLevel.Error, format, arg1, arg2);
/// <summary>
/// 记录Error级别日志消息（带多个格式化参数）
/// </summary>
/// <param name="format">格式化字符串</param>
/// <param name="arguments">格式化参数数组</param>
public void Error(string format, params object[] arguments) => LogIfEnabled(LogLevel.Error, format, arguments);
/// <summary>
/// 记录Error级别异常日志
/// </summary>
/// <param name="msg">日志消息</param>
/// <param name="t">异常对象</param>
public void Error(string msg, Exception t) => LogException(LogLevel.Error, msg, t);
#endregion
#region Fatal
/// <summary>
/// 记录Fatal级别日志消息
/// </summary>
/// <param name="msg">日志消息</param>
public void Fatal(string msg) => LogIfEnabled(LogLevel.Fatal, msg);
/// <summary>
/// 记录Fatal级别日志消息（带格式化参数）
/// </summary>
/// <param name="format">格式化字符串</param>
/// <param name="arg">格式化参数</param>
public void Fatal(string format, object arg) => LogIfEnabled(LogLevel.Fatal, format, arg);
/// <summary>
/// 记录Fatal级别日志消息（带两个格式化参数）
/// </summary>
/// <param name="format">格式化字符串</param>
/// <param name="arg1">第一个格式化参数</param>
/// <param name="arg2">第二个格式化参数</param>
public void Fatal(string format, object arg1, object arg2) => LogIfEnabled(LogLevel.Fatal, format, arg1, arg2);
/// <summary>
/// 记录Fatal级别日志消息（带多个格式化参数）
/// </summary>
/// <param name="format">格式化字符串</param>
/// <param name="arguments">格式化参数数组</param>
public void Fatal(string format, params object[] arguments) => LogIfEnabled(LogLevel.Fatal, format, arguments);
/// <summary>
/// 记录Fatal级别异常日志
/// </summary>
/// <param name="msg">日志消息</param>
/// <param name="t">异常对象</param>
public void Fatal(string msg, Exception t) => LogException(LogLevel.Fatal, msg, t);
#endregion
#region Internal Core
/// <summary>
/// 如果指定级别已启用，则记录日志消息
/// 写入日志消息到控制台
/// </summary>
/// <param name="level">日志级别</param>
/// <param name="message">日志消息</param>
private void LogIfEnabled(LogLevel level, string message)
{
if (!IsEnabled(level)) return;
LogInternal(level, message, null);
}
/// <summary>
/// 如果指定级别已启用，则记录格式化日志消息
/// </summary>
/// <param name="level">日志级别</param>
/// <param name="format">格式化字符串</param>
/// <param name="args">格式化参数数组</param>
private void LogIfEnabled(LogLevel level, string format, params object[] args)
{
if (!IsEnabled(level)) return;
LogInternal(level, string.Format(format, args), null);
}
/// <summary>
/// 如果指定级别已启用，则记录异常日志
/// </summary>
/// <param name="level">日志级别</param>
/// <param name="message">日志消息</param>
/// <param name="exception">异常对象</param>
private void LogException(LogLevel level, string message, Exception exception)
{
if (!IsEnabled(level)) return;
LogInternal(level, message, exception);
}
/// <summary>
/// 内部日志记录方法
/// </summary>
/// <param name="level">日志级别</param>
/// <param name="message">日志消息</param>
/// <param name="exception">异常对象（可选）</param>
private void LogInternal(LogLevel level, string message, Exception? exception)
/// <param name="exception">异常信息，可为空</param>
protected override void Write(LogLevel level, string message, Exception? exception)
{
var timestamp = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff");
var levelStr = level.ToString().ToUpper().PadRight(7);
var log = $"[{timestamp}] {levelStr} [{_name}] {message}";
var log = $"[{timestamp}] {levelStr} [{Name()}] {message}";
// 添加异常信息到日志
if (exception != null)
@ -384,7 +39,8 @@ public sealed class ConsoleLogger : ILogger
_writer.WriteLine(log);
}
}
#region Internal Core
/// <summary>
/// 以指定颜色写入日志消息
/// </summary>

3
GFramework.Core/logging/ILogger.cs
View File

@ -74,8 +74,7 @@ public interface ILogger
}
#endregion
#region Trace Logging Methods
/// <summary>

369
GFramework.Core/logging/NoopLogger.cs
View File

@ -3,368 +3,19 @@
/// <summary>
/// 空操作日志记录器实现，不执行任何实际的日志记录操作
/// </summary>
internal sealed class NoopLogger : ILogger
/// <param name="name">日志记录器名称，默认为null</param>
/// <param name="minLevel">最小日志级别，默认为Info</param>
internal sealed class NoopLogger(
string? name = null,
LogLevel minLevel = LogLevel.Info) : AbstractLogger(name ?? ILogger.RootLoggerName, minLevel)
{
/// <summary>
/// 获取日志记录器的名称
/// 重写写入方法，空操作实现，不执行任何实际的日志记录操作
/// </summary>
/// <returns>返回"NOOP"字符串</returns>
public string Name()
{
return "NOOP";
}
/// <summary>
/// 检查是否启用了跟踪级别日志
/// </summary>
/// <returns>始终返回false</returns>
public bool IsTraceEnabled()
{
return false;
}
/// <summary>
/// 检查是否启用了调试级别日志
/// </summary>
/// <returns>始终返回false</returns>
public bool IsDebugEnabled()
{
return false;
}
/// <summary>
/// 检查是否启用了信息级别日志
/// </summary>
/// <returns>始终返回false</returns>
public bool IsInfoEnabled()
{
return false;
}
/// <summary>
/// 检查是否启用了警告级别日志
/// </summary>
/// <returns>始终返回false</returns>
public bool IsWarnEnabled()
{
return false;
}
/// <summary>
/// 检查是否启用了错误级别日志
/// </summary>
/// <returns>始终返回false</returns>
public bool IsErrorEnabled()
{
return false;
}
/// <summary>
/// 检查是否启用了致命错误级别日志
/// </summary>
/// <returns>始终返回false</returns>
public bool IsFatalEnabled()
{
return false;
}
/// <summary>
/// 记录跟踪级别日志消息
/// </summary>
/// <param name="msg">要记录的消息</param>
public void Trace(string msg)
{
}
/// <summary>
/// 记录跟踪级别日志消息，支持格式化参数
/// </summary>
/// <param name="format">格式化字符串</param>
/// <param name="arg">格式化参数</param>
public void Trace(string format, object arg)
{
}
/// <summary>
/// 记录跟踪级别日志消息，支持两个格式化参数
/// </summary>
/// <param name="format">格式化字符串</param>
/// <param name="arg1">第一个格式化参数</param>
/// <param name="arg2">第二个格式化参数</param>
public void Trace(string format, object arg1, object arg2)
{
}
/// <summary>
/// 记录跟踪级别日志消息，支持多个格式化参数
/// </summary>
/// <param name="format">格式化字符串</param>
/// <param name="arguments">格式化参数数组</param>
public void Trace(string format, params object[] arguments)
{
}
/// <summary>
/// 记录跟踪级别日志消息和异常信息
/// </summary>
/// <param name="msg">要记录的消息</param>
/// <param name="t">要记录的异常</param>
public void Trace(string msg, Exception t)
{
}
/// <summary>
/// 记录调试级别日志消息
/// </summary>
/// <param name="msg">要记录的消息</param>
public void Debug(string msg)
{
}
/// <summary>
/// 记录调试级别日志消息，支持格式化参数
/// </summary>
/// <param name="format">格式化字符串</param>
/// <param name="arg">格式化参数</param>
public void Debug(string format, object arg)
{
}
/// <summary>
/// 记录调试级别日志消息，支持两个格式化参数
/// </summary>
/// <param name="format">格式化字符串</param>
/// <param name="arg1">第一个格式化参数</param>
/// <param name="arg2">第二个格式化参数</param>
public void Debug(string format, object arg1, object arg2)
{
}
/// <summary>
/// 记录调试级别日志消息，支持多个格式化参数
/// </summary>
/// <param name="format">格式化字符串</param>
/// <param name="arguments">格式化参数数组</param>
public void Debug(string format, params object[] arguments)
{
}
/// <summary>
/// 记录调试级别日志消息和异常信息
/// </summary>
/// <param name="msg">要记录的消息</param>
/// <param name="t">要记录的异常</param>
public void Debug(string msg, Exception t)
{
}
/// <summary>
/// 记录信息级别日志消息
/// </summary>
/// <param name="msg">要记录的消息</param>
public void Info(string msg)
{
}
/// <summary>
/// 记录信息级别日志消息，支持格式化参数
/// </summary>
/// <param name="format">格式化字符串</param>
/// <param name="arg">格式化参数</param>
public void Info(string format, object arg)
{
}
/// <summary>
/// 记录信息级别日志消息，支持两个格式化参数
/// </summary>
/// <param name="format">格式化字符串</param>
/// <param name="arg1">第一个格式化参数</param>
/// <param name="arg2">第二个格式化参数</param>
public void Info(string format, object arg1, object arg2)
{
}
/// <summary>
/// 记录信息级别日志消息，支持多个格式化参数
/// </summary>
/// <param name="format">格式化字符串</param>
/// <param name="arguments">格式化参数数组</param>
public void Info(string format, params object[] arguments)
{
}
/// <summary>
/// 记录信息级别日志消息和异常信息
/// </summary>
/// <param name="msg">要记录的消息</param>
/// <param name="t">要记录的异常</param>
public void Info(string msg, Exception t)
{
}
/// <summary>
/// 记录警告级别日志消息
/// </summary>
/// <param name="msg">要记录的消息</param>
public void Warn(string msg)
{
}
/// <summary>
/// 记录警告级别日志消息，支持格式化参数
/// </summary>
/// <param name="format">格式化字符串</param>
/// <param name="arg">格式化参数</param>
public void Warn(string format, object arg)
{
}
/// <summary>
/// 记录警告级别日志消息，支持两个格式化参数
/// </summary>
/// <param name="format">格式化字符串</param>
/// <param name="arg1">第一个格式化参数</param>
/// <param name="arg2">第二个格式化参数</param>
public void Warn(string format, object arg1, object arg2)
{
}
/// <summary>
/// 记录警告级别日志消息，支持多个格式化参数
/// </summary>
/// <param name="format">格式化字符串</param>
/// <param name="arguments">格式化参数数组</param>
public void Warn(string format, params object[] arguments)
{
}
/// <summary>
/// 记录警告级别日志消息和异常信息
/// </summary>
/// <param name="msg">要记录的消息</param>
/// <param name="t">要记录的异常</param>
public void Warn(string msg, Exception t)
{
}
/// <summary>
/// 记录错误级别日志消息
/// </summary>
/// <param name="msg">要记录的消息</param>
public void Error(string msg)
{
}
/// <summary>
/// 记录错误级别日志消息，支持格式化参数
/// </summary>
/// <param name="format">格式化字符串</param>
/// <param name="arg">格式化参数</param>
public void Error(string format, object arg)
{
}
/// <summary>
/// 记录错误级别日志消息，支持两个格式化参数
/// </summary>
/// <param name="format">格式化字符串</param>
/// <param name="arg1">第一个格式化参数</param>
/// <param name="arg2">第二个格式化参数</param>
public void Error(string format, object arg1, object arg2)
{
}
/// <summary>
/// 记录错误级别日志消息，支持多个格式化参数
/// </summary>
/// <param name="format">格式化字符串</param>
/// <param name="arguments">格式化参数数组</param>
public void Error(string format, params object[] arguments)
{
}
/// <summary>
/// 记录错误级别日志消息和异常信息
/// </summary>
/// <param name="msg">要记录的消息</param>
/// <param name="t">要记录的异常</param>
public void Error(string msg, Exception t)
{
}
/// <summary>
/// 记录致命错误级别日志消息
/// </summary>
/// <param name="msg">要记录的消息</param>
public void Fatal(string msg)
{
}
/// <summary>
/// 记录致命错误级别日志消息，支持格式化参数
/// </summary>
/// <param name="format">格式化字符串</param>
/// <param name="arg">格式化参数</param>
public void Fatal(string format, object arg)
{
}
/// <summary>
/// 记录致命错误级别日志消息，支持两个格式化参数
/// </summary>
/// <param name="format">格式化字符串</param>
/// <param name="arg1">第一个格式化参数</param>
/// <param name="arg2">第二个格式化参数</param>
public void Fatal(string format, object arg1, object arg2)
{
}
/// <summary>
/// 记录致命错误级别日志消息，支持多个格式化参数
/// </summary>
/// <param name="format">格式化字符串</param>
/// <param name="arguments">格式化参数数组</param>
public void Fatal(string format, params object[] arguments)
{
}
/// <summary>
/// 记录致命错误级别日志消息和异常信息
/// </summary>
/// <param name="msg">要记录的消息</param>
/// <param name="t">要记录的异常</param>
public void Fatal(string msg, Exception t)
/// <param name="level">日志级别</param>
/// <param name="message">日志消息</param>
/// <param name="exception">异常信息</param>
protected override void Write(LogLevel level, string message, Exception? exception)
{
}

7
GFramework.Godot/architecture/AbstractArchitecture.cs
View File

@ -9,8 +9,7 @@ namespace GFramework.Godot.architecture;
/// 抽象架构类，为特定类型的架构提供基础实现框架。
/// 此类负责管理架构的初始化、生命周期绑定以及扩展模块的安装与销毁。
/// </summary>
/// <typeparam name="T">架构的具体类型，必须继承自Architecture且能被实例化。</typeparam>
public abstract class AbstractArchitecture<T> : Architecture<T> where T : Architecture<T>, new()
public abstract class AbstractArchitecture: Architecture
{
/// <summary>
@ -23,7 +22,7 @@ public abstract class AbstractArchitecture<T> : Architecture<T> where T : Archit
/// 存储所有已安装的Godot架构扩展组件列表
/// 用于在架构销毁时正确清理所有扩展资源
/// </summary>
private readonly List<IGodotModule<T>> _extensions = [];
private readonly List<IGodotModule> _extensions = [];
/// <summary>
/// 架构锚点节点引用
@ -90,7 +89,7 @@ public abstract class AbstractArchitecture<T> : Architecture<T> where T : Archit
/// <typeparam name="TModule">模块类型，必须实现IGodotModule接口</typeparam>
/// <param name="module">要安装的模块实例</param>
/// <returns>异步任务</returns>
protected async Task InstallGodotModule<TModule>(TModule module) where TModule : IGodotModule<T>
protected async Task InstallGodotModule<TModule>(TModule module) where TModule : IGodotModule
{
module.Install(this);

5
GFramework.Godot/architecture/AbstractGodotModule.cs
View File

@ -6,8 +6,7 @@ namespace GFramework.Godot.architecture;
/// <summary>
/// 抽象的Godot模块基类，用于定义Godot框架中的模块行为
/// </summary>
/// <typeparam name="T">架构类型，必须继承自Architecture并且有无参构造函数</typeparam>
public abstract class AbstractGodotModule<T>: IGodotModule<T> where T : Architecture<T>, new()
public abstract class AbstractGodotModule: IGodotModule
{
/// <summary>
/// 当架构阶段发生变化时调用此方法
@ -43,7 +42,7 @@ public abstract class AbstractGodotModule<T>: IGodotModule<T> where T : Architec
/// 当模块被附加到架构时调用此方法
/// </summary>
/// <param name="architecture">被附加到的架构实例</param>
public virtual void OnAttach(Architecture<T> architecture)
public virtual void OnAttach(Architecture architecture)
{
}

12
GFramework.Godot/architecture/IGodotModule.cs
View File

@ -6,23 +6,21 @@ namespace GFramework.Godot.architecture;
/// <summary>
/// Godot模块接口，定义了Godot引擎中模块的基本行为和属性
/// </summary>
/// <typeparam name="T">架构类型，必须继承自Architecture&lt;T&gt;且具有无参构造函数</typeparam>
public interface IGodotModule<T> : IArchitectureModule where T : Architecture<T>, new()
public interface IGodotModule : IArchitectureModule
{
/// <summary>
/// 获取模块关联的Godot节点
/// </summary>
Node Node { get; }
/// <summary>
/// 当模块被附加到架构时调用
/// </summary>
/// <param name="architecture">要附加到的架构实例</param>
void OnAttach(Architecture<T> architecture);
void OnAttach(Architecture architecture);
/// <summary>
/// 当模块从架构分离时调用
/// </summary>
void OnDetach();
}
}

13
GFramework.Godot/assets/AbstractResourceFactorySystem.cs
View File

@ -1,11 +1,10 @@
using GFramework.Core.architecture;
using GFramework.Core.events;
using GFramework.Core.extensions;
using GFramework.Core.system;
using GFramework.Game.assets;
using GFramework.Godot.system;
using Godot;
namespace GFramework.Godot.system;
namespace GFramework.Godot.assets;
/// <summary>
/// 资源工厂系统抽象基类，用于统一管理各类资源的创建与预加载逻辑。
@ -25,16 +24,16 @@ public abstract class AbstractResourceFactorySystem : AbstractSystem, IResourceF
protected override void OnInit()
{
_registry = new ResourceFactory.Registry();
_resourceLoadSystem = this.GetSystem<IResourceLoadSystem>();
_assetCatalogSystem = this.GetSystem<IAssetCatalogSystem>();
_resourceLoadSystem = Context.GetSystem<IResourceLoadSystem>();
_assetCatalogSystem = Context.GetSystem<IAssetCatalogSystem>();
}
/// <summary>
/// 架构阶段回调，在架构就绪时注册和预加载资源
/// </summary>
/// <param name="phase">当前架构阶段</param>
/// <param name="arch">架构实例</param>
public void OnPhase(ArchitecturePhase phase, IArchitecture arch)
/// <param name="architecture">架构实例</param>
public void OnPhase(ArchitecturePhase phase, IArchitecture architecture)
{
if (phase == ArchitecturePhase.Ready)
{

100
GFramework.Godot/component/AbstractDragDrop2DComponentBase.cs
View File

@ -1,100 +0,0 @@
using GFramework.Core.architecture;
using GFramework.Core.controller;
using GFramework.Core.events;
using GFramework.Core.extensions;
using Godot;
namespace GFramework.Godot.component;
/// <summary>
/// 抽象基类，用于实现2D拖拽功能的组件。
/// 继承自Godot的Node类并实现了IController接口。
/// 提供了拖拽相关的信号定义以及基础属性配置。
/// </summary>
public abstract partial class AbstractDragDrop2DComponentBase : Node, IController
{
/// <summary>
/// 取消注册列表，用于管理需要在节点销毁时取消注册的对象
/// </summary>
protected readonly IUnRegisterList UnRegisterList = new UnRegisterList();
/// <summary>
/// 当拖拽被取消时触发的信号。
/// </summary>
/// <param name="startingPosition">拖拽起始位置。</param>
[Signal]
public delegate void DragCanceledEventHandler(Vector2 startingPosition);
/// <summary>
/// 当拖拽开始时触发的信号。
/// </summary>
[Signal]
public delegate void DragStartedEventHandler();
/// <summary>
/// 当拖拽结束并放置时触发的信号。
/// </summary>
/// <param name="startingPosition">拖拽起始位置。</param>
[Signal]
public delegate void DroppedEventHandler(Vector2 startingPosition);
/// <summary>
/// 是否启用拖拽功能。若为 false，则忽略所有输入事件。
/// </summary>
public bool Enable { get; set; }
/// <summary>
/// 拖拽组的名称，用于区分不同的拖拽组。
/// </summary>
public string GroupName { get; set; } = "dragging";
/// <summary>
/// 获取或设置取消拖拽输入操作的名称
/// </summary>
public string CancelDragInputActionName { get; set; } = "cancel_drag";
/// <summary>
/// 获取或设置选择输入操作的名称
/// </summary>
public string SelectInputActionName { get; set; } = "select";
/// <summary>
/// 拖拽时元素的最大Z轴索引值。
/// </summary>
public int ZIndexMax { get; set; } = 99;
/// <summary>
/// 拖拽时元素的最小Z轴索引值。
/// </summary>
public int ZIndexMin { get; set; } = 0;
/// <summary>
/// 获取架构实例。
/// </summary>
/// <returns>返回实现IArchitecture接口的架构实例。</returns>
public abstract IArchitecture GetArchitecture();
/// <summary>
/// 表示是否正在拖拽操作的标志位。
/// </summary>
protected bool IsDragging;
/// <summary>
/// 表示拖拽操作中的偏移量，用于计算当前位置与起始位置的差值。
/// </summary>
protected Vector2 Offset = Vector2.Zero;
/// <summary>
/// 表示拖拽操作的起始位置坐标。
/// </summary>
protected Vector2 StartingPosition;
/// <summary>
/// 节点退出场景树时的回调方法。
/// 在节点从场景树移除前调用，用于清理资源。
/// </summary>
public override void _ExitTree()
{
UnRegisterList.UnRegisterAll();
}
}

127
GFramework.Godot/component/AbstractDragDropArea2DComponent.cs
View File

@ -1,127 +0,0 @@
using GFramework.Godot.extensions;
using Godot;
namespace GFramework.Godot.component;
/// <summary>
/// 抽象拖拽组件类，用于处理节点的拖放逻辑。
/// 实现了 IController 接口以支持架构通信，并通过信号通知拖拽事件的发生。
/// </summary>
public abstract partial class AbstractDragDropArea2DComponent : AbstractDragDrop2DComponentBase
{
/// <summary>
/// 目标区域，通常是可交互的游戏对象（如单位或物品）所在的碰撞区域。
/// </summary>
public required Area2D Target { get; set; }
/// <summary>
/// 节点准备就绪时的回调方法。
/// 在节点添加到场景树后调用，绑定目标区域的输入事件处理器。
/// </summary>
public override void _Ready()
{
Target = GetParent() as Area2D ?? throw new InvalidOperationException("Target must be an Area2D node.");
Target.InputEvent += OnTargetInputEvent;
}
/// <summary>
/// 处理输入事件的回调方法。
/// 根据当前拖拽状态和输入事件类型，执行相应的拖拽操作。
/// </summary>
/// <param name="event">输入事件对象</param>
public override void _Input(InputEvent @event)
{
switch (IsDragging)
{
// 处理取消拖拽操作：当正在拖拽且按下取消拖拽按键时，执行取消拖拽逻辑
case true when Target.IsValidNode() && @event.IsActionPressed(CancelDragInputActionName):
CancelDragging();
// 设置输入为处理，防止输入穿透
this.SetInputAsHandled();
break;
case true when @event.IsActionReleased(SelectInputActionName):
Drop();
break;
}
}
/// <summary>
/// 目标区域的输入事件处理器。
/// 当目标区域接收到输入事件时被调用，用于控制拖拽的开始和结束。
/// </summary>
/// <param name="viewport">事件发生的视口节点</param>
/// <param name="event">输入事件对象</param>
/// <param name="_">事件触点ID（未使用）</param>
private void OnTargetInputEvent(Node viewport, InputEvent @event, long _)
{
if (!Enable) return;
// 获取当前正在拖拽的对象
var draggingObj = GetTree().GetFirstNodeInGroup(GroupName);
switch (IsDragging)
{
// 处理开始拖拽操作：当未在拖拽状态且按下选择按键时，开始拖拽
case false when
// 如果当前没有拖拽操作且已有其他对象正在拖拽，则直接返回
draggingObj is not null:
return;
case false when @event.IsActionPressed(SelectInputActionName):
StartDragging();
break;
}
}
/// <summary>
/// 每帧更新逻辑，在拖拽过程中持续更新目标的位置。
/// </summary>
/// <param name="delta">与上一帧的时间间隔（秒）。</param>
public override void _Process(double delta)
{
if (IsDragging && Target.IsValidNode()) Target.GlobalPosition = Target.GetGlobalMousePosition() + Offset;
}
/// <summary>
/// 结束拖拽流程的基础方法。
/// 清除拖拽标志位并将目标从拖拽组中移除，恢复其层级顺序。
/// </summary>
private void EndDragging()
{
IsDragging = false;
Target.RemoveFromGroup(GroupName);
Target.ZIndex = ZIndexMin;
}
/// <summary>
/// 执行取消拖拽的操作。
/// 调用 EndDragging 并发出 DragCanceled 信号。
/// </summary>
private void CancelDragging()
{
EndDragging();
EmitSignalDragCanceled(StartingPosition);
}
/// <summary>
/// 开始拖拽操作。
/// 设置初始位置和偏移量，将目标加入拖拽组并提升显示层级，最后发出 DragStarted 信号。
/// </summary>
private void StartDragging()
{
IsDragging = true;
StartingPosition = Target.GlobalPosition;
Target.AddToGroup(GroupName);
Target.ZIndex = ZIndexMax;
Offset = Target.GlobalPosition - Target.GetGlobalMousePosition();
EmitSignalDragStarted();
}
/// <summary>
/// 完成一次拖拽操作。
/// 调用 EndDragging 方法并发出 Dropped 信号。
/// </summary>
private void Drop()
{
EndDragging();
EmitSignalDropped(StartingPosition);
}
}

17
GFramework.Godot/logging/GodotLogProvider.cs
View File

@ -1,17 +0,0 @@
using GFramework.Core.logging;
namespace GFramework.Godot.logging;
/// <summary>
/// Godot日志提供程序，实现ILogProvider接口，用于创建GodotLogger实例
/// </summary>
public sealed class GodotLogProvider : ILogProvider
{
/// <summary>
/// 创建指定类别的日志记录器
/// </summary>
/// <param name="category">日志类别名称</param>
/// <returns>返回GodotLogger实例</returns>
public ILogger CreateLogger(string category)
=> new GodotLogger(category);
}

71
GFramework.Godot/logging/GodotLogger.cs
View File

@ -6,77 +6,34 @@ namespace GFramework.Godot.logging;
/// <summary>
/// Godot平台的日志记录器实现
/// </summary>
public sealed class GodotLogger : ILogger
public sealed class GodotLogger(
string? name = null,
LogLevel minLevel = LogLevel.Info) : AbstractLogger(name??ILogger.RootLoggerName, minLevel)
{
private readonly string _category;
public GodotLogger(string category) => _category = category;
/// <summary>
/// 记录日志消息到Godot控制台
/// </summary>
/// <param name="level">日志级别</param>
/// <param name="message">日志消息</param>
/// <param name="exception">关联的异常对象</param>
/// <param name="context">日志上下文</param>
public void Log(LogLevel level, string message, Exception? exception, object? context)
protected override void Write(LogLevel level, string message, Exception? exception)
{
var prefix = $"[{level}]";
var prefix = $"[{level.ToString().ToUpper()}][{Name()}]";
// 将异常信息追加到日志消息中
if (exception != null)
message += $"\n{exception}";
{
message += "\n" + exception;
}
// 根据日志级别选择不同的输出方法
switch (level)
{
case LogLevel.Error:
case LogLevel.Fatal:
GD.PrintErr(prefix, message);
GD.PrintErr($"{prefix} {message}");
break;
case LogLevel.Warning:
GD.PushWarning($"{prefix} {message}");
break;
case LogLevel.Trace:
case LogLevel.Debug:
case LogLevel.Info:
default:
GD.Print(prefix, message);
GD.Print($"{prefix} {message}");
break;
}
}
/// <summary>
/// 检查指定日志级别是否启用
/// </summary>
/// <param name="level">日志级别</param>
/// <returns>始终返回 true</returns>
public bool IsEnabled(LogLevel level) => true;
public void Info(string msg, object? ctx = null)
{
Log(LogLevel.Info, msg, null, ctx);
}
public void Error(string msg, Exception? ex = null, object? ctx = null)
{
Log(LogLevel.Error, msg, ex, ctx);
}
public void Debug(string msg, object? ctx = null)
{
Log(LogLevel.Debug, msg, null, ctx);
}
public void Trace(string msg, object? ctx = null)
{
Log(LogLevel.Trace, msg, null, ctx);
}
public void Warn(string msg, object? ctx = null)
{
Log(LogLevel.Warning, msg, null, ctx);
}
public void Fatal(string msg,Exception? ex = null, object? ctx = null)
{
Log(LogLevel.Fatal, msg, ex, ctx);
}
}
}

19
GFramework.Godot/logging/GodotLoggerFactory.cs Normal file
View File

@ -0,0 +1,19 @@
using GFramework.Core.logging;
namespace GFramework.Godot.logging;
/// <summary>
/// Godot日志工厂类，用于创建Godot平台专用的日志记录器实例
/// </summary>
public class GodotLoggerFactory: ILoggerFactory
{
/// <summary>
/// 获取指定名称的日志记录器实例
/// </summary>
/// <param name="name">日志记录器的名称</param>
/// <returns>返回GodotLogger类型的日志记录器实例</returns>
public ILogger GetLogger(string name)
{
return new GodotLogger(name);
}
}

7
GFramework.Godot/system/AbstractAudioManagerSystem.cs
View File

@ -1,4 +1,3 @@
using GFramework.Core.extensions;
using GFramework.Core.system;
using GFramework.Game.assets;
using Godot;
@ -106,9 +105,9 @@ public abstract class AbstractAudioManagerSystem : AbstractSystem, IAudioManager
protected override void OnInit()
{
// 获取依赖的系统
ResourceLoadSystem = this.GetSystem<IResourceLoadSystem>();
AssetCatalogSystem = this.GetSystem<IAssetCatalogSystem>();
ResourceFactorySystem = this.GetSystem<IResourceFactorySystem>();
ResourceLoadSystem = Context.GetSystem<IResourceLoadSystem>();
AssetCatalogSystem = Context.GetSystem<IAssetCatalogSystem>();
ResourceFactorySystem = Context.GetSystem<IResourceFactorySystem>();
// 初始化背景音乐播放器
MusicPlayer = new AudioStreamPlayer();