// Certain commands encode multiple pieces of data into their strings
// we only want to expose the part that should be translated
// use prefixing to signal to resource replacement when this is needed
public virtual string GetSpecializedKey(ScenarioData.Param param, int i, out string toTranslate)
{
var key = toTranslate = param.Args[i];
if (key.IsNullOrEmpty() || param.Command == Command.Text)
{
return(key);
}
if (param.Command == Command.Choice)
{
if (!key.Contains(ChoiceDelimiter))
{
// only choices that contain delimiters need translation
return(string.Empty);
}
toTranslate = key.Split(ChoiceDelimiter.ToCharArray())[0];
}
else
{
// does not used specialized key
return(key);
}
return(BuildSpecializedKey(param, toTranslate));
}
protected bool RedirectHook(string assetBundleName, string assetName, Type type, string manifestAssetBundleName, out AssetBundleLoadAssetOperation result)
{
if (type == typeof(ScenarioData))
{
string scenarioPath = Path.Combine(scenarioDir, Path.Combine(assetBundleName, $"{assetName}.csv")).Replace('/', '\\').Replace(".unity3d", "").Replace(@"adv\scenario\", "");
if (File.Exists(scenarioPath))
{
var rawData = ManualLoadAsset <ScenarioData>(assetBundleName, assetName, manifestAssetBundleName);
rawData.list.Clear();
foreach (IEnumerable <string> line in SplitAndEscape(File.ReadAllText(scenarioPath, Encoding.UTF8)))
{
string[] data = line.ToArray();
string[] args = new string[data.Length - 4];
Array.Copy(data, 4, args, 0, args.Length);
ScenarioData.Param param = new ScenarioData.Param(bool.Parse(data[3]), (Command)int.Parse(data[2]), args);
param.SetHash(int.Parse(data[0]));
rawData.list.Add(param);
}
result = new AssetBundleLoadAssetOperationSimulation(rawData);
return(true);
}
}
else if (type == typeof(ExcelData))
{
string communicationPath = Path.Combine(communicationDir, Path.Combine(assetBundleName.Replace("communication/", ""), $"{assetName}.csv")).Replace('/', '\\').Replace(".unity3d", "");
if (File.Exists(communicationPath))
{
var rawData = ManualLoadAsset <ExcelData>(assetBundleName, assetName, manifestAssetBundleName);
rawData.list.Clear();
foreach (IEnumerable <string> line in SplitAndEscape(File.ReadAllText(communicationPath, Encoding.UTF8)))
{
ExcelData.Param param = new ExcelData.Param()
{
list = line.ToList()
};
rawData.list.Add(param);
}
result = new AssetBundleLoadAssetOperationSimulation(rawData);
return(true);
}
}
result = null;
return(false);
}
// Certain commands encode multiple pieces of data into their strings
// we only want to expose the part that should be translated
// use prefixing to signal to resource replacement when this is needed
public string GetSpecializedKey(ScenarioData.Param param, int i, out string toTranslate)
{
string key = toTranslate = param.Args[i];
if (key.IsNullOrEmpty() || param.Command == Command.Text)
{
return(key);
}
if (param.Command == Command.Choice)
{
if (!key.Contains(ChoiceDelimiter))
{
// only choices that contain delimiters need translation
return(string.Empty);
}
toTranslate = key.Split(ChoiceDelimiter.ToCharArray())[0];
}
else
{
// does not used specialized key
return(key);
}
return(string.Join(SpecializedKeyDelimiter, new string[] { param.Command.ToString().ToUpperInvariant(), toTranslate }));
}
private bool TryRegisterTranslation(SimpleTextTranslationCache cache, ScenarioData.Param param, int i,
string calculatedModificationPath)
{
var key = TextResourceHelper.GetSpecializedKey(param, i, out var value);
if (!string.IsNullOrEmpty(key))
{
if (cache.TryGetTranslation(key, true, out var translated))
{
var result = TextResourceHelper.GetSpecializedTranslation(param, i, translated);
TranslationHelper.RegisterRedirectedResourceTextToPath(result, calculatedModificationPath);
param.Args[i] = result;
Logger.DebugLogDebug($"{GetType()} handled {calculatedModificationPath}");
return(true);
}
if (LanguageHelper.IsTranslatable(key))
{
TranslationHelper.RegisterRedirectedResourceTextToPath(key, calculatedModificationPath);
if (AutoTranslatorSettings.IsDumpingRedirectedResourcesEnabled)
{
cache.AddTranslationToCache(key, value);
}
}
}
return(false);
}
public override void DumpScenarioParam(ScenarioData.Param param, SimpleTextTranslationCache cache)
{
if (!IsSupportedCommand(param.Command))
{
Logger.DebugLogDebug("{0} skipping unsupported command: {1}", GetType().Name, param.Command);
return;
}
if (SelectionCommands.Contains(param.Command))
{
foreach (var i in GetScenarioCommandTranslationIndexes(param.Command))
{
var key = param.Args[i];
if (!string.IsNullOrEmpty(key) && !TextKeysBlacklist.Contains(key) &&
LanguageHelper.IsTranslatable(key))
{
cache.AddTranslationToCache(key, key);
}
}
return;
}
base.DumpScenarioParam(param, cache);
}
private static ScenarioData.Param CreateFromCsv(string[] csvFields)
{
var multi = bool.Parse(csvFields[0]);
var command = (Command)Enum.Parse(typeof(Command), csvFields[1]);
var args = csvFields.Skip(2).ToArray();
var param = new ScenarioData.Param(multi, command, args);
return(param);
}
public IEnumerable <string> GetTranslationKeys(ScenarioData.Param param, int i)
{
var key = GetSpecializedKey(param, i, out var rawKey);
yield return(key);
if (RawKeyDisabledCommands.Contains(param.Command) || key == rawKey)
{
yield break;
}
yield return(rawKey);
}
// For commands that encode multiple pieces of data into their strings
// keep all the extra data from the asset file and only replace the
// displayed section (otherwise just returns the passed translation)
public string GetSpecializedTranslation(ScenarioData.Param param, int i, string translation)
{
if (param.Command == Command.Choice)
{
try
{
return(string.Join(ChoiceDelimiter,
new string[] { translation, param.Args[i].Split(ChoiceDelimiter.ToCharArray(), 2)[1] }));
}
catch
{
// something went wrong, return original below
}
}
return(translation);
}
private static Exception PreventAdvCrash(Exception __exception, ScenarioData.Param param)
{
var item = param;
#endif
string GetCommandStr() => string.Join(" | ", item.Output().Skip(2).ToArray());
if (__exception != null)
{
var commandInfo = AdvCommandInfo.TryGetCommand(item.Command);
var commandName = commandInfo != null ? commandInfo.CommandName : item.Command.ToString();
AdvEditorPlugin.Logger.Log(LogLevel.Error | LogLevel.Message, $"Crash when running command {commandName}, check log for details. State might be corrupted!");
AdvEditorPlugin.Logger.Log(LogLevel.Error, $"Crash when parsing ADV command:\n{GetCommandStr()}\nSwallowing exception to prevent softlock, *fix this before distributing or people's games will crash*:\n{__exception}");
}
return(null);
}
private bool TryRegisterTranslation(SimpleTextTranslationCache cache, ScenarioData.Param param, int i)
{
var key = textResourceHelper.GetSpecializedKey(param, i, out string value);
if (!string.IsNullOrEmpty(key))
{
if (cache.TryGetTranslation(key, true, out var translated))
{
param.Args[i] = textResourceHelper.GetSpecializedTranslation(param, i, translated);
return(true);
}
else if (AutoTranslatorSettings.IsDumpingRedirectedResourcesEnabled && LanguageHelper.IsTranslatable(key))
{
cache.AddTranslationToCache(key, value);
}
}
return(false);
}
// For commands that encode multiple pieces of data into their strings
// keep all the extra data from the asset file and only replace the
// displayed section (otherwise just returns the passed translation)
public virtual string GetSpecializedTranslation(ScenarioData.Param param, int i, string translation)
{
if (param.Command == Command.Choice)
{
try
{
return(Helpers.JoinStrings(ChoiceDelimiter,
translation.Replace(ChoiceDelimiter[0], OptionSafeComma),
param.Args[i].Split(ChoiceDelimiter.ToCharArray(), 2)[1]));
}
catch
{
// something went wrong, return original below
}
}
return(translation);
}
public static bool RedirectHook(string assetBundleName, string assetName, Type type, string manifestAssetBundleName, out AssetBundleLoadAssetOperation result)
{
string TranslationPath = Path.Combine(DynamicTranslator.dirTranslation, Path.Combine(assetBundleName, assetName)).Replace('/', '\\').Replace(".unity3d", "");
if (type == typeof(ScenarioData))
{
if (Directory.Exists(TranslationPath) || File.Exists(TranslationPath + ".csv"))
{
var rawData = ManualLoadAsset <ScenarioData>(assetBundleName, assetName, manifestAssetBundleName);
//Clear the data and load the new data from the .csv, if there is one.
if (File.Exists(TranslationPath + ".csv"))
{
rawData.list.Clear();
foreach (var line in SplitAndEscape(File.ReadAllText(TranslationPath + ".csv", Encoding.UTF8)))
{
var data = line.ToArray();
var args = new string[data.Length - 4];
Array.Copy(data, 4, args, 0, args.Length);
var param = new ScenarioData.Param(bool.Parse(data[3]), (Command)int.Parse(data[2]), args);
param.SetHash(int.Parse(data[0]));
rawData.list.Add(param);
}
}
//Read any .txt translations and substitute translated text
if (Directory.Exists(TranslationPath))
{
foreach (var param in rawData.list)
{
if (param.Command == Command.Text)
{
for (int i = 0; i < param.Args.Count(); i++)
{
param.Args[i] = TranslateTextFromFolder(param.Args[i], TranslationPath);
}
}
}
}
result = new AssetBundleLoadAssetOperationSimulation(rawData);
return(true);
}
}
else if (type == typeof(ExcelData))
{
if (Directory.Exists(TranslationPath) || File.Exists(TranslationPath + ".csv"))
{
var rawData = ManualLoadAsset <ExcelData>(assetBundleName, assetName, manifestAssetBundleName);
//Clear the data and load the new data from the .csv, if there is one.
if (File.Exists(TranslationPath + ".csv"))
{
rawData.list.Clear();
foreach (var line in SplitAndEscape(File.ReadAllText(TranslationPath + ".csv", Encoding.UTF8)))
{
var list = line.ToList();
var param = new ExcelData.Param();
param.list = list;
rawData.list.Add(param);
}
}
//Read any .txt translations and substitute translated text
if (Directory.Exists(TranslationPath))
{
foreach (var param in rawData.list)
{
for (int i = 0; i < param.list.Count; i++)
{
param.list[i] = TranslateTextFromFolder(param.list[i], TranslationPath);
}
}
}
result = new AssetBundleLoadAssetOperationSimulation(rawData);
return(true);
}
}
result = null;
return(false);
}
public string GetSpecializedKey(ScenarioData.Param param, int i) => GetSpecializedKey(param, i, out string _);
public virtual string BuildSpecializedKey(ScenarioData.Param param, string toTranslate)
{
return(Helpers.JoinStrings(SpecializedKeyDelimiter, GetSpecializedKeyPrefix(param), toTranslate));
}
public override bool ReplaceOrUpdateScenarioParam(string calculatedModificationPath, ScenarioData.Param param, SimpleTextTranslationCache cache)
{
var result = false;
if (!IsSupportedCommand(param.Command))
{
Logger.DebugLogDebug("{0} skipping unsupported command: {1}", GetType().Name, param.Command);
return(false);
}
if (SelectionCommands.Contains(param.Command))
{
foreach (var i in GetScenarioCommandTranslationIndexes(param.Command))
{
if (TryRegisterScenarioTranslation(cache, param, i, calculatedModificationPath))
{
result = true;
}
}
// don't fall through to base call for selection commands
return(result);
}
// ReSharper disable once ConditionIsAlwaysTrueOrFalse -- future proofing
return(result || base.ReplaceOrUpdateScenarioParam(calculatedModificationPath, param, cache));
}
override public bool IsReplacement(ScenarioData.Param param) => param.Command == Command.ReplaceLanguage;
public virtual bool TryRegisterScenarioTranslation(SimpleTextTranslationCache cache, ScenarioData.Param param, int i,
string calculatedModificationPath)
{
var origKey = param.Args.SafeGet(i);
if (origKey.IsNullOrEmpty())
{
return(false);
}
foreach (var key in GetTranslationKeys(param, i))
{
if (string.IsNullOrEmpty(key))
{
return(false);
}
if (cache.TryGetTranslation(key, true, out var translated))
{
var result = GetSpecializedTranslation(param, i, translated);
TranslationHelper.RegisterRedirectedResourceTextToPath(result, calculatedModificationPath);
param.Args[i] = result;
Logger.DebugLogDebug("{0} handled {1}", GetType(), calculatedModificationPath);
return(true);
}
if (!LanguageHelper.IsTranslatable(origKey))
{
return(false);
}
TranslationHelper.RegisterRedirectedResourceTextToPath(key, calculatedModificationPath);
if (AutoTranslatorSettings.IsDumpingRedirectedResourcesEnabled)
{
cache.AddTranslationToCache(key, key);
}
}
return(false);
}
public override bool IsReplacement(ScenarioData.Param param)
{
return(param.Command == Command.ReplaceLanguage);
}
private static Exception PreventAdvCrash(Exception __exception, ScenarioData.Param item)
{
public virtual bool IsReplacement(ScenarioData.Param param)
{
return(false);
}
public string GetSpecializedKey(ScenarioData.Param param, int i)
{
return(GetSpecializedKey(param, i, out _));
}
public virtual void DumpScenarioParam(ScenarioData.Param param, SimpleTextTranslationCache cache)
{
if (!IsSupportedCommand(param.Command))
{
return;
}
if (param.Command == Command.Text)
{
foreach (var i in GetScenarioCommandTranslationIndexes(param.Command))
{
var key = param.Args[i];
if (!string.IsNullOrEmpty(key) && !TextKeysBlacklist.Contains(key) &&
LanguageHelper.IsTranslatable(key))
{
cache.AddTranslationToCache(key, key);
}
}
}
else if (param.Command == Command.Calc)
{
if (param.Args.Length >= 3 && CalcKeys.Contains(param.Args[0]))
{
foreach (var i in GetScenarioCommandTranslationIndexes(param.Command))
{
var key = param.Args[i];
cache.AddTranslationToCache(key, key);
}
}
}
else if (param.Command == Command.Format)
{
if (param.Args.Length >= 2 && FormatKeys.Contains(param.Args[0]))
{
foreach (var i in GetScenarioCommandTranslationIndexes(param.Command))
{
var key = param.Args[i];
cache.AddTranslationToCache(key, key);
}
}
}
else if (param.Command == Command.Choice)
{
for (var i = 0; i < param.Args.Length; i++)
{
var key = GetSpecializedKey(param, i, out var value);
if (!key.IsNullOrEmpty())
{
cache.AddTranslationToCache(key, value);
}
}
}
#if false
else if (param.Command == ADV.Command.Switch)
{
for (int i
= 1; i < param.Args.Length; i += 1)
{
cache.AddTokenTranslationToCache(param.Args[i], param.Args[i]);
}
}
#endif
#if false
else if (param.Command == ADV.Command.InfoText)
{
for (int i
= 1; i < param.Args.Length; i += 1)
{
cache.AddTokenTranslationToCache(param.Args[i], param.Args[i]);
}
}
#endif
#if false
else if (param.Command == ADV.Command.Jump)
{
// TODO: detect if should be dumped
if (param.Args.Length >= 1)
{
cache.AddTokenTranslationToCache(param.Args[0], param.Args[0]);
}
}
#endif
}
public virtual bool ReplaceOrUpdateScenarioParam(string calculatedModificationPath, ScenarioData.Param param,
SimpleTextTranslationCache cache)
{
var result = false;
if (!IsSupportedCommand(param.Command))
{
Logger.DebugLogDebug($"{GetType()} skipping unsupported command: {param.Command}");
return(false);
}
// ReSharper disable once SwitchStatementHandlesSomeKnownEnumValuesWithDefault
switch (param.Command)
{
case Command.Text:
// Text: 0 - jp speaker (if present), 1 - text
foreach (var i in GetScenarioCommandTranslationIndexes(param.Command))
{
var key = param.Args[i];
if (key.IsNullOrEmpty() || TextKeysBlacklist.Contains(key) ||
Helpers.StringIsSingleReplacement(key))
{
continue;
}
if (TryRegisterScenarioTranslation(cache, param, i, calculatedModificationPath))
{
result = true;
}
}
break;
case Command.Calc:
{
if (param.Args.Length >= 3 && CalcKeys.Contains(param.Args[0]))
{
foreach (var i in GetScenarioCommandTranslationIndexes(param.Command))
{
if (TryRegisterScenarioTranslation(cache, param, i, calculatedModificationPath))
{
result = true;
}
}
}
break;
}
case Command.Format:
{
if (param.Args.Length >= 2 && FormatKeys.Contains(param.Args[0]))
{
foreach (var i in GetScenarioCommandTranslationIndexes(param.Command))
{
if (TryRegisterScenarioTranslation(cache, param, i, calculatedModificationPath))
{
result = true;
}
}
}
break;
}
case Command.Choice:
{
for (var i = 0; i < param.Args.Length; i++)
{
if (TryRegisterScenarioTranslation(cache, param, i, calculatedModificationPath))
{
result = true;
}
}
break;
}
#if false
case ADV.Command.Switch:
// TODO
break;
#if AI
case ADV.Command.InfoText:
// TODO
break;
#endif
case ADV.Command.Jump:
// TODO
break;
#endif
default:
{
Logger.LogWarning(
$"{GetType()} expected to handle {param.Command}, but support not implemented");
break;
}
}
return(result);
}
public override bool IsReplacement(ScenarioData.Param param)
{
// only Party has ADV.Command.ReplaceLanguage
return((int)param.Command == 223);
}
public virtual string BuildSpecializedKey(ScenarioData.Param param, string toTranslate)
{
return(Helpers.JoinStrings(SpecializedKeyDelimiter, param.Command.ToString().ToUpperInvariant(),
toTranslate));
}
virtual public bool IsReplacement(ScenarioData.Param param) => false;
protected virtual void HandleAdvCommandDump(string assetBundleName, string assetName, ScenarioData.Param param,
IDictionary <string, string> translations,
ref Dictionary <string, KeyValuePair <string, string> > choiceDictionary, HashSet <string> allJpText)
{
if (!ResourceHelper.IsSupportedCommand(param.Command))
{
#if DEBUG
Logger.DebugLogDebug($"{nameof(HandleAdvCommandDump)}: Unsupported: {param.Command}: \"{string.Join("\", \"", param.Args)}\"");
#endif
return;
}
switch (param.Command)
{
case Command.Text:
case (Command)242:
{
// Text: 0 - jp speaker (if present), 1 - jp text, 2 - eng text
if (param.Args.Length == 0)
{
return;
}
var speaker = param.Args[0];
if (!speaker.IsNullOrEmpty() && !StringIsSingleReplacement(speaker) &&
!ResourceHelper.TextKeysBlacklist.Contains(speaker))
{
// capture speaker name
AddLocalizationToResults(translations, speaker,
LookupSpeakerLocalization(speaker, assetBundleName, assetName));
}
if (param.Args.Length >= 2 && !param.Args[1].IsNullOrEmpty())
{
var key = param.Args[1];
var value = string.Empty;
if (!ResourceHelper.TextKeysBlacklist.Contains(key))
{
Logger.DebugLogDebug(
$"{nameof(HandleAdvCommandDump)}: {param.Command}: \"{string.Join("\", \"", param.Args)}\"");
if (param.Args.Length >= 3 && !param.Args[2].IsNullOrEmpty())
{
value = param.Args[2];
}
allJpText.Add(key);
AddLocalizationToResults(translations, key, value);
}
}
break;
}
case Command.Calc:
{
if (param.Args.Length >= 3 && ResourceHelper.CalcKeys.Contains(param.Args[0]))
{
Logger.DebugLogDebug(
$"{nameof(HandleAdvCommandDump)}: {param.Command}: \"{string.Join("\", \"", param.Args)}\"");
var key = ResourceHelper.GetSpecializedKey(param, 2, out var value);
allJpText.Add(key);
AddLocalizationToResults(translations, key, value);
}
break;
}
case Command.Format:
{
if (param.Args.Length >= 2 && ResourceHelper.FormatKeys.Contains(param.Args[0]))
{
Logger.DebugLogDebug(
$"{nameof(HandleAdvCommandDump)}: {param.Command}: \"{string.Join("\", \"", param.Args)}\"");
var key = param.Args[1];
allJpText.Add(key);
AddLocalizationToResults(translations, key, string.Empty);
// not sure where localizations are, but they're not in the next arg
}
break;
}
case Command.Choice:
{
Logger.DebugLogDebug($"{nameof(HandleAdvCommandDump)}: {param.Command}: \"{string.Join("\", \"", param.Args)}\"");
for (var i = 0; i < param.Args.Length; i++)
{
var key = ResourceHelper.GetSpecializedKey(param, i, out var fallbackValue);
if (key.IsNullOrEmpty())
{
continue;
}
var value = string.Empty;
if (choiceDictionary.TryGetValue(
BuildReplacementKey(assetBundleName,
fallbackValue.TrimStart('[').TrimEnd(']')), out var entry))
{
key = ResourceHelper.BuildSpecializedKey(param, entry.Key);
value = entry.Value;
}
allJpText.Add(key);
AddLocalizationToResults(translations, key, value);
}
break;
}
case Command.Switch:
{
Logger.DebugLogDebug($"{nameof(HandleAdvCommandDump)}: {param.Command}: \"{string.Join("\", \"", param.Args)}\"");
for (var i = 0; i < param.Args.Length; i++)
{
var key = ResourceHelper.GetSpecializedKey(param, i, out var value);
allJpText.Add(key);
AddLocalizationToResults(translations, key, value);
}
break;
}
#if AI
case Command.InfoText:
{
Logger.DebugLogDebug($"{nameof(HandleAdvCommandDump)}: {param.Command}: \"{string.Join("\", \"", param.Args)}\"");
for (var i = 2; i < param.Args.Length; i += 2)
{
var key = param.Args[i];
allJpText.Add(key);
AddLocalizationToResults(translations, key, string.Empty);
}
break;
}
#endif
case Command.Jump:
{
if (param.Args.Length >= 1 &&
ContainsNonAscii(param.Args[0]))
{
Logger.DebugLogDebug(
$"{nameof(HandleAdvCommandDump)}: {param.Command}: \"{string.Join("\", \"", param.Args)}\"");
allJpText.Add(param.Args[0]);
AddLocalizationToResults(translations, param.Args[0],
"Jump");
}
break;
}
default:
Logger.LogError(
$"[TextDump] Unhandled command: {param.Command}: '{string.Join("', '", param.Args.Select(a => a?.ToString() ?? string.Empty).ToArray())}'");
break;
}
}
override public bool IsReplacement(ScenarioData.Param param) => (int)param.Command == 223; // only Party has ADV.Command.ReplaceLanguage
protected override string GetSpecializedKeyPrefix(ScenarioData.Param param)
{
var result = base.GetSpecializedKeyPrefix(param);
return(result.StartsWith(SelectionPrefix) ? SelectionPrefix : result);
}
protected virtual string GetSpecializedKeyPrefix(ScenarioData.Param param)
{
return(param.Command.ToString().ToUpperInvariant());
}
