[增加]1. 增加Localization 本地化组件

This commit is contained in:
AlianBlank 2024-04-10 17:44:53 +08:00
parent 28c0dc8ec4
commit a3b3079ea6
45 changed files with 3691 additions and 1 deletions

8
Editor.meta Normal file
View File

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

View File

@ -0,0 +1,19 @@
{
"name": "GameFrameX.Localization.Editor",
"references": [
"GameFrameX.Localization.Runtime",
"GameFrameX.Editor",
"GameFrameX.Runtime"
],
"includePlatforms": [
"Editor"
],
"excludePlatforms": [],
"allowUnsafeCode": false,
"overrideReferences": false,
"precompiledReferences": [],
"autoReferenced": true,
"defineConstraints": [],
"versionDefines": [],
"noEngineReferences": false
}

View File

@ -0,0 +1,7 @@
fileFormatVersion: 2
guid: 765f0c3296ad9fe429bb0243d8661349
AssemblyDefinitionImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

8
Editor/Inspector.meta Normal file
View File

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

View File

@ -0,0 +1,74 @@
//------------------------------------------------------------
// Game Framework
// Copyright © 2013-2021 Jiang Yin. All rights reserved.
// Homepage: https://gameframework.cn/
// Feedback: mailto:ellan@gameframework.cn
//------------------------------------------------------------
using GameFrameX.Editor;
using GameFrameX.Localization.Runtime;
using UnityEditor;
namespace GameFrameX.Localization.Editor
{
[CustomEditor(typeof(LocalizationComponent))]
internal sealed class LocalizationComponentInspector : GameFrameworkInspector
{
private SerializedProperty m_EnableLoadDictionaryUpdateEvent = null;
private SerializedProperty m_CachedBytesSize = null;
private HelperInfo<LocalizationHelperBase> m_LocalizationHelperInfo = new HelperInfo<LocalizationHelperBase>("Localization");
public override void OnInspectorGUI()
{
base.OnInspectorGUI();
serializedObject.Update();
LocalizationComponent localizationComponent = (LocalizationComponent)target;
EditorGUI.BeginDisabledGroup(EditorApplication.isPlayingOrWillChangePlaymode);
{
EditorGUILayout.PropertyField(m_EnableLoadDictionaryUpdateEvent);
m_LocalizationHelperInfo.Draw();
EditorGUILayout.PropertyField(m_CachedBytesSize);
}
EditorGUI.EndDisabledGroup();
if (EditorApplication.isPlaying && IsPrefabInHierarchy(localizationComponent.gameObject))
{
EditorGUILayout.LabelField("Language", localizationComponent.Language.ToString());
EditorGUILayout.LabelField("System Language", localizationComponent.SystemLanguage.ToString());
EditorGUILayout.LabelField("Dictionary Count", localizationComponent.DictionaryCount.ToString());
// EditorGUILayout.LabelField("Cached Bytes Size", t.CachedBytesSize.ToString());
}
serializedObject.ApplyModifiedProperties();
Repaint();
}
protected override void OnCompileComplete()
{
base.OnCompileComplete();
RefreshTypeNames();
}
private void OnEnable()
{
m_EnableLoadDictionaryUpdateEvent = serializedObject.FindProperty("m_EnableLoadDictionaryUpdateEvent");
m_CachedBytesSize = serializedObject.FindProperty("m_CachedBytesSize");
m_LocalizationHelperInfo.Init(serializedObject);
RefreshTypeNames();
}
private void RefreshTypeNames()
{
m_LocalizationHelperInfo.Refresh();
serializedObject.ApplyModifiedProperties();
}
}
}

View File

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

201
LICENSE.md Normal file
View File

@ -0,0 +1,201 @@
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "[]"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright [2023] [ALianBlank of copyright owner][alianblank@outlook.com][https://alianblank.com/]
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.

7
LICENSE.md.meta Normal file
View File

@ -0,0 +1,7 @@
fileFormatVersion: 2
guid: 7e04ca32553eca44ab7440f2e228dc54
TextScriptImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

View File

@ -1 +1,19 @@
# com.alianblank.gameframex.unity.localization
## HOMEPAGE
GameFrameX 的 Localization 本地化组件
**Localization 本地化组件 (Localization Component)** - 提供本地化组件相关的接口。
# 使用文档(文档编写于GPT4)
## 注意事项
# 使用方式(任选其一)
1. 直接在 `manifest.json` 的文件中的 `dependencies` 节点下添加以下内容
```json
{"com.alianblank.gameframex.localization": "https://github.com/AlianBlank/com.alianblank.gameframex.unity.localization.git"}
```
2. 在Unity 的`Packages Manager` 中使用`Git URL` 的方式添加库,地址为https://github.com/AlianBlank/com.alianblank.gameframex.unity.localization.git
3. 直接下载仓库放置到Unity 项目的`Packages` 目录下。会自动加载识别

7
README.md.meta Normal file
View File

@ -0,0 +1,7 @@
fileFormatVersion: 2
guid: c9039f279ed482b49ab41575f645e4c8
TextScriptImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

8
Runtime.meta Normal file
View File

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

3
Runtime/EventArgs.meta Normal file
View File

@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: 29f897f1a14848bd96dceef66e97450d
timeCreated: 1712727478

View File

@ -0,0 +1,81 @@
//------------------------------------------------------------
// Game Framework
// Copyright © 2013-2021 Jiang Yin. All rights reserved.
// Homepage: https://gameframework.cn/
// Feedback: mailto:ellan@gameframework.cn
//------------------------------------------------------------
using GameFrameX.Event.Runtime;
namespace GameFrameX.Localization.Runtime
{
/// <summary>
/// 加载字典失败事件。
/// </summary>
public sealed class LoadDictionaryFailureEventArgs : GameEventArgs
{
/// <summary>
/// 加载字典失败事件编号。
/// </summary>
public static readonly string EventId = typeof(LoadDictionaryFailureEventArgs).FullName;
/// <summary>
/// 初始化加载字典失败事件的新实例。
/// </summary>
public LoadDictionaryFailureEventArgs()
{
DictionaryAssetName = null;
ErrorMessage = null;
UserData = null;
}
/// <summary>
/// 获取加载字典失败事件编号。
/// </summary>
public override string Id
{
get { return EventId; }
}
/// <summary>
/// 获取字典资源名称。
/// </summary>
public string DictionaryAssetName { get; private set; }
/// <summary>
/// 获取错误信息。
/// </summary>
public string ErrorMessage { get; private set; }
/// <summary>
/// 获取用户自定义数据。
/// </summary>
public object UserData { get; private set; }
/// <summary>
/// 创建加载字典失败事件。
/// </summary>
/// <param name="dataAssetName">字典资源名称。</param>
/// <param name="errorMessage">错误信息。</param>
/// <param name="userData">用户自定义数据。</param>
/// <returns>创建的加载字典失败事件。</returns>
public static LoadDictionaryFailureEventArgs Create(string dataAssetName, string errorMessage, object userData)
{
LoadDictionaryFailureEventArgs loadDictionaryFailureEventArgs = ReferencePool.Acquire<LoadDictionaryFailureEventArgs>();
loadDictionaryFailureEventArgs.DictionaryAssetName = dataAssetName;
loadDictionaryFailureEventArgs.ErrorMessage = errorMessage;
loadDictionaryFailureEventArgs.UserData = userData;
return loadDictionaryFailureEventArgs;
}
/// <summary>
/// 清理加载字典失败事件。
/// </summary>
public override void Clear()
{
DictionaryAssetName = null;
ErrorMessage = null;
UserData = null;
}
}
}

View File

@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: 7e93c37ebea54a8ca707cbe08a1ddf6b
timeCreated: 1712727478

View File

@ -0,0 +1,81 @@
//------------------------------------------------------------
// Game Framework
// Copyright © 2013-2021 Jiang Yin. All rights reserved.
// Homepage: https://gameframework.cn/
// Feedback: mailto:ellan@gameframework.cn
//------------------------------------------------------------
using GameFrameX.Event.Runtime;
namespace GameFrameX.Localization.Runtime
{
/// <summary>
/// 加载字典成功事件。
/// </summary>
public sealed class LoadDictionarySuccessEventArgs : GameEventArgs
{
/// <summary>
/// 加载字典成功事件编号。
/// </summary>
public static readonly string EventId = typeof(LoadDictionarySuccessEventArgs).FullName;
/// <summary>
/// 初始化加载字典成功事件的新实例。
/// </summary>
public LoadDictionarySuccessEventArgs()
{
DictionaryAssetName = null;
Duration = 0f;
UserData = null;
}
/// <summary>
/// 获取加载字典成功事件编号。
/// </summary>
public override string Id
{
get { return EventId; }
}
/// <summary>
/// 获取字典资源名称。
/// </summary>
public string DictionaryAssetName { get; private set; }
/// <summary>
/// 获取加载持续时间。
/// </summary>
public float Duration { get; private set; }
/// <summary>
/// 获取用户自定义数据。
/// </summary>
public object UserData { get; private set; }
/// <summary>
/// 创建加载字典成功事件。
/// </summary>
/// <param name="dataAssetName">字典资源名称。</param>
/// <param name="duration">加载持续时间。</param>
/// <param name="userData">用户自定义数据。</param>
/// <returns>创建的加载字典成功事件。</returns>
public static LoadDictionarySuccessEventArgs Create(string dataAssetName, float duration, object userData)
{
LoadDictionarySuccessEventArgs loadDictionarySuccessEventArgs = ReferencePool.Acquire<LoadDictionarySuccessEventArgs>();
loadDictionarySuccessEventArgs.DictionaryAssetName = dataAssetName;
loadDictionarySuccessEventArgs.Duration = duration;
loadDictionarySuccessEventArgs.UserData = userData;
return loadDictionarySuccessEventArgs;
}
/// <summary>
/// 清理加载字典成功事件。
/// </summary>
public override void Clear()
{
DictionaryAssetName = null;
Duration = 0f;
UserData = null;
}
}
}

View File

@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: 076d746a1a844037a7e1b11f42a93d39
timeCreated: 1712727478

View File

@ -0,0 +1,81 @@
//------------------------------------------------------------
// Game Framework
// Copyright © 2013-2021 Jiang Yin. All rights reserved.
// Homepage: https://gameframework.cn/
// Feedback: mailto:ellan@gameframework.cn
//------------------------------------------------------------
using GameFrameX.Event.Runtime;
namespace GameFrameX.Localization.Runtime
{
/// <summary>
/// 加载字典更新事件。
/// </summary>
public sealed class LoadDictionaryUpdateEventArgs : GameEventArgs
{
/// <summary>
/// 加载字典更新事件编号。
/// </summary>
public static readonly string EventId = typeof(LoadDictionaryUpdateEventArgs).FullName;
/// <summary>
/// 初始化加载字典更新事件的新实例。
/// </summary>
public LoadDictionaryUpdateEventArgs()
{
DictionaryAssetName = null;
Progress = 0f;
UserData = null;
}
/// <summary>
/// 获取加载字典更新事件编号。
/// </summary>
public override string Id
{
get { return EventId; }
}
/// <summary>
/// 获取字典资源名称。
/// </summary>
public string DictionaryAssetName { get; private set; }
/// <summary>
/// 获取加载字典进度。
/// </summary>
public float Progress { get; private set; }
/// <summary>
/// 获取用户自定义数据。
/// </summary>
public object UserData { get; private set; }
/// <summary>
/// 创建加载字典更新事件。
/// </summary>
/// <param name="dataAssetName">字典资源名称。</param>
/// <param name="progress">加载字典进度。</param>
/// <param name="userData">用户自定义数据。</param>
/// <returns>创建的加载字典更新事件。</returns>
public static LoadDictionaryUpdateEventArgs Create(string dataAssetName, float progress, object userData)
{
LoadDictionaryUpdateEventArgs loadDictionaryUpdateEventArgs = ReferencePool.Acquire<LoadDictionaryUpdateEventArgs>();
loadDictionaryUpdateEventArgs.DictionaryAssetName = dataAssetName;
loadDictionaryUpdateEventArgs.Progress = progress;
loadDictionaryUpdateEventArgs.UserData = userData;
return loadDictionaryUpdateEventArgs;
}
/// <summary>
/// 清理加载字典更新事件。
/// </summary>
public override void Clear()
{
DictionaryAssetName = null;
Progress = 0f;
UserData = null;
}
}
}

View File

@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: 224eb81e1d174acd81af7538d0b3981f
timeCreated: 1712727478

View File

@ -0,0 +1,18 @@
{
"name": "GameFrameX.Localization.Runtime",
"references": [
"GameFrameX.Runtime",
"GameFrameX.Event.Runtime",
"GameFrameX.Asset.Runtime"
],
"rootNamespace": "GameFrameX.Localization.Runtime",
"includePlatforms": [],
"excludePlatforms": [],
"allowUnsafeCode": true,
"overrideReferences": false,
"precompiledReferences": [],
"autoReferenced": true,
"defineConstraints": [],
"versionDefines": [],
"noEngineReferences": false
}

View File

@ -0,0 +1,7 @@
fileFormatVersion: 2
guid: bf4e5ed5012de6f429b4d64a2a185b65
AssemblyDefinitionImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

View File

@ -0,0 +1,19 @@
using UnityEngine;
namespace GameFrameX.Localization.Runtime
{
public class GameFrameXLocalizationCroppingHelper : MonoBehaviour
{
private void Start()
{
_ = typeof(ILocalizationHelper);
_ = typeof(ILocalizationManager);
_ = typeof(Language);
_ = typeof(LoadDictionaryFailureEventArgs);
_ = typeof(LoadDictionarySuccessEventArgs);
_ = typeof(LoadDictionaryUpdateEventArgs);
_ = typeof(LocalizationManager);
_ = typeof(DefaultLocalizationHelper);
}
}
}

View File

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

View File

@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: e809ab4c24274f93b6c92c8c3cb6adea
timeCreated: 1712727478

View File

@ -0,0 +1,240 @@
//------------------------------------------------------------
// Game Framework
// Copyright © 2013-2021 Jiang Yin. All rights reserved.
// Homepage: https://gameframework.cn/
// Feedback: mailto:ellan@gameframework.cn
//------------------------------------------------------------
using GameFrameX.Localization;
using System;
using System.IO;
using System.Text;
using GameFrameX.Asset.Runtime;
using GameFrameX.Runtime;
using UnityEngine;
namespace GameFrameX.Localization.Runtime
{
/// <summary>
/// 默认本地化辅助器。
/// </summary>
public class DefaultLocalizationHelper : LocalizationHelperBase
{
private static readonly string[] ColumnSplitSeparator = new string[] { "\t" };
private static readonly string BytesAssetExtension = ".bytes";
private const int ColumnCount = 4;
private AssetComponent m_ResourceComponent = null;
/// <summary>
/// 获取系统语言。
/// </summary>
public override Language SystemLanguage
{
get
{
switch (Application.systemLanguage)
{
case UnityEngine.SystemLanguage.Afrikaans: return Language.Afrikaans;
case UnityEngine.SystemLanguage.Arabic: return Language.Arabic;
case UnityEngine.SystemLanguage.Basque: return Language.Basque;
case UnityEngine.SystemLanguage.Belarusian: return Language.Belarusian;
case UnityEngine.SystemLanguage.Bulgarian: return Language.Bulgarian;
case UnityEngine.SystemLanguage.Catalan: return Language.Catalan;
case UnityEngine.SystemLanguage.Chinese: return Language.ChineseSimplified;
case UnityEngine.SystemLanguage.ChineseSimplified: return Language.ChineseSimplified;
case UnityEngine.SystemLanguage.ChineseTraditional: return Language.ChineseTraditional;
case UnityEngine.SystemLanguage.Czech: return Language.Czech;
case UnityEngine.SystemLanguage.Danish: return Language.Danish;
case UnityEngine.SystemLanguage.Dutch: return Language.Dutch;
case UnityEngine.SystemLanguage.English: return Language.English;
case UnityEngine.SystemLanguage.Estonian: return Language.Estonian;
case UnityEngine.SystemLanguage.Faroese: return Language.Faroese;
case UnityEngine.SystemLanguage.Finnish: return Language.Finnish;
case UnityEngine.SystemLanguage.French: return Language.French;
case UnityEngine.SystemLanguage.German: return Language.German;
case UnityEngine.SystemLanguage.Greek: return Language.Greek;
case UnityEngine.SystemLanguage.Hebrew: return Language.Hebrew;
case UnityEngine.SystemLanguage.Hungarian: return Language.Hungarian;
case UnityEngine.SystemLanguage.Icelandic: return Language.Icelandic;
case UnityEngine.SystemLanguage.Indonesian: return Language.Indonesian;
case UnityEngine.SystemLanguage.Italian: return Language.Italian;
case UnityEngine.SystemLanguage.Japanese: return Language.Japanese;
case UnityEngine.SystemLanguage.Korean: return Language.Korean;
case UnityEngine.SystemLanguage.Latvian: return Language.Latvian;
case UnityEngine.SystemLanguage.Lithuanian: return Language.Lithuanian;
case UnityEngine.SystemLanguage.Norwegian: return Language.Norwegian;
case UnityEngine.SystemLanguage.Polish: return Language.Polish;
case UnityEngine.SystemLanguage.Portuguese: return Language.PortuguesePortugal;
case UnityEngine.SystemLanguage.Romanian: return Language.Romanian;
case UnityEngine.SystemLanguage.Russian: return Language.Russian;
case UnityEngine.SystemLanguage.SerboCroatian: return Language.SerboCroatian;
case UnityEngine.SystemLanguage.Slovak: return Language.Slovak;
case UnityEngine.SystemLanguage.Slovenian: return Language.Slovenian;
case UnityEngine.SystemLanguage.Spanish: return Language.Spanish;
case UnityEngine.SystemLanguage.Swedish: return Language.Swedish;
case UnityEngine.SystemLanguage.Thai: return Language.Thai;
case UnityEngine.SystemLanguage.Turkish: return Language.Turkish;
case UnityEngine.SystemLanguage.Ukrainian: return Language.Ukrainian;
case UnityEngine.SystemLanguage.Unknown: return Language.Unspecified;
case UnityEngine.SystemLanguage.Vietnamese: return Language.Vietnamese;
default: return Language.Unspecified;
}
}
}
/// <summary>
/// 读取字典。
/// </summary>
/// <param name="localizationManager">本地化管理器。</param>
/// <param name="dictionaryAssetName">字典资源名称。</param>
/// <param name="dictionaryAsset">字典资源。</param>
/// <param name="userData">用户自定义数据。</param>
/// <returns>是否读取字典成功。</returns>
public override bool ReadData(ILocalizationManager localizationManager, string dictionaryAssetName, object dictionaryAsset, object userData)
{
// TextAsset dictionaryTextAsset = dictionaryAsset as TextAsset;
// if (dictionaryTextAsset != null)
// {
// if (dictionaryAssetName.EndsWith(BytesAssetExtension, StringComparison.Ordinal))
// {
// return localizationManager.ParseData(dictionaryTextAsset.bytes, userData);
// }
// else
// {
// return localizationManager.ParseData(dictionaryTextAsset.text, userData);
// }
// }
//
// Log.Warning("Dictionary asset '{0}' is invalid.", dictionaryAssetName);
return false;
}
/// <summary>
/// 读取字典。
/// </summary>
/// <param name="localizationManager">本地化管理器。</param>
/// <param name="dictionaryAssetName">字典资源名称。</param>
/// <param name="dictionaryBytes">字典二进制流。</param>
/// <param name="startIndex">字典二进制流的起始位置。</param>
/// <param name="length">字典二进制流的长度。</param>
/// <param name="userData">用户自定义数据。</param>
/// <returns>是否读取字典成功。</returns>
public override bool ReadData(ILocalizationManager localizationManager, string dictionaryAssetName, byte[] dictionaryBytes, int startIndex, int length, object userData)
{
return true;
// if (dictionaryAssetName.EndsWith(BytesAssetExtension, StringComparison.Ordinal))
// {
// return localizationManager.ParseData(dictionaryBytes, startIndex, length, userData);
// }
// else
// {
// return localizationManager.ParseData(Utility.Converter.GetString(dictionaryBytes, startIndex, length), userData);
// }
}
/// <summary>
/// 解析字典。
/// </summary>
/// <param name="localizationManager">本地化管理器。</param>
/// <param name="dictionaryString">要解析的字典字符串。</param>
/// <param name="userData">用户自定义数据。</param>
/// <returns>是否解析字典成功。</returns>
public override bool ParseData(ILocalizationManager localizationManager, string dictionaryString, object userData)
{
try
{
int position = 0;
string dictionaryLineString = null;
while ((dictionaryLineString = dictionaryString.ReadLine(ref position)) != null)
{
if (dictionaryLineString[0] == '#')
{
continue;
}
string[] splitedLine = dictionaryLineString.Split(ColumnSplitSeparator, StringSplitOptions.None);
if (splitedLine.Length != ColumnCount)
{
Log.Warning("Can not parse dictionary line string '{0}' which column count is invalid.", dictionaryLineString);
return false;
}
string dictionaryKey = splitedLine[1];
string dictionaryValue = splitedLine[3];
if (!localizationManager.AddRawString(dictionaryKey, dictionaryValue))
{
Log.Warning("Can not add raw string with dictionary key '{0}' which may be invalid or duplicate.", dictionaryKey);
return false;
}
}
return true;
}
catch (Exception exception)
{
Log.Warning("Can not parse dictionary string with exception '{0}'.", exception);
return false;
}
}
/// <summary>
/// 解析字典。
/// </summary>
/// <param name="localizationManager">本地化管理器。</param>
/// <param name="dictionaryBytes">要解析的字典二进制流。</param>
/// <param name="startIndex">字典二进制流的起始位置。</param>
/// <param name="length">字典二进制流的长度。</param>
/// <param name="userData">用户自定义数据。</param>
/// <returns>是否解析字典成功。</returns>
public override bool ParseData(ILocalizationManager localizationManager, byte[] dictionaryBytes, int startIndex, int length, object userData)
{
try
{
using (MemoryStream memoryStream = new MemoryStream(dictionaryBytes, startIndex, length, false))
{
using (BinaryReader binaryReader = new BinaryReader(memoryStream, Encoding.UTF8))
{
while (binaryReader.BaseStream.Position < binaryReader.BaseStream.Length)
{
string dictionaryKey = binaryReader.ReadString();
string dictionaryValue = binaryReader.ReadString();
if (!localizationManager.AddRawString(dictionaryKey, dictionaryValue))
{
Log.Warning("Can not add raw string with dictionary key '{0}' which may be invalid or duplicate.", dictionaryKey);
return false;
}
}
}
}
return true;
}
catch (Exception exception)
{
Log.Warning("Can not parse dictionary bytes with exception '{0}'.", exception);
return false;
}
}
/// <summary>
/// 释放字典资源。
/// </summary>
/// <param name="localizationManager">本地化管理器。</param>
/// <param name="dictionaryAsset">要释放的字典资源。</param>
public override void ReleaseDataAsset(ILocalizationManager localizationManager, object dictionaryAsset)
{
// m_ResourceComponent.UnloadAsset(dictionaryAsset);
}
private void Start()
{
m_ResourceComponent = GameEntry.GetComponent<AssetComponent>();
if (m_ResourceComponent == null)
{
Log.Fatal("Resource component is invalid.");
return;
}
}
}
}

View File

@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: 561ac6912af54f1d996b2d4bae0a822f
timeCreated: 1712727478

View File

@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: f21bf0d39b424adaa2b9de2cd1e7797b
timeCreated: 1712727478

View File

@ -0,0 +1,23 @@
//------------------------------------------------------------
// Game Framework
// Copyright © 2013-2021 Jiang Yin. All rights reserved.
// Homepage: https://gameframework.cn/
// Feedback: mailto:ellan@gameframework.cn
//------------------------------------------------------------
namespace GameFrameX.Localization.Runtime
{
/// <summary>
/// 本地化辅助器接口。
/// </summary>
public interface ILocalizationHelper
{
/// <summary>
/// 获取系统语言。
/// </summary>
Language SystemLanguage
{
get;
}
}
}

View File

@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: 87755065a12c46e7986673b28862a9fe
timeCreated: 1712727478

View File

@ -0,0 +1,491 @@
//------------------------------------------------------------
// Game Framework
// Copyright © 2013-2021 Jiang Yin. All rights reserved.
// Homepage: https://gameframework.cn/
// Feedback: mailto:ellan@gameframework.cn
//------------------------------------------------------------
using GameFrameX.Asset;
using GameFrameX.Asset.Runtime;
namespace GameFrameX.Localization.Runtime
{
/// <summary>
/// 本地化管理器接口。
/// </summary>
public interface ILocalizationManager
{
/// <summary>
/// 获取或设置本地化语言。
/// </summary>
Language Language { get; set; }
/// <summary>
/// 获取系统语言。
/// </summary>
Language SystemLanguage { get; }
/// <summary>
/// 获取字典数量。
/// </summary>
int DictionaryCount { get; }
/// <summary>
/// 设置资源管理器。
/// </summary>
/// <param name="assetManager">资源管理器。</param>
void SetAssetManager(IAssetManager assetManager);
/// <summary>
/// 设置本地化辅助器。
/// </summary>
/// <param name="localizationHelper">本地化辅助器。</param>
void SetLocalizationHelper(ILocalizationHelper localizationHelper);
/*
/// <summary>
/// 确保二进制流缓存分配足够大小的内存并缓存。
/// </summary>
/// <param name="ensureSize">要确保二进制流缓存分配内存的大小。</param>
void EnsureCachedBytesSize(int ensureSize);
/// <summary>
/// 释放缓存的二进制流。
/// </summary>
void FreeCachedBytes();*/
/// <summary>
/// 根据字典主键获取字典内容字符串。
/// </summary>
/// <param name="key">字典主键。</param>
/// <returns>要获取的字典内容字符串。</returns>
string GetString(string key);
/// <summary>
/// 根据字典主键获取字典内容字符串。
/// </summary>
/// <typeparam name="T">字典参数的类型。</typeparam>
/// <param name="key">字典主键。</param>
/// <param name="args">字典参数列表。</param>
/// <returns>要获取的字典内容字符串。</returns>
string GetString(string key, params object[] args);
/// <summary>
/// 根据字典主键获取字典内容字符串。
/// </summary>
/// <typeparam name="T">字典参数的类型。</typeparam>
/// <param name="key">字典主键。</param>
/// <param name="arg">字典参数。</param>
/// <returns>要获取的字典内容字符串。</returns>
string GetString<T>(string key, T arg);
/// <summary>
/// 根据字典主键获取字典内容字符串。
/// </summary>
/// <typeparam name="T1">字典参数 1 的类型。</typeparam>
/// <typeparam name="T2">字典参数 2 的类型。</typeparam>
/// <param name="key">字典主键。</param>
/// <param name="arg1">字典参数 1。</param>
/// <param name="arg2">字典参数 2。</param>
/// <returns>要获取的字典内容字符串。</returns>
string GetString<T1, T2>(string key, T1 arg1, T2 arg2);
/// <summary>
/// 根据字典主键获取字典内容字符串。
/// </summary>
/// <typeparam name="T1">字典参数 1 的类型。</typeparam>
/// <typeparam name="T2">字典参数 2 的类型。</typeparam>
/// <typeparam name="T3">字典参数 3 的类型。</typeparam>
/// <param name="key">字典主键。</param>
/// <param name="arg1">字典参数 1。</param>
/// <param name="arg2">字典参数 2。</param>
/// <param name="arg3">字典参数 3。</param>
/// <returns>要获取的字典内容字符串。</returns>
string GetString<T1, T2, T3>(string key, T1 arg1, T2 arg2, T3 arg3);
/// <summary>
/// 根据字典主键获取字典内容字符串。
/// </summary>
/// <typeparam name="T1">字典参数 1 的类型。</typeparam>
/// <typeparam name="T2">字典参数 2 的类型。</typeparam>
/// <typeparam name="T3">字典参数 3 的类型。</typeparam>
/// <typeparam name="T4">字典参数 4 的类型。</typeparam>
/// <param name="key">字典主键。</param>
/// <param name="arg1">字典参数 1。</param>
/// <param name="arg2">字典参数 2。</param>
/// <param name="arg3">字典参数 3。</param>
/// <param name="arg4">字典参数 4。</param>
/// <returns>要获取的字典内容字符串。</returns>
string GetString<T1, T2, T3, T4>(string key, T1 arg1, T2 arg2, T3 arg3, T4 arg4);
/// <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="key">字典主键。</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>
string GetString<T1, T2, T3, T4, T5>(string key, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5);
/// <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="key">字典主键。</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>
string GetString<T1, T2, T3, T4, T5, T6>(string key, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6);
/// <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="key">字典主键。</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>
string GetString<T1, T2, T3, T4, T5, T6, T7>(string key, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7);
/// <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="key">字典主键。</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>
string GetString<T1, T2, T3, T4, T5, T6, T7, T8>(string key, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8);
/// <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="key">字典主键。</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>
string GetString<T1, T2, T3, T4, T5, T6, T7, T8, T9>(string key, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9);
/// <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="key">字典主键。</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>
string GetString<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(string key, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10);
/// <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="key">字典主键。</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>
string GetString<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(string key, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11);
/// <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="key">字典主键。</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>
string GetString<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(string key, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12);
/// <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="key">字典主键。</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>
string GetString<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(string key, 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);
/// <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="key">字典主键。</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>
string GetString<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(string key, 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);
/// <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="key">字典主键。</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>
string GetString<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>(string key, 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);
/// <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="key">字典主键。</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>
string GetString<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>(string key, 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);
/// <summary>
/// 是否存在字典。
/// </summary>
/// <param name="key">字典主键。</param>
/// <returns>是否存在字典。</returns>
bool HasRawString(string key);
/// <summary>
/// 根据字典主键获取字典值。
/// </summary>
/// <param name="key">字典主键。</param>
/// <returns>字典值。</returns>
string GetRawString(string key);
/// <summary>
/// 增加字典。
/// </summary>
/// <param name="key">字典主键。</param>
/// <param name="value">字典内容。</param>
/// <returns>是否增加字典成功。</returns>
bool AddRawString(string key, string value);
/// <summary>
/// 移除字典。
/// </summary>
/// <param name="key">字典主键。</param>
/// <returns>是否移除字典成功。</returns>
bool RemoveRawString(string key);
/// <summary>
/// 清空所有字典。
/// </summary>
void RemoveAllRawStrings();
}
}

View File

@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: 05600158150d4b108b0173acad47e0fe
timeCreated: 1712727478

View File

@ -0,0 +1,270 @@
//------------------------------------------------------------
// Game Framework
// Copyright © 2013-2021 Jiang Yin. All rights reserved.
// Homepage: https://gameframework.cn/
// Feedback: mailto:ellan@gameframework.cn
//------------------------------------------------------------
namespace GameFrameX.Localization.Runtime
{
/// <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
}
}

View File

@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: 2825df334b6f4897a96e2547d5a4b3c4
timeCreated: 1712727478

File diff suppressed because it is too large Load Diff

View File

@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: f881828389644d9ab16b6d084931ab49
timeCreated: 1712727478

View File

@ -0,0 +1,777 @@
//------------------------------------------------------------
// Game Framework
// Copyright © 2013-2021 Jiang Yin. All rights reserved.
// Homepage: https://gameframework.cn/
// Feedback: mailto:ellan@gameframework.cn
//------------------------------------------------------------
using GameFrameX.Asset;
using GameFrameX.Asset.Runtime;
using GameFrameX.Event.Runtime;
using GameFrameX.Runtime;
using UnityEngine;
namespace GameFrameX.Localization.Runtime
{
/// <summary>
/// 本地化组件。
/// </summary>
[DisallowMultipleComponent]
[AddComponentMenu("Game Framework/Localization")]
public sealed class LocalizationComponent : GameFrameworkComponent
{
private const int DefaultPriority = 0;
private ILocalizationManager m_LocalizationManager = null;
private EventComponent m_EventComponent = null;
[SerializeField] private bool m_EnableLoadDictionaryUpdateEvent = false;
[SerializeField] private string m_LocalizationHelperTypeName = "UnityGameFramework.Runtime.DefaultLocalizationHelper";
[SerializeField] private LocalizationHelperBase m_CustomLocalizationHelper = null;
[SerializeField] private int m_CachedBytesSize = 0;
/// <summary>
/// 获取或设置本地化语言。
/// </summary>
public Language Language
{
get { return m_LocalizationManager.Language; }
set { m_LocalizationManager.Language = value; }
}
/// <summary>
/// 获取系统语言。
/// </summary>
public Language SystemLanguage
{
get { return m_LocalizationManager.SystemLanguage; }
}
/// <summary>
/// 获取字典数量。
/// </summary>
public int DictionaryCount
{
get { return m_LocalizationManager.DictionaryCount; }
}
/// <summary>
/// 获取缓冲二进制流的大小。
/// </summary>
// public int CachedBytesSize
// {
// get { return m_LocalizationManager.CachedBytesSize; }
// }
/// <summary>
/// 游戏框架组件初始化。
/// </summary>
protected override void Awake()
{
base.Awake();
new LocalizationManager();
m_LocalizationManager = GameFrameworkEntry.GetModule<ILocalizationManager>();
if (m_LocalizationManager == null)
{
Log.Fatal("Localization manager is invalid.");
return;
}
/*m_LocalizationManager.ReadDataSuccess += OnReadDataSuccess;
m_LocalizationManager.ReadDataFailure += OnReadDataFailure;
if (m_EnableLoadDictionaryUpdateEvent)
{
m_LocalizationManager.ReadDataUpdate += OnReadDataUpdate;
}*/
}
private void Start()
{
BaseComponent baseComponent = GameEntry.GetComponent<BaseComponent>();
if (baseComponent == null)
{
Log.Fatal("Base component is invalid.");
return;
}
m_EventComponent = GameEntry.GetComponent<EventComponent>();
if (m_EventComponent == null)
{
Log.Fatal("Event component is invalid.");
return;
}
m_LocalizationManager.SetAssetManager(GameFrameworkEntry.GetModule<IAssetManager>());
LocalizationHelperBase localizationHelper =
Helper.CreateHelper(m_LocalizationHelperTypeName, m_CustomLocalizationHelper);
if (localizationHelper == null)
{
Log.Error("Can not create localization helper.");
return;
}
localizationHelper.name = "Localization Helper";
Transform localizationHelperTransform = localizationHelper.transform;
localizationHelperTransform.SetParent(this.transform);
localizationHelperTransform.localScale = Vector3.one;
m_LocalizationManager.SetLocalizationHelper(localizationHelper);
m_LocalizationManager.Language = baseComponent.EditorLanguage != Language.Unspecified
? baseComponent.EditorLanguage
: m_LocalizationManager.SystemLanguage;
if (m_CachedBytesSize > 0)
{
EnsureCachedBytesSize(m_CachedBytesSize);
}
}
/// <summary>
/// 确保二进制流缓存分配足够大小的内存并缓存。
/// </summary>
/// <param name="ensureSize">要确保二进制流缓存分配内存的大小。</param>
public void EnsureCachedBytesSize(int ensureSize)
{
// m_LocalizationManager.EnsureCachedBytesSize(ensureSize);
}
/// <summary>
/// 读取字典。
/// </summary>
/// <param name="dictionaryAssetName">字典资源名称。</param>
public void ReadData(string dictionaryAssetName)
{
// m_LocalizationManager.ReadData(dictionaryAssetName);
}
/// <summary>
/// 读取字典。
/// </summary>
/// <param name="dictionaryAssetName">字典资源名称。</param>
/// <param name="priority">加载字典资源的优先级。</param>
public void ReadData(string dictionaryAssetName, int priority)
{
// m_LocalizationManager.ReadData(dictionaryAssetName, priority);
}
/// <summary>
/// 读取字典。
/// </summary>
/// <param name="dictionaryAssetName">字典资源名称。</param>
/// <param name="userData">用户自定义数据。</param>
public void ReadData(string dictionaryAssetName, object userData)
{
// m_LocalizationManager.ReadData(dictionaryAssetName, userData);
}
/// <summary>
/// 读取字典。
/// </summary>
/// <param name="dictionaryAssetName">字典资源名称。</param>
/// <param name="priority">加载字典资源的优先级。</param>
/// <param name="userData">用户自定义数据。</param>
public void ReadData(string dictionaryAssetName, int priority, object userData)
{
// m_LocalizationManager.ReadData(dictionaryAssetName, priority, userData);
}
/// <summary>
/// 解析字典。
/// </summary>
/// <param name="dictionaryString">要解析的字典字符串。</param>
/// <returns>是否解析字典成功。</returns>
public bool ParseData(string dictionaryString)
{
// return m_LocalizationManager.ParseData(dictionaryString);
return false;
}
/// <summary>
/// 解析字典。
/// </summary>
/// <param name="dictionaryString">要解析的字典字符串。</param>
/// <param name="userData">用户自定义数据。</param>
/// <returns>是否解析字典成功。</returns>
public bool ParseData(string dictionaryString, object userData)
{
// return m_LocalizationManager.ParseData(dictionaryString, userData);
return false;
}
/// <summary>
/// 解析字典。
/// </summary>
/// <param name="dictionaryBytes">要解析的字典二进制流。</param>
/// <returns>是否解析字典成功。</returns>
public bool ParseData(byte[] dictionaryBytes)
{
// return m_LocalizationManager.ParseData(dictionaryBytes);
return false;
}
/// <summary>
/// 解析字典。
/// </summary>
/// <param name="dictionaryBytes">要解析的字典二进制流。</param>
/// <param name="userData">用户自定义数据。</param>
/// <returns>是否解析字典成功。</returns>
public bool ParseData(byte[] dictionaryBytes, object userData)
{
// return m_LocalizationManager.ParseData(dictionaryBytes, userData);
return false;
}
/// <summary>
/// 解析字典。
/// </summary>
/// <param name="dictionaryBytes">要解析的字典二进制流。</param>
/// <param name="startIndex">字典二进制流的起始位置。</param>
/// <param name="length">字典二进制流的长度。</param>
/// <returns>是否解析字典成功。</returns>
public bool ParseData(byte[] dictionaryBytes, int startIndex, int length)
{
// return m_LocalizationManager.ParseData(dictionaryBytes, startIndex, length);
return false;
}
/// <summary>
/// 解析字典。
/// </summary>
/// <param name="dictionaryBytes">要解析的字典二进制流。</param>
/// <param name="startIndex">字典二进制流的起始位置。</param>
/// <param name="length">字典二进制流的长度。</param>
/// <param name="userData">用户自定义数据。</param>
/// <returns>是否解析字典成功。</returns>
public bool ParseData(byte[] dictionaryBytes, int startIndex, int length, object userData)
{
// return m_LocalizationManager.ParseData(dictionaryBytes, startIndex, length, userData);
return false;
}
/// <summary>
/// 根据字典主键获取字典内容字符串。
/// </summary>
/// <param name="key">字典主键。</param>
/// <returns>要获取的字典内容字符串。</returns>
public string GetString(string key)
{
return m_LocalizationManager.GetString(key);
}
/// <summary>
/// 根据字典主键获取字典内容字符串。
/// </summary>
/// <typeparam name="T">字典参数的类型。</typeparam>
/// <param name="key">字典主键。</param>
/// <param name="arg">字典参数。</param>
/// <returns>要获取的字典内容字符串。</returns>
public string GetString<T>(string key, T arg)
{
return m_LocalizationManager.GetString(key, arg);
}
/// <summary>
/// 根据字典主键获取字典内容字符串。
/// </summary>
/// <typeparam name="T1">字典参数 1 的类型。</typeparam>
/// <typeparam name="T2">字典参数 2 的类型。</typeparam>
/// <param name="key">字典主键。</param>
/// <param name="arg1">字典参数 1。</param>
/// <param name="arg2">字典参数 2。</param>
/// <returns>要获取的字典内容字符串。</returns>
public string GetString<T1, T2>(string key, T1 arg1, T2 arg2)
{
return m_LocalizationManager.GetString(key, arg1, arg2);
}
/// <summary>
/// 根据字典主键获取字典内容字符串。
/// </summary>
/// <typeparam name="T1">字典参数 1 的类型。</typeparam>
/// <typeparam name="T2">字典参数 2 的类型。</typeparam>
/// <typeparam name="T3">字典参数 3 的类型。</typeparam>
/// <param name="key">字典主键。</param>
/// <param name="arg1">字典参数 1。</param>
/// <param name="arg2">字典参数 2。</param>
/// <param name="arg3">字典参数 3。</param>
/// <returns>要获取的字典内容字符串。</returns>
public string GetString<T1, T2, T3>(string key, T1 arg1, T2 arg2, T3 arg3)
{
return m_LocalizationManager.GetString(key, arg1, arg2, arg3);
}
/// <summary>
/// 根据字典主键获取字典内容字符串。
/// </summary>
/// <typeparam name="T1">字典参数 1 的类型。</typeparam>
/// <typeparam name="T2">字典参数 2 的类型。</typeparam>
/// <typeparam name="T3">字典参数 3 的类型。</typeparam>
/// <typeparam name="T4">字典参数 4 的类型。</typeparam>
/// <param name="key">字典主键。</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 GetString<T1, T2, T3, T4>(string key, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
{
return m_LocalizationManager.GetString(key, arg1, arg2, arg3, arg4);
}
/// <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="key">字典主键。</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 GetString<T1, T2, T3, T4, T5>(string key, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
{
return m_LocalizationManager.GetString(key, arg1, arg2, arg3, arg4, arg5);
}
/// <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="key">字典主键。</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 GetString<T1, T2, T3, T4, T5, T6>(string key, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5,
T6 arg6)
{
return m_LocalizationManager.GetString(key, arg1, arg2, arg3, arg4, arg5, arg6);
}
/// <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="key">字典主键。</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 GetString<T1, T2, T3, T4, T5, T6, T7>(string key, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5,
T6 arg6, T7 arg7)
{
return m_LocalizationManager.GetString(key, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
}
/// <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="key">字典主键。</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 GetString<T1, T2, T3, T4, T5, T6, T7, T8>(string key, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5,
T6 arg6, T7 arg7, T8 arg8)
{
return m_LocalizationManager.GetString(key, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
}
/// <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="key">字典主键。</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 GetString<T1, T2, T3, T4, T5, T6, T7, T8, T9>(string key, T1 arg1, T2 arg2, T3 arg3, T4 arg4,
T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)
{
return m_LocalizationManager.GetString(key, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
}
/// <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="key">字典主键。</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 GetString<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(string key, T1 arg1, T2 arg2, T3 arg3, T4 arg4,
T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10)
{
return m_LocalizationManager.GetString(key, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
}
/// <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="key">字典主键。</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 GetString<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(string key, T1 arg1, T2 arg2, T3 arg3,
T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11)
{
return m_LocalizationManager.GetString(key, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10,
arg11);
}
/// <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="key">字典主键。</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 GetString<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(string key, T1 arg1, T2 arg2,
T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12)
{
return m_LocalizationManager.GetString(key, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10,
arg11, arg12);
}
/// <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="key">字典主键。</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 GetString<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(string key, 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)
{
return m_LocalizationManager.GetString(key, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10,
arg11, arg12, arg13);
}
/// <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="key">字典主键。</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 GetString<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(string key, 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)
{
return m_LocalizationManager.GetString(key, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10,
arg11, arg12, arg13, arg14);
}
/// <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="key">字典主键。</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 GetString<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>(string key, 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)
{
return m_LocalizationManager.GetString(key, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10,
arg11, arg12, arg13, arg14, arg15);
}
/// <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="key">字典主键。</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 GetString<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>(string key,
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)
{
return m_LocalizationManager.GetString(key, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10,
arg11, arg12, arg13, arg14, arg15, arg16);
}
/// <summary>
/// 是否存在字典。
/// </summary>
/// <param name="key">字典主键。</param>
/// <returns>是否存在字典。</returns>
public bool HasRawString(string key)
{
return m_LocalizationManager.HasRawString(key);
}
/// <summary>
/// 根据字典主键获取字典值。
/// </summary>
/// <param name="key">字典主键。</param>
/// <returns>字典值。</returns>
public string GetRawString(string key)
{
return m_LocalizationManager.GetRawString(key);
}
/// <summary>
/// 移除字典。
/// </summary>
/// <param name="key">字典主键。</param>
/// <returns>是否移除字典成功。</returns>
public bool RemoveRawString(string key)
{
return m_LocalizationManager.RemoveRawString(key);
}
/// <summary>
/// 清空所有字典。
/// </summary>
public void RemoveAllRawStrings()
{
m_LocalizationManager.RemoveAllRawStrings();
}
/*
private void OnReadDataSuccess(object sender, ReadDataSuccessEventArgs e)
{
m_EventComponent.Fire(this, LoadDictionarySuccessEventArgs.Create(e));
}
private void OnReadDataFailure(object sender, ReadDataFailureEventArgs e)
{
Log.Warning("Load dictionary failure, asset name '{0}', error message '{1}'.", e.DataAssetName,
e.ErrorMessage);
m_EventComponent.Fire(this, LoadDictionaryFailureEventArgs.Create(e));
}
private void OnReadDataUpdate(object sender, ReadDataUpdateEventArgs e)
{
m_EventComponent.Fire(this, LoadDictionaryUpdateEventArgs.Create(e));
}*/
}
}

View File

@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: 577f4666bd05453d9b779ce3050b9ec2
timeCreated: 1712727478

View File

@ -0,0 +1,72 @@
//------------------------------------------------------------
// Game Framework
// Copyright © 2013-2021 Jiang Yin. All rights reserved.
// Homepage: https://gameframework.cn/
// Feedback: mailto:ellan@gameframework.cn
//------------------------------------------------------------
using GameFrameX.Localization;
using UnityEngine;
namespace GameFrameX.Localization.Runtime
{
/// <summary>
/// 本地化辅助器基类。
/// </summary>
public abstract class LocalizationHelperBase : MonoBehaviour, ILocalizationHelper
{
/// <summary>
/// 获取系统语言。
/// </summary>
public abstract Language SystemLanguage { get; }
/// <summary>
/// 读取字典。
/// </summary>
/// <param name="localizationManager">本地化管理器。</param>
/// <param name="dictionaryAssetName">字典资源名称。</param>
/// <param name="dictionaryAsset">字典资源。</param>
/// <param name="userData">用户自定义数据。</param>
/// <returns>是否读取字典成功。</returns>
public abstract bool ReadData(ILocalizationManager localizationManager, string dictionaryAssetName, object dictionaryAsset, object userData);
/// <summary>
/// 读取字典。
/// </summary>
/// <param name="localizationManager">本地化管理器。</param>
/// <param name="dictionaryAssetName">字典资源名称。</param>
/// <param name="dictionaryBytes">字典二进制流。</param>
/// <param name="startIndex">字典二进制流的起始位置。</param>
/// <param name="length">字典二进制流的长度。</param>
/// <param name="userData">用户自定义数据。</param>
/// <returns>是否读取字典成功。</returns>
public abstract bool ReadData(ILocalizationManager localizationManager, string dictionaryAssetName, byte[] dictionaryBytes, int startIndex, int length, object userData);
/// <summary>
/// 解析字典。
/// </summary>
/// <param name="localizationManager">本地化管理器。</param>
/// <param name="dictionaryString">要解析的字典字符串。</param>
/// <param name="userData">用户自定义数据。</param>
/// <returns>是否解析字典成功。</returns>
public abstract bool ParseData(ILocalizationManager localizationManager, string dictionaryString, object userData);
/// <summary>
/// 解析字典。
/// </summary>
/// <param name="localizationManager">本地化管理器。</param>
/// <param name="dictionaryBytes">要解析的字典二进制流。</param>
/// <param name="startIndex">字典二进制流的起始位置。</param>
/// <param name="length">字典二进制流的长度。</param>
/// <param name="userData">用户自定义数据。</param>
/// <returns>是否解析字典成功。</returns>
public abstract bool ParseData(ILocalizationManager localizationManager, byte[] dictionaryBytes, int startIndex, int length, object userData);
/// <summary>
/// 释放字典资源。
/// </summary>
/// <param name="localizationManager">本地化管理器。</param>
/// <param name="dictionaryAsset">要释放的字典资源。</param>
public abstract void ReleaseDataAsset(ILocalizationManager localizationManager, object dictionaryAsset);
}
}

View File

@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: c5a01fe863ca441b96599549327c0362
timeCreated: 1712727478

8
Tests.meta Normal file
View File

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

View File

@ -0,0 +1,18 @@
{
"name": "GameFrameX.Localization.Tests",
"references": [
"GameFrameX.Localization.Runtime"
],
"rootNamespace": "GameFrameX.Localization.Tests",
"includePlatforms": [
"Editor"
],
"excludePlatforms": [],
"allowUnsafeCode": false,
"overrideReferences": false,
"precompiledReferences": [],
"autoReferenced": true,
"defineConstraints": [],
"versionDefines": [],
"noEngineReferences": false
}

View File

@ -0,0 +1,7 @@
fileFormatVersion: 2
guid: 794c282664ff04b45a89f7562788ea3f
AssemblyDefinitionImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

37
Tests/UnitTests.cs Normal file
View File

@ -0,0 +1,37 @@
using System;
using NUnit.Framework;
namespace GameFrameX.Localization.Tests
{
internal class UnitTests
{
private DateTime dateTime, dateTime1;
[SetUp]
public void Setup()
{
dateTime = DateTime.Now;
dateTime1 = DateTime.Now.AddHours(1);
}
// Here is an example of a unit test for the IsUnixSameDay method
[Test]
public void TestIsUnixSameDay()
{
// Arrange
// long timestamp1 = 1617842400; // April 7, 2021 12:00:00 AM UTC
// long timestamp2 = 1617896400; // April 7, 2021 12:00:00 PM UTC
// Act
}
[Test]
public void Test1()
{
Assert.That(dateTime1.Year, Is.EqualTo(dateTime.Year));
Assert.That(dateTime1.Month, Is.EqualTo(dateTime.Month));
Assert.That(dateTime1.Day, Is.EqualTo(dateTime.Day));
}
}
}

11
Tests/UnitTests.cs.meta Normal file
View File

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

23
package.json Normal file
View File

@ -0,0 +1,23 @@
{
"name": "com.alianblank.gameframex.localization",
"displayName": "Game Frame X Localization",
"category": "Game Framework X",
"description": "Game Frame X Localization Component",
"version": "1.0.0",
"unity": "2017.1",
"keywords": [
"Game Framework X"
],
"repository": {
"name": "com.alianblank.gameframex.localization",
"url": "https://github.com/AlianBlank/com.alianblank.gameframex.unity.localization.git",
"type": "git"
},
"author": {
"name": "Blank",
"email": "alianblank@outlook.com",
"url": "https://alianblank.com/"
},
"dependencies": {
}
}

7
package.json.meta Normal file
View File

@ -0,0 +1,7 @@
fileFormatVersion: 2
guid: ea3520158b77bc541805480fadfa3bf5
PackageManifestImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant: