952 lines
37 KiB
C#
952 lines
37 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using Barotrauma.IO;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Text.RegularExpressions;
|
|
using Barotrauma.Extensions;
|
|
using System.Xml.Linq;
|
|
|
|
namespace Barotrauma
|
|
{
|
|
public static class TextManager
|
|
{
|
|
//only used if none of the selected content packages contain any text files
|
|
const string VanillaTextFilePath = "Content/Texts/English/EnglishVanilla.xml";
|
|
|
|
private static readonly object mutex = new object();
|
|
|
|
//key = language
|
|
private static Dictionary<string, List<TextPack>> textPacks;
|
|
|
|
private static readonly string[] serverMessageCharacters = new string[] { "~", "[", "]", "=" };
|
|
|
|
public static string Language;
|
|
|
|
public static bool Initialized
|
|
{
|
|
get;
|
|
private set;
|
|
}
|
|
|
|
private static HashSet<string> availableLanguages;
|
|
public static IEnumerable<string> AvailableLanguages
|
|
{
|
|
get
|
|
{
|
|
lock (mutex)
|
|
{
|
|
return new HashSet<string>(availableLanguages);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static List<string> GetTextFiles()
|
|
{
|
|
var list = new List<string>();
|
|
GetTextFilesRecursive(Path.Combine("Content", "Texts"), ref list);
|
|
return list;
|
|
}
|
|
|
|
private static void GetTextFilesRecursive(string directory, ref List<string> list)
|
|
{
|
|
foreach (string file in Directory.GetFiles(directory))
|
|
{
|
|
list.Add(file);
|
|
}
|
|
foreach (string subDir in Directory.GetDirectories(directory))
|
|
{
|
|
GetTextFilesRecursive(subDir, ref list);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the name of the language in the respective language
|
|
/// </summary>
|
|
public static string GetTranslatedLanguageName(string language)
|
|
{
|
|
lock (mutex)
|
|
{
|
|
if (!textPacks.ContainsKey(language))
|
|
{
|
|
return language;
|
|
}
|
|
|
|
foreach (var textPack in textPacks[language])
|
|
{
|
|
if (textPack.Language == language)
|
|
{
|
|
return textPack.TranslatedName;
|
|
}
|
|
}
|
|
return language;
|
|
}
|
|
}
|
|
|
|
public static void LoadTextPacks(IEnumerable<ContentPackage> selectedContentPackages)
|
|
{
|
|
HashSet<string> newLanguages = new HashSet<string>();
|
|
Dictionary<string, List<TextPack>> newTextPacks = new Dictionary<string, List<TextPack>>();
|
|
|
|
var textFiles = ContentPackage.GetFilesOfType(selectedContentPackages, ContentType.Text).ToList();
|
|
|
|
foreach (ContentFile file in textFiles)
|
|
{
|
|
#if !DEBUG
|
|
try
|
|
{
|
|
#endif
|
|
var textPack = new TextPack(file.Path);
|
|
newLanguages.Add(textPack.Language);
|
|
if (!newTextPacks.ContainsKey(textPack.Language))
|
|
{
|
|
newTextPacks.Add(textPack.Language, new List<TextPack>());
|
|
}
|
|
newTextPacks[textPack.Language].Add(textPack);
|
|
#if !DEBUG
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
DebugConsole.ThrowError("Failed to load text file \"" + file.Path + "\"!", e);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
if (newTextPacks.Count == 0)
|
|
{
|
|
DebugConsole.ThrowError("No text files available in any of the selected content packages. Attempting to find a vanilla English text file...");
|
|
if (!File.Exists(VanillaTextFilePath))
|
|
{
|
|
throw new Exception("No text files found in any of the selected content packages or in the default text path!");
|
|
}
|
|
var textPack = new TextPack(VanillaTextFilePath);
|
|
newLanguages.Add(textPack.Language);
|
|
newTextPacks.Add(textPack.Language, new List<TextPack>() { textPack });
|
|
}
|
|
|
|
if (newTextPacks.Count == 0)
|
|
{
|
|
throw new Exception("Failed to load text packs!");
|
|
}
|
|
|
|
lock (mutex)
|
|
{
|
|
textPacks = newTextPacks;
|
|
availableLanguages = newLanguages;
|
|
DebugConsole.NewMessage("Loaded languages: " + string.Join(", ", newLanguages));
|
|
}
|
|
|
|
Initialized = true;
|
|
}
|
|
|
|
public static void LoadTextPack(string file)
|
|
{
|
|
lock (mutex)
|
|
{
|
|
var textPack = new TextPack(file);
|
|
availableLanguages.Add(textPack.Language);
|
|
if (!textPacks.ContainsKey(textPack.Language))
|
|
{
|
|
textPacks.Add(textPack.Language, new List<TextPack>());
|
|
}
|
|
textPacks[textPack.Language].Add(textPack);
|
|
}
|
|
}
|
|
|
|
public static void RemoveTextPack(string file)
|
|
{
|
|
List<string> keysToRemove = new List<string>();
|
|
foreach (var textPackKVP in textPacks)
|
|
{
|
|
var textPackLanguage = textPackKVP.Key;
|
|
var textPackList = textPackKVP.Value;
|
|
for (int i = 0; i < textPackList.Count; i++)
|
|
{
|
|
if (textPackList[i].FilePath == file)
|
|
{
|
|
textPackList.Remove(textPackList[i]);
|
|
if (textPackList.Count == 0)
|
|
{
|
|
keysToRemove.Add(textPackLanguage);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
foreach (var key in keysToRemove)
|
|
{
|
|
availableLanguages.Remove(key);
|
|
textPacks.Remove(key);
|
|
}
|
|
}
|
|
|
|
public static bool ContainsTag(string textTag)
|
|
{
|
|
if (string.IsNullOrEmpty(textTag)) { return false; }
|
|
|
|
lock (mutex)
|
|
{
|
|
if (!textPacks.ContainsKey(Language))
|
|
{
|
|
DebugConsole.ThrowError("No text packs available for the selected language (" + Language + ")! Switching to English...");
|
|
Language = "English";
|
|
if (!textPacks.ContainsKey(Language))
|
|
{
|
|
throw new Exception("No text packs available in English!");
|
|
}
|
|
}
|
|
foreach (TextPack textPack in textPacks[Language])
|
|
{
|
|
if (textPack.Get(textTag) != null) { return true; }
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
private static readonly List<string> availableTexts = new List<string>();
|
|
|
|
public static string Get(string textTag, bool returnNull = false, string fallBackTag = null, bool useEnglishAsFallBack = true)
|
|
{
|
|
lock (mutex)
|
|
{
|
|
if (textPacks == null)
|
|
{
|
|
DebugConsole.ThrowError($"Failed to get the text \"{textTag}\" (no text packs loaded).");
|
|
return textTag;
|
|
}
|
|
|
|
if (!textPacks.ContainsKey(Language))
|
|
{
|
|
DebugConsole.ThrowError("No text packs available for the selected language (" + Language + ")! Switching to English...");
|
|
Language = "English";
|
|
if (!textPacks.ContainsKey(Language))
|
|
{
|
|
throw new Exception("No text packs available in English!");
|
|
}
|
|
}
|
|
|
|
#if DEBUG
|
|
if (GameMain.Config != null && GameMain.Config.TextManagerDebugModeEnabled)
|
|
{
|
|
return textTag;
|
|
}
|
|
#endif
|
|
availableTexts.Clear();
|
|
foreach (TextPack textPack in textPacks[Language])
|
|
{
|
|
var texts = textPack.GetAll(textTag);
|
|
if (texts != null)
|
|
{
|
|
availableTexts.AddRange(texts);
|
|
}
|
|
}
|
|
|
|
if (availableTexts.Any())
|
|
{
|
|
return availableTexts.GetRandom().Replace(@"\n", "\n");
|
|
}
|
|
|
|
if (!string.IsNullOrEmpty(fallBackTag))
|
|
{
|
|
foreach (TextPack textPack in textPacks[Language])
|
|
{
|
|
string text = textPack.Get(fallBackTag);
|
|
if (text != null) { return text; }
|
|
}
|
|
}
|
|
|
|
//if text was not found and we're using a language other than English, see if we can find an English version
|
|
//may happen, for example, if a user has selected another language and using mods that haven't been translated to that language
|
|
if (useEnglishAsFallBack && Language != "English" && textPacks.ContainsKey("English"))
|
|
{
|
|
foreach (TextPack textPack in textPacks["English"])
|
|
{
|
|
string text = textPack.Get(textTag);
|
|
if (text != null)
|
|
{
|
|
#if DEBUG
|
|
DebugConsole.NewMessage("Text \"" + textTag + "\" not found for the language \"" + Language + "\". Using the English text \"" + text + "\" instead.");
|
|
#endif
|
|
return text;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (returnNull)
|
|
{
|
|
return null;
|
|
}
|
|
else
|
|
{
|
|
DebugConsole.ThrowError("Text \"" + textTag + "\" not found.");
|
|
return textTag;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static string GetWithVariables(string textTag, string[] variableTags, string[] variableValues, bool[] formatCapitals = null, bool returnNull = false, string fallBackTag = null)
|
|
{
|
|
string text = Get(textTag, returnNull, fallBackTag);
|
|
|
|
if (text == null || text.Length == 0 || variableTags.Length != variableValues.Length)
|
|
{
|
|
#if DEBUG
|
|
if (variableTags.Length != variableValues.Length)
|
|
{
|
|
DebugConsole.ThrowError("variableTags.Length and variableValues.Length do not match for \"" + textTag + "\".");
|
|
}
|
|
|
|
if (formatCapitals != null && formatCapitals.Length != variableTags.Length)
|
|
{
|
|
DebugConsole.ThrowError("variableTags.Length and formatCapitals.Length do not match for \"" + textTag + "\".");
|
|
}
|
|
#endif
|
|
if (returnNull)
|
|
{
|
|
return null;
|
|
}
|
|
else
|
|
{
|
|
return textTag;
|
|
}
|
|
}
|
|
|
|
if (formatCapitals != null && (GameMain.Config == null || !GameMain.Config.Language.Contains("Chinese")))
|
|
{
|
|
for (int i = 0; i < variableTags.Length; i++)
|
|
{
|
|
if (string.IsNullOrEmpty(variableValues[i])) { continue; }
|
|
if (formatCapitals[i])
|
|
{
|
|
variableValues[i] = HandleVariableCapitalization(text, variableTags[i], variableValues[i]);
|
|
}
|
|
}
|
|
}
|
|
|
|
for (int i = 0; i < variableTags.Length; i++)
|
|
{
|
|
if (variableValues[i] == null)
|
|
{
|
|
#if DEBUG
|
|
DebugConsole.ThrowError("Error in TextManager.GetWithVariables (variable " + i + " was null).\n" + Environment.StackTrace.CleanupStackTrace());
|
|
#endif
|
|
continue;
|
|
}
|
|
text = text.Replace(variableTags[i], variableValues[i]);
|
|
}
|
|
|
|
return text;
|
|
}
|
|
|
|
public static string GetWithVariable(string textTag, string variableTag, string variableValue, bool formatCapitals = false, bool returnNull = false, string fallBackTag = null)
|
|
{
|
|
string text = Get(textTag, returnNull, fallBackTag);
|
|
|
|
if (text == null || text.Length == 0)
|
|
{
|
|
if (returnNull)
|
|
{
|
|
return null;
|
|
}
|
|
else
|
|
{
|
|
return textTag;
|
|
}
|
|
}
|
|
|
|
if (variableValue == null)
|
|
{
|
|
variableValue = "null";
|
|
#if DEBUG
|
|
throw new ArgumentException($"Variable value \"{variableTag}\" was null.");
|
|
#endif
|
|
}
|
|
|
|
if (formatCapitals && !GameMain.Config.Language.Contains("Chinese"))
|
|
{
|
|
variableValue = HandleVariableCapitalization(text, variableTag, variableValue);
|
|
}
|
|
|
|
return text.Replace(variableTag, variableValue);
|
|
}
|
|
|
|
private static string HandleVariableCapitalization(string text, string variableTag, string variableValue)
|
|
{
|
|
int index = text.IndexOf(variableTag) - 1;
|
|
if (index == -1)
|
|
{
|
|
return variableValue;
|
|
}
|
|
|
|
for (int i = index; i >= 0; i--)
|
|
{
|
|
if (text[i] == ' ')
|
|
{
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
if (text[i] != '.')
|
|
{
|
|
variableValue = variableValue.ToLower();
|
|
}
|
|
else
|
|
{
|
|
variableValue = Capitalize(variableValue);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return variableValue;
|
|
}
|
|
|
|
//TODO: the server should not be doing this!
|
|
public static string ParseInputTypes(string text)
|
|
{
|
|
#if CLIENT
|
|
foreach (InputType inputType in Enum.GetValues(typeof(InputType)))
|
|
{
|
|
text = text.Replace("[" + inputType.ToString().ToLowerInvariant() + "]", GameMain.Config.KeyBindText(inputType));
|
|
text = text.Replace("[InputType." + inputType.ToString() + "]", GameMain.Config.KeyBindText(inputType));
|
|
}
|
|
#endif
|
|
return text;
|
|
}
|
|
|
|
public static string GetFormatted(string textTag, bool returnNull = false, params object[] args)
|
|
{
|
|
string text = Get(textTag, returnNull);
|
|
|
|
if (text == null || text.Length == 0)
|
|
{
|
|
if (returnNull)
|
|
{
|
|
return null;
|
|
}
|
|
else
|
|
{
|
|
DebugConsole.ThrowError("Text \"" + textTag + "\" not found.");
|
|
return textTag;
|
|
}
|
|
}
|
|
|
|
try
|
|
{
|
|
return string.Format(text, args);
|
|
}
|
|
catch (FormatException)
|
|
{
|
|
string errorMsg = "Failed to format text \"" + text + "\", args: " + string.Join(", ", args);
|
|
GameAnalyticsManager.AddErrorEventOnce("TextManager.GetFormatted:FormatException", GameAnalyticsSDK.Net.EGAErrorSeverity.Error, errorMsg);
|
|
return text;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Constructs a string from XML in a way that allows replacing one or more variables with hard-coded or localized values. Usage example in the method's comments.
|
|
/// </summary>
|
|
public static void ConstructDescription(ref string Description, XElement descriptionElement)
|
|
{
|
|
/*
|
|
<Description tag="talentdescription.simultaneousskillgain">
|
|
<Replace tag="[skillname1]" value="skillname.helm"/>
|
|
<Replace tag="[skillname2]" value="skillname.weapons"/>
|
|
<Replace tag="[somevalue]" value="45.3"/>
|
|
</Description>
|
|
*/
|
|
|
|
if (descriptionElement.GetAttributeBool("linebreak", false))
|
|
{
|
|
Description += "\n";
|
|
return;
|
|
}
|
|
|
|
string descriptionTag = descriptionElement.GetAttributeString("tag", string.Empty);
|
|
string extraDescriptionLine = Get(descriptionTag);
|
|
if (string.IsNullOrEmpty(extraDescriptionLine)) { return; }
|
|
foreach (XElement replaceElement in descriptionElement.Elements())
|
|
{
|
|
if (replaceElement.Name.ToString().ToLowerInvariant() != "replace") { continue; }
|
|
|
|
string tag = replaceElement.GetAttributeString("tag", string.Empty);
|
|
string[] replacementValues = replaceElement.GetAttributeStringArray("value", new string[0]);
|
|
string replacementValue = string.Empty;
|
|
for (int i = 0; i < replacementValues.Length; i++)
|
|
{
|
|
#if DEBUG
|
|
if (!int.TryParse(replacementValues[i], out int _) && !float.TryParse(replacementValues[i], System.Globalization.NumberStyles.Any, System.Globalization.CultureInfo.InvariantCulture, out float __) && !ContainsTag(replacementValues[i]))
|
|
{
|
|
DebugConsole.AddWarning($"Couldn't find the tag \"{replacementValues[i]}\" in text files for description \"{descriptionTag}\". Is the tag correct?");
|
|
}
|
|
#endif
|
|
replacementValue += Get(replacementValues[i], returnNull: true) ?? replacementValues[i];
|
|
if (i < replacementValues.Length - 1)
|
|
{
|
|
replacementValue += ", ";
|
|
}
|
|
}
|
|
if (replaceElement.Attribute("color") != null)
|
|
{
|
|
string colorStr = replaceElement.GetAttributeString("color", "255,255,255,255");
|
|
replacementValue = $"‖color:{colorStr}‖{replacementValue}‖color:end‖";
|
|
}
|
|
extraDescriptionLine = extraDescriptionLine.Replace(tag, replacementValue);
|
|
}
|
|
if (!string.IsNullOrEmpty(Description)) { Description += "\n"; }
|
|
Description += extraDescriptionLine;
|
|
}
|
|
|
|
public static string FormatServerMessage(string textId)
|
|
{
|
|
return $"{textId}~";
|
|
}
|
|
|
|
public static string FormatServerMessage(string message, IEnumerable<string> keys, IEnumerable<string> values)
|
|
{
|
|
if (keys == null || values == null || !keys.Any() || !values.Any())
|
|
{
|
|
return FormatServerMessage(message);
|
|
}
|
|
var startIndex = message.LastIndexOf('/') + 1;
|
|
var endIndex = message.IndexOf('~', startIndex);
|
|
if (endIndex == -1)
|
|
{
|
|
endIndex = message.Length - 1;
|
|
}
|
|
var textId = message.Substring(startIndex, endIndex - startIndex + 1);
|
|
var keysWithValues = keys.Zip(values, (key, value) => new { Key = key, Value = value });
|
|
var prefixEntries = keysWithValues.Select((kv, index) =>
|
|
{
|
|
if (kv.Value.IndexOfAny(new char[] { '~', '/' }) != -1)
|
|
{
|
|
var kvStartIndex = kv.Value.LastIndexOf('/') + 1;
|
|
return kv.Value.Substring(0, kvStartIndex) + $"[{textId}.{index}]={kv.Value.Substring(kvStartIndex)}";
|
|
}
|
|
else
|
|
{
|
|
return null;
|
|
}
|
|
}).Where(e => e != null).ToArray();
|
|
return string.Join("",
|
|
(prefixEntries.Length > 0 ? string.Join("/", prefixEntries) + "/" : ""),
|
|
message,
|
|
string.Join("", keysWithValues.Select((kv, index) => kv.Value.IndexOfAny(new char[] { '~', '/' }) != -1 ? $"~{kv.Key}=[{textId}.{index}]" : $"~{kv.Key}={kv.Value}").ToArray())
|
|
);
|
|
}
|
|
|
|
static readonly string[] genderPronounVariables = {
|
|
"[genderpronoun]",
|
|
"[genderpronounpossessive]",
|
|
"[genderpronounreflexive]",
|
|
"[Genderpronoun]",
|
|
"[Genderpronounpossessive]",
|
|
"[Genderpronounreflexive]"
|
|
};
|
|
|
|
static readonly string[] genderPronounMaleValues = {
|
|
"PronounMaleLowercase",
|
|
"PronounPossessiveMaleLowercase",
|
|
"PronounReflexiveMaleLowercase",
|
|
"PronounMale",
|
|
"PronounPossessiveMale",
|
|
"PronounReflexiveMale"
|
|
};
|
|
|
|
static readonly string[] genderPronounFemaleValues = {
|
|
"PronounFemaleLowercase",
|
|
"PronounPossessiveFemaleLowercase",
|
|
"PronounReflexiveFemaleLowercase",
|
|
"PronounMale",
|
|
"PronounPossessiveFemale",
|
|
"PronounReflexiveFemale"
|
|
};
|
|
|
|
public static string FormatServerMessageWithGenderPronouns(Gender gender, string message, IEnumerable<string> keys, IEnumerable<string> values)
|
|
{
|
|
return FormatServerMessage(message, keys.Concat(genderPronounVariables), values.Concat(gender == Gender.Male ? genderPronounMaleValues : genderPronounFemaleValues));
|
|
}
|
|
|
|
// Same as string.Join(separator, parts) but performs the operation taking into account server message string replacements.
|
|
public static string JoinServerMessages(string separator, string[] parts, string namePrefix = "part.")
|
|
{
|
|
|
|
return string.Join("/",
|
|
string.Join("/", parts.Select((part, index) =>
|
|
{
|
|
var partStart = part.LastIndexOf('/') + 1;
|
|
return partStart > 0 ? $"{part.Substring(0, partStart)}/[{namePrefix}{index}]={part.Substring(partStart)}" : $"[{namePrefix}{index}]={part.Substring(partStart)}";
|
|
})),
|
|
string.Join(separator, parts.Select((part, index) => $"[{namePrefix}{index}]")));
|
|
}
|
|
|
|
static readonly Regex reFormattedMessage = new Regex(@"^(?<variable>[\[\].a-z0-9_]+?)=(?<formatter>[a-z0-9_]+?)\((?<value>.+?)\)", RegexOptions.Compiled | RegexOptions.IgnoreCase);
|
|
static readonly Regex reReplacedMessage = new Regex(@"^(?<variable>[\[\].a-z0-9_]+?)=(?<message>.*)$", RegexOptions.Compiled | RegexOptions.IgnoreCase);
|
|
static readonly Dictionary<string, Func<string, string>> messageFormatters = new Dictionary<string, Func<string, string>>
|
|
{
|
|
{ "duration", secondsValue => double.TryParse(secondsValue, out var seconds) ? $"{TimeSpan.FromSeconds(seconds):g}" : null }
|
|
};
|
|
|
|
// Format: ServerMessage.Identifier1/ServerMessage.Indentifier2~[variable1]=value~[variable2]=value
|
|
// Also: replacement=ServerMessage.Identifier1~[variable1]=value/ServerMessage.Identifier2~[variable2]=replacement
|
|
// And: replacement=formatter(value)
|
|
// Variable that requires translation -> ServerMessage.Indentifier1~[variable1]=§value
|
|
public static string GetServerMessage(string serverMessage)
|
|
{
|
|
lock (mutex)
|
|
{
|
|
if (!textPacks.ContainsKey(Language))
|
|
{
|
|
DebugConsole.ThrowError("No text packs available for the selected language (" + Language + ")! Switching to English...");
|
|
Language = "English";
|
|
if (!textPacks.ContainsKey(Language))
|
|
{
|
|
throw new Exception("No text packs available in English!");
|
|
}
|
|
}
|
|
}
|
|
|
|
string[] messages = serverMessage.Split('/');
|
|
var replacedMessages = new Dictionary<string, string>();
|
|
|
|
bool translationsFound = false;
|
|
|
|
try
|
|
{
|
|
for (int i = 0; i < messages.Length; i++)
|
|
{
|
|
if (messages[i].EndsWith("~", StringComparison.Ordinal))
|
|
{
|
|
messages[i] = messages[i].Substring(0, messages[i].Length - 1);
|
|
}
|
|
if (!IsServerMessageWithVariables(messages[i]) && !messages[i].Contains('=')) // No variables, try to translate
|
|
{
|
|
foreach (var replacedMessage in replacedMessages)
|
|
{
|
|
messages[i] = messages[i].Replace(replacedMessage.Key, replacedMessage.Value);
|
|
}
|
|
|
|
if (messages[i].Contains(" ")) continue; // Spaces found, do not translate
|
|
string msg = Get(messages[i], true);
|
|
if (msg != null) // If a translation was found, otherwise use the original
|
|
{
|
|
messages[i] = msg;
|
|
translationsFound = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
string messageVariable = null;
|
|
var matchFormatted = reFormattedMessage.Match(messages[i]);
|
|
if (matchFormatted.Success)
|
|
{
|
|
var formatter = matchFormatted.Groups["formatter"].ToString();
|
|
if (messageFormatters.TryGetValue(formatter, out var formatterFn))
|
|
{
|
|
var formattedValue = formatterFn(matchFormatted.Groups["value"].ToString());
|
|
if (formattedValue != null)
|
|
{
|
|
messageVariable = matchFormatted.Groups["variable"].ToString();
|
|
messages[i] = formattedValue;
|
|
}
|
|
}
|
|
}
|
|
if (messageVariable == null)
|
|
{
|
|
var matchReplaced = reReplacedMessage.Match(messages[i]);
|
|
if (matchReplaced.Success)
|
|
{
|
|
messageVariable = matchReplaced.Groups["variable"].ToString();
|
|
messages[i] = matchReplaced.Groups["message"].ToString();
|
|
}
|
|
}
|
|
|
|
foreach (var replacedMessage in replacedMessages)
|
|
{
|
|
messages[i] = messages[i].Replace(replacedMessage.Key, replacedMessage.Value);
|
|
}
|
|
|
|
|
|
string[] messageWithVariables = messages[i].Split('~');
|
|
|
|
string msg = Get(messageWithVariables[0], true);
|
|
|
|
if (msg != null) // If a translation was found, otherwise use the original
|
|
{
|
|
messages[i] = msg;
|
|
translationsFound = true;
|
|
}
|
|
else if (messageVariable == null)
|
|
{
|
|
continue; // No translation found, probably caused by player input -> skip variable handling
|
|
}
|
|
|
|
// First index is always the message identifier -> start at 1
|
|
for (int j = 1; j < messageWithVariables.Length; j++)
|
|
{
|
|
string[] variableAndValue = messageWithVariables[j].Split('=');
|
|
messages[i] = messages[i].Replace(variableAndValue[0], variableAndValue[1].Length > 1 && variableAndValue[1][0] == '§' ? Get(variableAndValue[1].Substring(1)) : variableAndValue[1]);
|
|
}
|
|
|
|
if (messageVariable != null)
|
|
{
|
|
replacedMessages[messageVariable] = messages[i];
|
|
messages[i] = null;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (translationsFound)
|
|
{
|
|
string translatedServerMessage = string.Empty;
|
|
for (int i = 0; i < messages.Length; i++)
|
|
{
|
|
if (messages[i] != null)
|
|
{
|
|
translatedServerMessage += messages[i];
|
|
}
|
|
}
|
|
return translatedServerMessage;
|
|
}
|
|
else
|
|
{
|
|
return serverMessage;
|
|
}
|
|
}
|
|
|
|
catch (IndexOutOfRangeException exception)
|
|
{
|
|
string errorMsg = "Failed to translate server message \"" + serverMessage + "\".";
|
|
#if DEBUG
|
|
DebugConsole.ThrowError(errorMsg, exception);
|
|
#endif
|
|
GameAnalyticsManager.AddErrorEventOnce("TextManager.GetServerMessage:" + serverMessage, GameAnalyticsSDK.Net.EGAErrorSeverity.Error, errorMsg);
|
|
return errorMsg;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Fetches a single variable from a servermessage
|
|
/// </summary>
|
|
public static string GetServerMessageVariable(string message, string variable)
|
|
{
|
|
int variableIndex = message.IndexOf(variable);
|
|
if (variableIndex == -1)
|
|
{
|
|
#if DEBUG
|
|
DebugConsole.ThrowError($"Server message variable: '{variable}' not found in message: '{message}'");
|
|
#endif
|
|
return string.Empty;
|
|
}
|
|
|
|
int startIndex = message.IndexOf('=', variableIndex) + 1;
|
|
int endIndex = startIndex;
|
|
|
|
for (int i = startIndex; i < message.Length; i++)
|
|
{
|
|
if (message[i] == '/' || message[i] == '~')
|
|
{
|
|
endIndex = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (endIndex == startIndex) endIndex = message.Length;
|
|
|
|
return message.Substring(startIndex, endIndex - startIndex);
|
|
}
|
|
|
|
public static bool IsServerMessageWithVariables(string message)
|
|
{
|
|
for (int i = 0; i < serverMessageCharacters.Length; i++)
|
|
{
|
|
if (!message.Contains(serverMessageCharacters[i])) return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Adds a punctuation symbol between two strings, taking into account special rules in some locales (e.g. non-breaking space before a colon in French)
|
|
/// </summary>
|
|
public static string AddPunctuation(char punctuationSymbol, params string[] texts)
|
|
{
|
|
string separator = "";
|
|
switch (GameMain.Config.Language)
|
|
{
|
|
case "French":
|
|
bool addNonBreakingSpace =
|
|
punctuationSymbol == ':' || punctuationSymbol == ';' ||
|
|
punctuationSymbol == '!' || punctuationSymbol == '?';
|
|
separator = addNonBreakingSpace ?
|
|
new string(new char[] { (char)(0xA0), punctuationSymbol, ' ' }) :
|
|
new string(new char[] { punctuationSymbol, ' ' });
|
|
break;
|
|
default:
|
|
separator = new string(new char[] { punctuationSymbol, ' ' });
|
|
break;
|
|
}
|
|
return string.Join(separator, texts);
|
|
}
|
|
|
|
public static List<string> GetAll(string textTag)
|
|
{
|
|
lock (mutex)
|
|
{
|
|
if (!textPacks.ContainsKey(Language))
|
|
{
|
|
DebugConsole.ThrowError("No text packs available for the selected language (" + Language + ")! Switching to English...");
|
|
Language = "English";
|
|
if (!textPacks.ContainsKey(Language))
|
|
{
|
|
throw new Exception("No text packs available in English!");
|
|
}
|
|
}
|
|
|
|
List<string> allText;
|
|
|
|
foreach (TextPack textPack in textPacks[Language])
|
|
{
|
|
allText = textPack.GetAll(textTag);
|
|
if (allText != null) return allText;
|
|
}
|
|
|
|
//if text was not found and we're using a language other than English, see if we can find an English version
|
|
//may happen, for example, if a user has selected another language and using mods that haven't been translated to that language
|
|
if (Language != "English" && textPacks.ContainsKey("English"))
|
|
{
|
|
foreach (TextPack textPack in textPacks["English"])
|
|
{
|
|
allText = textPack.GetAll(textTag);
|
|
if (allText != null) return allText;
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public static List<KeyValuePair<string, string>> GetAllTagTextPairs()
|
|
{
|
|
lock (mutex)
|
|
{
|
|
if (!textPacks.ContainsKey(Language))
|
|
{
|
|
DebugConsole.ThrowError("No text packs available for the selected language (" + Language + ")! Switching to English...");
|
|
Language = "English";
|
|
if (!textPacks.ContainsKey(Language))
|
|
{
|
|
throw new Exception("No text packs available in English!");
|
|
}
|
|
}
|
|
|
|
List<KeyValuePair<string, string>> allText = new List<KeyValuePair<string, string>>();
|
|
|
|
foreach (TextPack textPack in textPacks[Language])
|
|
{
|
|
allText.AddRange(textPack.GetAllTagTextPairs());
|
|
}
|
|
|
|
return allText;
|
|
}
|
|
}
|
|
|
|
public static string ReplaceGenderPronouns(string text, Gender gender)
|
|
{
|
|
if (gender == Gender.Male)
|
|
{
|
|
return text.Replace("[genderpronoun]", Get("PronounMaleLowercase"))
|
|
.Replace("[genderpronounpossessive]", Get("PronounPossessiveMaleLowercase"))
|
|
.Replace("[genderpronounreflexive]", Get("PronounReflexiveMaleLowercase"))
|
|
.Replace("[Genderpronoun]", Get("PronounMale"))
|
|
.Replace("[Genderpronounpossessive]", Get("PronounPossessiveMale"))
|
|
.Replace("[Genderpronounreflexive]", Get("PronounReflexiveMale"));
|
|
}
|
|
else
|
|
{
|
|
return text.Replace("[genderpronoun]", Get("PronounFemaleLowercase"))
|
|
.Replace("[genderpronounpossessive]", Get("PronounPossessiveFemaleLowercase"))
|
|
.Replace("[genderpronounreflexive]", Get("PronounReflexiveFemaleLowerCase"))
|
|
.Replace("[Genderpronoun]", Get("PronounFemale"))
|
|
.Replace("[Genderpronounpossessive]", Get("PronounPossessiveFemale"))
|
|
.Replace("[Genderpronounreflexive]", Get("PronounReflexiveFemale"));
|
|
}
|
|
}
|
|
|
|
static Regex isCJK = new Regex(
|
|
@"\p{IsHangulJamo}|" +
|
|
@"\p{IsHiragana}|" +
|
|
@"\p{IsKatakana}|" +
|
|
@"\p{IsCJKRadicalsSupplement}|" +
|
|
@"\p{IsCJKSymbolsandPunctuation}|" +
|
|
@"\p{IsEnclosedCJKLettersandMonths}|" +
|
|
@"\p{IsCJKCompatibility}|" +
|
|
@"\p{IsCJKUnifiedIdeographsExtensionA}|" +
|
|
@"\p{IsCJKUnifiedIdeographs}|" +
|
|
@"\p{IsHangulSyllables}|" +
|
|
@"\p{IsCJKCompatibilityForms}");
|
|
|
|
/// <summary>
|
|
/// Does the string contain symbols from Chinese, Japanese or Korean languages
|
|
/// </summary>
|
|
public static bool IsCJK(string text)
|
|
{
|
|
if (string.IsNullOrEmpty(text)) { return false; }
|
|
return isCJK.IsMatch(text);
|
|
}
|
|
|
|
#if DEBUG
|
|
public static void CheckForDuplicates(string lang)
|
|
{
|
|
lock (mutex)
|
|
{
|
|
if (!textPacks.ContainsKey(lang))
|
|
{
|
|
DebugConsole.ThrowError("No text packs available for the selected language (" + lang + ")!");
|
|
return;
|
|
}
|
|
|
|
int packIndex = 0;
|
|
foreach (TextPack textPack in textPacks[lang])
|
|
{
|
|
textPack.CheckForDuplicates(packIndex);
|
|
packIndex++;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static void WriteToCSV()
|
|
{
|
|
lock (mutex)
|
|
{
|
|
string lang = "English";
|
|
|
|
if (!textPacks.ContainsKey(lang))
|
|
{
|
|
DebugConsole.ThrowError("No text packs available for the selected language (" + lang + ")!");
|
|
return;
|
|
}
|
|
|
|
int packIndex = 0;
|
|
foreach (TextPack textPack in textPacks[lang])
|
|
{
|
|
textPack.WriteToCSV(packIndex);
|
|
packIndex++;
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
public static string Capitalize(string str)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(str))
|
|
{
|
|
return str;
|
|
}
|
|
|
|
return char.ToUpper(str[0]) + str.Substring(1);
|
|
}
|
|
}
|
|
}
|