Update

Update

Assets/Scenes/main.unity

@@ -416,9 +416,19 @@ MonoBehaviour:
   m_GameObject: {fileID: 2061060681}
   m_Enabled: 1
   m_EditorHideFlags: 0
-  m_Script: {fileID: 11500000, guid: 9b7cdcfd6cb40fe489faae0b85038cb9, type: 3}
+  m_Script: {fileID: 11500000, guid: 564a45007d8645cf96d33bb52471acd5, type: 3}
   m_Name: 
   m_EditorClassIdentifier: 
+  m_EditorLanguage: 0
+  m_TextHelperTypeName: TEngine.DefaultTextHelper
+  m_VersionHelperTypeName: TEngine.DefaultVersionHelper
+  m_LogHelperTypeName: TEngine.TEngineLogHelper
+  m_CompressionHelperTypeName: TEngine.DefaultCompressionHelper
+  m_JsonHelperTypeName: TEngine.DefaultJsonHelper
+  m_FrameRate: 120
+  m_GameSpeed: 1
+  m_RunInBackground: 1
+  m_NeverSleep: 1
 --- !u!1 &2108959335
 GameObject:
   m_ObjectHideFlags: 0

Assets/TEngine/Editor/Inspector/BaseComponentInspector.cs

@@ -0,0 +1,302 @@
+using TEngine;
+using System.Collections.Generic;
+using TEngine.Editor.Inspector;
+using UnityEditor;
+using UnityEngine;
+
+namespace TEngine.Editor
+{
+    [CustomEditor(typeof(BaseComponent))]
+    internal sealed class BaseComponentInspector : GameFrameworkInspector
+    {
+        private const string NoneOptionName = "<None>";
+        private static readonly float[] GameSpeed = new float[] { 0f, 0.01f, 0.1f, 0.25f, 0.5f, 1f, 1.5f, 2f, 4f, 8f };
+        private static readonly string[] GameSpeedForDisplay = new string[] { "0x", "0.01x", "0.1x", "0.25x", "0.5x", "1x", "1.5x", "2x", "4x", "8x" };
+
+        private SerializedProperty m_EditorLanguage = null;
+        private SerializedProperty m_TextHelperTypeName = null;
+        private SerializedProperty m_VersionHelperTypeName = null;
+        private SerializedProperty m_LogHelperTypeName = null;
+        private SerializedProperty m_CompressionHelperTypeName = null;
+        private SerializedProperty m_JsonHelperTypeName = null;
+        private SerializedProperty m_FrameRate = null;
+        private SerializedProperty m_GameSpeed = null;
+        private SerializedProperty m_RunInBackground = null;
+        private SerializedProperty m_NeverSleep = null;
+
+        private string[] m_TextHelperTypeNames = null;
+        private int m_TextHelperTypeNameIndex = 0;
+        private string[] m_VersionHelperTypeNames = null;
+        private int m_VersionHelperTypeNameIndex = 0;
+        private string[] m_LogHelperTypeNames = null;
+        private int m_LogHelperTypeNameIndex = 0;
+        private string[] m_CompressionHelperTypeNames = null;
+        private int m_CompressionHelperTypeNameIndex = 0;
+        private string[] m_JsonHelperTypeNames = null;
+        private int m_JsonHelperTypeNameIndex = 0;
+
+        public override void OnInspectorGUI()
+        {
+            base.OnInspectorGUI();
+
+            serializedObject.Update();
+
+            BaseComponent t = (BaseComponent)target;
+
+            EditorGUI.BeginDisabledGroup(EditorApplication.isPlayingOrWillChangePlaymode);
+            {
+                EditorGUILayout.BeginVertical("box");
+                {
+                    EditorGUILayout.LabelField("Global Helpers", EditorStyles.boldLabel);
+
+                    int textHelperSelectedIndex = EditorGUILayout.Popup("Text Helper", m_TextHelperTypeNameIndex, m_TextHelperTypeNames);
+                    if (textHelperSelectedIndex != m_TextHelperTypeNameIndex)
+                    {
+                        m_TextHelperTypeNameIndex = textHelperSelectedIndex;
+                        m_TextHelperTypeName.stringValue = textHelperSelectedIndex <= 0 ? null : m_TextHelperTypeNames[textHelperSelectedIndex];
+                    }
+
+                    int versionHelperSelectedIndex = EditorGUILayout.Popup("Version Helper", m_VersionHelperTypeNameIndex, m_VersionHelperTypeNames);
+                    if (versionHelperSelectedIndex != m_VersionHelperTypeNameIndex)
+                    {
+                        m_VersionHelperTypeNameIndex = versionHelperSelectedIndex;
+                        m_VersionHelperTypeName.stringValue = versionHelperSelectedIndex <= 0 ? null : m_VersionHelperTypeNames[versionHelperSelectedIndex];
+                    }
+
+                    int logHelperSelectedIndex = EditorGUILayout.Popup("Log Helper", m_LogHelperTypeNameIndex, m_LogHelperTypeNames);
+                    if (logHelperSelectedIndex != m_LogHelperTypeNameIndex)
+                    {
+                        m_LogHelperTypeNameIndex = logHelperSelectedIndex;
+                        m_LogHelperTypeName.stringValue = logHelperSelectedIndex <= 0 ? null : m_LogHelperTypeNames[logHelperSelectedIndex];
+                    }
+
+                    int compressionHelperSelectedIndex = EditorGUILayout.Popup("Compression Helper", m_CompressionHelperTypeNameIndex, m_CompressionHelperTypeNames);
+                    if (compressionHelperSelectedIndex != m_CompressionHelperTypeNameIndex)
+                    {
+                        m_CompressionHelperTypeNameIndex = compressionHelperSelectedIndex;
+                        m_CompressionHelperTypeName.stringValue = compressionHelperSelectedIndex <= 0 ? null : m_CompressionHelperTypeNames[compressionHelperSelectedIndex];
+                    }
+
+                    int jsonHelperSelectedIndex = EditorGUILayout.Popup("JSON Helper", m_JsonHelperTypeNameIndex, m_JsonHelperTypeNames);
+                    if (jsonHelperSelectedIndex != m_JsonHelperTypeNameIndex)
+                    {
+                        m_JsonHelperTypeNameIndex = jsonHelperSelectedIndex;
+                        m_JsonHelperTypeName.stringValue = jsonHelperSelectedIndex <= 0 ? null : m_JsonHelperTypeNames[jsonHelperSelectedIndex];
+                    }
+                }
+                EditorGUILayout.EndVertical();
+            }
+            EditorGUI.EndDisabledGroup();
+
+            int frameRate = EditorGUILayout.IntSlider("Frame Rate", m_FrameRate.intValue, 1, 120);
+            if (frameRate != m_FrameRate.intValue)
+            {
+                if (EditorApplication.isPlaying)
+                {
+                    t.FrameRate = frameRate;
+                }
+                else
+                {
+                    m_FrameRate.intValue = frameRate;
+                }
+            }
+
+            EditorGUILayout.BeginVertical("box");
+            {
+                float gameSpeed = EditorGUILayout.Slider("Game Speed", m_GameSpeed.floatValue, 0f, 8f);
+                int selectedGameSpeed = GUILayout.SelectionGrid(GetSelectedGameSpeed(gameSpeed), GameSpeedForDisplay, 5);
+                if (selectedGameSpeed >= 0)
+                {
+                    gameSpeed = GetGameSpeed(selectedGameSpeed);
+                }
+
+                if (gameSpeed != m_GameSpeed.floatValue)
+                {
+                    if (EditorApplication.isPlaying)
+                    {
+                        t.GameSpeed = gameSpeed;
+                    }
+                    else
+                    {
+                        m_GameSpeed.floatValue = gameSpeed;
+                    }
+                }
+            }
+            EditorGUILayout.EndVertical();
+
+            bool runInBackground = EditorGUILayout.Toggle("Run in Background", m_RunInBackground.boolValue);
+            if (runInBackground != m_RunInBackground.boolValue)
+            {
+                if (EditorApplication.isPlaying)
+                {
+                    t.RunInBackground = runInBackground;
+                }
+                else
+                {
+                    m_RunInBackground.boolValue = runInBackground;
+                }
+            }
+
+            bool neverSleep = EditorGUILayout.Toggle("Never Sleep", m_NeverSleep.boolValue);
+            if (neverSleep != m_NeverSleep.boolValue)
+            {
+                if (EditorApplication.isPlaying)
+                {
+                    t.NeverSleep = neverSleep;
+                }
+                else
+                {
+                    m_NeverSleep.boolValue = neverSleep;
+                }
+            }
+
+            serializedObject.ApplyModifiedProperties();
+        }
+
+        protected override void OnCompileComplete()
+        {
+            base.OnCompileComplete();
+
+            RefreshTypeNames();
+        }
+
+        private void OnEnable()
+        {
+            m_EditorLanguage = serializedObject.FindProperty("m_EditorLanguage");
+            m_TextHelperTypeName = serializedObject.FindProperty("m_TextHelperTypeName");
+            m_VersionHelperTypeName = serializedObject.FindProperty("m_VersionHelperTypeName");
+            m_LogHelperTypeName = serializedObject.FindProperty("m_LogHelperTypeName");
+            m_CompressionHelperTypeName = serializedObject.FindProperty("m_CompressionHelperTypeName");
+            m_JsonHelperTypeName = serializedObject.FindProperty("m_JsonHelperTypeName");
+            m_FrameRate = serializedObject.FindProperty("m_FrameRate");
+            m_GameSpeed = serializedObject.FindProperty("m_GameSpeed");
+            m_RunInBackground = serializedObject.FindProperty("m_RunInBackground");
+            m_NeverSleep = serializedObject.FindProperty("m_NeverSleep");
+
+            RefreshTypeNames();
+        }
+
+        private void RefreshTypeNames()
+        {
+            List<string> textHelperTypeNames = new List<string>
+            {
+                NoneOptionName
+            };
+
+            textHelperTypeNames.AddRange(Type.GetRuntimeTypeNames(typeof(Utility.Text.ITextHelper)));
+            m_TextHelperTypeNames = textHelperTypeNames.ToArray();
+            m_TextHelperTypeNameIndex = 0;
+            if (!string.IsNullOrEmpty(m_TextHelperTypeName.stringValue))
+            {
+                m_TextHelperTypeNameIndex = textHelperTypeNames.IndexOf(m_TextHelperTypeName.stringValue);
+                if (m_TextHelperTypeNameIndex <= 0)
+                {
+                    m_TextHelperTypeNameIndex = 0;
+                    m_TextHelperTypeName.stringValue = null;
+                }
+            }
+
+            List<string> versionHelperTypeNames = new List<string>
+            {
+                NoneOptionName
+            };
+
+            versionHelperTypeNames.AddRange(Type.GetRuntimeTypeNames(typeof(Version.IVersionHelper)));
+            m_VersionHelperTypeNames = versionHelperTypeNames.ToArray();
+            m_VersionHelperTypeNameIndex = 0;
+            if (!string.IsNullOrEmpty(m_VersionHelperTypeName.stringValue))
+            {
+                m_VersionHelperTypeNameIndex = versionHelperTypeNames.IndexOf(m_VersionHelperTypeName.stringValue);
+                if (m_VersionHelperTypeNameIndex <= 0)
+                {
+                    m_VersionHelperTypeNameIndex = 0;
+                    m_VersionHelperTypeName.stringValue = null;
+                }
+            }
+
+            List<string> logHelperTypeNames = new List<string>
+            {
+                NoneOptionName
+            };
+
+            logHelperTypeNames.AddRange(Type.GetRuntimeTypeNames(typeof(GameFrameworkLog.ILogHelper)));
+            m_LogHelperTypeNames = logHelperTypeNames.ToArray();
+            m_LogHelperTypeNameIndex = 0;
+            if (!string.IsNullOrEmpty(m_LogHelperTypeName.stringValue))
+            {
+                m_LogHelperTypeNameIndex = logHelperTypeNames.IndexOf(m_LogHelperTypeName.stringValue);
+                if (m_LogHelperTypeNameIndex <= 0)
+                {
+                    m_LogHelperTypeNameIndex = 0;
+                    m_LogHelperTypeName.stringValue = null;
+                }
+            }
+
+            List<string> compressionHelperTypeNames = new List<string>
+            {
+                NoneOptionName
+            };
+
+            compressionHelperTypeNames.AddRange(Type.GetRuntimeTypeNames(typeof(Utility.Compression.ICompressionHelper)));
+            m_CompressionHelperTypeNames = compressionHelperTypeNames.ToArray();
+            m_CompressionHelperTypeNameIndex = 0;
+            if (!string.IsNullOrEmpty(m_CompressionHelperTypeName.stringValue))
+            {
+                m_CompressionHelperTypeNameIndex = compressionHelperTypeNames.IndexOf(m_CompressionHelperTypeName.stringValue);
+                if (m_CompressionHelperTypeNameIndex <= 0)
+                {
+                    m_CompressionHelperTypeNameIndex = 0;
+                    m_CompressionHelperTypeName.stringValue = null;
+                }
+            }
+
+            List<string> jsonHelperTypeNames = new List<string>
+            {
+                NoneOptionName
+            };
+
+            jsonHelperTypeNames.AddRange(Type.GetRuntimeTypeNames(typeof(Utility.Json.IJsonHelper)));
+            m_JsonHelperTypeNames = jsonHelperTypeNames.ToArray();
+            m_JsonHelperTypeNameIndex = 0;
+            if (!string.IsNullOrEmpty(m_JsonHelperTypeName.stringValue))
+            {
+                m_JsonHelperTypeNameIndex = jsonHelperTypeNames.IndexOf(m_JsonHelperTypeName.stringValue);
+                if (m_JsonHelperTypeNameIndex <= 0)
+                {
+                    m_JsonHelperTypeNameIndex = 0;
+                    m_JsonHelperTypeName.stringValue = null;
+                }
+            }
+
+            serializedObject.ApplyModifiedProperties();
+        }
+
+        private float GetGameSpeed(int selectedGameSpeed)
+        {
+            if (selectedGameSpeed < 0)
+            {
+                return GameSpeed[0];
+            }
+
+            if (selectedGameSpeed >= GameSpeed.Length)
+            {
+                return GameSpeed[GameSpeed.Length - 1];
+            }
+
+            return GameSpeed[selectedGameSpeed];
+        }
+
+        private int GetSelectedGameSpeed(float gameSpeed)
+        {
+            for (int i = 0; i < GameSpeed.Length; i++)
+            {
+                if (gameSpeed == GameSpeed[i])
+                {
+                    return i;
+                }
+            }
+
+            return -1;
+        }
+    }
+}

Assets/TEngine/Editor/Inspector/BaseComponentInspector.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: d8acc7d98be34139882c0c02558e8d26
+timeCreated: 1680338392

Assets/TEngine/Editor/UI/ScriptGenerator.cs

@@ -73,7 +73,7 @@ namespace TEngine.Editor.UI
 
                     strFile.Append("using UnityEngine;\n");
                     strFile.Append("using UnityEngine.UI;\n");
-                    strFile.Append("using UnityGameFramework.Runtime;\n\n");
+                    strFile.Append("using TEngine;\n\n");
                     strFile.Append("namespace GameMain\n");
                     strFile.Append("{\n");
                     strFile.Append("\tclass " + root.name + " : UIFormLogic\n");

Assets/TEngine/Editor/Utility.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 9336045122f6433da12f0b4cea097333
+timeCreated: 1680338489

Assets/TEngine/Editor/Utility/ConfigPathAttribute.cs

@@ -0,0 +1,11 @@
+using System;
+
+namespace TEngine.Editor
+{
+    /// <summary>
+    /// 配置路径属性。
+    /// </summary>
+    public abstract class ConfigPathAttribute : Attribute
+    {
+    }
+}

Assets/TEngine/Editor/Utility/ConfigPathAttribute.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 6efbdd76bcb94dbf93f8d05c570df909
+timeCreated: 1680340111

Assets/TEngine/Editor/Utility/GetAssetHelper.cs

@@ -0,0 +1,41 @@
+using System.Linq;
+using UnityEditor;
+using UnityEngine;
+
+namespace TEngine.Editor
+{
+    /// <summary>
+    /// 获取资源路径相关的实用函数。
+    /// </summary>
+    public static class GetAssetHelper
+    {
+        [MenuItem("Assets/Get Asset Path", priority = 3)]
+        static void GetAssetPath()
+        {
+            UnityEngine.Object selObj = Selection.activeObject;
+
+            if (selObj != null)
+            {
+                string assetPath = AssetDatabase.GetAssetPath(selObj);
+                EditorGUIUtility.systemCopyBuffer = assetPath;
+                Debug.Log($"Asset path is {assetPath}");
+            }
+        }
+        
+        [MenuItem("Assets/Get Addressable Path", priority = 3)]
+        static void GetAddressablePath()
+        {
+            UnityEngine.Object selObj = Selection.activeObject;
+
+            if (selObj != null)
+            {
+                string assetPath = AssetDatabase.GetAssetPath(selObj);
+                var split = assetPath.Split('/');
+                var name = split.Last();
+                assetPath = name.Split('.').First();
+                EditorGUIUtility.systemCopyBuffer = assetPath;
+                Debug.Log($"Addressable path is {assetPath}");
+            }
+        }
+    }
+}

Assets/TEngine/Editor/Utility/GetAssetHelper.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: f55b5ab54785467dbd9bd2b5e46182ea
+timeCreated: 1680340111

Assets/TEngine/Editor/Utility/LogScriptingDefineSymbols.cs

@@ -0,0 +1,172 @@
+using UnityEditor;
+
+namespace TEngine.Editor
+{
+    /// <summary>
+    /// 日志脚本宏定义。
+    /// </summary>
+    public static class LogScriptingDefineSymbols
+    {
+        private const string EnableLogScriptingDefineSymbol = "ENABLE_LOG";
+        private const string EnableDebugAndAboveLogScriptingDefineSymbol = "ENABLE_DEBUG_AND_ABOVE_LOG";
+        private const string EnableInfoAndAboveLogScriptingDefineSymbol = "ENABLE_INFO_AND_ABOVE_LOG";
+        private const string EnableWarningAndAboveLogScriptingDefineSymbol = "ENABLE_WARNING_AND_ABOVE_LOG";
+        private const string EnableErrorAndAboveLogScriptingDefineSymbol = "ENABLE_ERROR_AND_ABOVE_LOG";
+        private const string EnableFatalAndAboveLogScriptingDefineSymbol = "ENABLE_FATAL_AND_ABOVE_LOG";
+        private const string EnableDebugLogScriptingDefineSymbol = "ENABLE_DEBUG_LOG";
+        private const string EnableInfoLogScriptingDefineSymbol = "ENABLE_INFO_LOG";
+        private const string EnableWarningLogScriptingDefineSymbol = "ENABLE_WARNING_LOG";
+        private const string EnableErrorLogScriptingDefineSymbol = "ENABLE_ERROR_LOG";
+        private const string EnableFatalLogScriptingDefineSymbol = "ENABLE_FATAL_LOG";
+
+        private static readonly string[] AboveLogScriptingDefineSymbols = new string[]
+        {
+            EnableDebugAndAboveLogScriptingDefineSymbol,
+            EnableInfoAndAboveLogScriptingDefineSymbol,
+            EnableWarningAndAboveLogScriptingDefineSymbol,
+            EnableErrorAndAboveLogScriptingDefineSymbol,
+            EnableFatalAndAboveLogScriptingDefineSymbol
+        };
+
+        private static readonly string[] SpecifyLogScriptingDefineSymbols = new string[]
+        {
+            EnableDebugLogScriptingDefineSymbol,
+            EnableInfoLogScriptingDefineSymbol,
+            EnableWarningLogScriptingDefineSymbol,
+            EnableErrorLogScriptingDefineSymbol,
+            EnableFatalLogScriptingDefineSymbol
+        };
+
+        /// <summary>
+        /// 禁用所有日志脚本宏定义。
+        /// </summary>
+        [MenuItem("Game Framework/Log Scripting Define Symbols/Disable All Logs", false, 30)]
+        public static void DisableAllLogs()
+        {
+            ScriptingDefineSymbols.RemoveScriptingDefineSymbol(EnableLogScriptingDefineSymbol);
+
+            foreach (string specifyLogScriptingDefineSymbol in SpecifyLogScriptingDefineSymbols)
+            {
+                ScriptingDefineSymbols.RemoveScriptingDefineSymbol(specifyLogScriptingDefineSymbol);
+            }
+
+            foreach (string aboveLogScriptingDefineSymbol in AboveLogScriptingDefineSymbols)
+            {
+                ScriptingDefineSymbols.RemoveScriptingDefineSymbol(aboveLogScriptingDefineSymbol);
+            }
+        }
+
+        /// <summary>
+        /// 开启所有日志脚本宏定义。
+        /// </summary>
+        [MenuItem("Game Framework/Log Scripting Define Symbols/Enable All Logs", false, 31)]
+        public static void EnableAllLogs()
+        {
+            DisableAllLogs();
+            ScriptingDefineSymbols.AddScriptingDefineSymbol(EnableLogScriptingDefineSymbol);
+        }
+
+        /// <summary>
+        /// 开启调试及以上级别的日志脚本宏定义。
+        /// </summary>
+        [MenuItem("Game Framework/Log Scripting Define Symbols/Enable Debug And Above Logs", false, 32)]
+        public static void EnableDebugAndAboveLogs()
+        {
+            SetAboveLogScriptingDefineSymbol(EnableDebugAndAboveLogScriptingDefineSymbol);
+        }
+
+        /// <summary>
+        /// 开启信息及以上级别的日志脚本宏定义。
+        /// </summary>
+        [MenuItem("Game Framework/Log Scripting Define Symbols/Enable Info And Above Logs", false, 33)]
+        public static void EnableInfoAndAboveLogs()
+        {
+            SetAboveLogScriptingDefineSymbol(EnableInfoAndAboveLogScriptingDefineSymbol);
+        }
+
+        /// <summary>
+        /// 开启警告及以上级别的日志脚本宏定义。
+        /// </summary>
+        [MenuItem("Game Framework/Log Scripting Define Symbols/Enable Warning And Above Logs", false, 34)]
+        public static void EnableWarningAndAboveLogs()
+        {
+            SetAboveLogScriptingDefineSymbol(EnableWarningAndAboveLogScriptingDefineSymbol);
+        }
+
+        /// <summary>
+        /// 开启错误及以上级别的日志脚本宏定义。
+        /// </summary>
+        [MenuItem("Game Framework/Log Scripting Define Symbols/Enable Error And Above Logs", false, 35)]
+        public static void EnableErrorAndAboveLogs()
+        {
+            SetAboveLogScriptingDefineSymbol(EnableErrorAndAboveLogScriptingDefineSymbol);
+        }
+
+        /// <summary>
+        /// 开启严重错误及以上级别的日志脚本宏定义。
+        /// </summary>
+        [MenuItem("Game Framework/Log Scripting Define Symbols/Enable Fatal And Above Logs", false, 36)]
+        public static void EnableFatalAndAboveLogs()
+        {
+            SetAboveLogScriptingDefineSymbol(EnableFatalAndAboveLogScriptingDefineSymbol);
+        }
+
+        /// <summary>
+        /// 设置日志脚本宏定义。
+        /// </summary>
+        /// <param name="aboveLogScriptingDefineSymbol">要设置的日志脚本宏定义。</param>
+        public static void SetAboveLogScriptingDefineSymbol(string aboveLogScriptingDefineSymbol)
+        {
+            if (string.IsNullOrEmpty(aboveLogScriptingDefineSymbol))
+            {
+                return;
+            }
+
+            foreach (string i in AboveLogScriptingDefineSymbols)
+            {
+                if (i == aboveLogScriptingDefineSymbol)
+                {
+                    DisableAllLogs();
+                    ScriptingDefineSymbols.AddScriptingDefineSymbol(aboveLogScriptingDefineSymbol);
+                    return;
+                }
+            }
+        }
+
+        /// <summary>
+        /// 设置日志脚本宏定义。
+        /// </summary>
+        /// <param name="specifyLogScriptingDefineSymbols">要设置的日志脚本宏定义。</param>
+        public static void SetSpecifyLogScriptingDefineSymbols(string[] specifyLogScriptingDefineSymbols)
+        {
+            if (specifyLogScriptingDefineSymbols == null || specifyLogScriptingDefineSymbols.Length <= 0)
+            {
+                return;
+            }
+
+            bool removed = false;
+            foreach (string specifyLogScriptingDefineSymbol in specifyLogScriptingDefineSymbols)
+            {
+                if (string.IsNullOrEmpty(specifyLogScriptingDefineSymbol))
+                {
+                    continue;
+                }
+
+                foreach (string i in SpecifyLogScriptingDefineSymbols)
+                {
+                    if (i == specifyLogScriptingDefineSymbol)
+                    {
+                        if (!removed)
+                        {
+                            removed = true;
+                            DisableAllLogs();
+                        }
+
+                        ScriptingDefineSymbols.AddScriptingDefineSymbol(specifyLogScriptingDefineSymbol);
+                        break;
+                    }
+                }
+            }
+        }
+    }
+}

Assets/TEngine/Editor/Utility/LogScriptingDefineSymbols.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 3e23fe1ee0074f3291860e98b7a6064a
+timeCreated: 1680338526

Assets/TEngine/Editor/Utility/OpenFolder.cs

@@ -0,0 +1,84 @@
+using TEngine;
+using System.Diagnostics;
+using UnityEditor;
+using UnityEngine;
+
+namespace TEngine.Editor
+{
+    /// <summary>
+    /// 打开文件夹相关的实用函数。
+    /// </summary>
+    public static class OpenFolder
+    {
+        /// <summary>
+        /// 打开 Data Path 文件夹。
+        /// </summary>
+        [MenuItem("Game Framework/Open Folder/Data Path", false, 10)]
+        public static void OpenFolderDataPath()
+        {
+            Execute(Application.dataPath);
+        }
+
+        /// <summary>
+        /// 打开 Persistent Data Path 文件夹。
+        /// </summary>
+        [MenuItem("Game Framework/Open Folder/Persistent Data Path", false, 11)]
+        public static void OpenFolderPersistentDataPath()
+        {
+            Execute(Application.persistentDataPath);
+        }
+
+        /// <summary>
+        /// 打开 Streaming Assets Path 文件夹。
+        /// </summary>
+        [MenuItem("Game Framework/Open Folder/Streaming Assets Path", false, 12)]
+        public static void OpenFolderStreamingAssetsPath()
+        {
+            Execute(Application.streamingAssetsPath);
+        }
+
+        /// <summary>
+        /// 打开 Temporary Cache Path 文件夹。
+        /// </summary>
+        [MenuItem("Game Framework/Open Folder/Temporary Cache Path", false, 13)]
+        public static void OpenFolderTemporaryCachePath()
+        {
+            Execute(Application.temporaryCachePath);
+        }
+
+#if UNITY_2018_3_OR_NEWER
+
+        /// <summary>
+        /// 打开 Console Log Path 文件夹。
+        /// </summary>
+        [MenuItem("Game Framework/Open Folder/Console Log Path", false, 14)]
+        public static void OpenFolderConsoleLogPath()
+        {
+            Execute(System.IO.Path.GetDirectoryName(Application.consoleLogPath));
+        }
+
+#endif
+
+        /// <summary>
+        /// 打开指定路径的文件夹。
+        /// </summary>
+        /// <param name="folder">要打开的文件夹的路径。</param>
+        public static void Execute(string folder)
+        {
+            folder = Utility.Text.Format("\"{0}\"", folder);
+            switch (Application.platform)
+            {
+                case RuntimePlatform.WindowsEditor:
+                    Process.Start("Explorer.exe", folder.Replace('/', '\\'));
+                    break;
+
+                case RuntimePlatform.OSXEditor:
+                    Process.Start("open", folder);
+                    break;
+
+                default:
+                    throw new GameFrameworkException(Utility.Text.Format("Not support open folder on '{0}' platform.", Application.platform));
+            }
+        }
+    }
+}

Assets/TEngine/Editor/Utility/OpenFolder.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: fad1fb9581db4034989ecc847f06ae09
+timeCreated: 1680338526

Assets/TEngine/Editor/Utility/ProfilerDefineSymbols.cs

@@ -0,0 +1,41 @@
+using UnityEditor;
+
+namespace TEngine.Editor
+{
+    public class ProfilerDefineSymbols
+    {
+        private const string EnableFirstProfiler = "FIRST_PROFILER";
+        private const string EnableDinProFiler = "DIN_PROFILER";
+        
+        private static readonly string[] AllProfilerDefineSymbols = new string[]
+        {
+            EnableFirstProfiler,
+            EnableDinProFiler,
+        };
+        
+        /// <summary>
+        /// 禁用所有日志脚本宏定义。
+        /// </summary>
+        [MenuItem("Game Framework/Profiler Define Symbols/Disable All Logs", false, 30)]
+        public static void DisableAllLogs()
+        {
+            foreach (string aboveLogScriptingDefineSymbol in AllProfilerDefineSymbols)
+            {
+                ScriptingDefineSymbols.RemoveScriptingDefineSymbol(aboveLogScriptingDefineSymbol);
+            }
+        }
+
+        /// <summary>
+        /// 开启所有日志脚本宏定义。
+        /// </summary>
+        [MenuItem("Game Framework/Profiler Define Symbols/Enable All Logs", false, 31)]
+        public static void EnableAllLogs()
+        {
+            DisableAllLogs();
+            foreach (string aboveLogScriptingDefineSymbol in AllProfilerDefineSymbols)
+            {
+                ScriptingDefineSymbols.AddScriptingDefineSymbol(aboveLogScriptingDefineSymbol);
+            }
+        }
+    }
+}

Assets/TEngine/Editor/Utility/ProfilerDefineSymbols.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 7b42362267f84f2c8926f1c48ddd900a
+timeCreated: 1680338526

Assets/TEngine/Editor/Utility/ScriptingDefineSymbols.cs

@@ -0,0 +1,150 @@
+using System.Collections.Generic;
+using UnityEditor;
+
+namespace TEngine.Editor
+{
+    /// <summary>
+    /// 脚本宏定义。
+    /// </summary>
+    public static class ScriptingDefineSymbols
+    {
+        private static readonly BuildTargetGroup[] BuildTargetGroups = new BuildTargetGroup[]
+        {
+            BuildTargetGroup.Standalone,
+            BuildTargetGroup.iOS,
+            BuildTargetGroup.Android,
+            BuildTargetGroup.WSA,
+            BuildTargetGroup.WebGL
+        };
+
+        /// <summary>
+        /// 检查指定平台是否存在指定的脚本宏定义。
+        /// </summary>
+        /// <param name="buildTargetGroup">要检查脚本宏定义的平台。</param>
+        /// <param name="scriptingDefineSymbol">要检查的脚本宏定义。</param>
+        /// <returns>指定平台是否存在指定的脚本宏定义。</returns>
+        public static bool HasScriptingDefineSymbol(BuildTargetGroup buildTargetGroup, string scriptingDefineSymbol)
+        {
+            if (string.IsNullOrEmpty(scriptingDefineSymbol))
+            {
+                return false;
+            }
+
+            string[] scriptingDefineSymbols = GetScriptingDefineSymbols(buildTargetGroup);
+            foreach (string i in scriptingDefineSymbols)
+            {
+                if (i == scriptingDefineSymbol)
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// 为指定平台增加指定的脚本宏定义。
+        /// </summary>
+        /// <param name="buildTargetGroup">要增加脚本宏定义的平台。</param>
+        /// <param name="scriptingDefineSymbol">要增加的脚本宏定义。</param>
+        public static void AddScriptingDefineSymbol(BuildTargetGroup buildTargetGroup, string scriptingDefineSymbol)
+        {
+            if (string.IsNullOrEmpty(scriptingDefineSymbol))
+            {
+                return;
+            }
+
+            if (HasScriptingDefineSymbol(buildTargetGroup, scriptingDefineSymbol))
+            {
+                return;
+            }
+
+            List<string> scriptingDefineSymbols = new List<string>(GetScriptingDefineSymbols(buildTargetGroup))
+            {
+                scriptingDefineSymbol
+            };
+
+            SetScriptingDefineSymbols(buildTargetGroup, scriptingDefineSymbols.ToArray());
+        }
+
+        /// <summary>
+        /// 为指定平台移除指定的脚本宏定义。
+        /// </summary>
+        /// <param name="buildTargetGroup">要移除脚本宏定义的平台。</param>
+        /// <param name="scriptingDefineSymbol">要移除的脚本宏定义。</param>
+        public static void RemoveScriptingDefineSymbol(BuildTargetGroup buildTargetGroup, string scriptingDefineSymbol)
+        {
+            if (string.IsNullOrEmpty(scriptingDefineSymbol))
+            {
+                return;
+            }
+
+            if (!HasScriptingDefineSymbol(buildTargetGroup, scriptingDefineSymbol))
+            {
+                return;
+            }
+
+            List<string> scriptingDefineSymbols = new List<string>(GetScriptingDefineSymbols(buildTargetGroup));
+            while (scriptingDefineSymbols.Contains(scriptingDefineSymbol))
+            {
+                scriptingDefineSymbols.Remove(scriptingDefineSymbol);
+            }
+
+            SetScriptingDefineSymbols(buildTargetGroup, scriptingDefineSymbols.ToArray());
+        }
+
+        /// <summary>
+        /// 为所有平台增加指定的脚本宏定义。
+        /// </summary>
+        /// <param name="scriptingDefineSymbol">要增加的脚本宏定义。</param>
+        public static void AddScriptingDefineSymbol(string scriptingDefineSymbol)
+        {
+            if (string.IsNullOrEmpty(scriptingDefineSymbol))
+            {
+                return;
+            }
+
+            foreach (BuildTargetGroup buildTargetGroup in BuildTargetGroups)
+            {
+                AddScriptingDefineSymbol(buildTargetGroup, scriptingDefineSymbol);
+            }
+        }
+
+        /// <summary>
+        /// 为所有平台移除指定的脚本宏定义。
+        /// </summary>
+        /// <param name="scriptingDefineSymbol">要移除的脚本宏定义。</param>
+        public static void RemoveScriptingDefineSymbol(string scriptingDefineSymbol)
+        {
+            if (string.IsNullOrEmpty(scriptingDefineSymbol))
+            {
+                return;
+            }
+
+            foreach (BuildTargetGroup buildTargetGroup in BuildTargetGroups)
+            {
+                RemoveScriptingDefineSymbol(buildTargetGroup, scriptingDefineSymbol);
+            }
+        }
+
+        /// <summary>
+        /// 获取指定平台的脚本宏定义。
+        /// </summary>
+        /// <param name="buildTargetGroup">要获取脚本宏定义的平台。</param>
+        /// <returns>平台的脚本宏定义。</returns>
+        public static string[] GetScriptingDefineSymbols(BuildTargetGroup buildTargetGroup)
+        {
+            return PlayerSettings.GetScriptingDefineSymbolsForGroup(buildTargetGroup).Split(';');
+        }
+
+        /// <summary>
+        /// 设置指定平台的脚本宏定义。
+        /// </summary>
+        /// <param name="buildTargetGroup">要设置脚本宏定义的平台。</param>
+        /// <param name="scriptingDefineSymbols">要设置的脚本宏定义。</param>
+        public static void SetScriptingDefineSymbols(BuildTargetGroup buildTargetGroup, string[] scriptingDefineSymbols)
+        {
+            PlayerSettings.SetScriptingDefineSymbolsForGroup(buildTargetGroup, string.Join(";", scriptingDefineSymbols));
+        }
+    }
+}

Assets/TEngine/Editor/Utility/ScriptingDefineSymbols.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 5a472e485b93472b941ca83f2d39181d
+timeCreated: 1680338526

Assets/TEngine/Editor/Utility/Type.cs

@@ -0,0 +1,129 @@
+using System.Collections.Generic;
+using System.Reflection;
+
+namespace TEngine.Editor
+{
+    /// <summary>
+    /// 类型相关的实用函数。
+    /// </summary>
+    internal static class Type
+    {
+        private static readonly string[] RuntimeAssemblyNames =
+        {
+            "TEngine.Runtime",
+            "Assembly-CSharp",
+            "GameMain.Runtime",
+
+            "GameBase",
+            "GameLogic",
+            "GameProto",
+            "BattleCore.Runtime",
+        };
+
+        private static readonly string[] RuntimeOrEditorAssemblyNames =
+        {
+            "TEngine.Runtime",
+            "Assembly-CSharp",
+            "TEngine.Editor",
+            "Assembly-CSharp-Editor",
+            "GameMain.Runtime",
+            "GameMain",
+            "GameMain.Editor",
+            "GameBase",
+            "GameLogic",
+            "GameProto",
+            "BattleCore.Runtime",
+        };
+
+        /// <summary>
+        /// 获取配置路径。
+        /// </summary>
+        /// <typeparam name="T">配置类型。</typeparam>
+        /// <returns>配置路径。</returns>
+        internal static string GetConfigurationPath<T>() where T : ConfigPathAttribute
+        {
+            foreach (System.Type type in Utility.Assembly.GetTypes())
+            {
+                if (!type.IsAbstract || !type.IsSealed)
+                {
+                    continue;
+                }
+
+                foreach (FieldInfo fieldInfo in type.GetFields(BindingFlags.Static | BindingFlags.Public |
+                                                               BindingFlags.NonPublic | BindingFlags.DeclaredOnly))
+                {
+                    if (fieldInfo.FieldType == typeof(string) && fieldInfo.IsDefined(typeof(T), false))
+                    {
+                        return (string)fieldInfo.GetValue(null);
+                    }
+                }
+
+                foreach (PropertyInfo propertyInfo in type.GetProperties(BindingFlags.Static | BindingFlags.Public |
+                                                                         BindingFlags.NonPublic |
+                                                                         BindingFlags.DeclaredOnly))
+                {
+                    if (propertyInfo.PropertyType == typeof(string) && propertyInfo.IsDefined(typeof(T), false))
+                    {
+                        return (string)propertyInfo.GetValue(null, null);
+                    }
+                }
+            }
+
+            return null;
+        }
+
+        /// <summary>
+        /// 在运行时程序集中获取指定基类的所有子类的名称。
+        /// </summary>
+        /// <param name="typeBase">基类类型。</param>
+        /// <returns>指定基类的所有子类的名称。</returns>
+        internal static string[] GetRuntimeTypeNames(System.Type typeBase)
+        {
+            return GetTypeNames(typeBase, RuntimeAssemblyNames);
+        }
+
+        /// <summary>
+        /// 在运行时或编辑器程序集中获取指定基类的所有子类的名称。
+        /// </summary>
+        /// <param name="typeBase">基类类型。</param>
+        /// <returns>指定基类的所有子类的名称。</returns>
+        internal static string[] GetRuntimeOrEditorTypeNames(System.Type typeBase)
+        {
+            return GetTypeNames(typeBase, RuntimeOrEditorAssemblyNames);
+        }
+
+        private static string[] GetTypeNames(System.Type typeBase, string[] assemblyNames)
+        {
+            List<string> typeNames = new List<string>();
+            foreach (string assemblyName in assemblyNames)
+            {
+                Assembly assembly = null;
+                try
+                {
+                    assembly = Assembly.Load(assemblyName);
+                }
+                catch
+                {
+                    continue;
+                }
+
+                if (assembly == null)
+                {
+                    continue;
+                }
+
+                System.Type[] types = assembly.GetTypes();
+                foreach (System.Type type in types)
+                {
+                    if (type.IsClass && !type.IsAbstract && typeBase.IsAssignableFrom(type))
+                    {
+                        typeNames.Add(type.FullName);
+                    }
+                }
+            }
+
+            typeNames.Sort();
+            return typeNames.ToArray();
+        }
+    }
+}

Assets/TEngine/Editor/Utility/Type.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: e9e03a1b8db74d8fb809ec83c6e72ca8
+timeCreated: 1680338526

Assets/TEngine/Runtime/BaseComponent.cs

@@ -0,0 +1,337 @@
+using System;
+using TEngine.Localization;
+using UnityEngine;
+
+namespace TEngine
+{
+    /// <summary>
+    /// 基础组件。
+    /// </summary>
+    [DisallowMultipleComponent]
+    [AddComponentMenu("Game Framework/Base")]
+    public sealed class BaseComponent : GameFrameworkComponent
+    {
+        private const int DefaultDpi = 96;  // default windows dpi
+
+        private float m_GameSpeedBeforePause = 1f;
+
+        [SerializeField]
+        private Language m_EditorLanguage = Language.Unspecified;
+
+        [SerializeField]
+        private string m_TextHelperTypeName = "TEngine.DefaultTextHelper";
+
+        [SerializeField]
+        private string m_VersionHelperTypeName = "TEngine.DefaultVersionHelper";
+
+        [SerializeField]
+        private string m_LogHelperTypeName = "TEngine.DefaultLogHelper";
+
+        [SerializeField]
+        private string m_CompressionHelperTypeName = "TEngine.DefaultCompressionHelper";
+
+        [SerializeField]
+        private string m_JsonHelperTypeName = "TEngine.DefaultJsonHelper";
+
+        [SerializeField]
+        private int m_FrameRate = 30;
+
+        [SerializeField]
+        private float m_GameSpeed = 1f;
+
+        [SerializeField]
+        private bool m_RunInBackground = true;
+
+        [SerializeField]
+        private bool m_NeverSleep = true;
+
+        /// <summary>
+        /// 获取或设置编辑器语言（仅编辑器内有效）。
+        /// </summary>
+        public Language EditorLanguage
+        {
+            get => m_EditorLanguage;
+            set => m_EditorLanguage = value;
+        }
+
+        /// <summary>
+        /// 获取或设置游戏帧率。
+        /// </summary>
+        public int FrameRate
+        {
+            get => m_FrameRate;
+            set => Application.targetFrameRate = m_FrameRate = value;
+        }
+
+        /// <summary>
+        /// 获取或设置游戏速度。
+        /// </summary>
+        public float GameSpeed
+        {
+            get => m_GameSpeed;
+            set => Time.timeScale = m_GameSpeed = value >= 0f ? value : 0f;
+        }
+
+        /// <summary>
+        /// 获取游戏是否暂停。
+        /// </summary>
+        public bool IsGamePaused => m_GameSpeed <= 0f;
+
+        /// <summary>
+        /// 获取是否正常游戏速度。
+        /// </summary>
+        public bool IsNormalGameSpeed => Math.Abs(m_GameSpeed - 1f) < 0.01f;
+
+        /// <summary>
+        /// 获取或设置是否允许后台运行。
+        /// </summary>
+        public bool RunInBackground
+        {
+            get => m_RunInBackground;
+            set => Application.runInBackground = m_RunInBackground = value;
+        }
+
+        /// <summary>
+        /// 获取或设置是否禁止休眠。
+        /// </summary>
+        public bool NeverSleep
+        {
+            get => m_NeverSleep;
+            set
+            {
+                m_NeverSleep = value;
+                Screen.sleepTimeout = value ? SleepTimeout.NeverSleep : SleepTimeout.SystemSetting;
+            }
+        }
+
+        /// <summary>
+        /// 游戏框架组件初始化。
+        /// </summary>
+        protected override void Awake()
+        {
+            base.Awake();
+
+            InitTextHelper();
+            InitVersionHelper();
+            InitLogHelper();
+            Log.Info("TEngine Version: {0}", TEngine.Version.GameFrameworkVersion);
+            Log.Info("Game Version: {0} ({1})", TEngine.Version.GameVersion, TEngine.Version.InternalGameVersion);
+            Log.Info("Unity Version: {0}", Application.unityVersion);
+
+            InitCompressionHelper();
+            InitJsonHelper();
+
+            Utility.Converter.ScreenDpi = Screen.dpi;
+            if (Utility.Converter.ScreenDpi <= 0)
+            {
+                Utility.Converter.ScreenDpi = DefaultDpi;
+            }
+            
+            Application.targetFrameRate = m_FrameRate;
+            Time.timeScale = m_GameSpeed;
+            Application.runInBackground = m_RunInBackground;
+            Screen.sleepTimeout = m_NeverSleep ? SleepTimeout.NeverSleep : SleepTimeout.SystemSetting;
+
+            Application.lowMemory += OnLowMemory;
+        }
+
+        private void Start()
+        {
+        }
+
+        private void Update()
+        {
+            GameFrameworkEntry.Update(Time.deltaTime, Time.unscaledDeltaTime);
+        }
+
+        private void OnApplicationQuit()
+        {
+            Application.lowMemory -= OnLowMemory;
+            StopAllCoroutines();
+        }
+
+        private void OnDestroy()
+        {
+            GameFrameworkEntry.Shutdown();
+        }
+
+        /// <summary>
+        /// 暂停游戏。
+        /// </summary>
+        public void PauseGame()
+        {
+            if (IsGamePaused)
+            {
+                return;
+            }
+
+            m_GameSpeedBeforePause = GameSpeed;
+            GameSpeed = 0f;
+        }
+
+        /// <summary>
+        /// 恢复游戏。
+        /// </summary>
+        public void ResumeGame()
+        {
+            if (!IsGamePaused)
+            {
+                return;
+            }
+
+            GameSpeed = m_GameSpeedBeforePause;
+        }
+
+        /// <summary>
+        /// 重置为正常游戏速度。
+        /// </summary>
+        public void ResetNormalGameSpeed()
+        {
+            if (IsNormalGameSpeed)
+            {
+                return;
+            }
+
+            GameSpeed = 1f;
+        }
+
+        internal void Shutdown()
+        {
+            Destroy(gameObject);
+        }
+
+        private void InitTextHelper()
+        {
+            if (string.IsNullOrEmpty(m_TextHelperTypeName))
+            {
+                return;
+            }
+
+            Type textHelperType = Utility.Assembly.GetType(m_TextHelperTypeName);
+            if (textHelperType == null)
+            {
+                Log.Error("Can not find text helper type '{0}'.", m_TextHelperTypeName);
+                return;
+            }
+
+            Utility.Text.ITextHelper textHelper = (Utility.Text.ITextHelper)Activator.CreateInstance(textHelperType);
+            if (textHelper == null)
+            {
+                Log.Error("Can not create text helper instance '{0}'.", m_TextHelperTypeName);
+                return;
+            }
+
+            Utility.Text.SetTextHelper(textHelper);
+        }
+
+        private void InitVersionHelper()
+        {
+            if (string.IsNullOrEmpty(m_VersionHelperTypeName))
+            {
+                return;
+            }
+
+            Type versionHelperType = Utility.Assembly.GetType(m_VersionHelperTypeName);
+            if (versionHelperType == null)
+            {
+                throw new GameFrameworkException(Utility.Text.Format("Can not find version helper type '{0}'.", m_VersionHelperTypeName));
+            }
+
+            TEngine.Version.IVersionHelper versionHelper = (TEngine.Version.IVersionHelper)Activator.CreateInstance(versionHelperType);
+            if (versionHelper == null)
+            {
+                throw new GameFrameworkException(Utility.Text.Format("Can not create version helper instance '{0}'.", m_VersionHelperTypeName));
+            }
+
+            TEngine.Version.SetVersionHelper(versionHelper);
+        }
+
+        private void InitLogHelper()
+        {
+            if (string.IsNullOrEmpty(m_LogHelperTypeName))
+            {
+                return;
+            }
+
+            Type logHelperType = Utility.Assembly.GetType(m_LogHelperTypeName);
+            if (logHelperType == null)
+            {
+                throw new GameFrameworkException(Utility.Text.Format("Can not find log helper type '{0}'.", m_LogHelperTypeName));
+            }
+
+            GameFrameworkLog.ILogHelper logHelper = (GameFrameworkLog.ILogHelper)Activator.CreateInstance(logHelperType);
+            if (logHelper == null)
+            {
+                throw new GameFrameworkException(Utility.Text.Format("Can not create log helper instance '{0}'.", m_LogHelperTypeName));
+            }
+
+            GameFrameworkLog.SetLogHelper(logHelper);
+        }
+
+        private void InitCompressionHelper()
+        {
+            if (string.IsNullOrEmpty(m_CompressionHelperTypeName))
+            {
+                return;
+            }
+
+            Type compressionHelperType = Utility.Assembly.GetType(m_CompressionHelperTypeName);
+            if (compressionHelperType == null)
+            {
+                Log.Error("Can not find compression helper type '{0}'.", m_CompressionHelperTypeName);
+                return;
+            }
+
+            Utility.Compression.ICompressionHelper compressionHelper = (Utility.Compression.ICompressionHelper)Activator.CreateInstance(compressionHelperType);
+            if (compressionHelper == null)
+            {
+                Log.Error("Can not create compression helper instance '{0}'.", m_CompressionHelperTypeName);
+                return;
+            }
+
+            Utility.Compression.SetCompressionHelper(compressionHelper);
+        }
+
+        private void InitJsonHelper()
+        {
+            if (string.IsNullOrEmpty(m_JsonHelperTypeName))
+            {
+                return;
+            }
+
+            Type jsonHelperType = Utility.Assembly.GetType(m_JsonHelperTypeName);
+            if (jsonHelperType == null)
+            {
+                Log.Error("Can not find JSON helper type '{0}'.", m_JsonHelperTypeName);
+                return;
+            }
+
+            Utility.Json.IJsonHelper jsonHelper = (Utility.Json.IJsonHelper)Activator.CreateInstance(jsonHelperType);
+            if (jsonHelper == null)
+            {
+                Log.Error("Can not create JSON helper instance '{0}'.", m_JsonHelperTypeName);
+                return;
+            }
+
+            Utility.Json.SetJsonHelper(jsonHelper);
+        }
+
+        private void OnLowMemory()
+        {
+            Log.Info("Low memory reported...");
+
+            //TODO 
+            /*ObjectPoolComponent objectPoolComponent = GameEntry.GetComponent<ObjectPoolComponent>();
+            if (objectPoolComponent != null)
+            {
+                objectPoolComponent.ReleaseAllUnused();
+            }
+
+            ResourceComponent resourceComponent = GameEntry.GetComponent<ResourceComponent>();
+            if (resourceComponent != null)
+            {
+                resourceComponent.ForceUnloadUnusedAssets(true);
+            }*/
+        }
+    }
+}

Assets/TEngine/Runtime/BaseComponent.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 564a45007d8645cf96d33bb52471acd5
+timeCreated: 1680337824

Assets/TEngine/Runtime/GameFramework/GameEntry.cs

@@ -0,0 +1,139 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.SceneManagement;
+
+namespace TEngine
+{
+    /// <summary>
+    /// 游戏入口。
+    /// </summary>
+    public static class GameEntry
+    {
+        private static readonly GameFrameworkLinkedList<GameFrameworkComponent> s_GameFrameworkComponents = new GameFrameworkLinkedList<GameFrameworkComponent>();
+
+        /// <summary>
+        /// 游戏框架所在的场景编号。
+        /// </summary>
+        internal const int GameFrameworkSceneId = 0;
+
+        /// <summary>
+        /// 获取游戏框架组件。
+        /// </summary>
+        /// <typeparam name="T">要获取的游戏框架组件类型。</typeparam>
+        /// <returns>要获取的游戏框架组件。</returns>
+        public static T GetComponent<T>() where T : GameFrameworkComponent
+        {
+            return (T)GetComponent(typeof(T));
+        }
+
+        /// <summary>
+        /// 获取游戏框架组件。
+        /// </summary>
+        /// <param name="type">要获取的游戏框架组件类型。</param>
+        /// <returns>要获取的游戏框架组件。</returns>
+        public static GameFrameworkComponent GetComponent(Type type)
+        {
+            LinkedListNode<GameFrameworkComponent> current = s_GameFrameworkComponents.First;
+            while (current != null)
+            {
+                if (current.Value.GetType() == type)
+                {
+                    return current.Value;
+                }
+
+                current = current.Next;
+            }
+
+            return null;
+        }
+
+        /// <summary>
+        /// 获取游戏框架组件。
+        /// </summary>
+        /// <param name="typeName">要获取的游戏框架组件类型名称。</param>
+        /// <returns>要获取的游戏框架组件。</returns>
+        public static GameFrameworkComponent GetComponent(string typeName)
+        {
+            LinkedListNode<GameFrameworkComponent> current = s_GameFrameworkComponents.First;
+            while (current != null)
+            {
+                Type type = current.Value.GetType();
+                if (type.FullName == typeName || type.Name == typeName)
+                {
+                    return current.Value;
+                }
+
+                current = current.Next;
+            }
+
+            return null;
+        }
+
+        /// <summary>
+        /// 关闭游戏框架。
+        /// </summary>
+        /// <param name="shutdownType">关闭游戏框架类型。</param>
+        public static void Shutdown(ShutdownType shutdownType)
+        {
+            Log.Info("Shutdown Game Framework ({0})...", shutdownType);
+            Utility.Unity.Release();
+            BaseComponent baseComponent = GetComponent<BaseComponent>();
+            if (baseComponent != null)
+            {
+                baseComponent.Shutdown();
+                baseComponent = null;
+            }
+
+            s_GameFrameworkComponents.Clear();
+
+            if (shutdownType == ShutdownType.None)
+            {
+                return;
+            }
+
+            if (shutdownType == ShutdownType.Restart)
+            {
+                SceneManager.LoadScene(GameFrameworkSceneId);
+                return;
+            }
+
+            if (shutdownType == ShutdownType.Quit)
+            {
+                Application.Quit();
+#if UNITY_EDITOR
+                UnityEditor.EditorApplication.isPlaying = false;
+#endif
+            }
+        }
+
+        /// <summary>
+        /// 注册游戏框架组件。
+        /// </summary>
+        /// <param name="gameFrameworkComponent">要注册的游戏框架组件。</param>
+        internal static void RegisterComponent(GameFrameworkComponent gameFrameworkComponent)
+        {
+            if (gameFrameworkComponent == null)
+            {
+                Log.Error("Game Framework component is invalid.");
+                return;
+            }
+
+            Type type = gameFrameworkComponent.GetType();
+
+            LinkedListNode<GameFrameworkComponent> current = s_GameFrameworkComponents.First;
+            while (current != null)
+            {
+                if (current.Value.GetType() == type)
+                {
+                    Log.Error("Game Framework component type '{0}' is already exist.", type.FullName);
+                    return;
+                }
+
+                current = current.Next;
+            }
+
+            s_GameFrameworkComponents.AddLast(gameFrameworkComponent);
+        }
+    }
+}

Assets/TEngine/Runtime/GameFramework/GameEntry.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 6d39a8de0dec418eba1ee81fefd4d5a5
+timeCreated: 1680338130

Assets/TEngine/Runtime/GameFramework/GameFrameworkComponent.cs

@@ -0,0 +1,18 @@
+using UnityEngine;
+
+namespace TEngine
+{
+    /// <summary>
+    /// 游戏框架组件抽象类。
+    /// </summary>
+    public abstract class GameFrameworkComponent : MonoBehaviour
+    {
+        /// <summary>
+        /// 游戏框架组件初始化。
+        /// </summary>
+        protected virtual void Awake()
+        {
+            GameEntry.RegisterComponent(this);
+        }
+    }
+}

Assets/TEngine/Runtime/GameFramework/GameFrameworkComponent.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 98aa729dea5649998b96191597d5af36
+timeCreated: 1680338130

Assets/TEngine/Runtime/GameFramework/Log/GameFrameworkLog.cs

@@ -5,7 +5,7 @@
     /// </summary>
     public static partial class GameFrameworkLog
     {
-        private static ILogHelper s_LogHelper = new TEngineLogHelper();
+        private static ILogHelper s_LogHelper;
 
         /// <summary>
         /// 设置游戏框架日志辅助器。

Assets/TEngine/Runtime/GameFramework/ShutdownType.cs

@@ -0,0 +1,23 @@
+namespace TEngine
+{
+    /// <summary>
+    /// 关闭游戏框架类型。
+    /// </summary>
+    public enum ShutdownType : byte
+    {
+        /// <summary>
+        /// 仅关闭游戏框架。
+        /// </summary>
+        None = 0,
+
+        /// <summary>
+        /// 关闭游戏框架并重启游戏。
+        /// </summary>
+        Restart,
+
+        /// <summary>
+        /// 关闭游戏框架并退出游戏。
+        /// </summary>
+        Quit,
+    }
+}

Assets/TEngine/Runtime/GameFramework/ShutdownType.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: a91e41b944ca4ac986dbf17b39ac44db
+timeCreated: 1680337945

Assets/TEngine/Runtime/GameFramework/Utility.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 4768a00bcf9cf9d4197da234b968867c
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TEngine/Runtime/Localization.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 93974dec76d94627817ea711a60ef9c4
+timeCreated: 1680337861

Assets/TEngine/Runtime/Localization/Language.cs

@@ -0,0 +1,263 @@
+namespace TEngine.Localization
+{
+    /// <summary>
+    /// 本地化语言。
+    /// </summary>
+    public enum Language : byte
+    {
+        /// <summary>
+        /// 未指定。
+        /// </summary>
+        Unspecified = 0,
+
+        /// <summary>
+        /// 南非荷兰语。
+        /// </summary>
+        Afrikaans,
+
+        /// <summary>
+        /// 阿尔巴尼亚语。
+        /// </summary>
+        Albanian,
+
+        /// <summary>
+        /// 阿拉伯语。
+        /// </summary>
+        Arabic,
+
+        /// <summary>
+        /// 巴斯克语。
+        /// </summary>
+        Basque,
+
+        /// <summary>
+        /// 白俄罗斯语。
+        /// </summary>
+        Belarusian,
+
+        /// <summary>
+        /// 保加利亚语。
+        /// </summary>
+        Bulgarian,
+
+        /// <summary>
+        /// 加泰罗尼亚语。
+        /// </summary>
+        Catalan,
+
+        /// <summary>
+        /// 简体中文。
+        /// </summary>
+        ChineseSimplified,
+
+        /// <summary>
+        /// 繁体中文。
+        /// </summary>
+        ChineseTraditional,
+
+        /// <summary>
+        /// 克罗地亚语。
+        /// </summary>
+        Croatian,
+
+        /// <summary>
+        /// 捷克语。
+        /// </summary>
+        Czech,
+
+        /// <summary>
+        /// 丹麦语。
+        /// </summary>
+        Danish,
+
+        /// <summary>
+        /// 荷兰语。
+        /// </summary>
+        Dutch,
+
+        /// <summary>
+        /// 英语。
+        /// </summary>
+        English,
+
+        /// <summary>
+        /// 爱沙尼亚语。
+        /// </summary>
+        Estonian,
+
+        /// <summary>
+        /// 法罗语。
+        /// </summary>
+        Faroese,
+
+        /// <summary>
+        /// 芬兰语。
+        /// </summary>
+        Finnish,
+
+        /// <summary>
+        /// 法语。
+        /// </summary>
+        French,
+
+        /// <summary>
+        /// 格鲁吉亚语。
+        /// </summary>
+        Georgian,
+
+        /// <summary>
+        /// 德语。
+        /// </summary>
+        German,
+
+        /// <summary>
+        /// 希腊语。
+        /// </summary>
+        Greek,
+
+        /// <summary>
+        /// 希伯来语。
+        /// </summary>
+        Hebrew,
+
+        /// <summary>
+        /// 匈牙利语。
+        /// </summary>
+        Hungarian,
+
+        /// <summary>
+        /// 冰岛语。
+        /// </summary>
+        Icelandic,
+
+        /// <summary>
+        /// 印尼语。
+        /// </summary>
+        Indonesian,
+
+        /// <summary>
+        /// 意大利语。
+        /// </summary>
+        Italian,
+
+        /// <summary>
+        /// 日语。
+        /// </summary>
+        Japanese,
+
+        /// <summary>
+        /// 韩语。
+        /// </summary>
+        Korean,
+
+        /// <summary>
+        /// 拉脱维亚语。
+        /// </summary>
+        Latvian,
+
+        /// <summary>
+        /// 立陶宛语。
+        /// </summary>
+        Lithuanian,
+
+        /// <summary>
+        /// 马其顿语。
+        /// </summary>
+        Macedonian,
+
+        /// <summary>
+        /// 马拉雅拉姆语。
+        /// </summary>
+        Malayalam,
+
+        /// <summary>
+        /// 挪威语。
+        /// </summary>
+        Norwegian,
+
+        /// <summary>
+        /// 波斯语。
+        /// </summary>
+        Persian,
+
+        /// <summary>
+        /// 波兰语。
+        /// </summary>
+        Polish,
+
+        /// <summary>
+        /// 巴西葡萄牙语。
+        /// </summary>
+        PortugueseBrazil,
+
+        /// <summary>
+        /// 葡萄牙语。
+        /// </summary>
+        PortuguesePortugal,
+
+        /// <summary>
+        /// 罗马尼亚语。
+        /// </summary>
+        Romanian,
+
+        /// <summary>
+        /// 俄语。
+        /// </summary>
+        Russian,
+
+        /// <summary>
+        /// 塞尔维亚克罗地亚语。
+        /// </summary>
+        SerboCroatian,
+
+        /// <summary>
+        /// 塞尔维亚西里尔语。
+        /// </summary>
+        SerbianCyrillic,
+
+        /// <summary>
+        /// 塞尔维亚拉丁语。
+        /// </summary>
+        SerbianLatin,
+
+        /// <summary>
+        /// 斯洛伐克语。
+        /// </summary>
+        Slovak,
+
+        /// <summary>
+        /// 斯洛文尼亚语。
+        /// </summary>
+        Slovenian,
+
+        /// <summary>
+        /// 西班牙语。
+        /// </summary>
+        Spanish,
+
+        /// <summary>
+        /// 瑞典语。
+        /// </summary>
+        Swedish,
+
+        /// <summary>
+        /// 泰语。
+        /// </summary>
+        Thai,
+
+        /// <summary>
+        /// 土耳其语。
+        /// </summary>
+        Turkish,
+
+        /// <summary>
+        /// 乌克兰语。
+        /// </summary>
+        Ukrainian,
+
+        /// <summary>
+        /// 越南语。
+        /// </summary>
+        Vietnamese
+    }
+}

Assets/TEngine/Runtime/Localization/Language.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 0b84caf139f3426a9e3adb7f015982c4
+timeCreated: 1680337879

Assets/TEngine/Runtime/Utility.meta

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: 4768a00bcf9cf9d4197da234b968867c
+guid: a8abc344e7b1e7040b2979eda41978e1
 folderAsset: yes
 DefaultImporter:
   externalObjects: {}

Assets/TEngine/Runtime/Utility/BinaryExtension.cs

@@ -0,0 +1,185 @@
+using System;
+using System.IO;
+using TEngine;
+
+/// <summary>
+/// 对 BinaryReader 和 BinaryWriter 的扩展方法。
+/// </summary>
+public static class BinaryExtension
+{
+    private static readonly byte[] s_CachedBytes = new byte[byte.MaxValue + 1];
+
+    /// <summary>
+    /// 从二进制流读取编码后的 32 位有符号整数。
+    /// </summary>
+    /// <param name="binaryReader">要读取的二进制流。</param>
+    /// <returns>读取的 32 位有符号整数。</returns>
+    public static int Read7BitEncodedInt32(this BinaryReader binaryReader)
+    {
+        int value = 0;
+        int shift = 0;
+        byte b;
+        do
+        {
+            if (shift >= 35)
+            {
+                throw new GameFrameworkException("7 bit encoded int is invalid.");
+            }
+
+            b = binaryReader.ReadByte();
+            value |= (b & 0x7f) << shift;
+            shift += 7;
+        } while ((b & 0x80) != 0);
+
+        return value;
+    }
+
+    /// <summary>
+    /// 向二进制流写入编码后的 32 位有符号整数。
+    /// </summary>
+    /// <param name="binaryWriter">要写入的二进制流。</param>
+    /// <param name="value">要写入的 32 位有符号整数。</param>
+    public static void Write7BitEncodedInt32(this BinaryWriter binaryWriter, int value)
+    {
+        uint num = (uint)value;
+        while (num >= 0x80)
+        {
+            binaryWriter.Write((byte)(num | 0x80));
+            num >>= 7;
+        }
+
+        binaryWriter.Write((byte)num);
+    }
+
+    /// <summary>
+    /// 从二进制流读取编码后的 32 位无符号整数。
+    /// </summary>
+    /// <param name="binaryReader">要读取的二进制流。</param>
+    /// <returns>读取的 32 位无符号整数。</returns>
+    public static uint Read7BitEncodedUInt32(this BinaryReader binaryReader)
+    {
+        return (uint)Read7BitEncodedInt32(binaryReader);
+    }
+
+    /// <summary>
+    /// 向二进制流写入编码后的 32 位无符号整数。
+    /// </summary>
+    /// <param name="binaryWriter">要写入的二进制流。</param>
+    /// <param name="value">要写入的 32 位无符号整数。</param>
+    public static void Write7BitEncodedUInt32(this BinaryWriter binaryWriter, uint value)
+    {
+        Write7BitEncodedInt32(binaryWriter, (int)value);
+    }
+
+    /// <summary>
+    /// 从二进制流读取编码后的 64 位有符号整数。
+    /// </summary>
+    /// <param name="binaryReader">要读取的二进制流。</param>
+    /// <returns>读取的 64 位有符号整数。</returns>
+    public static long Read7BitEncodedInt64(this BinaryReader binaryReader)
+    {
+        long value = 0L;
+        int shift = 0;
+        byte b;
+        do
+        {
+            if (shift >= 70)
+            {
+                throw new GameFrameworkException("7 bit encoded int is invalid.");
+            }
+
+            b = binaryReader.ReadByte();
+            value |= (b & 0x7fL) << shift;
+            shift += 7;
+        } while ((b & 0x80) != 0);
+
+        return value;
+    }
+
+    /// <summary>
+    /// 向二进制流写入编码后的 64 位有符号整数。
+    /// </summary>
+    /// <param name="binaryWriter">要写入的二进制流。</param>
+    /// <param name="value">要写入的 64 位有符号整数。</param>
+    public static void Write7BitEncodedInt64(this BinaryWriter binaryWriter, long value)
+    {
+        ulong num = (ulong)value;
+        while (num >= 0x80)
+        {
+            binaryWriter.Write((byte)(num | 0x80));
+            num >>= 7;
+        }
+
+        binaryWriter.Write((byte)num);
+    }
+
+    /// <summary>
+    /// 从二进制流读取编码后的 64 位无符号整数。
+    /// </summary>
+    /// <param name="binaryReader">要读取的二进制流。</param>
+    /// <returns>读取的 64 位无符号整数。</returns>
+    public static ulong Read7BitEncodedUInt64(this BinaryReader binaryReader)
+    {
+        return (ulong)Read7BitEncodedInt64(binaryReader);
+    }
+
+    /// <summary>
+    /// 向二进制流写入编码后的 64 位无符号整数。
+    /// </summary>
+    /// <param name="binaryWriter">要写入的二进制流。</param>
+    /// <param name="value">要写入的 64 位无符号整数。</param>
+    public static void Write7BitEncodedUInt64(this BinaryWriter binaryWriter, ulong value)
+    {
+        Write7BitEncodedInt64(binaryWriter, (long)value);
+    }
+
+    /// <summary>
+    /// 从二进制流读取加密字符串。
+    /// </summary>
+    /// <param name="binaryReader">要读取的二进制流。</param>
+    /// <param name="encryptBytes">密钥数组。</param>
+    /// <returns>读取的字符串。</returns>
+    public static string ReadEncryptedString(this BinaryReader binaryReader, byte[] encryptBytes)
+    {
+        byte length = binaryReader.ReadByte();
+        if (length <= 0)
+        {
+            return null;
+        }
+
+        for (byte i = 0; i < length; i++)
+        {
+            s_CachedBytes[i] = binaryReader.ReadByte();
+        }
+
+        Utility.Encryption.GetSelfXorBytes(s_CachedBytes, 0, length, encryptBytes);
+        string value = Utility.Converter.GetString(s_CachedBytes, 0, length);
+        Array.Clear(s_CachedBytes, 0, length);
+        return value;
+    }
+
+    /// <summary>
+    /// 向二进制流写入加密字符串。
+    /// </summary>
+    /// <param name="binaryWriter">要写入的二进制流。</param>
+    /// <param name="value">要写入的字符串。</param>
+    /// <param name="encryptBytes">密钥数组。</param>
+    public static void WriteEncryptedString(this BinaryWriter binaryWriter, string value, byte[] encryptBytes)
+    {
+        if (string.IsNullOrEmpty(value))
+        {
+            binaryWriter.Write((byte)0);
+            return;
+        }
+
+        int length = Utility.Converter.GetBytes(value, s_CachedBytes);
+        if (length > byte.MaxValue)
+        {
+            throw new GameFrameworkException(Utility.Text.Format("String '{0}' is too long.", value));
+        }
+
+        Utility.Encryption.GetSelfXorBytes(s_CachedBytes, encryptBytes);
+        binaryWriter.Write((byte)length);
+        binaryWriter.Write(s_CachedBytes, 0, length);
+    }
+}

Assets/TEngine/Runtime/Utility/BinaryExtension.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: eb8959e3dd580774a9d8e581c16ed6ab
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TEngine/Runtime/Utility/DUnityUtil.cs

@@ -0,0 +1,248 @@
+using System;
+using System.Collections.Generic;
+using System.Text.RegularExpressions;
+using UnityEngine;
+using UnityEngineInternal;
+
+namespace TEngine
+{
+    /// <summary>
+    /// Unity关的实用函数。
+    /// </summary>
+    public static class DUnityUtil
+    {
+        [TypeInferenceRule(TypeInferenceRules.TypeReferencedByFirstArgument)]
+        public static Component AddMonoBehaviour(Type type, GameObject go)
+        {
+            var comp = go.GetComponent(type);
+            if (comp == null)
+            {
+                comp = go.AddComponent(type);
+            }
+
+            return comp;
+        }
+
+        public static T AddMonoBehaviour<T>(Component comp) where T : Component
+        {
+
+            var ret = comp.GetComponent<T>();
+            if (ret == null)
+            {
+                ret = comp.gameObject.AddComponent<T>();
+            }
+
+            return ret;
+        }
+
+        public static T AddMonoBehaviour<T>(GameObject go) where T : Component
+        {
+            var comp = go.GetComponent<T>();
+            if (comp == null)
+            {
+                comp = go.AddComponent<T>();
+            }
+
+            return comp;
+        }
+
+        [TypeInferenceRule(TypeInferenceRules.TypeReferencedByFirstArgument)]
+        public static void RmvMonoBehaviour(Type type, GameObject go)
+        {
+            var comp = go.GetComponent(type);
+            if (comp != null)
+            {
+                UnityEngine.Object.Destroy(comp);
+            }
+        }
+
+        public static void RmvMonoBehaviour<T>(GameObject go) where T : Component
+        {
+            var comp = go.GetComponent<T>();
+            if (comp != null)
+            {
+                UnityEngine.Object.Destroy(comp);
+            }
+        }
+
+
+        public static Transform FindChild(Transform transform, string path)
+        {
+            var findTrans = transform.Find(path);
+            if (findTrans != null)
+            {
+                return findTrans;
+            }
+
+            return null;
+        }
+
+        /// <summary>
+        /// 根据名字找到子节点，主要用于dummy接口
+        /// </summary>
+        /// <param name="transform"></param>
+        /// <param name="name"></param>
+        /// <returns></returns>
+        public static Transform FindChildByName(Transform transform, string name)
+        {
+            if (transform == null)
+            {
+                return null;
+            }
+
+            for (int i = 0; i < transform.childCount; i++)
+            {
+                var childTrans = transform.GetChild(i);
+                if (childTrans.name == name)
+                {
+                    return childTrans;
+                }
+
+                var find = FindChildByName(childTrans, name);
+                if (find != null)
+                {
+                    return find;
+                }
+            }
+
+            return null;
+        }
+
+        [TypeInferenceRule(TypeInferenceRules.TypeReferencedByFirstArgument)]
+        public static Component FindChildComponent(Type type, Transform transform, string path)
+        {
+            var findTrans = transform.Find(path);
+            if (findTrans != null)
+            {
+                return findTrans.gameObject.GetComponent(type);
+            }
+
+            return null;
+        }
+        
+        public static T FindChildComponent<T>(Transform transform, string path) where T : Component
+        {
+            var findTrans = transform.Find(path);
+            if (findTrans != null)
+            {
+                return findTrans.gameObject.GetComponent<T>();
+            }
+
+            return null;
+        }
+
+        public static void SetLayer(GameObject go, int layer)
+        {
+            if (go == null)
+            {
+                return;
+            }
+            SetLayer(go.transform, layer);
+        }
+
+        public static void SetLayer(Transform trans, int layer)
+        {
+            if (trans == null)
+            {
+                return;
+            }
+            trans.gameObject.layer = layer;
+            for (int i = 0, imax = trans.childCount; i < imax; ++i)
+            {
+                Transform child = trans.GetChild(i);
+                SetLayer(child, layer);
+            }
+        }
+
+        public static int RandomRangeInt(int min, int max)
+        {
+            return UnityEngine.Random.Range(min, max);
+        }
+
+        public static float RandomRangeFloat(float min, float max)
+        {
+            return UnityEngine.Random.Range(min, max);
+        }
+
+        public static Vector2 RandomInsideCircle(float radius)
+        {
+            return UnityEngine.Random.insideUnitCircle * radius;
+        }
+
+        [TypeInferenceRule(TypeInferenceRules.TypeReferencedByFirstArgument)]
+        public static Array CreateUnityArray(Type type, int length)
+        {
+            return Array.CreateInstance(type, length);
+        }
+
+        public static T[] CreateUnityArray<T>(int length)
+        {
+            return new T[length];
+        }
+
+
+        public static GameObject Instantiate(GameObject go)
+        {
+            if (go != null)
+            {
+                return UnityEngine.Object.Instantiate(go);
+            }
+            
+            return null;
+        }
+
+        public static bool Raycast(Ray ray, out RaycastHit hitInfo, float maxDistance, int layerMask)
+        {
+            return Physics.Raycast(ray, out hitInfo, maxDistance, layerMask);
+        }
+
+        public static List<string> GetRegexMatchGroups(string pattern,string input)
+        {
+            List<string> list=new List<string>();
+            var regexLink = new Regex(pattern);
+            var links = regexLink.Match(input);
+            for (var i = 0; i < links.Groups.Count; ++i)
+            {
+                list.Add(links.Groups[i].Value);
+            }
+            return list;
+        }
+
+        public static void SetMaterialVector3(Material mat, int nameId, Vector3 val)
+        {
+            mat.SetVector(nameId, val);
+        }
+
+        public static void GetVectorData(Vector3 val, out float x, out float y, out float z)
+        {
+            x = val.x;
+            y = val.y;
+            z = val.z;
+        }
+        public static void GetVector2Data(Vector2 val, out float x, out float y)
+        {
+            x = val.x;
+            y = val.y;
+        }
+
+        public static bool GetTouchByFingerId(int fingerId, out Touch findTouch)
+        {
+            var find = false;
+            var touchCnt = Input.touchCount;
+
+            findTouch = new Touch();
+            for (int i = 0; i < touchCnt; i++)
+            {
+                var touch = Input.GetTouch(i);
+                if (touch.fingerId == fingerId)
+                {
+                    findTouch = touch;
+                    find = true;
+                    break;
+                }
+            }
+
+            return find;
+        }
+    }
+}

Assets/TEngine/Runtime/Utility/DUnityUtil.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 611c6fdc692b48645b80bf4aa915be32
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TEngine/Runtime/Utility/DefaultCompressionHelper.cs

@@ -0,0 +1,204 @@
+using ICSharpCode.SharpZipLib.GZip;
+using System;
+using System.IO;
+
+namespace TEngine
+{
+    /// <summary>
+    /// 默认压缩解压缩辅助器。
+    /// </summary>
+    public class DefaultCompressionHelper : Utility.Compression.ICompressionHelper
+    {
+        private const int CachedBytesLength = 0x1000;
+        private readonly byte[] m_CachedBytes = new byte[CachedBytesLength];
+
+        /// <summary>
+        /// 压缩数据。
+        /// </summary>
+        /// <param name="bytes">要压缩的数据的二进制流。</param>
+        /// <param name="offset">要压缩的数据的二进制流的偏移。</param>
+        /// <param name="length">要压缩的数据的二进制流的长度。</param>
+        /// <param name="compressedStream">压缩后的数据的二进制流。</param>
+        /// <returns>是否压缩数据成功。</returns>
+        public bool Compress(byte[] bytes, int offset, int length, Stream compressedStream)
+        {
+            if (bytes == null)
+            {
+                return false;
+            }
+
+            if (offset < 0 || length < 0 || offset + length > bytes.Length)
+            {
+                return false;
+            }
+
+            if (compressedStream == null)
+            {
+                return false;
+            }
+
+            try
+            {
+                GZipOutputStream gZipOutputStream = new GZipOutputStream(compressedStream);
+                gZipOutputStream.Write(bytes, offset, length);
+                gZipOutputStream.Finish();
+                ProcessHeader(compressedStream);
+                return true;
+            }
+            catch
+            {
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// 压缩数据。
+        /// </summary>
+        /// <param name="stream">要压缩的数据的二进制流。</param>
+        /// <param name="compressedStream">压缩后的数据的二进制流。</param>
+        /// <returns>是否压缩数据成功。</returns>
+        public bool Compress(Stream stream, Stream compressedStream)
+        {
+            if (stream == null)
+            {
+                return false;
+            }
+
+            if (compressedStream == null)
+            {
+                return false;
+            }
+
+            try
+            {
+                GZipOutputStream gZipOutputStream = new GZipOutputStream(compressedStream);
+                int bytesRead = 0;
+                while ((bytesRead = stream.Read(m_CachedBytes, 0, CachedBytesLength)) > 0)
+                {
+                    gZipOutputStream.Write(m_CachedBytes, 0, bytesRead);
+                }
+
+                gZipOutputStream.Finish();
+                ProcessHeader(compressedStream);
+                return true;
+            }
+            catch
+            {
+                return false;
+            }
+            finally
+            {
+                Array.Clear(m_CachedBytes, 0, CachedBytesLength);
+            }
+        }
+
+        /// <summary>
+        /// 解压缩数据。
+        /// </summary>
+        /// <param name="bytes">要解压缩的数据的二进制流。</param>
+        /// <param name="offset">要解压缩的数据的二进制流的偏移。</param>
+        /// <param name="length">要解压缩的数据的二进制流的长度。</param>
+        /// <param name="decompressedStream">解压缩后的数据的二进制流。</param>
+        /// <returns>是否解压缩数据成功。</returns>
+        public bool Decompress(byte[] bytes, int offset, int length, Stream decompressedStream)
+        {
+            if (bytes == null)
+            {
+                return false;
+            }
+
+            if (offset < 0 || length < 0 || offset + length > bytes.Length)
+            {
+                return false;
+            }
+
+            if (decompressedStream == null)
+            {
+                return false;
+            }
+
+            MemoryStream memoryStream = null;
+            try
+            {
+                memoryStream = new MemoryStream(bytes, offset, length, false);
+                using (GZipInputStream gZipInputStream = new GZipInputStream(memoryStream))
+                {
+                    int bytesRead = 0;
+                    while ((bytesRead = gZipInputStream.Read(m_CachedBytes, 0, CachedBytesLength)) > 0)
+                    {
+                        decompressedStream.Write(m_CachedBytes, 0, bytesRead);
+                    }
+                }
+
+                return true;
+            }
+            catch
+            {
+                return false;
+            }
+            finally
+            {
+                if (memoryStream != null)
+                {
+                    memoryStream.Dispose();
+                    memoryStream = null;
+                }
+
+                Array.Clear(m_CachedBytes, 0, CachedBytesLength);
+            }
+        }
+
+        /// <summary>
+        /// 解压缩数据。
+        /// </summary>
+        /// <param name="stream">要解压缩的数据的二进制流。</param>
+        /// <param name="decompressedStream">解压缩后的数据的二进制流。</param>
+        /// <returns>是否解压缩数据成功。</returns>
+        public bool Decompress(Stream stream, Stream decompressedStream)
+        {
+            if (stream == null)
+            {
+                return false;
+            }
+
+            if (decompressedStream == null)
+            {
+                return false;
+            }
+
+            try
+            {
+                GZipInputStream gZipInputStream = new GZipInputStream(stream);
+                int bytesRead = 0;
+                while ((bytesRead = gZipInputStream.Read(m_CachedBytes, 0, CachedBytesLength)) > 0)
+                {
+                    decompressedStream.Write(m_CachedBytes, 0, bytesRead);
+                }
+
+                return true;
+            }
+            catch
+            {
+                return false;
+            }
+            finally
+            {
+                Array.Clear(m_CachedBytes, 0, CachedBytesLength);
+            }
+        }
+
+        private static void ProcessHeader(Stream compressedStream)
+        {
+            if (compressedStream.Length >= 8L)
+            {
+                long current = compressedStream.Position;
+                compressedStream.Position = 4L;
+                compressedStream.WriteByte(25);
+                compressedStream.WriteByte(134);
+                compressedStream.WriteByte(2);
+                compressedStream.WriteByte(32);
+                compressedStream.Position = current;
+            }
+        }
+    }
+}

Assets/TEngine/Runtime/Utility/DefaultCompressionHelper.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 1d184e46fc6573c4abb31c8039d407b1
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TEngine/Runtime/Utility/DefaultJsonHelper.cs

@@ -0,0 +1,43 @@
+using System;
+using UnityEngine;
+
+namespace TEngine
+{
+    /// <summary>
+    /// 默认 JSON 函数集辅助器。
+    /// </summary>
+    public class DefaultJsonHelper : Utility.Json.IJsonHelper
+    {
+        /// <summary>
+        /// 将对象序列化为 JSON 字符串。
+        /// </summary>
+        /// <param name="obj">要序列化的对象。</param>
+        /// <returns>序列化后的 JSON 字符串。</returns>
+        public string ToJson(object obj)
+        {
+            return JsonUtility.ToJson(obj);
+        }
+
+        /// <summary>
+        /// 将 JSON 字符串反序列化为对象。
+        /// </summary>
+        /// <typeparam name="T">对象类型。</typeparam>
+        /// <param name="json">要反序列化的 JSON 字符串。</param>
+        /// <returns>反序列化后的对象。</returns>
+        public T ToObject<T>(string json)
+        {
+            return JsonUtility.FromJson<T>(json);
+        }
+
+        /// <summary>
+        /// 将 JSON 字符串反序列化为对象。
+        /// </summary>
+        /// <param name="objectType">对象类型。</param>
+        /// <param name="json">要反序列化的 JSON 字符串。</param>
+        /// <returns>反序列化后的对象。</returns>
+        public object ToObject(Type objectType, string json)
+        {
+            return JsonUtility.FromJson(json, objectType);
+        }
+    }
+}

Assets/TEngine/Runtime/Utility/DefaultJsonHelper.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 124edaf04e2d94b4eaeec913cc6b2bf3
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TEngine/Runtime/Utility/DefaultLogHelper.cs

@@ -0,0 +1,40 @@
+using UnityEngine;
+
+namespace TEngine
+{
+    /// <summary>
+    /// 默认游戏框架日志辅助器。
+    /// </summary>
+    public class DefaultLogHelper : GameFrameworkLog.ILogHelper
+    {
+        /// <summary>
+        /// 记录日志。
+        /// </summary>
+        /// <param name="level">日志等级。</param>
+        /// <param name="message">日志内容。</param>
+        public void Log(GameFrameworkLogLevel level, object message)
+        {
+            switch (level)
+            {
+                case GameFrameworkLogLevel.Debug:
+                    Debug.Log(Utility.Text.Format("<color=#888888>{0}</color>", message));
+                    break;
+
+                case GameFrameworkLogLevel.Info:
+                    Debug.Log(message.ToString());
+                    break;
+
+                case GameFrameworkLogLevel.Warning:
+                    Debug.LogWarning(message.ToString());
+                    break;
+
+                case GameFrameworkLogLevel.Error:
+                    Debug.LogError(message.ToString());
+                    break;
+
+                default:
+                    throw new GameFrameworkException(message.ToString());
+            }
+        }
+    }
+}

Assets/TEngine/Runtime/Utility/DefaultLogHelper.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 5cc7992e02f878541bfc9ee9ae7b92aa
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TEngine/Runtime/Utility/DefaultTextHelper.cs

@@ -0,0 +1,584 @@
+using System;
+using System.Text;
+
+namespace TEngine
+{
+    /// <summary>
+    /// 默认字符辅助器。
+    /// </summary>
+    public class DefaultTextHelper : Utility.Text.ITextHelper
+    {
+        private const int StringBuilderCapacity = 1024;
+
+        [ThreadStatic]
+        private static StringBuilder s_CachedStringBuilder = null;
+
+        /// <summary>
+        /// 获取格式化字符串。
+        /// </summary>
+        /// <typeparam name="T">字符串参数的类型。</typeparam>
+        /// <param name="format">字符串格式。</param>
+        /// <param name="arg">字符串参数。</param>
+        /// <returns>格式化后的字符串。</returns>
+        public string Format<T>(string format, T arg)
+        {
+            if (format == null)
+            {
+                throw new GameFrameworkException("Format is invalid.");
+            }
+
+            CheckCachedStringBuilder();
+            s_CachedStringBuilder.Length = 0;
+            s_CachedStringBuilder.AppendFormat(format, arg);
+            return s_CachedStringBuilder.ToString();
+        }
+
+        /// <summary>
+        /// 获取格式化字符串。
+        /// </summary>
+        /// <typeparam name="T1">字符串参数 1 的类型。</typeparam>
+        /// <typeparam name="T2">字符串参数 2 的类型。</typeparam>
+        /// <param name="format">字符串格式。</param>
+        /// <param name="arg1">字符串参数 1。</param>
+        /// <param name="arg2">字符串参数 2。</param>
+        /// <returns>格式化后的字符串。</returns>
+        public string Format<T1, T2>(string format, T1 arg1, T2 arg2)
+        {
+            if (format == null)
+            {
+                throw new GameFrameworkException("Format is invalid.");
+            }
+
+            CheckCachedStringBuilder();
+            s_CachedStringBuilder.Length = 0;
+            s_CachedStringBuilder.AppendFormat(format, arg1, arg2);
+            return s_CachedStringBuilder.ToString();
+        }
+
+        /// <summary>
+        /// 获取格式化字符串。
+        /// </summary>
+        /// <typeparam name="T1">字符串参数 1 的类型。</typeparam>
+        /// <typeparam name="T2">字符串参数 2 的类型。</typeparam>
+        /// <typeparam name="T3">字符串参数 3 的类型。</typeparam>
+        /// <param name="format">字符串格式。</param>
+        /// <param name="arg1">字符串参数 1。</param>
+        /// <param name="arg2">字符串参数 2。</param>
+        /// <param name="arg3">字符串参数 3。</param>
+        /// <returns>格式化后的字符串。</returns>
+        public string Format<T1, T2, T3>(string format, T1 arg1, T2 arg2, T3 arg3)
+        {
+            if (format == null)
+            {
+                throw new GameFrameworkException("Format is invalid.");
+            }
+
+            CheckCachedStringBuilder();
+            s_CachedStringBuilder.Length = 0;
+            s_CachedStringBuilder.AppendFormat(format, arg1, arg2, arg3);
+            return s_CachedStringBuilder.ToString();
+        }
+
+        /// <summary>
+        /// 获取格式化字符串。
+        /// </summary>
+        /// <typeparam name="T1">字符串参数 1 的类型。</typeparam>
+        /// <typeparam name="T2">字符串参数 2 的类型。</typeparam>
+        /// <typeparam name="T3">字符串参数 3 的类型。</typeparam>
+        /// <typeparam name="T4">字符串参数 4 的类型。</typeparam>
+        /// <param name="format">字符串格式。</param>
+        /// <param name="arg1">字符串参数 1。</param>
+        /// <param name="arg2">字符串参数 2。</param>
+        /// <param name="arg3">字符串参数 3。</param>
+        /// <param name="arg4">字符串参数 4。</param>
+        /// <returns>格式化后的字符串。</returns>
+        public string Format<T1, T2, T3, T4>(string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
+        {
+            if (format == null)
+            {
+                throw new GameFrameworkException("Format is invalid.");
+            }
+
+            CheckCachedStringBuilder();
+            s_CachedStringBuilder.Length = 0;
+            s_CachedStringBuilder.AppendFormat(format, arg1, arg2, arg3, arg4);
+            return s_CachedStringBuilder.ToString();
+        }
+
+        /// <summary>
+        /// 获取格式化字符串。
+        /// </summary>
+        /// <typeparam name="T1">字符串参数 1 的类型。</typeparam>
+        /// <typeparam name="T2">字符串参数 2 的类型。</typeparam>
+        /// <typeparam name="T3">字符串参数 3 的类型。</typeparam>
+        /// <typeparam name="T4">字符串参数 4 的类型。</typeparam>
+        /// <typeparam name="T5">字符串参数 5 的类型。</typeparam>
+        /// <param name="format">字符串格式。</param>
+        /// <param name="arg1">字符串参数 1。</param>
+        /// <param name="arg2">字符串参数 2。</param>
+        /// <param name="arg3">字符串参数 3。</param>
+        /// <param name="arg4">字符串参数 4。</param>
+        /// <param name="arg5">字符串参数 5。</param>
+        /// <returns>格式化后的字符串。</returns>
+        public string Format<T1, T2, T3, T4, T5>(string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
+        {
+            if (format == null)
+            {
+                throw new GameFrameworkException("Format is invalid.");
+            }
+
+            CheckCachedStringBuilder();
+            s_CachedStringBuilder.Length = 0;
+            s_CachedStringBuilder.AppendFormat(format, arg1, arg2, arg3, arg4, arg5);
+            return s_CachedStringBuilder.ToString();
+        }
+
+        /// <summary>
+        /// 获取格式化字符串。
+        /// </summary>
+        /// <typeparam name="T1">字符串参数 1 的类型。</typeparam>
+        /// <typeparam name="T2">字符串参数 2 的类型。</typeparam>
+        /// <typeparam name="T3">字符串参数 3 的类型。</typeparam>
+        /// <typeparam name="T4">字符串参数 4 的类型。</typeparam>
+        /// <typeparam name="T5">字符串参数 5 的类型。</typeparam>
+        /// <typeparam name="T6">字符串参数 6 的类型。</typeparam>
+        /// <param name="format">字符串格式。</param>
+        /// <param name="arg1">字符串参数 1。</param>
+        /// <param name="arg2">字符串参数 2。</param>
+        /// <param name="arg3">字符串参数 3。</param>
+        /// <param name="arg4">字符串参数 4。</param>
+        /// <param name="arg5">字符串参数 5。</param>
+        /// <param name="arg6">字符串参数 6。</param>
+        /// <returns>格式化后的字符串。</returns>
+        public string Format<T1, T2, T3, T4, T5, T6>(string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
+        {
+            if (format == null)
+            {
+                throw new GameFrameworkException("Format is invalid.");
+            }
+
+            CheckCachedStringBuilder();
+            s_CachedStringBuilder.Length = 0;
+            s_CachedStringBuilder.AppendFormat(format, arg1, arg2, arg3, arg4, arg5, arg6);
+            return s_CachedStringBuilder.ToString();
+        }
+
+        /// <summary>
+        /// 获取格式化字符串。
+        /// </summary>
+        /// <typeparam name="T1">字符串参数 1 的类型。</typeparam>
+        /// <typeparam name="T2">字符串参数 2 的类型。</typeparam>
+        /// <typeparam name="T3">字符串参数 3 的类型。</typeparam>
+        /// <typeparam name="T4">字符串参数 4 的类型。</typeparam>
+        /// <typeparam name="T5">字符串参数 5 的类型。</typeparam>
+        /// <typeparam name="T6">字符串参数 6 的类型。</typeparam>
+        /// <typeparam name="T7">字符串参数 7 的类型。</typeparam>
+        /// <param name="format">字符串格式。</param>
+        /// <param name="arg1">字符串参数 1。</param>
+        /// <param name="arg2">字符串参数 2。</param>
+        /// <param name="arg3">字符串参数 3。</param>
+        /// <param name="arg4">字符串参数 4。</param>
+        /// <param name="arg5">字符串参数 5。</param>
+        /// <param name="arg6">字符串参数 6。</param>
+        /// <param name="arg7">字符串参数 7。</param>
+        /// <returns>格式化后的字符串。</returns>
+        public string Format<T1, T2, T3, T4, T5, T6, T7>(string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
+        {
+            if (format == null)
+            {
+                throw new GameFrameworkException("Format is invalid.");
+            }
+
+            CheckCachedStringBuilder();
+            s_CachedStringBuilder.Length = 0;
+            s_CachedStringBuilder.AppendFormat(format, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
+            return s_CachedStringBuilder.ToString();
+        }
+
+        /// <summary>
+        /// 获取格式化字符串。
+        /// </summary>
+        /// <typeparam name="T1">字符串参数 1 的类型。</typeparam>
+        /// <typeparam name="T2">字符串参数 2 的类型。</typeparam>
+        /// <typeparam name="T3">字符串参数 3 的类型。</typeparam>
+        /// <typeparam name="T4">字符串参数 4 的类型。</typeparam>
+        /// <typeparam name="T5">字符串参数 5 的类型。</typeparam>
+        /// <typeparam name="T6">字符串参数 6 的类型。</typeparam>
+        /// <typeparam name="T7">字符串参数 7 的类型。</typeparam>
+        /// <typeparam name="T8">字符串参数 8 的类型。</typeparam>
+        /// <param name="format">字符串格式。</param>
+        /// <param name="arg1">字符串参数 1。</param>
+        /// <param name="arg2">字符串参数 2。</param>
+        /// <param name="arg3">字符串参数 3。</param>
+        /// <param name="arg4">字符串参数 4。</param>
+        /// <param name="arg5">字符串参数 5。</param>
+        /// <param name="arg6">字符串参数 6。</param>
+        /// <param name="arg7">字符串参数 7。</param>
+        /// <param name="arg8">字符串参数 8。</param>
+        /// <returns>格式化后的字符串。</returns>
+        public string Format<T1, T2, T3, T4, T5, T6, T7, T8>(string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
+        {
+            if (format == null)
+            {
+                throw new GameFrameworkException("Format is invalid.");
+            }
+
+            CheckCachedStringBuilder();
+            s_CachedStringBuilder.Length = 0;
+            s_CachedStringBuilder.AppendFormat(format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
+            return s_CachedStringBuilder.ToString();
+        }
+
+        /// <summary>
+        /// 获取格式化字符串。
+        /// </summary>
+        /// <typeparam name="T1">字符串参数 1 的类型。</typeparam>
+        /// <typeparam name="T2">字符串参数 2 的类型。</typeparam>
+        /// <typeparam name="T3">字符串参数 3 的类型。</typeparam>
+        /// <typeparam name="T4">字符串参数 4 的类型。</typeparam>
+        /// <typeparam name="T5">字符串参数 5 的类型。</typeparam>
+        /// <typeparam name="T6">字符串参数 6 的类型。</typeparam>
+        /// <typeparam name="T7">字符串参数 7 的类型。</typeparam>
+        /// <typeparam name="T8">字符串参数 8 的类型。</typeparam>
+        /// <typeparam name="T9">字符串参数 9 的类型。</typeparam>
+        /// <param name="format">字符串格式。</param>
+        /// <param name="arg1">字符串参数 1。</param>
+        /// <param name="arg2">字符串参数 2。</param>
+        /// <param name="arg3">字符串参数 3。</param>
+        /// <param name="arg4">字符串参数 4。</param>
+        /// <param name="arg5">字符串参数 5。</param>
+        /// <param name="arg6">字符串参数 6。</param>
+        /// <param name="arg7">字符串参数 7。</param>
+        /// <param name="arg8">字符串参数 8。</param>
+        /// <param name="arg9">字符串参数 9。</param>
+        /// <returns>格式化后的字符串。</returns>
+        public string Format<T1, T2, T3, T4, T5, T6, T7, T8, T9>(string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)
+        {
+            if (format == null)
+            {
+                throw new GameFrameworkException("Format is invalid.");
+            }
+
+            CheckCachedStringBuilder();
+            s_CachedStringBuilder.Length = 0;
+            s_CachedStringBuilder.AppendFormat(format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+            return s_CachedStringBuilder.ToString();
+        }
+
+        /// <summary>
+        /// 获取格式化字符串。
+        /// </summary>
+        /// <typeparam name="T1">字符串参数 1 的类型。</typeparam>
+        /// <typeparam name="T2">字符串参数 2 的类型。</typeparam>
+        /// <typeparam name="T3">字符串参数 3 的类型。</typeparam>
+        /// <typeparam name="T4">字符串参数 4 的类型。</typeparam>
+        /// <typeparam name="T5">字符串参数 5 的类型。</typeparam>
+        /// <typeparam name="T6">字符串参数 6 的类型。</typeparam>
+        /// <typeparam name="T7">字符串参数 7 的类型。</typeparam>
+        /// <typeparam name="T8">字符串参数 8 的类型。</typeparam>
+        /// <typeparam name="T9">字符串参数 9 的类型。</typeparam>
+        /// <typeparam name="T10">字符串参数 10 的类型。</typeparam>
+        /// <param name="format">字符串格式。</param>
+        /// <param name="arg1">字符串参数 1。</param>
+        /// <param name="arg2">字符串参数 2。</param>
+        /// <param name="arg3">字符串参数 3。</param>
+        /// <param name="arg4">字符串参数 4。</param>
+        /// <param name="arg5">字符串参数 5。</param>
+        /// <param name="arg6">字符串参数 6。</param>
+        /// <param name="arg7">字符串参数 7。</param>
+        /// <param name="arg8">字符串参数 8。</param>
+        /// <param name="arg9">字符串参数 9。</param>
+        /// <param name="arg10">字符串参数 10。</param>
+        /// <returns>格式化后的字符串。</returns>
+        public string Format<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10)
+        {
+            if (format == null)
+            {
+                throw new GameFrameworkException("Format is invalid.");
+            }
+
+            CheckCachedStringBuilder();
+            s_CachedStringBuilder.Length = 0;
+            s_CachedStringBuilder.AppendFormat(format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
+            return s_CachedStringBuilder.ToString();
+        }
+
+        /// <summary>
+        /// 获取格式化字符串。
+        /// </summary>
+        /// <typeparam name="T1">字符串参数 1 的类型。</typeparam>
+        /// <typeparam name="T2">字符串参数 2 的类型。</typeparam>
+        /// <typeparam name="T3">字符串参数 3 的类型。</typeparam>
+        /// <typeparam name="T4">字符串参数 4 的类型。</typeparam>
+        /// <typeparam name="T5">字符串参数 5 的类型。</typeparam>
+        /// <typeparam name="T6">字符串参数 6 的类型。</typeparam>
+        /// <typeparam name="T7">字符串参数 7 的类型。</typeparam>
+        /// <typeparam name="T8">字符串参数 8 的类型。</typeparam>
+        /// <typeparam name="T9">字符串参数 9 的类型。</typeparam>
+        /// <typeparam name="T10">字符串参数 10 的类型。</typeparam>
+        /// <typeparam name="T11">字符串参数 11 的类型。</typeparam>
+        /// <param name="format">字符串格式。</param>
+        /// <param name="arg1">字符串参数 1。</param>
+        /// <param name="arg2">字符串参数 2。</param>
+        /// <param name="arg3">字符串参数 3。</param>
+        /// <param name="arg4">字符串参数 4。</param>
+        /// <param name="arg5">字符串参数 5。</param>
+        /// <param name="arg6">字符串参数 6。</param>
+        /// <param name="arg7">字符串参数 7。</param>
+        /// <param name="arg8">字符串参数 8。</param>
+        /// <param name="arg9">字符串参数 9。</param>
+        /// <param name="arg10">字符串参数 10。</param>
+        /// <param name="arg11">字符串参数 11。</param>
+        /// <returns>格式化后的字符串。</returns>
+        public string Format<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11)
+        {
+            if (format == null)
+            {
+                throw new GameFrameworkException("Format is invalid.");
+            }
+
+            CheckCachedStringBuilder();
+            s_CachedStringBuilder.Length = 0;
+            s_CachedStringBuilder.AppendFormat(format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
+            return s_CachedStringBuilder.ToString();
+        }
+
+        /// <summary>
+        /// 获取格式化字符串。
+        /// </summary>
+        /// <typeparam name="T1">字符串参数 1 的类型。</typeparam>
+        /// <typeparam name="T2">字符串参数 2 的类型。</typeparam>
+        /// <typeparam name="T3">字符串参数 3 的类型。</typeparam>
+        /// <typeparam name="T4">字符串参数 4 的类型。</typeparam>
+        /// <typeparam name="T5">字符串参数 5 的类型。</typeparam>
+        /// <typeparam name="T6">字符串参数 6 的类型。</typeparam>
+        /// <typeparam name="T7">字符串参数 7 的类型。</typeparam>
+        /// <typeparam name="T8">字符串参数 8 的类型。</typeparam>
+        /// <typeparam name="T9">字符串参数 9 的类型。</typeparam>
+        /// <typeparam name="T10">字符串参数 10 的类型。</typeparam>
+        /// <typeparam name="T11">字符串参数 11 的类型。</typeparam>
+        /// <typeparam name="T12">字符串参数 12 的类型。</typeparam>
+        /// <param name="format">字符串格式。</param>
+        /// <param name="arg1">字符串参数 1。</param>
+        /// <param name="arg2">字符串参数 2。</param>
+        /// <param name="arg3">字符串参数 3。</param>
+        /// <param name="arg4">字符串参数 4。</param>
+        /// <param name="arg5">字符串参数 5。</param>
+        /// <param name="arg6">字符串参数 6。</param>
+        /// <param name="arg7">字符串参数 7。</param>
+        /// <param name="arg8">字符串参数 8。</param>
+        /// <param name="arg9">字符串参数 9。</param>
+        /// <param name="arg10">字符串参数 10。</param>
+        /// <param name="arg11">字符串参数 11。</param>
+        /// <param name="arg12">字符串参数 12。</param>
+        /// <returns>格式化后的字符串。</returns>
+        public string Format<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12)
+        {
+            if (format == null)
+            {
+                throw new GameFrameworkException("Format is invalid.");
+            }
+
+            CheckCachedStringBuilder();
+            s_CachedStringBuilder.Length = 0;
+            s_CachedStringBuilder.AppendFormat(format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
+            return s_CachedStringBuilder.ToString();
+        }
+
+        /// <summary>
+        /// 获取格式化字符串。
+        /// </summary>
+        /// <typeparam name="T1">字符串参数 1 的类型。</typeparam>
+        /// <typeparam name="T2">字符串参数 2 的类型。</typeparam>
+        /// <typeparam name="T3">字符串参数 3 的类型。</typeparam>
+        /// <typeparam name="T4">字符串参数 4 的类型。</typeparam>
+        /// <typeparam name="T5">字符串参数 5 的类型。</typeparam>
+        /// <typeparam name="T6">字符串参数 6 的类型。</typeparam>
+        /// <typeparam name="T7">字符串参数 7 的类型。</typeparam>
+        /// <typeparam name="T8">字符串参数 8 的类型。</typeparam>
+        /// <typeparam name="T9">字符串参数 9 的类型。</typeparam>
+        /// <typeparam name="T10">字符串参数 10 的类型。</typeparam>
+        /// <typeparam name="T11">字符串参数 11 的类型。</typeparam>
+        /// <typeparam name="T12">字符串参数 12 的类型。</typeparam>
+        /// <typeparam name="T13">字符串参数 13 的类型。</typeparam>
+        /// <param name="format">字符串格式。</param>
+        /// <param name="arg1">字符串参数 1。</param>
+        /// <param name="arg2">字符串参数 2。</param>
+        /// <param name="arg3">字符串参数 3。</param>
+        /// <param name="arg4">字符串参数 4。</param>
+        /// <param name="arg5">字符串参数 5。</param>
+        /// <param name="arg6">字符串参数 6。</param>
+        /// <param name="arg7">字符串参数 7。</param>
+        /// <param name="arg8">字符串参数 8。</param>
+        /// <param name="arg9">字符串参数 9。</param>
+        /// <param name="arg10">字符串参数 10。</param>
+        /// <param name="arg11">字符串参数 11。</param>
+        /// <param name="arg12">字符串参数 12。</param>
+        /// <param name="arg13">字符串参数 13。</param>
+        /// <returns>格式化后的字符串。</returns>
+        public string Format<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13)
+        {
+            if (format == null)
+            {
+                throw new GameFrameworkException("Format is invalid.");
+            }
+
+            CheckCachedStringBuilder();
+            s_CachedStringBuilder.Length = 0;
+            s_CachedStringBuilder.AppendFormat(format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);
+            return s_CachedStringBuilder.ToString();
+        }
+
+        /// <summary>
+        /// 获取格式化字符串。
+        /// </summary>
+        /// <typeparam name="T1">字符串参数 1 的类型。</typeparam>
+        /// <typeparam name="T2">字符串参数 2 的类型。</typeparam>
+        /// <typeparam name="T3">字符串参数 3 的类型。</typeparam>
+        /// <typeparam name="T4">字符串参数 4 的类型。</typeparam>
+        /// <typeparam name="T5">字符串参数 5 的类型。</typeparam>
+        /// <typeparam name="T6">字符串参数 6 的类型。</typeparam>
+        /// <typeparam name="T7">字符串参数 7 的类型。</typeparam>
+        /// <typeparam name="T8">字符串参数 8 的类型。</typeparam>
+        /// <typeparam name="T9">字符串参数 9 的类型。</typeparam>
+        /// <typeparam name="T10">字符串参数 10 的类型。</typeparam>
+        /// <typeparam name="T11">字符串参数 11 的类型。</typeparam>
+        /// <typeparam name="T12">字符串参数 12 的类型。</typeparam>
+        /// <typeparam name="T13">字符串参数 13 的类型。</typeparam>
+        /// <typeparam name="T14">字符串参数 14 的类型。</typeparam>
+        /// <param name="format">字符串格式。</param>
+        /// <param name="arg1">字符串参数 1。</param>
+        /// <param name="arg2">字符串参数 2。</param>
+        /// <param name="arg3">字符串参数 3。</param>
+        /// <param name="arg4">字符串参数 4。</param>
+        /// <param name="arg5">字符串参数 5。</param>
+        /// <param name="arg6">字符串参数 6。</param>
+        /// <param name="arg7">字符串参数 7。</param>
+        /// <param name="arg8">字符串参数 8。</param>
+        /// <param name="arg9">字符串参数 9。</param>
+        /// <param name="arg10">字符串参数 10。</param>
+        /// <param name="arg11">字符串参数 11。</param>
+        /// <param name="arg12">字符串参数 12。</param>
+        /// <param name="arg13">字符串参数 13。</param>
+        /// <param name="arg14">字符串参数 14。</param>
+        /// <returns>格式化后的字符串。</returns>
+        public string Format<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14)
+        {
+            if (format == null)
+            {
+                throw new GameFrameworkException("Format is invalid.");
+            }
+
+            CheckCachedStringBuilder();
+            s_CachedStringBuilder.Length = 0;
+            s_CachedStringBuilder.AppendFormat(format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14);
+            return s_CachedStringBuilder.ToString();
+        }
+
+        /// <summary>
+        /// 获取格式化字符串。
+        /// </summary>
+        /// <typeparam name="T1">字符串参数 1 的类型。</typeparam>
+        /// <typeparam name="T2">字符串参数 2 的类型。</typeparam>
+        /// <typeparam name="T3">字符串参数 3 的类型。</typeparam>
+        /// <typeparam name="T4">字符串参数 4 的类型。</typeparam>
+        /// <typeparam name="T5">字符串参数 5 的类型。</typeparam>
+        /// <typeparam name="T6">字符串参数 6 的类型。</typeparam>
+        /// <typeparam name="T7">字符串参数 7 的类型。</typeparam>
+        /// <typeparam name="T8">字符串参数 8 的类型。</typeparam>
+        /// <typeparam name="T9">字符串参数 9 的类型。</typeparam>
+        /// <typeparam name="T10">字符串参数 10 的类型。</typeparam>
+        /// <typeparam name="T11">字符串参数 11 的类型。</typeparam>
+        /// <typeparam name="T12">字符串参数 12 的类型。</typeparam>
+        /// <typeparam name="T13">字符串参数 13 的类型。</typeparam>
+        /// <typeparam name="T14">字符串参数 14 的类型。</typeparam>
+        /// <typeparam name="T15">字符串参数 15 的类型。</typeparam>
+        /// <param name="format">字符串格式。</param>
+        /// <param name="arg1">字符串参数 1。</param>
+        /// <param name="arg2">字符串参数 2。</param>
+        /// <param name="arg3">字符串参数 3。</param>
+        /// <param name="arg4">字符串参数 4。</param>
+        /// <param name="arg5">字符串参数 5。</param>
+        /// <param name="arg6">字符串参数 6。</param>
+        /// <param name="arg7">字符串参数 7。</param>
+        /// <param name="arg8">字符串参数 8。</param>
+        /// <param name="arg9">字符串参数 9。</param>
+        /// <param name="arg10">字符串参数 10。</param>
+        /// <param name="arg11">字符串参数 11。</param>
+        /// <param name="arg12">字符串参数 12。</param>
+        /// <param name="arg13">字符串参数 13。</param>
+        /// <param name="arg14">字符串参数 14。</param>
+        /// <param name="arg15">字符串参数 15。</param>
+        /// <returns>格式化后的字符串。</returns>
+        public string Format<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>(string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14, T15 arg15)
+        {
+            if (format == null)
+            {
+                throw new GameFrameworkException("Format is invalid.");
+            }
+
+            CheckCachedStringBuilder();
+            s_CachedStringBuilder.Length = 0;
+            s_CachedStringBuilder.AppendFormat(format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15);
+            return s_CachedStringBuilder.ToString();
+        }
+
+        /// <summary>
+        /// 获取格式化字符串。
+        /// </summary>
+        /// <typeparam name="T1">字符串参数 1 的类型。</typeparam>
+        /// <typeparam name="T2">字符串参数 2 的类型。</typeparam>
+        /// <typeparam name="T3">字符串参数 3 的类型。</typeparam>
+        /// <typeparam name="T4">字符串参数 4 的类型。</typeparam>
+        /// <typeparam name="T5">字符串参数 5 的类型。</typeparam>
+        /// <typeparam name="T6">字符串参数 6 的类型。</typeparam>
+        /// <typeparam name="T7">字符串参数 7 的类型。</typeparam>
+        /// <typeparam name="T8">字符串参数 8 的类型。</typeparam>
+        /// <typeparam name="T9">字符串参数 9 的类型。</typeparam>
+        /// <typeparam name="T10">字符串参数 10 的类型。</typeparam>
+        /// <typeparam name="T11">字符串参数 11 的类型。</typeparam>
+        /// <typeparam name="T12">字符串参数 12 的类型。</typeparam>
+        /// <typeparam name="T13">字符串参数 13 的类型。</typeparam>
+        /// <typeparam name="T14">字符串参数 14 的类型。</typeparam>
+        /// <typeparam name="T15">字符串参数 15 的类型。</typeparam>
+        /// <typeparam name="T16">字符串参数 16 的类型。</typeparam>
+        /// <param name="format">字符串格式。</param>
+        /// <param name="arg1">字符串参数 1。</param>
+        /// <param name="arg2">字符串参数 2。</param>
+        /// <param name="arg3">字符串参数 3。</param>
+        /// <param name="arg4">字符串参数 4。</param>
+        /// <param name="arg5">字符串参数 5。</param>
+        /// <param name="arg6">字符串参数 6。</param>
+        /// <param name="arg7">字符串参数 7。</param>
+        /// <param name="arg8">字符串参数 8。</param>
+        /// <param name="arg9">字符串参数 9。</param>
+        /// <param name="arg10">字符串参数 10。</param>
+        /// <param name="arg11">字符串参数 11。</param>
+        /// <param name="arg12">字符串参数 12。</param>
+        /// <param name="arg13">字符串参数 13。</param>
+        /// <param name="arg14">字符串参数 14。</param>
+        /// <param name="arg15">字符串参数 15。</param>
+        /// <param name="arg16">字符串参数 16。</param>
+        /// <returns>格式化后的字符串。</returns>
+        public string Format<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>(string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14, T15 arg15, T16 arg16)
+        {
+            if (format == null)
+            {
+                throw new GameFrameworkException("Format is invalid.");
+            }
+
+            CheckCachedStringBuilder();
+            s_CachedStringBuilder.Length = 0;
+            s_CachedStringBuilder.AppendFormat(format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16);
+            return s_CachedStringBuilder.ToString();
+        }
+
+        private static void CheckCachedStringBuilder()
+        {
+            if (s_CachedStringBuilder == null)
+            {
+                s_CachedStringBuilder = new StringBuilder(StringBuilderCapacity);
+            }
+        }
+    }
+}

Assets/TEngine/Runtime/Utility/DefaultTextHelper.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: cda9d41dd292f9049b948679c8784657
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TEngine/Runtime/Utility/DefaultVersionHelper.cs

@@ -0,0 +1,32 @@
+using UnityEngine;
+
+namespace TEngine
+{
+    /// <summary>
+    /// 默认版本号辅助器。
+    /// </summary>
+    public class DefaultVersionHelper : Version.IVersionHelper
+    {
+        /// <summary>
+        /// 获取游戏版本号。
+        /// </summary>
+        public string GameVersion
+        {
+            get
+            {
+                return Application.version;
+            }
+        }
+
+        /// <summary>
+        /// 获取内部游戏版本号。
+        /// </summary>
+        public int InternalGameVersion
+        {
+            get
+            {
+                return 0;
+            }
+        }
+    }
+}

Assets/TEngine/Runtime/Utility/DefaultVersionHelper.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 6a351c5e9718e3040ae02cf488d57641
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TEngine/Runtime/Utility/Helper.cs

@@ -0,0 +1,68 @@
+using TEngine;
+using UnityEngine;
+
+namespace TEngine
+{
+    /// <summary>
+    /// 辅助器创建器相关的实用函数。
+    /// </summary>
+    public static class Helper
+    {
+        /// <summary>
+        /// 创建辅助器。
+        /// </summary>
+        /// <typeparam name="T">要创建的辅助器类型。</typeparam>
+        /// <param name="helperTypeName">要创建的辅助器类型名称。</param>
+        /// <param name="customHelper">若要创建的辅助器类型为空时，使用的自定义辅助器类型。</param>
+        /// <returns>创建的辅助器。</returns>
+        public static T CreateHelper<T>(string helperTypeName, T customHelper) where T : MonoBehaviour
+        {
+            return CreateHelper(helperTypeName, customHelper, 0);
+        }
+
+        /// <summary>
+        /// 创建辅助器。
+        /// </summary>
+        /// <typeparam name="T">要创建的辅助器类型。</typeparam>
+        /// <param name="helperTypeName">要创建的辅助器类型名称。</param>
+        /// <param name="customHelper">若要创建的辅助器类型为空时，使用的自定义辅助器类型。</param>
+        /// <param name="index">要创建的辅助器索引。</param>
+        /// <returns>创建的辅助器。</returns>
+        public static T CreateHelper<T>(string helperTypeName, T customHelper, int index) where T : MonoBehaviour
+        {
+            T helper = null;
+            if (!string.IsNullOrEmpty(helperTypeName))
+            {
+                System.Type helperType = Utility.Assembly.GetType(helperTypeName);
+                if (helperType == null)
+                {
+                    Log.Warning("Can not find helper type '{0}'.", helperTypeName);
+                    return null;
+                }
+
+                if (!typeof(T).IsAssignableFrom(helperType))
+                {
+                    Log.Warning("Type '{0}' is not assignable from '{1}'.", typeof(T).FullName, helperType.FullName);
+                    return null;
+                }
+
+                helper = (T)new GameObject().AddComponent(helperType);
+            }
+            else if (customHelper == null)
+            {
+                Log.Warning("You must set custom helper with '{0}' type first.", typeof(T).FullName);
+                return null;
+            }
+            else if (customHelper.gameObject.InScene())
+            {
+                helper = index > 0 ? Object.Instantiate(customHelper) : customHelper;
+            }
+            else
+            {
+                helper = Object.Instantiate(customHelper);
+            }
+
+            return helper;
+        }
+    }
+}

Assets/TEngine/Runtime/Utility/Helper.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 30e8ce1cbe85414488bd7a209e01e33e
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TEngine/Runtime/Utility/StringExtension.cs

@@ -0,0 +1,59 @@
+/// <summary>
+/// 对 string 的扩展方法。
+/// </summary>
+public static class StringExtension
+{
+    /// <summary>
+    /// 从指定字符串中的指定位置处开始读取一行。
+    /// </summary>
+    /// <param name="rawString">指定的字符串。</param>
+    /// <param name="position">从指定位置处开始读取一行，读取后将返回下一行开始的位置。</param>
+    /// <returns>读取的一行字符串。</returns>
+    public static string ReadLine(this string rawString, ref int position)
+    {
+        if (position < 0)
+        {
+            return null;
+        }
+
+        int length = rawString.Length;
+        int offset = position;
+        while (offset < length)
+        {
+            char ch = rawString[offset];
+            switch (ch)
+            {
+                case '\r':
+                case '\n':
+                    if (offset > position)
+                    {
+                        string line = rawString.Substring(position, offset - position);
+                        position = offset + 1;
+                        if ((ch == '\r') && (position < length) && (rawString[position] == '\n'))
+                        {
+                            position++;
+                        }
+
+                        return line;
+                    }
+
+                    offset++;
+                    position++;
+                    break;
+
+                default:
+                    offset++;
+                    break;
+            }
+        }
+
+        if (offset > position)
+        {
+            string line = rawString.Substring(position, offset - position);
+            position = offset;
+            return line;
+        }
+
+        return null;
+    }
+}

Assets/TEngine/Runtime/Utility/StringExtension.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: cf3c6e399e5abde4e8b867e4dc5ca9ee
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TEngine/Runtime/Utility/UnityExtension.cs

@@ -0,0 +1,340 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+
+/// <summary>
+/// 对 Unity 的扩展方法。
+/// </summary>
+public static class UnityExtension
+{
+    private static readonly List<Transform> s_CachedTransforms = new List<Transform>();
+
+    /// <summary>
+    /// 获取或增加组件。
+    /// </summary>
+    /// <typeparam name="T">要获取或增加的组件。</typeparam>
+    /// <param name="gameObject">目标对象。</param>
+    /// <returns>获取或增加的组件。</returns>
+    public static T GetOrAddComponent<T>(this GameObject gameObject) where T : Component
+    {
+        T component = gameObject.GetComponent<T>();
+        if (component == null)
+        {
+            component = gameObject.AddComponent<T>();
+        }
+
+        return component;
+    }
+
+    /// <summary>
+    /// 获取或增加组件。
+    /// </summary>
+    /// <param name="gameObject">目标对象。</param>
+    /// <param name="type">要获取或增加的组件类型。</param>
+    /// <returns>获取或增加的组件。</returns>
+    public static Component GetOrAddComponent(this GameObject gameObject, Type type)
+    {
+        Component component = gameObject.GetComponent(type);
+        if (component == null)
+        {
+            component = gameObject.AddComponent(type);
+        }
+
+        return component;
+    }
+
+    /// <summary>
+    /// 获取 GameObject 是否在场景中。
+    /// </summary>
+    /// <param name="gameObject">目标对象。</param>
+    /// <returns>GameObject 是否在场景中。</returns>
+    /// <remarks>若返回 true，表明此 GameObject 是一个场景中的实例对象；若返回 false，表明此 GameObject 是一个 Prefab。</remarks>
+    public static bool InScene(this GameObject gameObject)
+    {
+        return gameObject.scene.name != null;
+    }
+
+    /// <summary>
+    /// 递归设置游戏对象的层次。
+    /// </summary>
+    /// <param name="gameObject"><see cref="GameObject" /> 对象。</param>
+    /// <param name="layer">目标层次的编号。</param>
+    public static void SetLayerRecursively(this GameObject gameObject, int layer)
+    {
+        gameObject.GetComponentsInChildren(true, s_CachedTransforms);
+        for (int i = 0; i < s_CachedTransforms.Count; i++)
+        {
+            s_CachedTransforms[i].gameObject.layer = layer;
+        }
+
+        s_CachedTransforms.Clear();
+    }
+
+    /// <summary>
+    /// 取 <see cref="Vector3" /> 的 (x, y, z) 转换为 <see cref="Vector2" /> 的 (x, z)。
+    /// </summary>
+    /// <param name="vector3">要转换的 Vector3。</param>
+    /// <returns>转换后的 Vector2。</returns>
+    public static Vector2 ToVector2(this Vector3 vector3)
+    {
+        return new Vector2(vector3.x, vector3.z);
+    }
+
+    /// <summary>
+    /// 取 <see cref="Vector2" /> 的 (x, y) 转换为 <see cref="Vector3" /> 的 (x, 0, y)。
+    /// </summary>
+    /// <param name="vector2">要转换的 Vector2。</param>
+    /// <returns>转换后的 Vector3。</returns>
+    public static Vector3 ToVector3(this Vector2 vector2)
+    {
+        return new Vector3(vector2.x, 0f, vector2.y);
+    }
+
+    /// <summary>
+    /// 取 <see cref="Vector2" /> 的 (x, y) 和给定参数 y 转换为 <see cref="Vector3" /> 的 (x, 参数 y, y)。
+    /// </summary>
+    /// <param name="vector2">要转换的 Vector2。</param>
+    /// <param name="y">Vector3 的 y 值。</param>
+    /// <returns>转换后的 Vector3。</returns>
+    public static Vector3 ToVector3(this Vector2 vector2, float y)
+    {
+        return new Vector3(vector2.x, y, vector2.y);
+    }
+
+    #region Transform
+
+    /// <summary>
+    /// 设置绝对位置的 x 坐标。
+    /// </summary>
+    /// <param name="transform"><see cref="Transform" /> 对象。</param>
+    /// <param name="newValue">x 坐标值。</param>
+    public static void SetPositionX(this Transform transform, float newValue)
+    {
+        Vector3 v = transform.position;
+        v.x = newValue;
+        transform.position = v;
+    }
+
+    /// <summary>
+    /// 设置绝对位置的 y 坐标。
+    /// </summary>
+    /// <param name="transform"><see cref="Transform" /> 对象。</param>
+    /// <param name="newValue">y 坐标值。</param>
+    public static void SetPositionY(this Transform transform, float newValue)
+    {
+        Vector3 v = transform.position;
+        v.y = newValue;
+        transform.position = v;
+    }
+
+    /// <summary>
+    /// 设置绝对位置的 z 坐标。
+    /// </summary>
+    /// <param name="transform"><see cref="Transform" /> 对象。</param>
+    /// <param name="newValue">z 坐标值。</param>
+    public static void SetPositionZ(this Transform transform, float newValue)
+    {
+        Vector3 v = transform.position;
+        v.z = newValue;
+        transform.position = v;
+    }
+
+    /// <summary>
+    /// 增加绝对位置的 x 坐标。
+    /// </summary>
+    /// <param name="transform"><see cref="Transform" /> 对象。</param>
+    /// <param name="deltaValue">x 坐标值增量。</param>
+    public static void AddPositionX(this Transform transform, float deltaValue)
+    {
+        Vector3 v = transform.position;
+        v.x += deltaValue;
+        transform.position = v;
+    }
+
+    /// <summary>
+    /// 增加绝对位置的 y 坐标。
+    /// </summary>
+    /// <param name="transform"><see cref="Transform" /> 对象。</param>
+    /// <param name="deltaValue">y 坐标值增量。</param>
+    public static void AddPositionY(this Transform transform, float deltaValue)
+    {
+        Vector3 v = transform.position;
+        v.y += deltaValue;
+        transform.position = v;
+    }
+
+    /// <summary>
+    /// 增加绝对位置的 z 坐标。
+    /// </summary>
+    /// <param name="transform"><see cref="Transform" /> 对象。</param>
+    /// <param name="deltaValue">z 坐标值增量。</param>
+    public static void AddPositionZ(this Transform transform, float deltaValue)
+    {
+        Vector3 v = transform.position;
+        v.z += deltaValue;
+        transform.position = v;
+    }
+
+    /// <summary>
+    /// 设置相对位置的 x 坐标。
+    /// </summary>
+    /// <param name="transform"><see cref="Transform" /> 对象。</param>
+    /// <param name="newValue">x 坐标值。</param>
+    public static void SetLocalPositionX(this Transform transform, float newValue)
+    {
+        Vector3 v = transform.localPosition;
+        v.x = newValue;
+        transform.localPosition = v;
+    }
+
+    /// <summary>
+    /// 设置相对位置的 y 坐标。
+    /// </summary>
+    /// <param name="transform"><see cref="Transform" /> 对象。</param>
+    /// <param name="newValue">y 坐标值。</param>
+    public static void SetLocalPositionY(this Transform transform, float newValue)
+    {
+        Vector3 v = transform.localPosition;
+        v.y = newValue;
+        transform.localPosition = v;
+    }
+
+    /// <summary>
+    /// 设置相对位置的 z 坐标。
+    /// </summary>
+    /// <param name="transform"><see cref="Transform" /> 对象。</param>
+    /// <param name="newValue">z 坐标值。</param>
+    public static void SetLocalPositionZ(this Transform transform, float newValue)
+    {
+        Vector3 v = transform.localPosition;
+        v.z = newValue;
+        transform.localPosition = v;
+    }
+
+    /// <summary>
+    /// 增加相对位置的 x 坐标。
+    /// </summary>
+    /// <param name="transform"><see cref="Transform" /> 对象。</param>
+    /// <param name="deltaValue">x 坐标值。</param>
+    public static void AddLocalPositionX(this Transform transform, float deltaValue)
+    {
+        Vector3 v = transform.localPosition;
+        v.x += deltaValue;
+        transform.localPosition = v;
+    }
+
+    /// <summary>
+    /// 增加相对位置的 y 坐标。
+    /// </summary>
+    /// <param name="transform"><see cref="Transform" /> 对象。</param>
+    /// <param name="deltaValue">y 坐标值。</param>
+    public static void AddLocalPositionY(this Transform transform, float deltaValue)
+    {
+        Vector3 v = transform.localPosition;
+        v.y += deltaValue;
+        transform.localPosition = v;
+    }
+
+    /// <summary>
+    /// 增加相对位置的 z 坐标。
+    /// </summary>
+    /// <param name="transform"><see cref="Transform" /> 对象。</param>
+    /// <param name="deltaValue">z 坐标值。</param>
+    public static void AddLocalPositionZ(this Transform transform, float deltaValue)
+    {
+        Vector3 v = transform.localPosition;
+        v.z += deltaValue;
+        transform.localPosition = v;
+    }
+
+    /// <summary>
+    /// 设置相对尺寸的 x 分量。
+    /// </summary>
+    /// <param name="transform"><see cref="Transform" /> 对象。</param>
+    /// <param name="newValue">x 分量值。</param>
+    public static void SetLocalScaleX(this Transform transform, float newValue)
+    {
+        Vector3 v = transform.localScale;
+        v.x = newValue;
+        transform.localScale = v;
+    }
+
+    /// <summary>
+    /// 设置相对尺寸的 y 分量。
+    /// </summary>
+    /// <param name="transform"><see cref="Transform" /> 对象。</param>
+    /// <param name="newValue">y 分量值。</param>
+    public static void SetLocalScaleY(this Transform transform, float newValue)
+    {
+        Vector3 v = transform.localScale;
+        v.y = newValue;
+        transform.localScale = v;
+    }
+
+    /// <summary>
+    /// 设置相对尺寸的 z 分量。
+    /// </summary>
+    /// <param name="transform"><see cref="Transform" /> 对象。</param>
+    /// <param name="newValue">z 分量值。</param>
+    public static void SetLocalScaleZ(this Transform transform, float newValue)
+    {
+        Vector3 v = transform.localScale;
+        v.z = newValue;
+        transform.localScale = v;
+    }
+
+    /// <summary>
+    /// 增加相对尺寸的 x 分量。
+    /// </summary>
+    /// <param name="transform"><see cref="Transform" /> 对象。</param>
+    /// <param name="deltaValue">x 分量增量。</param>
+    public static void AddLocalScaleX(this Transform transform, float deltaValue)
+    {
+        Vector3 v = transform.localScale;
+        v.x += deltaValue;
+        transform.localScale = v;
+    }
+
+    /// <summary>
+    /// 增加相对尺寸的 y 分量。
+    /// </summary>
+    /// <param name="transform"><see cref="Transform" /> 对象。</param>
+    /// <param name="deltaValue">y 分量增量。</param>
+    public static void AddLocalScaleY(this Transform transform, float deltaValue)
+    {
+        Vector3 v = transform.localScale;
+        v.y += deltaValue;
+        transform.localScale = v;
+    }
+
+    /// <summary>
+    /// 增加相对尺寸的 z 分量。
+    /// </summary>
+    /// <param name="transform"><see cref="Transform" /> 对象。</param>
+    /// <param name="deltaValue">z 分量增量。</param>
+    public static void AddLocalScaleZ(this Transform transform, float deltaValue)
+    {
+        Vector3 v = transform.localScale;
+        v.z += deltaValue;
+        transform.localScale = v;
+    }
+
+    /// <summary>
+    /// 二维空间下使 <see cref="Transform" /> 指向指向目标点的算法，使用世界坐标。
+    /// </summary>
+    /// <param name="transform"><see cref="Transform" /> 对象。</param>
+    /// <param name="lookAtPoint2D">要朝向的二维坐标点。</param>
+    /// <remarks>假定其 forward 向量为 <see cref="Vector3.up" />。</remarks>
+    public static void LookAt2D(this Transform transform, Vector2 lookAtPoint2D)
+    {
+        Vector3 vector = lookAtPoint2D.ToVector3() - transform.position;
+        vector.y = 0f;
+
+        if (vector.magnitude > 0f)
+        {
+            transform.rotation = Quaternion.LookRotation(vector.normalized, Vector3.up);
+        }
+    }
+
+    #endregion Transform
+}

Assets/TEngine/Runtime/Utility/UnityExtension.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: a1a3443e3fec16542b5f5c354803bcd4
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TEngine/Runtime/Version.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 27d9499af68549ca973bcb5af278018f
+timeCreated: 1680338287

Assets/TEngine/Runtime/Version/Version.IVersionHelper.cs

@@ -0,0 +1,27 @@
+namespace TEngine
+{
+    public static partial class Version
+    {
+        /// <summary>
+        /// 版本号辅助器接口。
+        /// </summary>
+        public interface IVersionHelper
+        {
+            /// <summary>
+            /// 获取游戏版本号。
+            /// </summary>
+            string GameVersion
+            {
+                get;
+            }
+
+            /// <summary>
+            /// 获取内部游戏版本号。
+            /// </summary>
+            int InternalGameVersion
+            {
+                get;
+            }
+        }
+    }
+}

Assets/TEngine/Runtime/Version/Version.IVersionHelper.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 80f76c740d32479986a4a4eb04a8a9da
+timeCreated: 1680338288

Assets/TEngine/Runtime/Version/Version.cs

@@ -0,0 +1,58 @@
+namespace TEngine
+{
+    /// <summary>
+    /// 版本号类。
+    /// </summary>
+    public static partial class Version
+    {
+        private const string GameFrameworkVersionString = "2023.04.31";
+
+        private static IVersionHelper s_VersionHelper = null;
+
+        /// <summary>
+        /// 获取游戏框架版本号。
+        /// </summary>
+        public static string GameFrameworkVersion => GameFrameworkVersionString;
+
+        /// <summary>
+        /// 获取游戏版本号。
+        /// </summary>
+        public static string GameVersion
+        {
+            get
+            {
+                if (s_VersionHelper == null)
+                {
+                    return string.Empty;
+                }
+
+                return s_VersionHelper.GameVersion;
+            }
+        }
+
+        /// <summary>
+        /// 获取内部游戏版本号。
+        /// </summary>
+        public static int InternalGameVersion
+        {
+            get
+            {
+                if (s_VersionHelper == null)
+                {
+                    return 0;
+                }
+
+                return s_VersionHelper.InternalGameVersion;
+            }
+        }
+
+        /// <summary>
+        /// 设置版本号辅助器。
+        /// </summary>
+        /// <param name="versionHelper">要设置的版本号辅助器。</param>
+        public static void SetVersionHelper(IVersionHelper versionHelper)
+        {
+            s_VersionHelper = versionHelper;
+        }
+    }
+}

Assets/TEngine/Runtime/Version/Version.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 145aad75d48e46af9099829684014934
+timeCreated: 1680338287