using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Net.Http;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security.Cryptography;
using System.Text;
using System.Threading.Tasks;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Newtonsoft.Json;
using UnityEngine;
[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.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyCompany("HeimdallVoice")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+6038451d89c7bb0324241a2c518aea9778756540")]
[assembly: AssemblyProduct("HeimdallVoice")]
[assembly: AssemblyTitle("HeimdallVoice")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace HeimdallVoice;
public static class ApiClient
{
private static string _baseUrl = "http://127.0.0.1:24600";
private static readonly HttpClient Http = new HttpClient
{
Timeout = TimeSpan.FromSeconds(3.0)
};
public static void Configure(string baseUrl)
{
_baseUrl = PluginSettings.NormalizeBaseUrl(baseUrl);
ManualLogSource log = HeimdallVoicePlugin.Log;
if (log != null)
{
log.LogInfo((object)("Bridge configurado para " + _baseUrl));
}
}
public static void SendZoneUpdate(string steamId, ZoneData zone)
{
SendRequestAsync(_baseUrl + "/move", steamId, zone?.name, null, zone?.discordChannelId);
}
public static void RestorePreviousChannel(string steamId)
{
SendRequestAsync(_baseUrl + "/restore", steamId, null);
}
public static void RegisterLinkCode(string steamId, string code)
{
SendRequestAsync(_baseUrl + "/register-link", steamId, null, code);
}
private static async Task SendRequestAsync(string url, string steamId, string zone, string code = null, string discordChannelId = null)
{
try
{
var payload = new { steamId, zone, code, discordChannelId };
string json = JsonConvert.SerializeObject((object)payload);
StringContent content = new StringContent(json, Encoding.UTF8, "application/json");
try
{
HttpResponseMessage response = await Http.PostAsync(url, (HttpContent)(object)content).ConfigureAwait(continueOnCapturedContext: false);
if (!response.IsSuccessStatusCode)
{
ManualLogSource log = HeimdallVoicePlugin.Log;
if (log != null)
{
log.LogError((object)$"Erro ao chamar API ({url}): {(int)response.StatusCode} {response.ReasonPhrase}");
}
return;
}
}
finally
{
((IDisposable)content)?.Dispose();
}
ManualLogSource log2 = HeimdallVoicePlugin.Log;
if (log2 != null)
{
log2.LogInfo((object)("API chamada com sucesso (" + url + ")"));
}
}
catch (Exception ex2)
{
Exception ex = ex2;
ManualLogSource log3 = HeimdallVoicePlugin.Log;
if (log3 != null)
{
log3.LogError((object)("Falha ao chamar API (" + url + "): " + ex.Message));
}
}
}
}
[BepInPlugin("heimdall.voice", "HeimdallVoice", "0.4.2")]
public class HeimdallVoicePlugin : BaseUnityPlugin
{
[CompilerGenerated]
private sealed class <ShowExtendedMessage>d__17 : IEnumerator<object>, IDisposable, IEnumerator
{
private int <>1__state;
private object <>2__current;
public string message;
public HeimdallVoicePlugin <>4__this;
private int <i>5__1;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <ShowExtendedMessage>d__17(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0055: Unknown result type (might be due to invalid IL or missing references)
//IL_005f: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<i>5__1 = 0;
break;
case 1:
<>1__state = -1;
<i>5__1++;
break;
}
if (<i>5__1 < 3)
{
if ((Object)(object)Player.m_localPlayer == (Object)null)
{
return false;
}
((Character)Player.m_localPlayer).Message((MessageType)1, message, 0, (Sprite)null);
<>2__current = (object)new WaitForSeconds(1.8f);
<>1__state = 1;
return true;
}
return false;
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
public static ManualLogSource Log;
public static HeimdallVoicePlugin Instance;
private ZoneManager _zoneManager;
private ZoneData _currentZone;
private float _checkTimer;
private LinkCodeManager _linkCodeManager;
private Harmony _harmony;
private string _clientId;
private PluginSettings _settings;
private void Awake()
{
Instance = this;
Log = ((BaseUnityPlugin)this).Logger;
Log.LogInfo((object)"HeimdallVoice initializing...");
_linkCodeManager = new LinkCodeManager();
_settings = PluginSettings.Bind(((BaseUnityPlugin)this).Config);
_zoneManager = new ZoneManager(((BaseUnityPlugin)this).Config);
_zoneManager.LoadZones();
ApiClient.Configure(_settings.BridgeBaseUrl);
_clientId = LoadOrCreateClientId();
RegisterCommands();
PatchChatVoiceCommand();
Log.LogInfo((object)"HeimdallVoice initialized.");
}
private void RegisterCommands()
{
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
//IL_0025: Expected O, but got Unknown
//IL_0020: Unknown result type (might be due to invalid IL or missing references)
new ConsoleCommand("voice", "Gera codigo de vinculo do Discord", (ConsoleEvent)delegate
{
HandleVoiceCommand();
}, true, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
Log.LogInfo((object)"Comando 'voice' registrado.");
}
private void PatchChatVoiceCommand()
{
//IL_0062: Unknown result type (might be due to invalid IL or missing references)
//IL_006c: Expected O, but got Unknown
//IL_0082: Unknown result type (might be due to invalid IL or missing references)
//IL_0088: Expected O, but got Unknown
try
{
Type type = AccessTools.TypeByName("Chat");
if (type == null)
{
Log.LogWarning((object)"Tipo Chat nao encontrado; /voice no chat nao foi habilitado.");
return;
}
MethodInfo methodInfo = AccessTools.Method(type, "InputText", (Type[])null, (Type[])null);
if (methodInfo == null)
{
Log.LogWarning((object)"Metodo Chat.InputText nao encontrado; /voice no chat nao foi habilitado.");
return;
}
_harmony = new Harmony("heimdall.voice.chat");
HarmonyMethod val = new HarmonyMethod(AccessTools.Method(typeof(HeimdallVoicePlugin), "ChatInputTextPrefix", (Type[])null, (Type[])null));
_harmony.Patch((MethodBase)methodInfo, val, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
Log.LogInfo((object)"Comando /voice no chat habilitado.");
}
catch (Exception ex)
{
Log.LogError((object)("Falha ao habilitar /voice no chat: " + ex.Message));
}
}
private static bool ChatInputTextPrefix(object __instance)
{
try
{
if ((Object)(object)Instance == (Object)null)
{
return true;
}
string chatInputText = Instance.GetChatInputText(__instance);
if (string.IsNullOrWhiteSpace(chatInputText))
{
return true;
}
string text = chatInputText.Trim();
if (!text.Equals("/voice", StringComparison.OrdinalIgnoreCase))
{
return true;
}
Instance.HandleVoiceCommand();
Instance.ClearChatInputText(__instance);
return false;
}
catch (Exception ex)
{
ManualLogSource log = Log;
if (log != null)
{
log.LogError((object)("Erro no interceptador de /voice: " + ex.Message));
}
return true;
}
}
private string GetChatInputText(object chatInstance)
{
if (chatInstance == null)
{
return null;
}
Type type = chatInstance.GetType();
FieldInfo fieldInfo = AccessTools.Field(type, "m_input");
if (fieldInfo == null)
{
return null;
}
object value = fieldInfo.GetValue(chatInstance);
if (value == null)
{
return null;
}
PropertyInfo propertyInfo = AccessTools.Property(value.GetType(), "text");
if (propertyInfo != null)
{
return propertyInfo.GetValue(value, null) as string;
}
FieldInfo fieldInfo2 = AccessTools.Field(value.GetType(), "text");
if (fieldInfo2 != null)
{
return fieldInfo2.GetValue(value) as string;
}
return null;
}
private void ClearChatInputText(object chatInstance)
{
if (chatInstance == null)
{
return;
}
Type type = chatInstance.GetType();
object obj = AccessTools.Field(type, "m_input")?.GetValue(chatInstance);
if (obj != null)
{
PropertyInfo propertyInfo = AccessTools.Property(obj.GetType(), "text");
if (propertyInfo != null)
{
propertyInfo.SetValue(obj, string.Empty, null);
}
(AccessTools.Method(type, "Hide", (Type[])null, (Type[])null) ?? AccessTools.Method(type, "HideInput", (Type[])null, (Type[])null))?.Invoke(chatInstance, null);
}
}
private void HandleVoiceCommand()
{
if (string.IsNullOrEmpty(_clientId))
{
ShowInGame("[HeimdallVoice] ClientID invalido.", extendedTime: false);
return;
}
string text = _linkCodeManager.GenerateCode(_clientId);
ApiClient.RegisterLinkCode(_clientId, text);
string message = "[HeimdallVoice] Codigo: " + text + ". Use no Discord: !link " + text;
ShowInGame(message, extendedTime: true);
Log.LogInfo((object)("Codigo de vinculo gerado para " + _clientId + ": " + text));
}
private void ShowInGame(string message, bool extendedTime)
{
Log.LogInfo((object)message);
if (!((Object)(object)Player.m_localPlayer == (Object)null))
{
if (!extendedTime)
{
((Character)Player.m_localPlayer).Message((MessageType)1, message, 0, (Sprite)null);
}
else
{
((MonoBehaviour)this).StartCoroutine(ShowExtendedMessage(message));
}
}
}
[IteratorStateMachine(typeof(<ShowExtendedMessage>d__17))]
private IEnumerator ShowExtendedMessage(string message)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <ShowExtendedMessage>d__17(0)
{
<>4__this = this,
message = message
};
}
private void Update()
{
//IL_0079: Unknown result type (might be due to invalid IL or missing references)
//IL_007e: Unknown result type (might be due to invalid IL or missing references)
//IL_0085: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)Player.m_localPlayer == (Object)null)
{
return;
}
_checkTimer += Time.deltaTime;
if (_checkTimer < 1f)
{
return;
}
_checkTimer = 0f;
if (string.IsNullOrEmpty(_clientId))
{
Log.LogWarning((object)"ClientID invalido.");
return;
}
Vector3 position = ((Component)Player.m_localPlayer).transform.position;
ZoneData zoneForPosition = _zoneManager.GetZoneForPosition(position);
if (zoneForPosition == null)
{
if (_currentZone != null)
{
Log.LogInfo((object)("Player saiu da zona " + _currentZone.name + "; restaurando canal anterior."));
_currentZone = null;
ApiClient.RestorePreviousChannel(_clientId);
}
}
else if (_currentZone == null || !(_currentZone.name == zoneForPosition.name))
{
_currentZone = zoneForPosition;
Log.LogInfo((object)("Player moved to zone " + zoneForPosition.name));
ApiClient.SendZoneUpdate(_clientId, zoneForPosition);
}
}
private void OnDestroy()
{
Harmony harmony = _harmony;
if (harmony != null)
{
harmony.UnpatchSelf();
}
}
private string LoadOrCreateClientId()
{
try
{
string text = SystemInfo.deviceUniqueIdentifier?.Trim();
if (IsUsableDeviceId(text))
{
string text2 = HashClientId(text);
Log.LogInfo((object)("ClientID derivado do dispositivo: " + text2));
return text2;
}
string text3 = Path.Combine(Paths.ConfigPath, "HeimdallVoice");
string path = Path.Combine(text3, "client_id.txt");
if (File.Exists(path))
{
string text4 = File.ReadAllText(path).Trim();
if (!string.IsNullOrEmpty(text4))
{
Log.LogWarning((object)("ClientID em fallback local: " + text4));
return text4;
}
}
Directory.CreateDirectory(text3);
string text5 = Guid.NewGuid().ToString("N");
File.WriteAllText(path, text5);
Log.LogWarning((object)("DeviceUniqueIdentifier indisponivel; fallback gerado: " + text5));
return text5;
}
catch (Exception ex)
{
Log.LogError((object)("Falha ao carregar/gerar ClientID: " + ex.Message));
return null;
}
}
private static bool IsUsableDeviceId(string deviceId)
{
if (string.IsNullOrWhiteSpace(deviceId))
{
return false;
}
return !deviceId.Equals("n/a", StringComparison.OrdinalIgnoreCase);
}
private static string HashClientId(string value)
{
using SHA256 sHA = SHA256.Create();
byte[] bytes = Encoding.UTF8.GetBytes(value);
byte[] array = sHA.ComputeHash(bytes);
StringBuilder stringBuilder = new StringBuilder(array.Length * 2);
byte[] array2 = array;
foreach (byte b in array2)
{
stringBuilder.Append(b.ToString("x2"));
}
return stringBuilder.ToString();
}
}
public class LinkCodeManager
{
private Dictionary<string, string> _activeCodes = new Dictionary<string, string>();
private Random _random = new Random();
public string GenerateCode(string steamId)
{
string text = _random.Next(100000, 999999).ToString();
_activeCodes[steamId] = text;
return text;
}
public string GetCode(string steamId)
{
if (_activeCodes.ContainsKey(steamId))
{
return _activeCodes[steamId];
}
return null;
}
}
public class LinkManager
{
private Dictionary<string, string> _links;
private string _filePath;
public LinkManager()
{
_filePath = Path.Combine(Paths.ConfigPath, "HeimdallVoice", "links.json");
Load();
}
private void Load()
{
if (!File.Exists(_filePath))
{
_links = new Dictionary<string, string>();
return;
}
string text = File.ReadAllText(_filePath);
_links = JsonConvert.DeserializeObject<Dictionary<string, string>>(text);
}
public string GetDiscordId(string steamId)
{
if (_links.ContainsKey(steamId))
{
return _links[steamId];
}
return null;
}
}
public class PluginSettings
{
private class LegacyPluginSettings
{
public string bridgeBaseUrl = "http://127.0.0.1:24600";
}
private class BridgeConfig
{
public string bridgeBaseUrl = "http://127.0.0.1:24600";
public string discordToken = "COLOQUE_O_TOKEN_DO_BOT";
public string guildId = "COLOQUE_O_ID_DO_SERVIDOR";
public string serverHost = "0.0.0.0";
public int serverPort = 24600;
}
private const string DefaultBridgeBaseUrl = "http://127.0.0.1:24600";
private const string DefaultDiscordToken = "COLOQUE_O_TOKEN_DO_BOT";
private const string DefaultGuildId = "COLOQUE_O_ID_DO_SERVIDOR";
private const string DefaultServerHost = "0.0.0.0";
private const int DefaultServerPort = 24600;
private ConfigEntry<string> _bridgeBaseUrl;
private ConfigEntry<string> _discordToken;
private ConfigEntry<string> _guildId;
private ConfigEntry<string> _serverHost;
private ConfigEntry<int> _serverPort;
private string _bridgeConfigPath;
private bool _isSynchronizing;
public string BridgeBaseUrl => NormalizeBaseUrl(_bridgeBaseUrl?.Value);
public static PluginSettings Bind(ConfigFile config)
{
//IL_004b: Unknown result type (might be due to invalid IL or missing references)
//IL_0055: Expected O, but got Unknown
//IL_0081: Unknown result type (might be due to invalid IL or missing references)
//IL_008b: Expected O, but got Unknown
//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
//IL_00c1: Expected O, but got Unknown
//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
//IL_00f7: Expected O, but got Unknown
//IL_011e: Unknown result type (might be due to invalid IL or missing references)
//IL_0128: Expected O, but got Unknown
PluginSettings pluginSettings = new PluginSettings();
string text = LoadLegacyBridgeBaseUrl();
BridgeConfig bridgeConfig = LoadBridgeConfig();
pluginSettings._bridgeConfigPath = ResolveBridgeConfigPath();
pluginSettings._bridgeBaseUrl = config.Bind<string>("Bridge", "URL Base", string.IsNullOrWhiteSpace(text) ? NormalizeBaseUrl(bridgeConfig.bridgeBaseUrl) : text, new ConfigDescription("Endereco base da API do HeimdallVoice Bridge.", (AcceptableValueBase)null, Array.Empty<object>()));
pluginSettings._discordToken = config.Bind<string>("Bot do Discord", "Token do Bot", NormalizeText(bridgeConfig.discordToken, "COLOQUE_O_TOKEN_DO_BOT"), new ConfigDescription("Token do bot do Discord usado pelo HeimdallVoice Bridge.", (AcceptableValueBase)null, Array.Empty<object>()));
pluginSettings._guildId = config.Bind<string>("Servidor do Discord", "ID do Servidor", NormalizeText(bridgeConfig.guildId, "COLOQUE_O_ID_DO_SERVIDOR"), new ConfigDescription("ID do servidor (guild) do Discord.", (AcceptableValueBase)null, Array.Empty<object>()));
pluginSettings._serverHost = config.Bind<string>("Servidor da Bridge", "Host", NormalizeText(bridgeConfig.serverHost, "0.0.0.0"), new ConfigDescription("Host onde o HeimdallVoice Bridge vai escutar.", (AcceptableValueBase)null, Array.Empty<object>()));
pluginSettings._serverPort = config.Bind<int>("Servidor da Bridge", "Porta", NormalizePort(bridgeConfig.serverPort), new ConfigDescription("Porta onde o HeimdallVoice Bridge vai escutar.", (AcceptableValueBase)null, Array.Empty<object>()));
pluginSettings._bridgeBaseUrl.Value = NormalizeBaseUrl(pluginSettings._bridgeBaseUrl.Value);
pluginSettings._discordToken.Value = NormalizeText(pluginSettings._discordToken.Value, "COLOQUE_O_TOKEN_DO_BOT");
pluginSettings._guildId.Value = NormalizeText(pluginSettings._guildId.Value, "COLOQUE_O_ID_DO_SERVIDOR");
pluginSettings._serverHost.Value = NormalizeText(pluginSettings._serverHost.Value, "0.0.0.0");
pluginSettings._serverPort.Value = NormalizePort(pluginSettings._serverPort.Value);
pluginSettings._bridgeBaseUrl.SettingChanged += pluginSettings.HandleBridgeSettingChanged;
pluginSettings._discordToken.SettingChanged += pluginSettings.HandleBridgeSettingChanged;
pluginSettings._guildId.SettingChanged += pluginSettings.HandleBridgeSettingChanged;
pluginSettings._serverHost.SettingChanged += pluginSettings.HandleBridgeSettingChanged;
pluginSettings._serverPort.SettingChanged += pluginSettings.HandleBridgeSettingChanged;
pluginSettings.PersistBridgeConfig();
return pluginSettings;
}
private static string LoadLegacyBridgeBaseUrl()
{
string path = Path.Combine(Paths.ConfigPath, "HeimdallVoice");
string path2 = Path.Combine(path, "settings.json");
try
{
if (!File.Exists(path2))
{
return null;
}
string text = File.ReadAllText(path2);
return NormalizeBaseUrl(JsonConvert.DeserializeObject<LegacyPluginSettings>(text)?.bridgeBaseUrl);
}
catch (Exception ex)
{
ManualLogSource log = HeimdallVoicePlugin.Log;
if (log != null)
{
log.LogError((object)("Falha ao carregar settings.json legado: " + ex.Message));
}
return null;
}
}
public static string NormalizeBaseUrl(string url)
{
if (string.IsNullOrWhiteSpace(url))
{
return "http://127.0.0.1:24600";
}
return url.Trim().TrimEnd(new char[1] { '/' });
}
private void HandleBridgeSettingChanged(object sender, EventArgs args)
{
if (_isSynchronizing)
{
return;
}
_isSynchronizing = true;
try
{
_bridgeBaseUrl.Value = NormalizeBaseUrl(_bridgeBaseUrl.Value);
_discordToken.Value = NormalizeText(_discordToken.Value, "COLOQUE_O_TOKEN_DO_BOT");
_guildId.Value = NormalizeText(_guildId.Value, "COLOQUE_O_ID_DO_SERVIDOR");
_serverHost.Value = NormalizeText(_serverHost.Value, "0.0.0.0");
_serverPort.Value = NormalizePort(_serverPort.Value);
ApiClient.Configure(_bridgeBaseUrl.Value);
PersistBridgeConfig();
}
finally
{
_isSynchronizing = false;
}
}
private void PersistBridgeConfig()
{
try
{
if (!string.IsNullOrWhiteSpace(_bridgeConfigPath))
{
string directoryName = Path.GetDirectoryName(_bridgeConfigPath);
if (!string.IsNullOrWhiteSpace(directoryName))
{
Directory.CreateDirectory(directoryName);
}
BridgeConfig bridgeConfig = new BridgeConfig
{
bridgeBaseUrl = NormalizeBaseUrl(_bridgeBaseUrl.Value),
discordToken = NormalizeText(_discordToken.Value, "COLOQUE_O_TOKEN_DO_BOT"),
guildId = NormalizeText(_guildId.Value, "COLOQUE_O_ID_DO_SERVIDOR"),
serverHost = NormalizeText(_serverHost.Value, "0.0.0.0"),
serverPort = NormalizePort(_serverPort.Value)
};
string contents = JsonConvert.SerializeObject((object)bridgeConfig, (Formatting)1);
File.WriteAllText(_bridgeConfigPath, contents);
}
}
catch (Exception ex)
{
ManualLogSource log = HeimdallVoicePlugin.Log;
if (log != null)
{
log.LogError((object)("Falha ao salvar config do bridge: " + ex.Message));
}
}
}
private static BridgeConfig LoadBridgeConfig()
{
string text = ResolveBridgeConfigPath();
BridgeConfig result = new BridgeConfig();
try
{
if (string.IsNullOrWhiteSpace(text) || !File.Exists(text))
{
return result;
}
string text2 = File.ReadAllText(text);
if (string.IsNullOrWhiteSpace(text2))
{
return result;
}
BridgeConfig bridgeConfig = JsonConvert.DeserializeObject<BridgeConfig>(text2) ?? new BridgeConfig();
bridgeConfig.bridgeBaseUrl = NormalizeBaseUrl(bridgeConfig.bridgeBaseUrl);
bridgeConfig.discordToken = NormalizeText(bridgeConfig.discordToken, "COLOQUE_O_TOKEN_DO_BOT");
bridgeConfig.guildId = NormalizeText(bridgeConfig.guildId, "COLOQUE_O_ID_DO_SERVIDOR");
bridgeConfig.serverHost = NormalizeText(bridgeConfig.serverHost, "0.0.0.0");
bridgeConfig.serverPort = NormalizePort(bridgeConfig.serverPort);
return bridgeConfig;
}
catch (Exception ex)
{
ManualLogSource log = HeimdallVoicePlugin.Log;
if (log != null)
{
log.LogError((object)("Falha ao carregar config do bridge: " + ex.Message));
}
return result;
}
}
private static string ResolveBridgeConfigPath()
{
try
{
string text = Directory.GetParent(Paths.BepInExRootPath)?.FullName;
if (!string.IsNullOrWhiteSpace(text))
{
return Path.Combine(text, "HeimdallVoice-Bridge", "config.json");
}
}
catch (Exception ex)
{
ManualLogSource log = HeimdallVoicePlugin.Log;
if (log != null)
{
log.LogWarning((object)("Nao foi possivel resolver o caminho do bridge: " + ex.Message));
}
}
return Path.Combine(Paths.ConfigPath, "HeimdallVoice", "bridge-config.json");
}
private static string NormalizeText(string value, string fallback)
{
return string.IsNullOrWhiteSpace(value) ? fallback : value.Trim();
}
private static int NormalizePort(int port)
{
return (port <= 0) ? 24600 : port;
}
}
public class ZoneManager
{
private const int MaxZoneSlots = 10;
private List<ZoneData> _zones = new List<ZoneData>();
private string _zoneFilePath;
private ConfigEntry<int> _zoneCount;
private readonly List<ZoneConfigEntrySet> _zoneEntries = new List<ZoneConfigEntrySet>();
private bool _isSynchronizing;
public ZoneManager(ConfigFile config)
{
_zoneFilePath = Path.Combine(Paths.ConfigPath, "HeimdallVoice", "zones.json");
BindConfig(config);
}
public void LoadZones()
{
ApplyConfigToRuntimeZones();
HeimdallVoicePlugin.Log.LogInfo((object)$"Loaded {_zones.Count} zones.");
}
public ZoneData GetZoneForPosition(Vector3 position)
{
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
//IL_001f: Unknown result type (might be due to invalid IL or missing references)
//IL_0025: Unknown result type (might be due to invalid IL or missing references)
//IL_0036: Unknown result type (might be due to invalid IL or missing references)
foreach (ZoneData zone in _zones)
{
float num = Vector2.Distance(new Vector2(position.x, position.z), new Vector2(zone.x, zone.z));
if (num <= zone.radius)
{
return zone;
}
}
return null;
}
private void CreateDefaultZonesFile()
{
Directory.CreateDirectory(Path.GetDirectoryName(_zoneFilePath));
List<ZoneData> list = CreateDefaultZones();
string contents = JsonConvert.SerializeObject((object)list, (Formatting)1);
File.WriteAllText(_zoneFilePath, contents);
}
private void BindConfig(ConfigFile config)
{
//IL_0065: Unknown result type (might be due to invalid IL or missing references)
//IL_006f: Expected O, but got Unknown
//IL_0109: Unknown result type (might be due to invalid IL or missing references)
//IL_0113: Expected O, but got Unknown
//IL_0132: Unknown result type (might be due to invalid IL or missing references)
//IL_013c: Expected O, but got Unknown
//IL_015b: Unknown result type (might be due to invalid IL or missing references)
//IL_0165: Expected O, but got Unknown
//IL_0198: Unknown result type (might be due to invalid IL or missing references)
//IL_01a2: Expected O, but got Unknown
//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
//IL_01d0: Expected O, but got Unknown
List<ZoneData> list = LoadZonesFromDisk();
if (list.Count == 0)
{
CreateDefaultZonesFile();
HeimdallVoicePlugin.Log.LogWarning((object)"Zones file not found. Arquivo de exemplo criado.");
list = CreateDefaultZones();
}
_zoneCount = config.Bind<int>("Zonas", "Quantidade de Zonas", Mathf.Clamp(list.Count, 1, 10), new ConfigDescription($"Quantidade de zonas ativas exibidas abaixo. Maximo: {10}.", (AcceptableValueBase)null, Array.Empty<object>()));
_zoneCount.Value = Mathf.Clamp(_zoneCount.Value, 1, 10);
_zoneCount.SettingChanged += HandleZoneSettingsChanged;
for (int i = 0; i < 10; i++)
{
ZoneData zoneData = ((i < list.Count) ? list[i] : CreateDefaultZone(i + 1));
string text = $"Zona {i + 1}";
ZoneConfigEntrySet zoneConfigEntrySet = new ZoneConfigEntrySet
{
Name = config.Bind<string>(text, "Nome", NormalizeZoneName(zoneData.name, i + 1), new ConfigDescription("Nome da zona.", (AcceptableValueBase)null, Array.Empty<object>())),
X = config.Bind<float>(text, "Posicao X", zoneData.x, new ConfigDescription("Posicao X da zona no mapa.", (AcceptableValueBase)null, Array.Empty<object>())),
Z = config.Bind<float>(text, "Posicao Z", zoneData.z, new ConfigDescription("Posicao Z da zona no mapa.", (AcceptableValueBase)null, Array.Empty<object>())),
Radius = config.Bind<float>(text, "Raio", (zoneData.radius <= 0f) ? 60f : zoneData.radius, new ConfigDescription("Raio da zona.", (AcceptableValueBase)null, Array.Empty<object>())),
DiscordChannelId = config.Bind<string>(text, "ID da Sala Discord", NormalizeChannelId(zoneData.discordChannelId), new ConfigDescription("ID da sala de voz do Discord para esta zona.", (AcceptableValueBase)null, Array.Empty<object>()))
};
zoneConfigEntrySet.Name.SettingChanged += HandleZoneSettingsChanged;
zoneConfigEntrySet.X.SettingChanged += HandleZoneSettingsChanged;
zoneConfigEntrySet.Z.SettingChanged += HandleZoneSettingsChanged;
zoneConfigEntrySet.Radius.SettingChanged += HandleZoneSettingsChanged;
zoneConfigEntrySet.DiscordChannelId.SettingChanged += HandleZoneSettingsChanged;
_zoneEntries.Add(zoneConfigEntrySet);
}
PersistZonesFromConfig();
}
private void HandleZoneSettingsChanged(object sender, EventArgs args)
{
if (!_isSynchronizing)
{
PersistZonesFromConfig();
}
}
private void PersistZonesFromConfig()
{
_isSynchronizing = true;
try
{
_zoneCount.Value = Mathf.Clamp(_zoneCount.Value, 1, 10);
ApplyConfigToRuntimeZones();
Directory.CreateDirectory(Path.GetDirectoryName(_zoneFilePath));
string contents = JsonConvert.SerializeObject((object)_zones, (Formatting)1);
File.WriteAllText(_zoneFilePath, contents);
}
catch (Exception ex)
{
ManualLogSource log = HeimdallVoicePlugin.Log;
if (log != null)
{
log.LogError((object)("Falha ao salvar zonas: " + ex.Message));
}
}
finally
{
_isSynchronizing = false;
}
}
private void ApplyConfigToRuntimeZones()
{
List<ZoneData> list = new List<ZoneData>();
int num = Mathf.Clamp(_zoneCount?.Value ?? 1, 1, 10);
for (int i = 0; i < num && i < _zoneEntries.Count; i++)
{
ZoneConfigEntrySet zoneConfigEntrySet = _zoneEntries[i];
list.Add(new ZoneData
{
name = NormalizeZoneName(zoneConfigEntrySet.Name.Value, i + 1),
x = zoneConfigEntrySet.X.Value,
z = zoneConfigEntrySet.Z.Value,
radius = ((zoneConfigEntrySet.Radius.Value <= 0f) ? 60f : zoneConfigEntrySet.Radius.Value),
discordChannelId = NormalizeChannelId(zoneConfigEntrySet.DiscordChannelId.Value)
});
}
_zones = list;
}
private List<ZoneData> LoadZonesFromDisk()
{
try
{
if (!File.Exists(_zoneFilePath))
{
return new List<ZoneData>();
}
string text = File.ReadAllText(_zoneFilePath);
if (string.IsNullOrWhiteSpace(text))
{
return new List<ZoneData>();
}
return JsonConvert.DeserializeObject<List<ZoneData>>(text) ?? new List<ZoneData>();
}
catch (Exception ex)
{
ManualLogSource log = HeimdallVoicePlugin.Log;
if (log != null)
{
log.LogError((object)("Falha ao carregar zonas: " + ex.Message));
}
return new List<ZoneData>();
}
}
private static List<ZoneData> CreateDefaultZones()
{
return new List<ZoneData> { CreateDefaultZone(1) };
}
private static ZoneData CreateDefaultZone(int index)
{
return new ZoneData
{
name = ((index == 1) ? "Global" : $"Zone {index}"),
x = 0f,
z = 0f,
radius = 60f,
discordChannelId = "ID_DO_CANAL_DISCORD"
};
}
private static string NormalizeZoneName(string name, int index)
{
return string.IsNullOrWhiteSpace(name) ? $"Zone {index}" : name.Trim();
}
private static string NormalizeChannelId(string channelId)
{
return string.IsNullOrWhiteSpace(channelId) ? "ID_DO_CANAL_DISCORD" : channelId.Trim();
}
}
internal class ZoneConfigEntrySet
{
public ConfigEntry<string> Name;
public ConfigEntry<float> X;
public ConfigEntry<float> Z;
public ConfigEntry<float> Radius;
public ConfigEntry<string> DiscordChannelId;
}
public class ZoneData
{
public string name;
public float x;
public float z;
public float radius;
public string discordChannelId;
}
