using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using BepInEx;
using BepInEx.Configuration;
using HarmonyLib;
using Jotunn.Utils;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using UnityEngine;
using UnityEngine.SceneManagement;
using ValMod.Localization.DeepSeekApi;
using ValModLocalization.Data;
using local;
using 全局本地化.Data;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETFramework,Version=v4.8.1", FrameworkDisplayName = "")]
[assembly: AssemblyCompany("全局本地化")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+a1bcb304f805c35486011f12a5e86c4ac7217d27")]
[assembly: AssemblyProduct("全局本地化")]
[assembly: AssemblyTitle("全局本地化")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
internal sealed class NullableAttribute : Attribute
{
public readonly byte[] NullableFlags;
public NullableAttribute(byte P_0)
{
NullableFlags = new byte[1] { P_0 };
}
public NullableAttribute(byte[] P_0)
{
NullableFlags = P_0;
}
}
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
internal sealed class NullableContextAttribute : Attribute
{
public readonly byte Flag;
public NullableContextAttribute(byte P_0)
{
Flag = P_0;
}
}
}
public class MonsterPrefabFinder
{
public static GameObject FindMonsterPrefabByName(string monsterName)
{
if ((Object)(object)ZNetScene.instance == (Object)null)
{
return null;
}
int stableHashCode = StringExtensionMethods.GetStableHashCode(monsterName);
return ZNetScene.instance.GetPrefab(stableHashCode);
}
public static GameObject FindMonsterPrefabByHash(int monsterHash)
{
if ((Object)(object)ZNetScene.instance == (Object)null)
{
return null;
}
return ZNetScene.instance.GetPrefab(monsterHash);
}
public static List<GameObject> GetAllMonsterPrefabs()
{
List<GameObject> list = new List<GameObject>();
if ((Object)(object)ZNetScene.instance == (Object)null)
{
return list;
}
List<string> prefabNames = ZNetScene.instance.GetPrefabNames();
foreach (string item in prefabNames)
{
GameObject prefab = ZNetScene.instance.GetPrefab(item);
if ((Object)(object)prefab != (Object)null)
{
Humanoid component = prefab.GetComponent<Humanoid>();
MonsterAI component2 = prefab.GetComponent<MonsterAI>();
Character component3 = prefab.GetComponent<Character>();
if (((Object)(object)component != (Object)null && !Object.op_Implicit((Object)(object)prefab.GetComponent<Player>())) || (Object)(object)component2 != (Object)null || ((Object)(object)component3 != (Object)null && !component3.IsPlayer()))
{
list.Add(prefab);
}
}
}
return list;
}
}
namespace ValMod.Localization.DeepSeekApi
{
internal class DeepSeekTranslator
{
private static DeepSeekTranslator _instance;
private static readonly object _lock = new object();
private const string ApiEndpoint = "https://api.deepseek.com/chat/completions";
private const int TimeoutSeconds = 30;
private string _apiKey;
private readonly HttpClient _httpClient;
private readonly CancellationTokenSource _globalCts;
public static DeepSeekTranslator Instance
{
get
{
if (_instance == null)
{
lock (_lock)
{
if (_instance == null)
{
_instance = new DeepSeekTranslator();
}
}
}
return _instance;
}
}
private DeepSeekTranslator()
{
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
//IL_0013: Expected O, but got Unknown
//IL_0028: Unknown result type (might be due to invalid IL or missing references)
//IL_0032: Expected O, but got Unknown
_httpClient = new HttpClient();
_httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
_httpClient.Timeout = TimeSpan.FromSeconds(30.0);
_globalCts = new CancellationTokenSource();
}
public void SetApiKey(string apiKey)
{
_apiKey = apiKey;
}
public async Task<string> TranslateAsync(string text, string targetLanguage, string context = null)
{
if (string.IsNullOrEmpty(_apiKey))
{
throw new InvalidOperationException("API密钥未设置");
}
if (string.IsNullOrEmpty(text))
{
return string.Empty;
}
using CancellationTokenSource cts = CancellationTokenSource.CreateLinkedTokenSource(new CancellationToken[1] { _globalCts.Token });
cts.CancelAfter(TimeSpan.FromSeconds(30.0));
try
{
string prompt = BuildPrompt(text, targetLanguage, context);
string systemMessage = BuildSystemMessage(context);
var requestBody = new
{
model = "deepseek-chat",
messages = new[]
{
new
{
role = "system",
content = systemMessage
},
new
{
role = "user",
content = prompt
}
},
stream = false,
temperature = 0.7
};
string jsonContent = JsonConvert.SerializeObject((object)requestBody);
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Post, "https://api.deepseek.com/chat/completions")
{
Content = (HttpContent)new StringContent(jsonContent, Encoding.UTF8, "application/json")
};
request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", _apiKey);
HttpResponseMessage response = await ((HttpMessageInvoker)_httpClient).SendAsync(request, cts.Token);
response.EnsureSuccessStatusCode();
return CleanTranslationResult(JsonConvert.DeserializeObject<DeepSeekResponse>(await response.Content.ReadAsStringAsync())?.choices?[0]?.message?.content) ?? text;
}
catch (TaskCanceledException)
{
throw new Exception("翻译请求超时");
}
catch (HttpRequestException val)
{
HttpRequestException val2 = val;
HttpRequestException ex2 = val2;
throw new Exception("HTTP请求失败: " + ((Exception)(object)ex2).Message, (Exception?)(object)ex2);
}
catch (Exception ex4)
{
Exception ex = ex4;
throw new Exception("翻译服务出错: " + ex.Message, ex);
}
}
private string BuildPrompt(string text, string targetLanguage, string context)
{
if (context != null && context.StartsWith("$"))
{
string text2 = text ?? "该物品";
return "为" + text2 + "设计一个简单的" + targetLanguage + "描述，要求简洁明了，符合维京游戏风格，直接返回描述内容不要其他文字";
}
return "请将以下游戏文本翻译成" + targetLanguage + "，保持专业准确，直接返回翻译结果：\n" + text;
}
private string BuildSystemMessage(string context)
{
return (context != null && context.StartsWith("$")) ? "你是一个游戏物品描述设计师，创作符合维京风格的描述。" : "你是一个专业的翻译助手，请准确翻译用户提供的文本。";
}
private string CleanTranslationResult(string result)
{
return result?.Trim('"', '\'', '“', '”', '。', ' ') ?? string.Empty;
}
public void CancelAllOperations()
{
_globalCts.Cancel();
}
public void Dispose()
{
_globalCts?.Cancel();
HttpClient httpClient = _httpClient;
if (httpClient != null)
{
((HttpMessageInvoker)httpClient).Dispose();
}
_globalCts?.Dispose();
}
}
internal class DeepSeekResponse
{
public List<DeepSeekChoice> choices { get; set; }
}
internal class DeepSeekChoice
{
public int index { get; set; }
public DeepSeekMessage message { get; set; }
public object logprobs { get; set; }
public string finish_reason { get; set; }
}
internal class DeepSeekMessage
{
public string role { get; set; }
public string content { get; set; }
}
}
namespace local
{
public class 翻译工具
{
public static Dictionary<string, EffectInfoData> 效果字典 = new Dictionary<string, EffectInfoData>();
public static Dictionary<string, iteminfodata> 物品字典 = new Dictionary<string, iteminfodata>();
public static Dictionary<string, monsterinfodata> 怪物字典 = new Dictionary<string, monsterinfodata>();
public static Dictionary<string, pieceInfoData> 工具字典 = new Dictionary<string, pieceInfoData>();
}
public class 缓存
{
public static Dictionary<string, GameObject> m_PrefabCache = new Dictionary<string, GameObject>();
public static Dictionary<int, GameObject> m_PrefabHashCache = new Dictionary<int, GameObject>();
public static Dictionary<string, string> monsterNameCache = new Dictionary<string, string>();
public static Dictionary<string, (string name, string desc)> pieceCache = new Dictionary<string, (string, string)>();
public static Dictionary<string, (string name, string desc)> statusEffectCache = new Dictionary<string, (string, string)>();
public static Dictionary<string, (string name, string desc, int hash)> itemTranslationCache = new Dictionary<string, (string, string, int)>();
}
}
namespace ValModLocalization.Data
{
public class 存放
{
public string 预制名 { get; set; } = string.Empty;
public string 名 { get; set; } = string.Empty;
public string 描述 { get; set; } = string.Empty;
public string 哈希 { get; set; } = string.Empty;
}
}
namespace 全局本地化
{
public static class TranslationProcessor
{
[Serializable]
private class SerializableDictionary
{
public List<string> keys = new List<string>();
public List<int> values = new List<int>();
public SerializableDictionary()
{
}
public SerializableDictionary(Dictionary<string, int> dict)
{
foreach (KeyValuePair<string, int> item in dict)
{
keys.Add(item.Key);
values.Add(item.Value);
}
}
public Dictionary<string, int> ToDictionary()
{
Dictionary<string, int> dictionary = new Dictionary<string, int>();
for (int i = 0; i < keys.Count && i < values.Count; i++)
{
dictionary[keys[i]] = values[i];
}
return dictionary;
}
}
public class TranslationTimer : IDisposable
{
private string _operationName;
private Stopwatch _stopwatch;
public TranslationTimer(string operationName)
{
_operationName = operationName;
_stopwatch = Stopwatch.StartNew();
}
public void Dispose()
{
_stopwatch.Stop();
Debug.Log((object)$"[TIMER] {_operationName} - 耗时: {_stopwatch.Elapsed.TotalSeconds:F2}秒");
}
}
private static Dictionary<string, int> translationStats = new Dictionary<string, int>();
private static Dictionary<string, int> progressTracker = new Dictionary<string, int>();
private static 存放 存 => 全局本地化.存;
public static string AiLocalizationFolder { get; set; }
public static int TranslationDelay { get; set; } = 50;
public static string ProgressFile => Path.Combine(AiLocalizationFolder, "translation_progress.txt");
public static async void ProcessAllTranslations()
{
try
{
if (string.IsNullOrEmpty(AiLocalizationFolder))
{
Debug.LogError((object)"翻译文件夹路径未设置！");
return;
}
if (!Directory.Exists(AiLocalizationFolder))
{
Debug.LogError((object)("翻译文件夹不存在: " + AiLocalizationFolder));
return;
}
Debug.Log((object)"开始批量翻译处理...");
LoadProgress();
translationStats.Clear();
string[] allFiles = (from f in Directory.GetFiles(AiLocalizationFolder, "*", SearchOption.AllDirectories)
where Path.GetExtension(f) == ".txt" && !Path.GetFileName(f).Contains("_translated")
select f).ToArray();
Debug.Log((object)$"找到 {allFiles.Length} 个待翻译文件");
string[] array = allFiles;
foreach (string filePath in array)
{
await ProcessSingleFile(filePath);
}
ClearProgress();
LogTranslationStats();
Debug.Log((object)"批量翻译处理完成！");
}
catch (Exception ex2)
{
Exception ex = ex2;
Debug.LogError((object)("批量翻译处理失败: " + ex.Message));
SaveProgress();
}
}
private static async Task ProcessSingleFile(string filePath)
{
try
{
string fileName = Path.GetFileNameWithoutExtension(filePath);
string translatedFilePath = GetTranslatedFilePath(filePath);
if (File.Exists(translatedFilePath))
{
string fileKey = Path.GetFileName(filePath);
if (!progressTracker.ContainsKey(fileKey) || progressTracker[fileKey] <= 0)
{
Debug.Log((object)("已翻译文件存在，跳过: " + fileName));
return;
}
Debug.Log((object)$"继续翻译文件: {fileName} (进度: {progressTracker[fileKey]})");
}
Debug.Log((object)("处理文件: " + fileName));
if (fileName.StartsWith("汉化信息_怪物"))
{
await ProcessMonsterTranslations(filePath);
}
else if (fileName.StartsWith("汉化信息_工具"))
{
await ProcessPieceTranslations(filePath);
}
else if (fileName.StartsWith("汉化信息_效果"))
{
await ProcessStatusEffectsTranslations(filePath);
}
else if (fileName.StartsWith("汉化信息_物品"))
{
await ProcessItemTranslations(filePath);
}
else
{
Debug.LogWarning((object)("未知文件类型，跳过: " + fileName));
}
}
catch (Exception ex2)
{
Exception ex = ex2;
Debug.LogError((object)("处理文件失败 " + filePath + ": " + ex.Message));
SaveProgress();
}
}
private static async Task ProcessItemTranslations(string filePath)
{
if (!File.Exists(filePath))
{
Debug.LogError((object)("文件不存在: " + filePath));
return;
}
string[] lines = File.ReadAllLines(filePath, Encoding.UTF8);
List<string> translatedLines = LoadPartialTranslation(filePath);
int translatedCount = 0;
string fileKey = Path.GetFileName(filePath);
int startIndex = (progressTracker.ContainsKey(fileKey) ? progressTracker[fileKey] : 0);
if (translatedLines.Count > 0)
{
Debug.Log((object)$"从临时文件继续翻译 {fileKey}，已有 {translatedLines.Count} 行");
startIndex = Math.Max(startIndex, translatedLines.Count);
}
else
{
translatedLines = new List<string>();
for (int j = 0; j < Math.Min(startIndex, lines.Length); j++)
{
translatedLines.Add(lines[j]);
}
}
Debug.Log((object)$"开始处理文件 {fileKey}，从第 {startIndex} 行开始，总行数: {lines.Length}");
for (int i = startIndex; i < lines.Length; i++)
{
try
{
string line = lines[i];
if (i < translatedLines.Count)
{
continue;
}
translatedLines.Add(line);
if (line.StartsWith(存.预制名) && i + 2 < lines.Length)
{
string prefabNameLine = line;
string nameLine = lines[i + 1];
string descLine = lines[i + 2];
string originalName = nameLine.Substring(存.名.Length).Trim();
string originalDesc = descLine.Substring(存.描述.Length).Trim();
if (!ContainsChinese(originalName) || !ContainsChinese(originalDesc))
{
using (new TranslationTimer("翻译物品 " + originalName))
{
var (translatedName, translatedDesc) = await TranslateWithRetry(originalName, originalDesc, "物品");
translatedLines[translatedLines.Count - 1] = prefabNameLine;
translatedLines.Add(存.名 + translatedName);
translatedLines.Add(存.描述 + translatedDesc);
translatedCount += 2;
i += 2;
}
}
else
{
translatedLines.Add(nameLine);
translatedLines.Add(descLine);
i += 2;
}
if (i + 1 < lines.Length && lines[i + 1].StartsWith(存.哈希))
{
translatedLines.Add(lines[i + 1]);
i++;
}
}
progressTracker[fileKey] = i + 1;
if (translatedCount > 0 && translatedCount % 10 == 0)
{
SaveProgress();
SavePartialTranslation(filePath, translatedLines);
Debug.Log((object)$"已保存进度: {fileKey} - 第 {i + 1}/{lines.Length} 行");
}
}
catch (Exception ex)
{
Debug.LogError((object)$"处理第 {i} 行时出错: {ex.Message}");
SaveProgress();
SavePartialTranslation(filePath, translatedLines);
throw;
}
}
string outputPath = GetTranslatedFilePath(filePath);
File.WriteAllLines(outputPath, translatedLines, Encoding.UTF8);
CleanTempFile(filePath);
translationStats["物品"] = translatedCount / 2;
Debug.Log((object)$"物品翻译完成: {translatedCount / 2} 个物品已翻译");
}
private static async Task ProcessMonsterTranslations(string filePath)
{
if (!File.Exists(filePath))
{
Debug.LogError((object)("文件不存在: " + filePath));
return;
}
string[] lines = File.ReadAllLines(filePath, Encoding.UTF8);
List<string> translatedLines = LoadPartialTranslation(filePath);
int translatedCount = 0;
string fileKey = Path.GetFileName(filePath);
int startIndex = (progressTracker.ContainsKey(fileKey) ? progressTracker[fileKey] : 0);
if (translatedLines.Count > 0)
{
startIndex = Math.Max(startIndex, translatedLines.Count);
}
else
{
translatedLines = new List<string>();
for (int j = 0; j < Math.Min(startIndex, lines.Length); j++)
{
translatedLines.Add(lines[j]);
}
}
Debug.Log((object)$"开始处理怪物文件 {fileKey}，从第 {startIndex} 行开始");
for (int i = startIndex; i < lines.Length; i++)
{
try
{
string line = lines[i];
if (i < translatedLines.Count)
{
continue;
}
translatedLines.Add(line);
if (line.StartsWith(存.预制名) && i + 1 < lines.Length)
{
string prefabNameLine = line;
string nameLine = lines[i + 1];
string originalName = nameLine.Substring(存.名.Length).Trim();
if (!ContainsChinese(originalName))
{
using (new TranslationTimer("翻译怪物 " + originalName))
{
string translatedName = await TranslateWithRetry(originalName, "怪物");
translatedLines[translatedLines.Count - 1] = prefabNameLine;
translatedLines.Add(存.名 + translatedName);
translatedCount++;
i++;
}
}
else
{
translatedLines.Add(nameLine);
i++;
}
}
progressTracker[fileKey] = i + 1;
if (translatedCount > 0 && translatedCount % 10 == 0)
{
SaveProgress();
SavePartialTranslation(filePath, translatedLines);
}
}
catch (Exception ex)
{
Debug.LogError((object)$"处理第 {i} 行时出错: {ex.Message}");
SaveProgress();
SavePartialTranslation(filePath, translatedLines);
throw;
}
}
string outputPath = GetTranslatedFilePath(filePath);
File.WriteAllLines(outputPath, translatedLines, Encoding.UTF8);
CleanTempFile(filePath);
translationStats["怪物"] = translatedCount;
Debug.Log((object)$"怪物翻译完成: {translatedCount} 个怪物已翻译");
}
private static async Task ProcessPieceTranslations(string filePath)
{
if (!File.Exists(filePath))
{
Debug.LogError((object)("文件不存在: " + filePath));
return;
}
string[] lines = File.ReadAllLines(filePath, Encoding.UTF8);
List<string> translatedLines = LoadPartialTranslation(filePath);
int translatedCount = 0;
string fileKey = Path.GetFileName(filePath);
int startIndex = (progressTracker.ContainsKey(fileKey) ? progressTracker[fileKey] : 0);
if (translatedLines.Count > 0)
{
startIndex = Math.Max(startIndex, translatedLines.Count);
}
else
{
translatedLines = new List<string>();
for (int j = 0; j < Math.Min(startIndex, lines.Length); j++)
{
translatedLines.Add(lines[j]);
}
}
Debug.Log((object)$"开始处理工具文件 {fileKey}，从第 {startIndex} 行开始");
for (int i = startIndex; i < lines.Length; i++)
{
try
{
string line = lines[i];
if (i < translatedLines.Count)
{
continue;
}
translatedLines.Add(line);
if (line.StartsWith(存.预制名) && i + 2 < lines.Length)
{
string prefabNameLine = line;
string nameLine = lines[i + 1];
string descLine = lines[i + 2];
string originalName = nameLine.Substring(存.名.Length).Trim();
string originalDesc = descLine.Substring(存.描述.Length).Trim();
if (!ContainsChinese(originalName) || !ContainsChinese(originalDesc))
{
using (new TranslationTimer("翻译工具 " + originalName))
{
var (translatedName, translatedDesc) = await TranslateWithRetry(originalName, originalDesc, "建造项目");
translatedLines[translatedLines.Count - 1] = prefabNameLine;
translatedLines.Add(存.名 + translatedName);
translatedLines.Add(存.描述 + translatedDesc);
translatedCount += 2;
i += 2;
}
}
else
{
translatedLines.Add(nameLine);
translatedLines.Add(descLine);
i += 2;
}
}
progressTracker[fileKey] = i + 1;
if (translatedCount > 0 && translatedCount % 10 == 0)
{
SaveProgress();
SavePartialTranslation(filePath, translatedLines);
}
}
catch (Exception ex)
{
Debug.LogError((object)$"处理第 {i} 行时出错: {ex.Message}");
SaveProgress();
SavePartialTranslation(filePath, translatedLines);
throw;
}
}
string outputPath = GetTranslatedFilePath(filePath);
File.WriteAllLines(outputPath, translatedLines, Encoding.UTF8);
CleanTempFile(filePath);
translationStats["工具"] = translatedCount / 2;
Debug.Log((object)$"工具翻译完成: {translatedCount / 2} 个工具已翻译");
}
private static async Task ProcessStatusEffectsTranslations(string filePath)
{
if (!File.Exists(filePath))
{
Debug.LogError((object)("文件不存在: " + filePath));
return;
}
string[] lines = File.ReadAllLines(filePath, Encoding.UTF8);
List<string> translatedLines = LoadPartialTranslation(filePath);
int translatedCount = 0;
string fileKey = Path.GetFileName(filePath);
int startIndex = (progressTracker.ContainsKey(fileKey) ? progressTracker[fileKey] : 0);
if (translatedLines.Count > 0)
{
startIndex = Math.Max(startIndex, translatedLines.Count);
}
else
{
translatedLines = new List<string>();
for (int j = 0; j < Math.Min(startIndex, lines.Length); j++)
{
translatedLines.Add(lines[j]);
}
}
Debug.Log((object)$"开始处理状态效果文件 {fileKey}，从第 {startIndex} 行开始");
for (int i = startIndex; i < lines.Length; i++)
{
try
{
string line = lines[i];
if (i < translatedLines.Count)
{
continue;
}
translatedLines.Add(line);
if (line.StartsWith(存.预制名) && i + 2 < lines.Length)
{
string prefabNameLine = line;
string nameLine = lines[i + 1];
string descLine = lines[i + 2];
string originalName = nameLine.Substring(存.名.Length).Trim();
string originalDesc = descLine.Substring(存.描述.Length).Trim();
if (!ContainsChinese(originalName) || !ContainsChinese(originalDesc))
{
using (new TranslationTimer("翻译状态效果 " + originalName))
{
var (translatedName, translatedDesc) = await TranslateWithRetry(originalName, originalDesc, "角色状态效果");
translatedLines[translatedLines.Count - 1] = prefabNameLine;
translatedLines.Add(存.名 + translatedName);
translatedLines.Add(存.描述 + translatedDesc);
translatedCount += 2;
i += 2;
}
}
else
{
translatedLines.Add(nameLine);
translatedLines.Add(descLine);
i += 2;
}
}
progressTracker[fileKey] = i + 1;
if (translatedCount > 0 && translatedCount % 10 == 0)
{
SaveProgress();
SavePartialTranslation(filePath, translatedLines);
}
}
catch (Exception ex)
{
Debug.LogError((object)$"处理第 {i} 行时出错: {ex.Message}");
SaveProgress();
SavePartialTranslation(filePath, translatedLines);
throw;
}
}
string outputPath = GetTranslatedFilePath(filePath);
File.WriteAllLines(outputPath, translatedLines, Encoding.UTF8);
CleanTempFile(filePath);
translationStats["状态效果"] = translatedCount / 2;
Debug.Log((object)$"状态效果翻译完成: {translatedCount / 2} 个效果已翻译");
}
private static async Task<string> TranslateWithRetry(string text, string fileType, int maxRetries = 3)
{
for (int retry = 0; retry < maxRetries; retry++)
{
try
{
return await TranslateText(text);
}
catch (Exception ex) when (retry < maxRetries - 1)
{
Debug.LogWarning((object)$"翻译重试 {retry + 1}/{maxRetries}: {ex.Message}");
await Task.Delay(1000 * (retry + 1));
}
}
Debug.LogError((object)("翻译失败，返回原始文本: " + text));
return text;
}
private static async Task<(string name, string desc)> TranslateWithRetry(string originalName, string originalDesc, string fileType, int maxRetries = 3)
{
for (int retry = 0; retry < maxRetries; retry++)
{
try
{
return await TranslateWithIntelligence(originalName, originalDesc, fileType);
}
catch (Exception ex) when (retry < maxRetries - 1)
{
Debug.LogWarning((object)$"翻译重试 {retry + 1}/{maxRetries}: {ex.Message}");
await Task.Delay(1000 * (retry + 1));
}
}
Debug.LogError((object)("翻译失败，返回原始文本: " + originalName));
return (originalName, originalDesc);
}
private static async Task<(string name, string desc)> TranslateWithIntelligence(string originalName, string originalDesc, string fileType)
{
try
{
string translatedName = await DeepSeekTranslator.Instance.TranslateAsync(originalName, 全局本地化.TARGET_LANGUAGE.Value);
string translatedDesc = (string.IsNullOrEmpty(originalDesc) ? (await DeepSeekTranslator.Instance.TranslateAsync(translatedName, 全局本地化.TARGET_LANGUAGE.Value, "$design_description")) : ((!originalDesc.StartsWith("$")) ? (await DeepSeekTranslator.Instance.TranslateAsync(originalDesc, 全局本地化.TARGET_LANGUAGE.Value)) : (await DeepSeekTranslator.Instance.TranslateAsync(translatedName, 全局本地化.TARGET_LANGUAGE.Value, originalDesc))));
if (string.IsNullOrEmpty(translatedDesc))
{
translatedDesc = translatedName + "的装备";
}
await Task.Delay(TranslationDelay);
return (translatedName, translatedDesc);
}
catch (Exception ex2)
{
Exception ex = ex2;
Debug.LogError((object)("智能翻译失败: " + ex.Message));
return (originalName, originalDesc);
}
}
private static void SavePartialTranslation(string originalPath, List<string> translatedLines)
{
try
{
string path = GetTranslatedFilePath(originalPath) + ".temp";
File.WriteAllLines(path, translatedLines, Encoding.UTF8);
}
catch (Exception ex)
{
Debug.LogWarning((object)("保存临时文件失败: " + ex.Message));
}
}
private static List<string> LoadPartialTranslation(string originalPath)
{
try
{
string path = GetTranslatedFilePath(originalPath) + ".temp";
if (File.Exists(path))
{
List<string> list = File.ReadAllLines(path, Encoding.UTF8).ToList();
Debug.Log((object)$"加载临时翻译文件: {Path.GetFileName(originalPath)}，共 {list.Count} 行");
return list;
}
}
catch (Exception ex)
{
Debug.LogWarning((object)("加载临时文件失败: " + ex.Message));
}
return new List<string>();
}
private static void CleanTempFile(string originalPath)
{
try
{
string path = GetTranslatedFilePath(originalPath) + ".temp";
if (File.Exists(path))
{
File.Delete(path);
Debug.Log((object)("清理临时文件: " + Path.GetFileName(path)));
}
}
catch (Exception ex)
{
Debug.LogWarning((object)("清理临时文件失败: " + ex.Message));
}
}
private static void LoadProgress()
{
try
{
if (File.Exists(ProgressFile))
{
string text = File.ReadAllText(ProgressFile);
progressTracker = JsonUtility.FromJson<SerializableDictionary>(text)?.ToDictionary() ?? new Dictionary<string, int>();
Debug.Log((object)$"加载翻译进度，共 {progressTracker.Count} 个文件的进度");
}
}
catch (Exception ex)
{
Debug.LogWarning((object)("加载进度文件失败: " + ex.Message));
progressTracker = new Dictionary<string, int>();
}
}
private static void SaveProgress()
{
try
{
SerializableDictionary serializableDictionary = new SerializableDictionary(progressTracker);
string contents = JsonUtility.ToJson((object)serializableDictionary);
File.WriteAllText(ProgressFile, contents);
}
catch (Exception ex)
{
Debug.LogWarning((object)("保存进度文件失败: " + ex.Message));
}
}
private static void ClearProgress()
{
try
{
if (File.Exists(ProgressFile))
{
File.Delete(ProgressFile);
Debug.Log((object)"清理进度文件");
}
string[] files = Directory.GetFiles(AiLocalizationFolder, "*.temp", SearchOption.AllDirectories);
foreach (string text in files)
{
try
{
File.Delete(text);
}
catch (Exception ex)
{
Debug.LogWarning((object)("清理临时文件失败 " + text + ": " + ex.Message));
}
}
progressTracker.Clear();
}
catch (Exception ex2)
{
Debug.LogWarning((object)("清理进度文件失败: " + ex2.Message));
}
}
private static async Task<string> TranslateText(string text)
{
if (string.IsNullOrEmpty(text))
{
return text;
}
try
{
string translatedText = await DeepSeekTranslator.Instance.TranslateAsync(text, 全局本地化.TARGET_LANGUAGE.Value);
await Task.Delay(TranslationDelay);
return translatedText ?? text;
}
catch (Exception ex)
{
Debug.LogError((object)("翻译文本失败 '" + text + "': " + ex.Message));
return text;
}
}
private static string GetTranslatedFilePath(string originalPath)
{
string directoryName = Path.GetDirectoryName(originalPath);
string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(originalPath);
string extension = Path.GetExtension(originalPath);
return Path.Combine(directoryName, fileNameWithoutExtension + "_translated" + extension);
}
private static bool ContainsChinese(string text)
{
return !string.IsNullOrEmpty(text) && text.Any((char c) => c >= '一' && c <= '\u9fff');
}
private static void LogTranslationStats()
{
Debug.Log((object)"=== 翻译统计 ===");
foreach (KeyValuePair<string, int> translationStat in translationStats)
{
Debug.Log((object)$"{translationStat.Key}: {translationStat.Value} 个条目已翻译");
}
Debug.Log((object)"=================");
}
public static async void TestSingleFileTranslation(string fileName = "汉化信息_物品.txt")
{
try
{
string testFile = Path.Combine(AiLocalizationFolder, fileName);
if (File.Exists(testFile))
{
Debug.Log((object)("开始测试翻译文件: " + fileName));
await ProcessSingleFile(testFile);
}
else
{
Debug.LogError((object)("测试文件不存在: " + testFile));
}
}
catch (Exception ex2)
{
Exception ex = ex2;
Debug.LogError((object)("测试翻译失败: " + ex.Message));
}
}
public static async void ResumeTranslation()
{
Debug.Log((object)"恢复上次的翻译进度...");
LoadProgress();
ProcessAllTranslations();
}
public static void ResetProgress()
{
ClearProgress();
Debug.Log((object)"翻译进度已重置");
}
public static string GetProgressInfo()
{
if (progressTracker.Count == 0)
{
return "暂无翻译进度";
}
string text = "当前翻译进度:\n";
foreach (KeyValuePair<string, int> item in progressTracker)
{
text += $"{item.Key}: 第 {item.Value} 行\n";
}
return text;
}
public static bool HasProgress()
{
return progressTracker.Count > 0;
}
public static void ShowProgress()
{
string progressInfo = GetProgressInfo();
Debug.Log((object)progressInfo);
}
}
[BepInPlugin("lanlng_locailization", "懒濑的本地化", "1.6")]
public class 全局本地化 : BaseUnityPlugin
{
[HarmonyPatch(typeof(ObjectDB), "Awake")]
[HarmonyPriority(800)]
private class ObjectDBInitializationPatch
{
private static void Postfix(ObjectDB __instance)
{
InitializeAllData(__instance);
Debug.Log((object)"懒濑：初始化成功！");
if (finish2.Value)
{
ApplyAllTranslations(__instance);
}
}
}
internal const string mod_GUID = "lanlng_locailization";
internal const string mod_NAME = "懒濑的本地化";
internal const string mod_VERSION = "1.6";
internal readonly Harmony harmony = new Harmony("lanlng_locailization");
public static 存放 存 = new 存放();
internal static string[] searchFields = Array.Empty<string>();
internal static List<iteminfodata> 物品汉化结果 = new List<iteminfodata>();
internal static List<EffectInfoData> 效果汉化结果 = new List<EffectInfoData>();
internal static List<monsterinfodata> 怪物汉化结果 = new List<monsterinfodata>();
internal static int num1 = 0;
internal static int num2 = 0;
internal static int num3 = 0;
internal static int num4 = 0;
internal static string configFolder = "BepInEx/config";
internal static string modLocalizationFolder = Path.Combine(configFolder, "mod汉化");
internal static string savePath = Path.Combine(Application.dataPath, "../" + modLocalizationFolder + "/汉化信息_物品.txt");
internal static string monstersavePath = Path.Combine(Application.dataPath, "../" + modLocalizationFolder + "/汉化信息_怪物.txt");
internal static string effectsavePath = Path.Combine(Application.dataPath, "../" + modLocalizationFolder + "/汉化信息_效果.txt");
internal static string piecesavePath = Path.Combine(Application.dataPath, "../" + modLocalizationFolder + "/汉化信息_工具.txt");
internal static string modSearchSavePath = Path.Combine(Application.dataPath, "../" + modLocalizationFolder + "/汉化信息_Mod名称.txt");
private static ConfigEntry<string> apiKey;
private static ConfigEntry<bool> finish;
private static ConfigEntry<bool> finish2;
private static ConfigEntry<KeyboardShortcut> Shortcut;
private static ConfigEntry<KeyboardShortcut> modShortcut;
private static ConfigEntry<KeyboardShortcut> TranslateShortcut;
private static ConfigEntry<KeyboardShortcut> textup;
public static ConfigEntry<string> TARGET_LANGUAGE;
public static string[] ItemSearchFields;
public static string[] EffectSearchFields;
public static string[] MonsterSearchFields;
public static string[] PieceSearchFields;
private static bool isInitialized = false;
private const string FilterConfigFileName = "筛选条件.txt";
internal static string modNameConfigPath => Path.Combine(Application.dataPath, "../" + modLocalizationFolder + "/筛选条件_Mod名称.txt");
public void Awake()
{
//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
//IL_012d: Unknown result type (might be due to invalid IL or missing references)
apiKey = ((BaseUnityPlugin)this).Config.Bind<string>("General通用", "APIKey", "sk-eb0f2f33abc548219d36d05b39e23177", "你的API密钥");
TARGET_LANGUAGE = ((BaseUnityPlugin)this).Config.Bind<string>("General通用", "ai翻译的目标语言如Japanese，Korean,Spanish,French,German,Russian,Italian,Portuguese,Dutch等", "中文", "你想要翻译成什么语言");
finish = ((BaseUnityPlugin)this).Config.Bind<bool>("General通用", "是否开启文本收集", true, "是否开启文本收集");
finish2 = ((BaseUnityPlugin)this).Config.Bind<bool>("General通用", "是否应用文本翻译", true, "是否应用文本翻译");
TranslateShortcut = ((BaseUnityPlugin)this).Config.Bind<KeyboardShortcut>("Hotkeys快捷键", "api翻译导出快捷键", new KeyboardShortcut((KeyCode)291, Array.Empty<KeyCode>()), "api翻译快捷键");
Shortcut = ((BaseUnityPlugin)this).Config.Bind<KeyboardShortcut>("Hotkeys快捷键", "筛选条件导出快捷键", new KeyboardShortcut((KeyCode)293, Array.Empty<KeyCode>()), "筛选条件导出快捷键");
modShortcut = ((BaseUnityPlugin)this).Config.Bind<KeyboardShortcut>("Hotkeys快捷键", "mod筛选导出快捷键", new KeyboardShortcut((KeyCode)292, Array.Empty<KeyCode>()), "mod筛选导出快捷键");
textup = ((BaseUnityPlugin)this).Config.Bind<KeyboardShortcut>("Hotkeys快捷键", "更新翻译", new KeyboardShortcut((KeyCode)290, Array.Empty<KeyCode>()), "mod筛选导出快捷键");
((BaseUnityPlugin)this).Logger.LogInfo((object)"初始化 插件 lanlng_locailization ");
Directory.CreateDirectory(Path.Combine(Application.dataPath, "../" + modLocalizationFolder));
TranslationProcessor.AiLocalizationFolder = Path.Combine(modLocalizationFolder, "ai翻译");
Directory.CreateDirectory(Path.Combine(Application.dataPath, "../" + TranslationProcessor.AiLocalizationFolder));
DeepSeekTranslator instance = DeepSeekTranslator.Instance;
instance.SetApiKey(apiKey.Value);
存.预制名 = "预制名:";
存.名 = "名字:";
存.描述 = "描述:";
存.哈希 = "哈希:";
harmony.PatchAll();
EnsureFilterFile("筛选条件.txt", new Dictionary<string, string[]>
{
{
"物品",
new string[2] { "_Ygg", "_Custom" }
},
{
"效果",
new string[1] { "SE_" }
},
{
"怪物",
new string[2] { "RRR", "Custom" }
},
{
"工具",
new string[2] { "_piece", "_Piece" }
}
});
EnsureFilterFile("筛选条件_Mod名称.txt", new Dictionary<string, string[]> {
{
"Mod名称",
new string[3] { "CustomMod", "Extended", "Additional" }
} });
}
private void EnsureFilterFile(string fileName, Dictionary<string, string[]> defaultSections)
{
try
{
string text = Path.Combine(Application.dataPath, "../" + modLocalizationFolder + "/" + fileName);
if (File.Exists(text))
{
return;
}
Directory.CreateDirectory(Path.GetDirectoryName(text));
List<string> list = new List<string>();
foreach (KeyValuePair<string, string[]> defaultSection in defaultSections)
{
list.Add("[" + defaultSection.Key + "]//filter condition for “" + defaultSection.Key + "”");
list.AddRange(defaultSection.Value);
list.Add("");
}
File.WriteAllLines(text, list, Encoding.UTF8);
((BaseUnityPlugin)this).Logger.LogInfo((object)("懒濑：已创建默认筛选文件 " + text));
}
catch (Exception ex)
{
((BaseUnityPlugin)this).Logger.LogError((object)("懒濑：创建筛选文件 " + fileName + " 失败: " + ex.Message));
}
}
public static void InitializeAllData(ObjectDB instance)
{
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
//IL_0016: Unknown result type (might be due to invalid IL or missing references)
if (isInitialized || (Object)(object)instance == (Object)null)
{
return;
}
Scene activeScene = SceneManager.GetActiveScene();
if (!(((Scene)(ref activeScene)).name != "main"))
{
LoadAllSearchFields();
if (finish.Value)
{
CollectAllItems(instance);
CollectAllEffects(instance);
CollectAllMonsters();
CollectAllPieces();
Debug.Log((object)"懒濑：完整数据收集完成");
}
ModPrefabManager.InitializeModInfo();
isInitialized = true;
}
}
public static void ExportFilteredData()
{
try
{
LoadAllSearchFields();
ExportFilteredItems();
ExportFilteredEffects();
ExportFilteredMonsters();
ExportFilteredPieces();
Debug.Log((object)"懒濑：筛选数据导出完成");
}
catch (Exception ex)
{
Debug.LogError((object)("懒濑：导出数据时出错: " + ex.Message));
}
}
private static void CollectAllItems(ObjectDB instance)
{
foreach (KeyValuePair<int, GameObject> item in instance.m_itemByHash)
{
if ((Object)(object)item.Value == (Object)null)
{
continue;
}
ItemDrop component = item.Value.GetComponent<ItemDrop>();
if (!((Object)(object)component == (Object)null))
{
iteminfodata value = new iteminfodata
{
itemname = GetLocalizedText(component.m_itemData.m_shared.m_name),
itemdesc = GetLocalizedText(component.m_itemData.m_shared.m_description),
itemHash = item.Key
};
if (!翻译工具.物品字典.ContainsKey(((Object)item.Value).name))
{
翻译工具.物品字典.Add(((Object)item.Value).name, value);
}
}
}
Debug.Log((object)$"懒濑：收集到 {翻译工具.物品字典.Count} 个物品");
}
private static void CollectAllEffects(ObjectDB instance)
{
foreach (StatusEffect statusEffect in instance.m_StatusEffects)
{
if (!((Object)(object)statusEffect == (Object)null) && !翻译工具.效果字典.ContainsKey(((Object)statusEffect).name))
{
EffectInfoData value = new EffectInfoData
{
effectprename = ((Object)statusEffect).name,
effectname = GetLocalizedText(statusEffect.m_name),
effectdesc = GetLocalizedText(statusEffect.m_tooltip),
effecthash = statusEffect.m_nameHash
};
if (!翻译工具.效果字典.ContainsKey(((Object)statusEffect).name))
{
翻译工具.效果字典.Add(((Object)statusEffect).name, value);
}
}
}
Debug.Log((object)$"懒濑：收集到 {翻译工具.效果字典.Count} 个效果");
}
private static void CollectAllMonsters()
{
Humanoid[] array = Resources.FindObjectsOfTypeAll<Humanoid>();
Humanoid[] array2 = array;
foreach (Humanoid val in array2)
{
monsterinfodata value = new monsterinfodata
{
monsterprename = ((Object)val).name,
monstername = GetLocalizedText(((Character)((Component)val).GetComponent<Humanoid>()).m_name),
monsterhash = ((object)val).GetHashCode()
};
if (!翻译工具.怪物字典.ContainsKey(((Object)val).name))
{
翻译工具.怪物字典.Add(((Object)val).name, value);
}
}
Debug.Log((object)$"懒濑：收集到 {翻译工具.怪物字典.Count} 个怪物");
}
private static void CollectAllPieces()
{
Piece[] array = Resources.FindObjectsOfTypeAll<Piece>();
Piece[] array2 = array;
foreach (Piece val in array2)
{
if (!((Object)(object)val == (Object)null) && !翻译工具.工具字典.ContainsKey(((Object)val).name))
{
pieceInfoData value = new pieceInfoData
{
pieceprename = ((Object)val).name,
piecename = GetLocalizedText(val.m_name),
piecedesc = GetLocalizedText(val.m_description),
piecehash = ((object)val).GetHashCode()
};
if (!翻译工具.工具字典.ContainsKey(((Object)val).name))
{
翻译工具.工具字典.Add(((Object)val).name, value);
}
}
}
Debug.Log((object)$"懒濑：收集到 {翻译工具.工具字典.Count} 个工具");
}
private static string GetLocalizedText(string text)
{
if (string.IsNullOrEmpty(text))
{
return string.Empty;
}
try
{
if (Localization.instance == null)
{
return text;
}
string text2 = Localization.instance.Localize(text);
if (!string.IsNullOrEmpty(text2))
{
return text2;
}
return text;
}
catch (Exception ex)
{
Debug.LogWarning((object)("本地化文本失败: " + text + ", 错误: " + ex.Message));
return text;
}
}
private static void ExportFilteredItems()
{
Dictionary<string, iteminfodata> dictionary = FilterDictionary(翻译工具.物品字典, ItemSearchFields);
string filePath = Path.Combine(modLocalizationFolder, $"汉化信息_物品_{DateTime.Now:yyyyMMdd_HHmm}.txt");
SaveDictionaryToTxt(filePath, "物品", dictionary);
}
private static void ExportFilteredEffects()
{
Dictionary<string, EffectInfoData> dictionary = FilterDictionary(翻译工具.效果字典, EffectSearchFields);
string filePath = Path.Combine(modLocalizationFolder, $"汉化信息_效果_{DateTime.Now:yyyyMMdd_HHmm}.txt");
SaveDictionaryToTxt(filePath, "效果", dictionary);
}
private static void ExportFilteredMonsters()
{
Dictionary<string, monsterinfodata> dictionary = FilterDictionary(翻译工具.怪物字典, MonsterSearchFields);
string filePath = Path.Combine(modLocalizationFolder, $"汉化信息_怪物_{DateTime.Now:yyyyMMdd_HHmm}.txt");
SaveDictionaryToTxt(filePath, "怪物", dictionary);
}
private static void ExportFilteredPieces()
{
Dictionary<string, pieceInfoData> dictionary = FilterDictionary(翻译工具.工具字典, PieceSearchFields);
string filePath = Path.Combine(modLocalizationFolder, $"汉化信息_工具_{DateTime.Now:yyyyMMdd_HHmm}.txt");
SaveDictionaryToTxt(filePath, "工具", dictionary);
}
private static Dictionary<string, T> FilterDictionary<T>(Dictionary<string, T> source, string[] searchFields)
{
Dictionary<string, T> dictionary = new Dictionary<string, T>();
bool flag = searchFields == null || searchFields.Length == 0;
foreach (KeyValuePair<string, T> item in source)
{
if (flag)
{
dictionary.Add(item.Key, item.Value);
continue;
}
foreach (string value in searchFields)
{
if (item.Key.Contains(value))
{
dictionary.Add(item.Key, item.Value);
break;
}
}
}
return dictionary;
}
private static void LoadAllSearchFields()
{
Dictionary<string, string[]> dictionary = new Dictionary<string, string[]>();
dictionary.Add("物品", new string[3] { "_Ygg", "_Custom", "//Filtering conditions for items(This bank's note can be deleted.)" });
dictionary.Add("效果", new string[2] { "SE_", "//Filtering conditions for effects(This bank's note can be deleted.)" });
dictionary.Add("怪物", new string[2] { "RRR", "//Filtering conditions for creature(This bank's note can be deleted.)" });
dictionary.Add("工具", new string[3] { "_piece", "_Piece", "//Filtering conditions for pieces(This bank's note can be deleted.)" });
Dictionary<string, string[]> defaultFilters = dictionary;
(string[], string[], string[], string[]) tuple = LoadAllFiltersFromFile(defaultFilters);
string[] item = tuple.Item1;
string[] item2 = tuple.Item2;
string[] item3 = tuple.Item3;
string[] item4 = tuple.Item4;
ItemSearchFields = item;
EffectSearchFields = item2;
MonsterSearchFields = item3;
PieceSearchFields = item4;
}
private static (string[], string[], string[], string[]) LoadAllFiltersFromFile(Dictionary<string, string[]> defaultFilters)
{
try
{
string path = Path.Combine(modLocalizationFolder, "筛选条件.txt");
Dictionary<string, List<string>> dictionary = new Dictionary<string, List<string>>
{
{
"物品",
new List<string>()
},
{
"效果",
new List<string>()
},
{
"怪物",
new List<string>()
},
{
"工具",
new List<string>()
}
};
string text = null;
if (!File.Exists(path))
{
string directoryName = Path.GetDirectoryName(path);
if (!Directory.Exists(directoryName))
{
Directory.CreateDirectory(directoryName);
}
List<string> list = new List<string>();
string[] array = new string[4] { "物品", "效果", "怪物", "工具" };
foreach (string text2 in array)
{
list.Add("[" + text2 + "]//filter condition");
if (defaultFilters.ContainsKey(text2) && defaultFilters[text2].Length != 0)
{
list.AddRange(defaultFilters[text2]);
}
list.Add("");
}
File.WriteAllLines(path, list);
Debug.Log((object)"懒濑：配置文件不存在，已创建默认配置文件");
return (defaultFilters["物品"], defaultFilters["效果"], defaultFilters["怪物"], defaultFilters["工具"]);
}
string[] array2 = File.ReadAllLines(path);
foreach (string text3 in array2)
{
string text4 = text3.Trim();
if (!string.IsNullOrWhiteSpace(text4))
{
if (text4.StartsWith("[") && text4.Contains("]"))
{
text = text4.Trim('[', ']').Trim();
}
else if (text != null && dictionary.ContainsKey(text))
{
dictionary[text].Add(text4);
}
}
}
return (dictionary["物品"].ToArray(), dictionary["效果"].ToArray(), dictionary["怪物"].ToArray(), dictionary["工具"].ToArray());
}
catch (Exception ex)
{
Debug.LogError((object)("懒濑：加载配置文件 筛选条件.txt 失败: " + ex.Message));
return (defaultFilters["物品"], defaultFilters["效果"], defaultFilters["怪物"], defaultFilters["工具"]);
}
}
private static void SaveDictionaryToTxt<T>(string filePath, string dictionaryType, Dictionary<string, T> dictionary)
{
try
{
using (StreamWriter streamWriter = new StreamWriter(filePath, append: false, Encoding.UTF8))
{
streamWriter.WriteLine(dictionaryType + "信息列表 - " + DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"));
streamWriter.WriteLine("使用说明Instructions:汉化名字和描述后面的内容，然后重启游戏即可，本mod只读取以“汉化信息_怪物”等形式开头的本地化文件");
streamWriter.WriteLine("Locate the content after \"名字:\" and \"描述:\", then restart the game.This mod only reads the localized files that start with \"汉化信息_物品\"、\"汉化信息_工具\"、\"汉化信息_怪物\"、\"汉化信息_效果\"");
streamWriter.WriteLine("==========================================");
foreach (KeyValuePair<string, T> item in dictionary)
{
if (typeof(T) == typeof(iteminfodata))
{
iteminfodata iteminfodata = item.Value as iteminfodata;
streamWriter.WriteLine(存.预制名 + item.Key);
streamWriter.WriteLine(存.名 + iteminfodata.itemname);
streamWriter.WriteLine(存.描述 + iteminfodata.itemdesc);
streamWriter.WriteLine($"{存.哈希}{iteminfodata.itemHash}");
}
else if (typeof(T) == typeof(EffectInfoData))
{
EffectInfoData effectInfoData = item.Value as EffectInfoData;
streamWriter.WriteLine(存.预制名 + effectInfoData.effectprename);
streamWriter.WriteLine(存.名 + effectInfoData.effectname);
streamWriter.WriteLine(存.描述 + effectInfoData.effectdesc);
streamWriter.WriteLine($"{存.哈希}{effectInfoData.effecthash}");
}
else if (typeof(T) == typeof(monsterinfodata))
{
monsterinfodata monsterinfodata = item.Value as monsterinfodata;
streamWriter.WriteLine(存.预制名 + monsterinfodata.monsterprename);
streamWriter.WriteLine(存.名 + monsterinfodata.monstername);
streamWriter.WriteLine($"{存.哈希}{monsterinfodata.monsterhash}");
}
else if (typeof(T) == typeof(pieceInfoData))
{
pieceInfoData pieceInfoData = item.Value as pieceInfoData;
streamWriter.WriteLine(存.预制名 + pieceInfoData.pieceprename);
streamWriter.WriteLine(存.名 + pieceInfoData.piecename);
streamWriter.WriteLine(存.描述 + pieceInfoData.piecedesc);
streamWriter.WriteLine($"{存.哈希}{pieceInfoData.piecehash}");
}
streamWriter.WriteLine("------------------------------------------");
}
}
Debug.Log((object)("懒濑：" + dictionaryType + "字典已成功保存到: " + filePath));
}
catch (Exception ex)
{
Debug.LogError((object)("懒濑：保存" + dictionaryType + "字典时出错: " + ex.Message));
}
}
public static void ApplyAllTranslations(ObjectDB objectDB)
{
//IL_0030: Unknown result type (might be due to invalid IL or missing references)
//IL_0035: Unknown result type (might be due to invalid IL or missing references)
Stopwatch stopwatch = Stopwatch.StartNew();
num1 = 0;
num2 = 0;
num3 = 0;
num4 = 0;
string[] files = Directory.GetFiles(modLocalizationFolder, "*", SearchOption.AllDirectories);
Scene activeScene = SceneManager.GetActiveScene();
if (((Scene)(ref activeScene)).name != "main")
{
return;
}
string[] array = files;
foreach (string text in array)
{
string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(text);
string extension = Path.GetExtension(text);
if (!(extension != ".txt"))
{
if (fileNameWithoutExtension.StartsWith("汉化信息_怪物"))
{
Stopwatch stopwatch2 = Stopwatch.StartNew();
ApplyMonsterTranslations(objectDB, text);
stopwatch2.Stop();
Debug.Log((object)$"懒：怪物翻译耗时 {stopwatch2.Elapsed.TotalSeconds:F2}秒，处理文件：{text}");
}
else if (fileNameWithoutExtension.StartsWith("汉化信息_效果"))
{
Stopwatch stopwatch3 = Stopwatch.StartNew();
ApplyStatusEffects1(objectDB, text);
stopwatch3.Stop();
Debug.Log((object)$"懒：效果翻译耗时 {stopwatch3.Elapsed.TotalSeconds:F2}秒，处理文件：{text}");
}
else if (fileNameWithoutExtension.StartsWith("汉化信息_物品"))
{
Stopwatch stopwatch4 = Stopwatch.StartNew();
ApplyItemTranslations(objectDB, text);
stopwatch4.Stop();
Debug.Log((object)$"懒：物品翻译耗时 {stopwatch4.Elapsed.TotalSeconds:F2}秒，处理文件：{text}");
}
else if (fileNameWithoutExtension.StartsWith("汉化信息_工具"))
{
Stopwatch stopwatch5 = Stopwatch.StartNew();
ApplyPicecTranslations(objectDB, text);
stopwatch5.Stop();
Debug.Log((object)$"懒：工具翻译耗时 {stopwatch5.Elapsed.TotalSeconds:F2}秒，处理文件：{text}");
}
}
}
stopwatch.Stop();
Debug.Log((object)$"懒：翻译完成 - 总耗时 {stopwatch.Elapsed.TotalSeconds:F2}秒");
Debug.Log((object)$"懒：翻译统计 - 物品：{num1} 个，怪物：{num2} 个，工具：{num3} 个，效果：{num4} 个");
}
public static void ApplyItemTranslations(ObjectDB objectDB, string filePath)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
Scene activeScene = SceneManager.GetActiveScene();
if (((Scene)(ref activeScene)).name != "main" || !File.Exists(filePath))
{
return;
}
string[] array = File.ReadAllLines(filePath, Encoding.UTF8);
for (int i = 0; i < array.Length - 3; i++)
{
if (!array[i].StartsWith(存.预制名))
{
continue;
}
string prefabName = array[i].Substring(存.预制名.Length).Trim();
string text = array[i + 1].Substring(存.名.Length).Trim();
string description = array[i + 2].Substring(存.描述.Length).Trim();
int result = 0;
if (i + 3 < array.Length && array[i + 3].StartsWith(存.哈希))
{
int.TryParse(array[i + 3].Substring(存.哈希.Length).Trim(), out result);
}
GameObject itemPrefab = GetItemPrefab(objectDB, result, prefabName, text);
if (!((Object)(object)itemPrefab == (Object)null))
{
ItemDrop component = itemPrefab.GetComponent<ItemDrop>();
if (component?.m_itemData?.m_shared != null)
{
component.m_itemData.m_shared.m_name = text;
component.m_itemData.m_shared.m_description = description;
num1++;
}
}
}
}
public static void ApplyMonsterTranslations(ObjectDB objectDB, string filePath)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
Scene activeScene = SceneManager.GetActiveScene();
if (((Scene)(ref activeScene)).name != "main" || !File.Exists(filePath))
{
return;
}
string[] array = File.ReadAllLines(filePath);
for (int i = 0; i < array.Length - 1; i++)
{
if (!array[i].StartsWith(存.预制名))
{
continue;
}
string text = array[i].Substring(存.预制名.Length);
string text2 = array[i + 1].Substring(存.名.Length);
int result = 0;
if (i + 2 < array.Length && array[i + 2].StartsWith(存.哈希))
{
int.TryParse(array[i + 2].Substring(存.哈希.Length).Trim(), out result);
}
GameObject itemPrefab = GetItemPrefab(objectDB, result, text, text2);
Humanoid val = ((itemPrefab != null) ? itemPrefab.GetComponent<Humanoid>() : null);
if (val != null)
{
((Character)val).m_name = text2;
num2++;
continue;
}
Humanoid[] array2 = Resources.FindObjectsOfTypeAll<Humanoid>();
foreach (Humanoid val2 in array2)
{
if (((Object)val2).name == text)
{
((Character)val2).m_name = text2;
num2++;
}
}
}
}
public static void ApplyPicecTranslations(ObjectDB objectDB, string filePath)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
Scene activeScene = SceneManager.GetActiveScene();
if (((Scene)(ref activeScene)).name != "main" || !File.Exists(filePath))
{
return;
}
string[] array = File.ReadAllLines(filePath);
for (int i = 0; i < array.Length - 1; i++)
{
if (!array[i].StartsWith(存.预制名))
{
continue;
}
string text = array[i].Substring(存.预制名.Length);
string text2 = array[i + 1].Substring(存.名.Length);
string description = array[i + 2].Substring(存.描述.Length);
int result = 0;
if (i + 3 < array.Length && array[i + 3].StartsWith(存.哈希))
{
int.TryParse(array[i + 3].Substring(存.哈希.Length).Trim(), out result);
}
GameObject itemPrefab = GetItemPrefab(objectDB, result, text, text2);
Piece val = ((itemPrefab != null) ? itemPrefab.GetComponent<Piece>() : null);
if (val != null)
{
val.m_name = text2;
val.m_description = description;
num3++;
continue;
}
Piece[] array2 = Resources.FindObjectsOfTypeAll<Piece>();
foreach (Piece val2 in array2)
{
if (((Object)val2).name == text)
{
val2.m_name = text2;
val2.m_description = description;
num3++;
}
}
}
}
public static void ApplyStatusEffects1(ObjectDB objectDB, string filePath)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
Scene activeScene = SceneManager.GetActiveScene();
if (((Scene)(ref activeScene)).name != "main" || !File.Exists(filePath))
{
return;
}
string[] array = File.ReadAllLines(filePath);
for (int i = 0; i < array.Length - 1; i++)
{
if (!array[i].StartsWith(存.预制名))
{
continue;
}
string text = array[i].Substring(存.预制名.Length);
string text2 = array[i + 1].Substring(存.名.Length);
string text3 = array[i + 2].Substring(存.描述.Length);
int result = 0;
if (i + 3 < array.Length && array[i + 3].StartsWith(存.哈希))
{
int.TryParse(array[i + 3].Substring(存.哈希.Length).Trim(), out result);
}
Dictionary<int, EffectInfoData> dictionary = new Dictionary<int, EffectInfoData>();
Dictionary<string, EffectInfoData> dictionary2 = new Dictionary<string, EffectInfoData>();
dictionary[result] = new EffectInfoData
{
effectprename = text,
effectdesc = text3,
effectname = text2,
effecthash = result
};
dictionary2[text] = new EffectInfoData
{
effectprename = text,
effectdesc = text3,
effectname = text2,
effecthash = result
};
foreach (StatusEffect item in objectDB.m_StatusEffects.Where((StatusEffect se) => (Object)(object)se != (Object)null))
{
EffectInfoData value;
EffectInfoData effectInfoData = (dictionary.TryGetValue(item.NameHash(), out value) ? value : (dictionary2.TryGetValue(((Object)item).name, out value) ? value : null));
if (effectInfoData != null)
{
item.m_name = text2;
item.m_tooltip = text3;
num4++;
}
}
}
}
private static GameObject GetItemPrefab(ObjectDB objectDB, int hash, string prefabName, string itemName)
{
string prefabName2 = prefabName;
string itemName2 = itemName;
if (hash != 0)
{
GameObject val = GetGameObject(hash) ?? ((objectDB != null) ? objectDB.GetItemPrefab(hash) : null);
if ((Object)(object)val != (Object)null)
{
return val;
}
}
if (!string.IsNullOrEmpty(prefabName2))
{
GameObject val2 = GetGameObject(prefabName2) ?? ((IEnumerable<GameObject>)objectDB?.m_items).FirstOrDefault((Func<GameObject, bool>)((GameObject item) => ((item != null) ? ((Object)item).name : null) == prefabName2));
if ((Object)(object)val2 != (Object)null)
{
return val2;
}
}
if (!string.IsNullOrEmpty(itemName2))
{
return GetGameObject(itemName2) ?? ((IEnumerable<GameObject>)objectDB?.m_items).FirstOrDefault((Func<GameObject, bool>)((GameObject item) => ((item != null) ? ((Object)item).name : null) == itemName2));
}
return null;
}
public static GameObject GetGameObject(string name)
{
if (string.IsNullOrEmpty(name))
{
Debug.LogError((object)"获取预制件名时，传入了空字符");
return null;
}
if (缓存.m_PrefabCache.ContainsKey(name))
{
return 缓存.m_PrefabCache[name];
}
GameObject val = ZNetScene.instance.GetPrefab(name) ?? ObjectDB.instance.GetItemPrefab(name) ?? ResourcesGetGameObject(name);
if ((Object)(object)val == (Object)null)
{
return null;
}
if (!缓存.m_PrefabCache.ContainsKey(((Object)val).name))
{
缓存.m_PrefabCache.Add(((Object)val).name, val);
}
return val;
}
public static GameObject GetGameObject(int hash)
{
GameObject val = ZNetScene.instance.GetPrefab(hash) ?? ObjectDB.instance.GetItemPrefab(hash);
if ((Object)(object)val == (Object)null)
{
return null;
}
if (!缓存.m_PrefabCache.ContainsKey(((Object)val).name))
{
缓存.m_PrefabCache.Add(((Object)val).name, val);
}
return val;
}
private static GameObject ResourcesGetGameObject(string name)
{
GameObject[] array = Resources.FindObjectsOfTypeAll<GameObject>();
GameObject[] array2 = array;
foreach (GameObject val in array2)
{
if (((Object)val).name == name)
{
return val;
}
}
return null;
}
public void Update()
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
//IL_0029: Unknown result type (might be due to invalid IL or missing references)
//IL_0073: Unknown result type (might be due to invalid IL or missing references)
//IL_0078: Unknown result type (might be due to invalid IL or missing references)
//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
//IL_00db: Unknown result type (might be due to invalid IL or missing references)
//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
//IL_010a: Unknown result type (might be due to invalid IL or missing references)
//IL_010f: Unknown result type (might be due to invalid IL or missing references)
KeyboardShortcut value = Shortcut.Value;
if (((KeyboardShortcut)(ref value)).IsDown())
{
ExportFilteredData();
}
value = modShortcut.Value;
if (((KeyboardShortcut)(ref value)).IsDown())
{
LoadModNamesFromConfig();
string[] array = LoadModNamesFromConfig();
string[] array2 = array;
foreach (string modName in array2)
{
ExportByModSearch(modName);
}
}
value = TranslateShortcut.Value;
if (((KeyboardShortcut)(ref value)).IsDown())
{
if (TranslationProcessor.HasProgress())
{
TranslationProcessor.ResumeTranslation();
}
else
{
TranslationProcessor.ProcessAllTranslations();
}
}
value = TranslateShortcut.Value;
if (((KeyboardShortcut)(ref value)).IsDown() && Input.GetKey((KeyCode)306))
{
TranslationProcessor.ResetProgress();
TranslationProcessor.ProcessAllTranslations();
}
value = TranslateShortcut.Value;
if (((KeyboardShortcut)(ref value)).IsDown() && Input.GetKey((KeyCode)308))
{
TranslationProcessor.ShowProgress();
}
value = textup.Value;
if (((KeyboardShortcut)(ref value)).IsDown())
{
ObjectDB instance = ObjectDB.instance;
if ((Object)(object)instance != (Object)null)
{
ApplyAllTranslations(instance);
}
else
{
Debug.LogError((object)"懒濑：按键触发时无法获取 ObjectDB 实例");
}
}
}
private async void TestTranslation()
{
try
{
((BaseUnityPlugin)this).Logger.LogInfo((object)"开始测试翻译功能...");
string testText = "Hello world! This is a translation test.";
string translatedText = await DeepSeekTranslator.Instance.TranslateAsync(testText, "中文");
if (!string.IsNullOrEmpty(translatedText))
{
((BaseUnityPlugin)this).Logger.LogInfo((object)("翻译前: " + testText));
((BaseUnityPlugin)this).Logger.LogInfo((object)("翻译后: " + translatedText));
((BaseUnityPlugin)this).Logger.LogInfo((object)"翻译测试成功完成！");
}
else
{
((BaseUnityPlugin)this).Logger.LogError((object)"翻译测试失败：返回结果为空");
}
}
catch (Exception ex2)
{
Exception ex = ex2;
((BaseUnityPlugin)this).Logger.LogError((object)("翻译测试过程中发生异常: " + ex.Message));
}
}
private string[] LoadModNamesFromConfig()
{
try
{
if (File.Exists(modNameConfigPath))
{
return (from line in File.ReadAllLines(modNameConfigPath)
where !string.IsNullOrWhiteSpace(line)
select line.Trim()).ToArray();
}
string[] array = new string[2] { "//Please enter the name of the mod to which the text you want to export belongs.for example, SouthsilArmor，Multiple entries, please press enter to continue.", "SouthsilArmor" };
File.WriteAllLines(modNameConfigPath, array);
Debug.Log((object)("已创建默认Mod名称筛选文件: " + modNameConfigPath));
return array;
}
catch (Exception ex)
{
Debug.LogError((object)("加载Mod名称配置文件失败: " + ex.Message));
return new string[0];
}
}
private void ExportByModSearch(string modName)
{
if (string.IsNullOrWhiteSpace(modName))
{
Debug.LogWarning((object)"跳过空的Mod名称筛选条件");
return;
}
int num = 0;
bool flag = false;
bool flag2 = false;
bool flag3 = false;
bool flag4 = false;
bool flag5 = false;
try
{
ModPrefabManager.InitializeModInfo();
List<string> list = ModPrefabManager.SearchPrefabsByModName(modName);
if (list.Count == 0)
{
Debug.LogWarning((object)("未找到Mod '" + modName + "' 相关的预制件"));
return;
}
string path = $"汉化信息__{modName}_{DateTime.Now:yyyyMMdd_HHmm}.txt";
string text = Path.Combine(modLocalizationFolder, path);
using (StreamWriter streamWriter = new StreamWriter(text, append: false, Encoding.UTF8))
{
streamWriter.WriteLine("Mod名称/modname: " + modName);
streamWriter.WriteLine($"导出时间: {DateTime.Now:yyyy-MM-dd HH:mm:ss}");
streamWriter.WriteLine($"找到预制件数量: {list.Count}");
streamWriter.WriteLine("这里是根据mod名导出的文本，例如SouthsilArmor。");
streamWriter.WriteLine("This is the text derived based on the mod name. ");
streamWriter.WriteLine("本地化后将其中内容按板块分别复制到以\"汉化信息_物品\\\"、\\\"汉化信息_工具\\\"、\\\"汉化信息_怪物\\\"、\\\"汉化信息_效果\\\"开头的文件。 ");
streamWriter.WriteLine("完成后重启生效");
streamWriter.WriteLine("After localization, the contents should be copied to separate files starting with \"汉化信息_物品\"、\"汉化信息_工具\"、\"汉化信息_怪物\"and\"汉化信息_效果\", respectively.");
streamWriter.WriteLine("After completion, restart to make the localization take effect.");
streamWriter.WriteLine("==========================================");
streamWriter.WriteLine();
foreach (string item in list)
{
EffectInfoData value2;
monsterinfodata value3;
pieceInfoData value4;
if (翻译工具.物品字典.TryGetValue(item, out iteminfodata value))
{
if (!flag)
{
streamWriter.WriteLine("【物品item】");
streamWriter.WriteLine("------------------------------------------");
flag = true;
}
streamWriter.WriteLine(存.预制名 + item);
streamWriter.WriteLine(存.名 + value.itemname);
streamWriter.WriteLine(存.描述 + value.itemdesc);
streamWriter.WriteLine($"{存.哈希}{value.itemHash}");
streamWriter.WriteLine("------------------------------------------");
num++;
}
else if (翻译工具.效果字典.TryGetValue(item, out value2))
{
if (!flag2)
{
streamWriter.WriteLine("【效果effect】");
streamWriter.WriteLine("------------------------------------------");
flag2 = true;
}
streamWriter.WriteLine(存.预制名 + item);
streamWriter.WriteLine(存.名 + value2.effectname);
streamWriter.WriteLine(存.描述 + value2.effectdesc);
streamWriter.WriteLine($"{存.哈希}{value2.effecthash}");
streamWriter.WriteLine("------------------------------------------");
num++;
}
else if (翻译工具.怪物字典.TryGetValue(item, out value3))
{
if (!flag3)
{
streamWriter.WriteLine("【怪物creature】");
streamWriter.WriteLine("------------------------------------------");
flag3 = true;
}
streamWriter.WriteLine(存.预制名 + item);
streamWriter.WriteLine(存.名 + value3.monstername);
streamWriter.WriteLine($"{存.哈希}{value3.monsterhash}");
streamWriter.WriteLine("------------------------------------------");
num++;
}
else if (翻译工具.工具字典.TryGetValue(item, out value4))
{
if (!flag4)
{
streamWriter.WriteLine("【工具pieces】");
streamWriter.WriteLine("------------------------------------------");
flag4 = true;
}
streamWriter.WriteLine(存.预制名 + item);
streamWriter.WriteLine(存.名 + value4.piecename);
streamWriter.WriteLine(存.描述 + value4.piecedesc);
streamWriter.WriteLine($"{存.哈希}{value4.piecehash}");
streamWriter.WriteLine("------------------------------------------");
num++;
}
else
{
if (!flag5)
{
streamWriter.WriteLine("【未知unknown】");
streamWriter.WriteLine("------------------------------------------");
flag5 = true;
}
streamWriter.WriteLine(存.预制名 + item);
streamWriter.WriteLine(存.名 + "未找到本地化信息");
streamWriter.WriteLine(存.描述 + "未找到本地化信息");
streamWriter.WriteLine(存.哈希 + "未找到本地化信息");
streamWriter.WriteLine("------------------------------------------");
num++;
}
}
streamWriter.WriteLine();
streamWriter.WriteLine($"成功导出: {num} 个预制件");
}
Debug.Log((object)$"懒濑：已导出Mod '{modName}' 的 {num} 个预制件到: {text}");
}
catch (Exception ex)
{
Debug.LogError((object)("懒濑：导出Mod '" + modName + "' 时出错: " + ex.Message));
}
}
public void OnDestroy()
{
}
}
}
namespace 全局本地化.Data
{
public class EffectInfoData
{
public string effectprename { get; set; } = string.Empty;
public string effectname { get; set; } = string.Empty;
public string effectdesc { get; set; } = string.Empty;
public int effecthash { get; set; } = 0;
}
public class EffectInfoData1
{
public string effectprename { get; set; }
public string effectdesc { get; set; }
public string effectname { get; set; }
public string effecthash { get; set; }
}
public class iteminfodata
{
public string itemname { get; set; } = string.Empty;
public string itemdesc { get; set; } = string.Empty;
public int itemHash { get; set; } = 0;
}
public class ModInfoData
{
public string ModName { get; set; } = "";
public string ModGUID { get; set; } = "";
public List<string> PrefabNames { get; set; } = new List<string>();
}
public static class ModPrefabManager
{
public static readonly Dictionary<string, ModInfoData> ModInfoDict = new Dictionary<string, ModInfoData>();
public static readonly Dictionary<string, string> PrefabToModMap = new Dictionary<string, string>();
public static void InitializeModInfo()
{
ModInfoDict.Clear();
PrefabToModMap.Clear();
foreach (IModPrefab prefab in ModQuery.GetPrefabs())
{
if (prefab != null && Object.op_Implicit((Object)(object)prefab.Prefab) && prefab.SourceMod != null)
{
string gUID = prefab.SourceMod.GUID;
string name = ((Object)prefab.Prefab).name;
if (!ModInfoDict.ContainsKey(gUID))
{
ModInfoDict[gUID] = new ModInfoData
{
ModName = prefab.SourceMod.Name,
ModGUID = gUID,
PrefabNames = new List<string>()
};
}
if (!ModInfoDict[gUID].PrefabNames.Contains(name))
{
ModInfoDict[gUID].PrefabNames.Add(name);
}
if (!PrefabToModMap.ContainsKey(name))
{
PrefabToModMap[name] = gUID;
}
}
}
}
public static List<string> SearchPrefabsByModName(string modName)
{
List<string> list = new List<string>();
foreach (ModInfoData value in ModInfoDict.Values)
{
if (value.ModName.IndexOf(modName, StringComparison.OrdinalIgnoreCase) >= 0 || value.ModGUID.IndexOf(modName, StringComparison.OrdinalIgnoreCase) >= 0)
{
list.AddRange(value.PrefabNames);
}
}
return list.Distinct().ToList();
}
public static List<string> GetAllModNames()
{
return ModInfoDict.Values.Select((ModInfoData mod) => mod.ModName).Distinct().ToList();
}
public static ModInfoData GetModByPrefabName(string prefabName)
{
if (PrefabToModMap.TryGetValue(prefabName, out string value) && ModInfoDict.TryGetValue(value, out ModInfoData value2))
{
return value2;
}
return null;
}
}
public class monsterinfodata
{
public string monstername { get; set; } = string.Empty;
public string monsterprename { get; set; } = string.Empty;
public int monsterhash { get; set; } = 0;
}
public class pieceInfoData
{
public string pieceprename { get; set; } = string.Empty;
public string piecename { get; set; } = string.Empty;
public string piecedesc { get; set; } = string.Empty;
public int piecehash { get; set; } = 0;
}
}
