void AddLanguageGUI()
{
EditorGUI.indentLevel = 0;
isFoldAddLanguage = EditorGUILayout.Foldout(isFoldAddLanguage, "新增语言");
if (isFoldAddLanguage)
{
EditorGUI.indentLevel = 1;
m_selectLanguage = (SystemLanguage)EditorGUILayout.EnumPopup("语言类型", m_selectLanguage);
if (!s_languageList.Contains(m_selectLanguage.ToString()))
{
if (GUILayout.Button("新增"))
{
s_languageList.Add(m_selectLanguage.ToString());
LoadLanguage(m_selectLanguage.ToString());
isFoldAddLanguage = false;
}
}
else
{
EditorGUILayout.LabelField("已存在该语言", EditorGUIStyleData.WarnMessageLabel);
}
}
EditorGUILayout.Space();
}
public void CreateWorkspace(bool bOpenRoot = true)
{
if (!WorkspaceExists())
{
Directory.CreateDirectory(Localizator.Path.WorkspaceRootPath);
Directory.CreateDirectory(Localizator.Path.DatabaseRootPath);
Directory.CreateDirectory(Localizator.Path.BackupRootPath);
Directory.CreateDirectory(Localizator.Path.GeneratedFilesRootPath);
Directory.CreateDirectory(Localizator.Path.ScriptRootPath);
DefaultLanguage = _currentDefaultLanguage;
_localizationDatabaseFiles = new Dictionary <SystemLanguage, string>();
_localizationDatabaseFiles.Add(DefaultLanguage, DefaultLanguage.ToString() + ".csv");
SaveRootFile();
SaveLocalizationFile(DefaultLanguage.ToString());
SaveWorkspace();
LanguageManager.CreateInstance();
if (bOpenRoot)
{
EditorWindow.GetWindow <CustomEditorWindow_Localizator_EditRoot>("Edit Root", true, typeof(CustomEditorWindow_Localizator));
}
}
AssetDatabase.Refresh();
}
public static void SetCurrentLocalization(SystemLanguage language)
{
if (currentLanguage == language)
{
return;
}
currentLanguage = language;
currentLocalizationText = Resources.Load(LOCALIZATION_FOLDER + language.ToString(), typeof(TextAsset)) as TextAsset;
if (currentLocalizationText == null)
{
Debug.LogFormat("Missing locale {0}", language.ToString());
SetCurrentLocalization(SystemLanguage.English);
}
else
{
string[] lines = currentLocalizationText.text.Split(new string[] { "\r\n", "\n\r", "\n" }, System.StringSplitOptions.RemoveEmptyEntries);
CurrentLanguageStrings.Clear();
for (int i = 0; i < lines.Length; i++)
{
string[] pairs = lines[i].Split(new char[] { '\t', '=' }, 2);
if (pairs.Length == 2)
{
CurrentLanguageStrings.Add(pairs[0].Trim(), pairs[1].Trim());
}
}
LocalizeText[] texts = localizeTexts.ToArray();
for (int i = 0; i < texts.Length; i++)
{
texts[i].UpdateLocale();
}
}
}
private void UpdateLang(SystemLanguage lang)
{
_currentLang = lang;
_spriteAtlas = Resources.Load <SpriteAtlas>(STR_LOCALIZATION_PREFIX + _currentLang.ToString());
if (_spriteAtlas == null)
{
Debug.Log(_currentLang + " language not exist, change Language to English ");
_currentLang = SystemLanguage.English;
_spriteAtlas = Resources.Load <SpriteAtlas>(STR_LOCALIZATION_PREFIX + _currentLang.ToString());
}
if (_spriteAtlas == null)
{
Debug.Log("SpriteAltas not exist" + STR_LOCALIZATION_PREFIX + _currentLang.ToString());
}
var currentAsset = Resources.Load <TextAsset>(STR_LOCALIZATION_TEXT + _currentLang.ToString() + "_local");
var tellAsset = Resources.Load <TextAsset>(STR_TELLOUT_TEXT + _currentLang.ToString() + "_local");
currentTextsDict = MTJSON.Deserialize(currentAsset.ToString()).dict;
if (tellAsset != null)
{
var tellDict = MTJSON.Deserialize(tellAsset.ToString()).dict;
foreach (var p in tellDict)
{
if (currentTextsDict.ContainsKey(p.Key))
{
currentTextsDict[p.Key] = p.Value;
}
}
}
}
public static void LoadStrings(SystemLanguage language)
{
Debug.Log("Carregando Strings para: " + language.ToString());
TextAsset text;
text = Resources.Load(RESOURCES_PATH + language.ToString(), typeof(TextAsset)) as TextAsset;
if (text == null)
{
Debug.Log("Arquivo não encontrado! Carregando arquivo padrão...");
text = Resources.Load(RESOURCES_PATH + SystemLanguage.English.ToString(), typeof(TextAsset)) as TextAsset;
}
Debug.Log("Arquivo carregado! preenchendo dicionário...");
string[] lines = text.text.Split(new string[] { "\r\n", "\n\r", "\n" }, StringSplitOptions.RemoveEmptyEntries);
currentLanguageStrings.Clear();
for (int i = 0; i < lines.Length; i++)
{
string line = lines[i];
string[] pairs = line.Split(new char[] { '=' }, 2);
currentLanguageStrings.Add(pairs[0].Trim(), pairs[1].Trim());
}
IsLanguagesStringsLoaded = true;
Debug.Log("Strings Carregadas para " + language.ToString() + "(Total de " + currentLanguageStrings.Count + " palavras");
}
private static void Init()
{
if (!_isLoaded)
{
var fallback = Resources.Load <TextAsset>("Languages/" + FALLBACK_LANGUAGE.ToString());
if (fallback == null)
{
// Make sure the fallback language was not missing
throw new System.NullReferenceException("Fallback language (" + FALLBACK_LANGUAGE.ToString() + ") is missing!");
}
_manager = new LanguageManager(CreateContainer(fallback));
_manager.OnCurrentLanguageChanged += () => { if (OnLanguageChanged != null)
{
OnLanguageChanged();
}
};
// Add languages
var textAssets = Resources.LoadAll <TextAsset>("Languages/");
foreach (var asset in textAssets)
{
if (asset.name != fallback.name)
{
_manager.AddLanguage(CreateContainer(asset));
}
}
_isLoaded = true;
}
}
void SaveConfig()
{
Dictionary <string, SingleField> config = new Dictionary <string, SingleField>();
//保存默认语言
config.Add(LanguageManager.c_defaultLanguageKey, new SingleField(m_defaultLanguage.ToString()));
//保存语言列表
List <string> languageList = new List <string>();
foreach (var item in s_languageList)
{
if (item != "None")
{
languageList.Add(item);
}
}
config.Add(LanguageManager.c_languageListKey, new SingleField(languageList));
//保存模块列表
List <string> moduleList = new List <string>();
foreach (var item in s_languageKeyDict)
{
moduleList.Add(item.Key);
}
config.Add(LanguageManager.c_moduleListKey, new SingleField(moduleList));
ConfigEditorWindow.SaveData(LanguageManager.c_configFileName, config);
}
private static void getTranslations(SystemLanguage language, bool fallback = false)
{
TranslationsFile file = JsonUtility.FromJson <TranslationsFile>("{\"translations\":" + ((TextAsset)Resources.Load("i18n/" + language.ToString())).text.TrimEnd('\r', '\n') + "}");
if (file.translations == null)
{
Debug.LogError("Translation file for " + language.ToString() + " is invalid");
return;
}
if (!fallback)
{
translationFile = file;
}
foreach (PhraseTranslation phrase in file.translations)
{
try {
if (fallback)
{
fallbackTranslation.Add(phrase.key, phrase.translation);
}
else
{
translation.Add(phrase.key, phrase.translation);
}
} catch (Exception) {
Debug.LogError("Duplicated key " + phrase.key + " for " + language.ToString());
}
}
}
void LoadLanguageInfo()
{
languageDic = JsonFile.ReadFromFile <LanguageDic>(dataPath, languageType.ToString());
if (languageDic == null)
{
languageDic = new LanguageDic();
}
}
static void DeleteLocalizationFile(SystemLanguage lang)
{
_localizationDatabaseFiles.Remove(lang);
CustomEditorWindow_Localizator_EditLang.Backup(lang.ToString());
File.Delete(Localizator.Path.DatabaseRootPath + lang.ToString() + ".csv");
SaveWorkspace();
}
public static string ToIdentifier(this SystemLanguage systemLanguage)
{
switch (systemLanguage)
{
case SystemLanguage.Basque:
return("eu");
case SystemLanguage.Chinese:
return("zh-cn");
case SystemLanguage.ChineseSimplified:
return("zh-chs");
case SystemLanguage.ChineseTraditional:
return("zh-cht");
case SystemLanguage.Czech:
return("cs");
case SystemLanguage.Dutch:
return("nl");
case SystemLanguage.Spanish:
return("es");
case SystemLanguage.SerboCroatian:
return("hr");
case SystemLanguage.Swedish:
return("sv");
case SystemLanguage.German:
return("de");
case SystemLanguage.Greek:
return("el");
case SystemLanguage.Icelandic:
return("is");
case SystemLanguage.Slovak:
return("sk");
case SystemLanguage.Estonian:
case SystemLanguage.Indonesian:
case SystemLanguage.Lithuanian:
case SystemLanguage.Polish:
case SystemLanguage.Turkish:
return(systemLanguage.ToString().Substring(0, 3).Remove(1, 1).ToLower());
case SystemLanguage.Faroese:
case SystemLanguage.Latvian:
case SystemLanguage.Portuguese:
case SystemLanguage.Bulgarian:
return(systemLanguage.ToString().Substring(0, 4).Remove(1, 2).ToLower());
}
return(systemLanguage.ToString().Substring(0, 2).ToLowerInvariant());
}
/// <summary>
/// Method that uses System.XML to parse from XMLs localization files
/// </summary>
/// <param name="asset"></param>
void ParseTexts(TextAsset asset)
{
Dictionary <string, PC_TextItem> m_vTempDictionary = new Dictionary <string, PC_TextItem>();
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.LoadXml(asset.text);
string language = m_currentLanguage.ToString();
XmlNodeList langTable = xmlDoc.GetElementsByTagName("Language");
foreach (XmlNode lang in langTable)
{
language = lang.InnerText;
try
{
SystemLanguage parsedLanguage = (SystemLanguage)System.Enum.Parse(typeof(SystemLanguage), language);
m_activelanguages.Add(parsedLanguage);
}
catch (System.Exception error)
{
Debug.LogError("Can't parse " + language + " to enum. Exiting the program...");
Application.Quit();
}
}
if (m_texts.ContainsKey(language))
{
Debug.LogError("[Text Manager] Error! The Language should always be unique");
Debug.LogError("Name: " + language);
return;
}
XmlNodeList globalTable = xmlDoc.GetElementsByTagName("Table1");
foreach (XmlNode TableNode in globalTable)
{
string newItemContext = TableNode.ChildNodes[0].InnerText;
if (newItemContext != "")
{
if (m_vTempDictionary.ContainsKey(newItemContext))
{
Debug.LogError("[UHMLXMLParse] Error! The context should always be unique (Script line " + TableNode.ChildNodes[0] + ")");
Debug.LogError("Name: " + newItemContext);
}
else
{
PC_TextItem newInfoText = null;
//(string _key, string _text, string _audioName, bool _hasOptions, bool _showOptions)
newInfoText = new PC_TextItem(newItemContext, TableNode.ChildNodes[1].InnerText);
m_vTempDictionary.Add(newItemContext, newInfoText);
}
}
}
m_texts.Add(language, m_vTempDictionary);
}
/// <summary>
/// 按优先级枚举所有符合要求的语言包;
/// </summary>
private IEnumerable <LanguagePackInfo> EnumerateLanguagePask(LocalizationConfig?config, IEnumerable <LanguagePackInfo> languagePacks)
{
//语言优先级排列顺序
string[] spareLanguages;
if (config.HasValue)
{
//匹配语言包信息,并且返回;
LocalizationConfig _config = config.Value;
foreach (var info in languagePacks)
{
if (_config.Language == info.Description.Language && _config.Name == info.Description.Name)
{
yield return(info);
}
}
spareLanguages = new string[]
{
_config.Language,
SystemLanguage.ToString(),
defaultLanguage.ToString(),
};
}
else
{
spareLanguages = new string[]
{
SystemLanguage.ToString(),
defaultLanguage.ToString(),
};
}
//按语言优先级返回合适的语言包;
for (int i = 0; i < spareLanguages.Length; i++)
{
string language = spareLanguages[i];
foreach (var fileInfo in LanguagePacks)
{
if (fileInfo.Description.Language == language)
{
yield return(fileInfo);
}
}
}
//若之前都未成功,则再次返回所有语言包;
foreach (var fileInfo in LanguagePacks)
{
yield return(fileInfo);
}
}
static Culture()
{
if (!Translate.Present)
{
m_languageNamesArray = new string[] { DEFAULT_LANGUAGE.ToString() };
m_languageMapping = new Dictionary <string, SystemLanguage>
{
{ DEFAULT_LANGUAGE.ToString(), DEFAULT_LANGUAGE }
};
m_selectedLangIndex = 0;
}
Language = DEFAULT_LANGUAGE;
}
/// <summary>
/// Initialize level dialogue by the specified language.
/// if
/// </summary>
public static void InitializeLevelDialogue(string LevelName, SystemLanguage? _language)
{
TargetLanguage = _language == null ? SystemLanguage.English :
(SupportLanguage.Contains(_language.Value.ToString()) ? _language.Value : SystemLanguage.English);
string DialogFilePath = DialogAssetRootFolder + "/" + LevelName + "/" + TargetLanguage.ToString() + "/" + TargetLanguage.ToString();
TextAsset dialogFile = Resources.Load(DialogFilePath, typeof(TextAsset)) as TextAsset;
TextAsset characterXMLFile = Resources.Load(CharacterAssetRootFolder, typeof(TextAsset)) as TextAsset;
CharacterDict.Clear();
DialogueDict.Clear();
CharacterDict = ParseCharacterLocalizationXMLFile(ParseTextAssetToXMLDocument(characterXMLFile), TargetLanguage);
DialogueDict = ParseDialogLocalizationXMLFile(ParseTextAssetToXMLDocument(dialogFile));
}
IEnumerator InitLocalizationData(SystemLanguage newLanguage = SystemLanguage.Unknown, bool notify = false)
{
// clear the vocabulary
vocabulary = new Dictionary <string, string>();
currentLanguage = ConformSystemLanguage(newLanguage);
string languageName = currentLanguage.ToString();
//Debug.Log("Application language is " + languageName);
if (availableLocalizations.Contains(currentLanguage))
{
int entriesRead = 0;
string localizationFileName = LocalizationFileName(currentLanguage);
StartCoroutine(LoadStreamableAsset(localizationFileName, (stream, exists) =>
{
if (!exists)
{
//Debug.Log("No localization files for " + languageName + " found");
}
else
{
stream.BaseStream.Seek(0, SeekOrigin.Begin);
while (!stream.EndOfStream)
{
string srcline = stream.ReadLine();
if (srcline != null)
{
// explicit JSON parsing
LocalizationEntry entry = JsonUtility.FromJson <LocalizationEntry>(srcline);
if (entry.language == languageName)
{
if (!vocabulary.ContainsKey(entry.id))
{
vocabulary.Add(entry.id, NormalizeString(entry.value));
entriesRead++;
}
else
{
//Debug.Log("Entry " + entry.id + " is already in vocabulary!");
}
}
}
}
}
}));
while (!IsLoaded)
{
yield return(null);
}
//Debug.Log(entriesRead.ToString() + " entries read for " + languageName + " language");
if (notify)
{
GlobalManager.MInstantMessage.DeliverMessage(InstantMessageType.LanguageChanged, this, currentLanguage);
}
}
else
{
//Debug.Log("No localization files for " + languageName + " found");
}
processFlag = true;
}
private void LoadLanguage()
{
//加载文件
TextAsset textAsset = Resources.Load <TextAsset>(language.ToString());
if (textAsset == null)
{
Debug.LogError("没有该语言的本地化文件！");
return;
}
//通过\n分割每行内容
string[] lines = textAsset.text.Split('\n');
//获取key,value
for (int i = 0; i < lines.Length; i++)
{
//检测,如果为空串直接跳过
if (string.IsNullOrEmpty(lines[i]))
{
continue;
}
//获取key,value
string[] kv = lines[i].Split(':');
//保存键值对
dict.Add(kv[0], kv[1]);
}
}
public static Dictionary <string, string> Load(SystemLanguage language)
{
XmlDocument document = new XmlDocument();
Dictionary <string, string> result = new Dictionary <string, string>();
if (Application.isEditor)
{
if (!(new FileInfo(string.Format(filepath, language)).Exists))
{
return(result);
}
document.Load(string.Format(filepath, language));
}
else
{
TextAsset text = Resources.Load("Languages/" + language.ToString()) as TextAsset;
if (text == null || string.IsNullOrEmpty(text.text))
{
return(result);
}
document.LoadXml(text.text);
}
XmlElement root = document.DocumentElement;
foreach (XmlNode node in root.ChildNodes)
{
if (node.Name == "phrase")
{
result[node.Attributes[0].Value] = node.Attributes[1].Value;
}
}
return(result);
}
/// <summary>
/// 加載預翻譯的語言
/// </summary>
private void loadLanguage()
{
//加載文件
TextAsset ta = Resources.Load <TextAsset>(language.ToString());
if (ta == null)
{
Debug.LogWarning("沒有這個語言的翻譯文件");
return;
}
//獲取每一行
string[] lines = ta.text.Split('\n');
//獲取key value
for (int i = 0; i < lines.Length; i++)
{
//檢測
if (string.IsNullOrEmpty(lines[i]))
{
continue;
}
//獲取 key:kv[0] value kv[1]
string[] kv = lines[i].Split(':');
//保存到字典
dict.Add(kv[0], kv[1]);
Debug.Log(string.Format("key:{0}, value:{1}", kv[0], kv[1]));
}
}
public static void CreateMissingTranslationFilesForSupportedLanguages()
{
log.Info(_Logger.User.Msaw, "Creating missing translation files for supported languages...");
// default language is always English
SystemLanguage defaultLanguage = SystemLanguage.English;
string locaPath = Application.dataPath + "/Resources/" + locaFileBasePath;
string defaultLanguageFile = locaPath + defaultLanguage.ToString().ToLower() + locaFileExtension;
// if the default translation file does not exist, create an empty one
if (System.IO.File.Exists(defaultLanguageFile) == false)
{
log.Warn(_Logger.User.Msaw, "Default translation file does not exist - creating an empty one: " + defaultLanguageFile);
System.IO.File.Create(defaultLanguageFile);
}
if (SupportedLanguages != null)
{
SupportedLanguages.ForEach(language =>
{
if (language != defaultLanguage)
{
// if the translation file does not exist, copy the default language file
string languageFile = locaPath + language.ToString().ToLower() + locaFileExtension;
if (System.IO.File.Exists(languageFile) == false)
{
log.Info(_Logger.User.Msaw, "Creating a translation file for " + language.ToString());
System.IO.File.Copy(defaultLanguageFile, languageFile);
}
}
});
}
}
private static void Init()
{
if (!_inited)
{
_settings = DB.Get <LocalizationSettingsDBEntry>();
_defaultLanguage = DB.Get <LanguageItem>(_defaultSystemLanguage.ToString());
var localizationSettingsData = PlayerPrefsLocalData.GetDataNode(LOCALIZATION_SETTINGS_KEY);
var savedLanguageString = localizationSettingsData.ContainsKey(LOCALIZATION_SAVED_LANGUAGE_KEY)
? localizationSettingsData.GetString(LOCALIZATION_SAVED_LANGUAGE_KEY)
: null;
if (string.IsNullOrEmpty(savedLanguageString))
{
ChangeLanguage(_currentSystemLanguage.ToString());
}
else
{
var savedLanguage = DB.Get <LanguageItem>(savedLanguageString);
if (savedLanguage != null)
{
ChangeLanguage(savedLanguage);
}
else
{
Debug.LogWarning(string.Format("Language not found: {0}", savedLanguageString));
}
}
_inited = true;
}
}
IEnumerator SpriteShapeOut()
{
SystemLanguage lenguaje = Application.systemLanguage;
yield return(new WaitForSeconds(3f));
//COMPRUEBA COMPATIBILIDAD DE DISPOSITIVO
if (SpeechRecognizer.ExistsOnDevice())
{
//VERIFICA LENGUAJE ACTIVO DEL DISPOSITIVO
if (lenguaje.ToString() == "Spanish")
{
SceneManager.LoadScene("NewMenu");
}
else
{
resultErrores.text = "DEBE HABILITAR EL IDIOMA ESPAÑOL EN SU DISPOSITIVO";
contenedor.SetActive(true);
}
}
else
{
resultErrores.text = "SU DISPOSITIVO NO ES COMPATIBLE CON LA APLICACION";
contenedor.SetActive(true);
}
}
public void LoadLocalizedText(SystemLanguage language)
{
localizedText = new Dictionary <string, string>();
string fileName = language.ToString() + ".json";
string filePath = Path.Combine(Application.streamingAssetsPath, fileName);
string dataAsJson;
if (Application.platform == RuntimePlatform.Android)
{
UnityWebRequest reader = new UnityWebRequest(filePath);
dataAsJson = reader.downloadHandler.text;
}
else
{
dataAsJson = File.ReadAllText(filePath);
}
LocalizationData loadedData = JsonUtility.FromJson <LocalizationData>(dataAsJson);
for (int i = 0; i < loadedData.items.Length; i++)
{
localizedText.Add(loadedData.items[i].key, loadedData.items[i].value);
}
isReady = true;
}
// https://new-translate-web-staging.unity3d.jp/api/file-api/upload-translation-file
private static void SendTranslationFileToServer(string localFilePath, SystemLanguage targetLanguage, TranslateProject projectSettings)
{
var uploadFile = new Dictionary <string, object>();
var translationFilePath = Path.ChangeExtension(localFilePath, ".po");
uploadFile["name"] = translationFilePath;
uploadFile["mimeType"] = "application/x-po";
var fileContent = GetFileDataInPoFormat(localFilePath, targetLanguage, projectSettings);
uploadFile["text"] = fileContent;
var data = new Dictionary <string, object>();
data["projectID"] = projectSettings.id;
data["branch"] = projectSettings.currentBranch;
data["languageID"] = serverLanguageCodes[targetLanguage.ToString()];
var sourceFilePath = GetServerPathForLocalPath(localFilePath);
data["filename"] = sourceFilePath;
data["uploadFile"] = uploadFile;
var jsonData = Json.Serialize(data);
Downloader.Response response;
Downloader.SendGetPostData(serverUrl + "/v1/files/translation-file"
, jsonData, out response);
}
private void InitLanguagePack()
{
SystemLanguage systemLanguage = Application.systemLanguage;
//Debug.Log(systemLanguage.ToString());
//Localization.language = ENGLISH; return;
switch (systemLanguage)
{
case SystemLanguage.Chinese:
#if UNITY_IOS
Localization.language = SystemLanguage.ChineseSimplified.ToString();
#elif UNITY_ANDROID
Localization.language = SystemLanguage.ChineseSimplified.ToString();
#elif UNITY_EDITOR
Localization.language = SystemLanguage.ChineseSimplified.ToString();
#endif
break;
case SystemLanguage.ChineseSimplified:
Localization.language = SystemLanguage.ChineseSimplified.ToString();
break;
case SystemLanguage.ChineseTraditional:
Localization.language = SystemLanguage.ChineseTraditional.ToString();
break;
case SystemLanguage.English:
Localization.language = SystemLanguage.English.ToString();
break;
default:
Localization.language = systemLanguage.ToString();
break;
}
}
/// <summary>
/// Loads a language pack and returns it, or null.
/// </summary>
/// <param name="name">Name of the lang pack.</param>
/// <param name="language">Language of the lang pack.</param>
/// <returns>A language pack with the name and language, or null</returns>
public static LanguagePack Load(string name, SystemLanguage language)
{
string filename = name + "." + language.ToString();
#if UNITY_EDITOR
string[] guids = AssetDatabase.FindAssets(filename);
if (guids == null || guids.Length < 1)
{
return(null);
}
#endif
string path = null;
#if UNITY_EDITOR
// Find the first match
foreach (var guid in guids)
{
string p = AssetDatabase.GUIDToAssetPath(guid);
if (p.EndsWith("." + PWConst.LANG_PK_EXTENSION))
{
path = p;
break;
}
}
#endif
if (string.IsNullOrEmpty(path))
{
return(null);
}
return(LanguagePack.Load(path));
}
public bool GetLanguageMap(SystemLanguage language, Dictionary <string, string> map)
{
try {
var path = Util.CombinePaths(RootPath, language.ToString() + ".txt");
if (!Util.FileExists(path))
{
return(false);
}
map.Clear();
using (var reader = new StreamReader(path, true)) {
string key = null, value = null;
string line = null;
while ((line = reader.ReadLine()) != null)
{
int i = line.IndexOf(':');
if (i >= 0)
{
key = line.Substring(0, i);
value = line.Substring(i + 1, line.Length - i - 1);
if (!string.IsNullOrEmpty(key) && !map.ContainsKey(key))
{
map.Add(key, value);
}
}
}
}
} catch { }
return(true);
}
/// <summary>
/// Set the current language, downloading missing language files.
/// </summary>
/// <param name="_Language">The new language.</param>
static public void Set(SystemLanguage _Language, ChangeCallback _Callback)
{
if (!Ready)
{
return;
}
Current = _Language;
if (!CurrentData.Load(Current))
{
Debug.Log("Language: Missing language file, requesting.");
Ready = false;
ReadyCallback = _Callback;
GameObject go = new GameObject("Download");
GetTextFromInternet dl = go.AddComponent <GetTextFromInternet>();
dl.Request("?language=" + _Language.ToString(), RequestCallback);
}
if (Ready && _Callback != null)
{
_Callback();
}
}
/// <summary>
/// 加载预翻译的语言
/// </summary>
private void loadLocalizationText()
{
//从resours文件中加载text
TextAsset ta = Resources.Load <TextAsset>(language.ToString());
if (ta == null)
{
Debug.LogWarning("没有这个语言的翻译文件");
return;
}
//获取每一行
string[] lines = ta.text.Split('\n');
//获取key value
for (int i = 0; i < lines.Length; i++)
{
//检测
if (string.IsNullOrEmpty(lines[i]))
{
continue;
}
//获取 key:kv[0] value kv[1]
string[] kv = lines[i].Split(':');
//保存到字典
dict.Add(kv[0], kv[1]);
Debug.Log(string.Format("key:{0}, value:{1}", kv[0], kv[1]));
}
}
private IEnumerator CoProcParse_Locale(SystemLanguage eLocale)
{
_pStrBuilder.Length = 0;
//#if UNITY_EDITOR
// _pStrBuilder.Append("file://");
//#endif
_pStrBuilder.Append(Application.streamingAssetsPath).Append("/").Append(const_strLocalePath).Append("/")
.Append(eLocale.ToString()).Append(const_strLocaleFileExtension);
WWW pReader = null;
if (System.IO.File.Exists(_pStrBuilder.ToString()))
{
pReader = new WWW(_pStrBuilder.ToString());
yield return(pReader);
}
if (++_iParsingFinishCount >= (int)SystemLanguage.Unknown + 1)
{
p_bIsFinishParse = true;
}
if (pReader == null || pReader.error != null || pReader.bytes.Length == 0)
{
if (p_bIsFinishParse)
{
ExcuteFinishEvent();
}
yield break;
}
//EventSet_LocalizeParsing(eLocale, pReader.text, pReader.bytes, p_bIsFinishParse);
}
/// <summary>
/// 加载预翻译语言
/// </summary>
private void LoadLanguage()
{
TextAsset ta = Resources.Load <TextAsset>(language.ToString());
if (ta == null)
{
Debug.LogWarning("没有此语言的预编译"); return;
}
//分割行，，
string[] lines = ta.text.Split('\n');
//读取key : value，并存到上面字典中
for (int i = 0; i < lines.Length; i++)
{
if (string.IsNullOrEmpty(lines[i]))
{
continue;
}
else
{
string[] kv = lines[i].Split(':');
//存到字典中
dict.Add(kv[0], kv[1]);
Debug.Log("Key:" + kv[0] + "Value:" + kv[1]);
}
}
}
public static string GetLocalizedDynamicSoundGroupFileName(SystemLanguage localLanguage, bool useLocalization,
string resourceFileName) {
if (!useLocalization) {
return resourceFileName;
}
if (MasterAudio.Instance != null) {
// ReSharper disable once ConditionIsAlwaysTrueOrFalse
return GetLocalizedFileName(useLocalization, resourceFileName);
}
return localLanguage.ToString() + "/" + resourceFileName;
}
public static void SetLanguage(SystemLanguage l_lang)
{
s_currentLanguage = l_lang;
string languageDataName = c_DataFilePrefix + l_lang.ToString();
if(DataManager.GetIsExistData(languageDataName))
{
s_languageData = DataManager.GetData(languageDataName);
}
else
{
string defaultLanguage = ConfigManager.GetData(c_configFileName)[c_defaultLanguageKey].GetString();
s_languageData = DataManager.GetData(defaultLanguage);
}
}
/// <summary>
/// Parses the character localization XML file.
/// </summary>
static IDictionary<string, LocalizeCharacter> ParseCharacterLocalizationXMLFile(XmlDocument xmlDoc, SystemLanguage language)
{
IDictionary<string, LocalizeCharacter> ret = new Dictionary<string, LocalizeCharacter>();
XmlElement root = xmlDoc.DocumentElement;
XmlNodeList xmlNodeList = root.GetElementsByTagName("character");
foreach (XmlNode node in xmlNodeList)
{
XmlElement characterElement = (XmlElement)node;
LocalizeCharacter localization_Character = new LocalizeCharacter();
localization_Character.CharacterID = characterElement.GetAttribute("id"); ;
localization_Character.CharacterName = characterElement.GetAttribute(language.ToString());
///CharacterIconPath can be empty
localization_Character.CharacterIconPath = characterElement.HasAttribute("imagepath") ? characterElement.GetAttribute("imagepath") : string.Empty;
///the image can be null
localization_Character.PortraitIconTexture = localization_Character.CharacterIconPath != string.Empty ? (Texture2D)Resources.Load(localization_Character.CharacterIconPath, typeof(Texture2D)) : null;
ret.Add(localization_Character.CharacterID, localization_Character);
}
return ret;
}
private static void LoadCollection(string moduleName,string format,
SystemLanguage lan,
System.Action<Collection> onDone,
ILoader loader = null){
if(!_decoderMap.ContainsKey(format)){
throw new System.Exception("there is no decoder for this format : "+format);
}
var decoder = _decoderMap[format];
var filePath = lan.ToString()+"/"+moduleName+"."+format;
if(loader == null){
loader = _defaultLoader;
}
loader.StartLoad(filePath,delegate(TextAsset txt) {
Collection col = null;
if(txt != null){
col = decoder.Invoke(txt.text);
}else{
Debug.LogError("[Localize] Load failed:"+filePath);
}
onDone(col);
});
}
public static void SetPlayerLanguage(SystemLanguage language)
{
PlayerPrefs.SetString(Language, language.ToString());
}
private static void LoadCollection(string moduelName,SystemLanguage lan,System.Action<Collection> onDone,ILoader loader = null){
var filePath = lan.ToString()+"/"+moduelName;
if(loader == null){
loader = _defaultLoader;
}
loader.StartLoad(filePath,delegate(TextAsset txt) {
Collection col = null;
if(txt != null){
col = JsonMapper.ToObject<Collection>(txt.text);
}else{
Debug.LogError("[Localize] Load failed:"+filePath);
}
onDone(col);
});
}
