using System;
using System.CodeDom.Compiler;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Reflection;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Threading.Tasks;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using TMPro;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.UI;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: IgnoresAccessChecksTo("")]
[assembly: AssemblyCompany("Jor02")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+3b95e8201248fcaf0ffd5c34b191a9d640f43625")]
[assembly: AssemblyProduct("RadialQuickMessage")]
[assembly: AssemblyTitle("RadialQuickMessage")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
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;
}
}
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
internal sealed class RefSafetyRulesAttribute : Attribute
{
public readonly int Version;
public RefSafetyRulesAttribute(int P_0)
{
Version = P_0;
}
}
}
namespace RadialQuickMessage
{
public class RadialButton : MonoBehaviour
{
public string label;
public string? message;
public RadialContent[]? radialContent;
public Image image;
}
[Serializable]
public class RadialContent
{
public string? Label;
public string? Message;
public RadialContent[]? Children;
}
internal class RadialMenuManager : MonoBehaviour
{
[CompilerGenerated]
private sealed class <CenterCursor>d__24 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <CenterCursor>d__24(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
Cursor.lockState = (CursorLockMode)1;
<>2__current = null;
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
Cursor.lockState = (CursorLockMode)0;
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 UnityEvent<string?> OnMessageClicked = new UnityEvent<string>();
public float RadialSize = 250f;
public float InnerCircleRange = 0.2f;
public Color MenuColor = new Color(0f, 0f, 0f, 0.6039216f);
public Color HoverColor = new Color(0.25098038f, 28f / 51f, 1f, 1f);
public Sprite RadialSprite;
public Sprite CenterSprite;
public Sprite SeparatorSprite;
public TextMeshProUGUI ReferenceLabel;
private GameObject outerButtonRoot;
private RadialButton radialCenterButton;
private RadialButton[] outerButtons = new RadialButton[0];
private int sliceHovered = -1;
private RadialContent[] currentContent;
private Stack<RadialContent[]> menuStack = new Stack<RadialContent[]>();
private List<string?> selectedMessageStack = new List<string>();
public void Open(RadialContent[] content)
{
menuStack.Clear();
selectedMessageStack.Clear();
GenerateMenu(content, pushToStack: false);
}
public void Close()
{
if ((Object)(object)radialCenterButton != (Object)null)
{
Object.Destroy((Object)(object)((Component)radialCenterButton).gameObject);
}
Object.Destroy((Object)(object)outerButtonRoot);
}
public bool IsOpen()
{
if (!((Object)(object)radialCenterButton != (Object)null))
{
return (Object)(object)outerButtonRoot != (Object)null;
}
return true;
}
private void GenerateMenu(RadialContent[] newContent, bool pushToStack = true)
{
if (Object.op_Implicit((Object)(object)RadialSprite) && Object.op_Implicit((Object)(object)CenterSprite) && Object.op_Implicit((Object)(object)SeparatorSprite))
{
((MonoBehaviour)this).StartCoroutine(CenterCursor());
if (pushToStack && currentContent != null)
{
menuStack.Push(currentContent);
}
currentContent = newContent;
sliceHovered = -1;
if (menuStack.Count > 0)
{
GenerateCenterButton();
}
else if ((Object)(object)radialCenterButton != (Object)null)
{
Object.Destroy((Object)(object)((Component)radialCenterButton).gameObject);
}
GenerateRadialSlices(currentContent);
Utils.SetLayerRecursively(((Component)this).gameObject, LayerMask.NameToLayer("UI"));
}
}
private void GenerateCenterButton()
{
//IL_0050: Unknown result type (might be due to invalid IL or missing references)
//IL_0056: Expected O, but got Unknown
//IL_007a: Unknown result type (might be due to invalid IL or missing references)
//IL_0099: Unknown result type (might be due to invalid IL or missing references)
//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
//IL_0135: Unknown result type (might be due to invalid IL or missing references)
//IL_0154: Unknown result type (might be due to invalid IL or missing references)
//IL_0160: Unknown result type (might be due to invalid IL or missing references)
//IL_0162: Unknown result type (might be due to invalid IL or missing references)
//IL_016e: Unknown result type (might be due to invalid IL or missing references)
//IL_017a: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)radialCenterButton != (Object)null)
{
Object.Destroy((Object)(object)((Component)radialCenterButton).gameObject);
}
GameObject val = new GameObject("Center", new Type[3]
{
typeof(RectTransform),
typeof(Image),
typeof(RadialButton)
});
val.transform.SetParent(((Component)this).transform, false);
val.GetComponent<RectTransform>().sizeDelta = new Vector2(RadialSize, RadialSize);
Image component = val.GetComponent<Image>();
component.sprite = CenterSprite;
((Graphic)component).color = MenuColor;
RadialButton component2 = val.GetComponent<RadialButton>();
component2.image = component;
radialCenterButton = component2;
if ((Object)(object)ReferenceLabel != (Object)null)
{
Transform transform = ((Component)this).transform;
RectTransform val2 = (RectTransform)(object)((transform is RectTransform) ? transform : null);
Vector2 val3 = Vector2.op_Implicit(((Object)(object)val2 != (Object)null) ? ((Transform)val2).position : ((Component)this).transform.position);
TextMeshProUGUI val4 = Object.Instantiate<TextMeshProUGUI>(ReferenceLabel, val.transform);
((TMP_Text)val4).text = "BACK";
((Behaviour)val4).enabled = true;
((TMP_Text)val4).alignment = (TextAlignmentOptions)514;
((MaskableGraphic)val4).maskable = false;
((TMP_Text)val4).margin = Vector4.zero;
RectTransform component3 = ((Component)val4).GetComponent<RectTransform>();
component3.pivot = new Vector2(0.5f, 0.5f);
((Transform)component3).position = Vector2.op_Implicit(val3);
((Transform)component3).rotation = Quaternion.identity;
((Transform)component3).localScale = Vector3.one;
((Component)component3).gameObject.SetActive(true);
}
}
private void GenerateRadialSlices(params RadialContent[] content)
{
int num = content.Length;
if (num <= 0)
{
RadialQuickMessage.Logger.LogWarning((object)"Number of slices must be greater than 0.");
return;
}
Object.Destroy((Object)(object)outerButtonRoot);
Transform parent = CreateSeparatorMasks(num);
outerButtons = new RadialButton[num];
for (int i = 0; i < num; i++)
{
outerButtons[i] = CreateOuterButton(i, num, parent, content[i]);
}
}
private Transform CreateSeparatorMasks(int numberOfSlices)
{
//IL_0046: Unknown result type (might be due to invalid IL or missing references)
//IL_004c: Expected O, but got Unknown
//IL_0088: Unknown result type (might be due to invalid IL or missing references)
//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
Transform val = null;
for (int i = 0; i < numberOfSlices; i++)
{
GameObject val2 = new GameObject($"Separator_{i}", new Type[3]
{
typeof(RectTransform),
typeof(Image),
typeof(Mask)
});
val2.transform.SetParent(((Object)(object)val == (Object)null) ? ((Component)this).transform : val, false);
if (i == 0)
{
outerButtonRoot = val2;
}
RectTransform component = val2.GetComponent<RectTransform>();
component.sizeDelta = new Vector2(RadialSize, RadialSize);
((Transform)component).localRotation = Quaternion.Euler(0f, 0f, -360f / (float)numberOfSlices + (float)((numberOfSlices == 2 && i == 0) ? 90 : 0));
Image component2 = val2.GetComponent<Image>();
component2.sprite = SeparatorSprite;
val2.GetComponent<Mask>().showMaskGraphic = false;
val = val2.transform;
}
return val;
}
private RadialButton CreateOuterButton(int index, int totalSlices, Transform parent, RadialContent content)
{
//IL_003d: Unknown result type (might be due to invalid IL or missing references)
//IL_0043: Expected O, but got Unknown
//IL_0064: Unknown result type (might be due to invalid IL or missing references)
//IL_0084: Unknown result type (might be due to invalid IL or missing references)
//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
//IL_0150: Unknown result type (might be due to invalid IL or missing references)
//IL_0147: Unknown result type (might be due to invalid IL or missing references)
//IL_0155: Unknown result type (might be due to invalid IL or missing references)
//IL_015a: Unknown result type (might be due to invalid IL or missing references)
//IL_01af: Unknown result type (might be due to invalid IL or missing references)
//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
//IL_0219: Unknown result type (might be due to invalid IL or missing references)
//IL_0244: Unknown result type (might be due to invalid IL or missing references)
//IL_0250: Unknown result type (might be due to invalid IL or missing references)
//IL_0252: Unknown result type (might be due to invalid IL or missing references)
//IL_025e: Unknown result type (might be due to invalid IL or missing references)
//IL_026a: Unknown result type (might be due to invalid IL or missing references)
GameObject val = new GameObject($"Slice_{index}", new Type[3]
{
typeof(RectTransform),
typeof(Image),
typeof(RadialButton)
});
val.transform.SetParent(parent, false);
RectTransform component = val.GetComponent<RectTransform>();
component.sizeDelta = new Vector2(RadialSize, RadialSize);
((Transform)component).localRotation = Quaternion.Euler(0f, 0f, -360f * (float)index / (float)totalSlices);
Image component2 = val.GetComponent<Image>();
component2.sprite = RadialSprite;
((Graphic)component2).color = MenuColor;
component2.type = (Type)3;
component2.fillMethod = (FillMethod)4;
component2.fillOrigin = 2;
component2.fillAmount = 1f / (float)totalSlices;
RadialButton component3 = val.GetComponent<RadialButton>();
component3.image = component2;
component3.label = content.Label ?? content.Message ?? "Error";
component3.message = content.Message;
component3.radialContent = content.Children;
if ((Object)(object)ReferenceLabel != (Object)null)
{
Transform transform = ((Component)this).transform;
RectTransform val2 = (RectTransform)(object)((transform is RectTransform) ? transform : null);
Vector2 val3 = Vector2.op_Implicit(((Object)(object)val2 != (Object)null) ? ((Transform)val2).position : ((Component)this).transform.position);
float num = RadialSize * 0.35f;
float num2 = -360f / (float)totalSlices;
float num3 = ((float)index + 0.5f) * num2 + (float)((totalSlices == 2) ? (-180) : 90);
float num4 = num3 * (MathF.PI / 180f);
Vector2 val4 = default(Vector2);
((Vector2)(ref val4))..ctor(Mathf.Cos(num4), Mathf.Sin(num4));
Vector2 val5 = val3 + val4 * num;
TextMeshProUGUI val6 = Object.Instantiate<TextMeshProUGUI>(ReferenceLabel, val.transform);
((TMP_Text)val6).text = (content.Label ?? content.Message ?? "Error").ToUpper();
((Behaviour)val6).enabled = true;
((TMP_Text)val6).alignment = (TextAlignmentOptions)514;
((MaskableGraphic)val6).maskable = false;
((TMP_Text)val6).margin = Vector4.zero;
((TMP_Text)val6).lineSpacing = -50f;
RectTransform component4 = ((Component)val6).GetComponent<RectTransform>();
component4.pivot = new Vector2(0.5f, 0.5f);
((Transform)component4).position = Vector2.op_Implicit(val5);
((Transform)component4).rotation = Quaternion.identity;
((Transform)component4).localScale = Vector3.one;
((Component)component4).gameObject.SetActive(true);
}
return component3;
}
[IteratorStateMachine(typeof(<CenterCursor>d__24))]
private IEnumerator CenterCursor()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <CenterCursor>d__24(0);
}
private void Update()
{
//IL_001d: Unknown result type (might be due to invalid IL or missing references)
//IL_0028: Unknown result type (might be due to invalid IL or missing references)
//IL_002d: Unknown result type (might be due to invalid IL or missing references)
//IL_0032: Unknown result type (might be due to invalid IL or missing references)
//IL_0037: Unknown result type (might be due to invalid IL or missing references)
//IL_007d: Unknown result type (might be due to invalid IL or missing references)
//IL_0084: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)radialCenterButton == (Object)null && (Object)(object)outerButtonRoot == (Object)null)
{
return;
}
Vector2 val = SemiFunc.UIMousePosToUIPos() - Vector2.op_Implicit(((Component)this).transform.position);
float magnitude = ((Vector2)(ref val)).magnitude;
if (magnitude > RadialSize * 0.5f)
{
sliceHovered = -1;
UpdateSliceColors();
return;
}
int num = -1;
if (magnitude < RadialSize * InnerCircleRange)
{
num = 0;
}
else if (outerButtons.Length != 0)
{
float num2 = Mathf.Atan2(0f - val.y, val.x) * 57.29578f + (float)((outerButtons.Length == 2) ? 180 : 90);
num2 = (num2 + 360f) % 360f;
float num3 = 360f / (float)outerButtons.Length;
num = Mathf.FloorToInt(num2 / num3) + 1;
}
if (sliceHovered != num)
{
sliceHovered = num;
if (UpdateSliceColors())
{
MenuManager.instance.MenuEffectClick((MenuClickEffectType)4, (MenuPage)null, -1f, -1f, true);
}
}
if (!Input.GetMouseButtonUp(0))
{
return;
}
MenuManager.instance.MenuEffectClick((MenuClickEffectType)1, (MenuPage)null, 1f, 1f, true);
RadialButton radialButton = GetRadialButton(sliceHovered);
if (sliceHovered == 0)
{
GoBack();
return;
}
if (radialButton.radialContent != null && radialButton.radialContent.Length != 0)
{
selectedMessageStack.Add(radialButton.message);
GenerateMenu(radialButton.radialContent);
return;
}
string text = radialButton.message;
for (int num4 = selectedMessageStack.Count - 1; num4 >= 0; num4--)
{
string text2 = selectedMessageStack[num4];
if (!string.IsNullOrEmpty(text2) && text2.Contains("{$}"))
{
text = text2.Replace("{$}", text);
}
else if (!string.IsNullOrEmpty(text2))
{
text = text2 + text;
}
}
if (OnMessageClicked != null)
{
OnMessageClicked.Invoke(text);
}
}
private void GoBack()
{
if (menuStack.Count > 0)
{
RadialContent[] newContent = menuStack.Pop();
if (selectedMessageStack.Count > 0)
{
selectedMessageStack.RemoveAt(selectedMessageStack.Count - 1);
}
GenerateMenu(newContent, pushToStack: false);
}
}
private bool UpdateSliceColors()
{
//IL_002c: Unknown result type (might be due to invalid IL or missing references)
//IL_005f: Unknown result type (might be due to invalid IL or missing references)
//IL_0091: Unknown result type (might be due to invalid IL or missing references)
for (int i = 0; i < outerButtons.Length; i++)
{
if ((Object)(object)outerButtons[i] == (Object)null)
{
Close();
return false;
}
Image component = ((Component)outerButtons[i]).GetComponent<Image>();
((Graphic)component).color = MenuColor;
}
if ((Object)(object)radialCenterButton != (Object)null)
{
((Graphic)radialCenterButton.image).color = MenuColor;
}
if (sliceHovered != -1)
{
RadialButton radialButton = GetRadialButton(sliceHovered);
if ((Object)(object)radialButton == (Object)null)
{
return false;
}
((Graphic)radialButton.image).color = HoverColor;
}
return true;
}
private RadialButton GetRadialButton(int index)
{
if (outerButtons.Length == 0 || index == 0)
{
return radialCenterButton;
}
return outerButtons[index - 1];
}
}
[BepInPlugin("Jor02.RadialQuickMessage", "RadialQuickMessage", "1.0")]
[BepInProcess("REPO.exe")]
public class RadialQuickMessage : BaseUnityPlugin
{
private RadialMenuManager radialMenu;
private RadialQuickMessageConfig config;
private CursorLockMode prevLockMode;
internal static RadialQuickMessage Instance { get; private set; }
internal static ManualLogSource Logger => Instance._logger;
private ManualLogSource _logger => ((BaseUnityPlugin)this).Logger;
internal Harmony? Harmony { get; set; }
private void Awake()
{
Instance = this;
((Component)this).gameObject.transform.parent = null;
((Object)((Component)this).gameObject).hideFlags = (HideFlags)61;
config = new RadialQuickMessageConfig(this);
config.OnContentChanged += OnConfigChanged;
Logger.LogInfo((object)$"{((BaseUnityPlugin)this).Info.Metadata.GUID} v{((BaseUnityPlugin)this).Info.Metadata.Version} has loaded!");
}
private void OnConfigChanged(RadialContent[] _)
{
//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)
//IL_002c: Unknown result type (might be due to invalid IL or missing references)
//IL_0031: Unknown result type (might be due to invalid IL or missing references)
radialMenu.MenuColor = config.MenuColor.Value;
radialMenu.HoverColor = config.HoverColor.Value;
}
private void Update()
{
//IL_003d: Unknown result type (might be due to invalid IL or missing references)
//IL_0097: Unknown result type (might be due to invalid IL or missing references)
//IL_004a: Unknown result type (might be due to invalid IL or missing references)
//IL_004f: Unknown result type (might be due to invalid IL or missing references)
//IL_00af: Unknown result type (might be due to invalid IL or missing references)
if (!ChatManager.instance.localPlayerAvatarFetched)
{
return;
}
if ((Object)(object)radialMenu != (Object)null)
{
if (!radialMenu.IsOpen() && UnityInput.Current.GetKey(config.OpenMenuKey.Value))
{
prevLockMode = Cursor.lockState;
radialMenu.Open(config.Content);
}
else if (radialMenu.IsOpen())
{
SemiFunc.CameraOverrideStopAim();
MenuCursor.instance.Show();
if (!UnityInput.Current.GetKey(config.OpenMenuKey.Value))
{
radialMenu.Close();
Cursor.lockState = prevLockMode;
}
}
}
else
{
CreateRadialMenuManager();
}
}
private void CreateRadialMenuManager()
{
//IL_0059: Unknown result type (might be due to invalid IL or missing references)
//IL_005f: Expected O, but got Unknown
//IL_009b: Unknown result type (might be due to invalid IL or missing references)
//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
//IL_0152: Unknown result type (might be due to invalid IL or missing references)
//IL_0157: Unknown result type (might be due to invalid IL or missing references)
//IL_016d: Unknown result type (might be due to invalid IL or missing references)
//IL_0172: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)radialMenu != (Object)null)
{
Object.Destroy((Object)(object)radialMenu);
}
GameObject val = GameObject.Find("UI/HUD/HUD Canvas/HUD/");
TextMeshProUGUI component = GameObject.Find("UI/HUD/HUD Canvas/HUD/Chat/Chat Text/").GetComponent<TextMeshProUGUI>();
GameObject val2 = new GameObject("RadialMenu", new Type[2]
{
typeof(RectTransform),
typeof(RadialMenuManager)
});
val2.transform.SetParent(val.transform, false);
val2.transform.SetSiblingIndex(val.transform.childCount - 2);
RectTransform component2 = val2.GetComponent<RectTransform>();
component2.anchorMin = new Vector2(0.5f, 0.5f);
component2.anchorMax = new Vector2(0.5f, 0.5f);
component2.pivot = new Vector2(0.5f, 0.5f);
component2.anchoredPosition = Vector2.zero;
radialMenu = val2.GetComponent<RadialMenuManager>();
radialMenu.OnMessageClicked.AddListener((UnityAction<string>)RelayMessage);
radialMenu.RadialSprite = Utils.CreateSpriteFromBytes(Resources.RadialCircle);
radialMenu.CenterSprite = Utils.CreateSpriteFromBytes(Resources.RadialCenter);
radialMenu.SeparatorSprite = Utils.CreateSpriteFromBytes(Resources.RadialSeparator);
radialMenu.MenuColor = config.MenuColor.Value;
radialMenu.HoverColor = config.HoverColor.Value;
radialMenu.ReferenceLabel = component;
}
private void RelayMessage(string? message)
{
ChatManager.instance.ForceSendMessage(message ?? "Error");
}
private void OnDestroy()
{
config?.Dispose();
}
}
internal class RadialQuickMessageConfig
{
private readonly RadialQuickMessage plugin;
private readonly ManualLogSource logger;
private FileSystemWatcher? contentWatcher;
private static readonly JsonSerializerSettings serializerSettings = new JsonSerializerSettings
{
NullValueHandling = (NullValueHandling)1
};
public string ContentFilePath { get; private set; }
public ConfigEntry<KeyCode> OpenMenuKey { get; private set; }
public ConfigEntry<Color> MenuColor { get; private set; }
public ConfigEntry<Color> HoverColor { get; private set; }
public RadialContent[] Content { get; private set; }
public event Action<RadialContent[]>? OnContentChanged;
public RadialQuickMessageConfig(RadialQuickMessage plugin)
{
this.plugin = plugin;
logger = RadialQuickMessage.Logger;
string path = ((BaseUnityPlugin)plugin).Info.Metadata.GUID + ".content.json";
ContentFilePath = Path.Combine(Paths.ConfigPath, path);
BindConfig();
LoadRadialContent();
StartWatchingContentFile();
}
private void BindConfig()
{
//IL_0051: Unknown result type (might be due to invalid IL or missing references)
//IL_008f: Unknown result type (might be due to invalid IL or missing references)
OpenMenuKey = ((BaseUnityPlugin)plugin).Config.Bind<KeyCode>("Radial Menu", "Open Menu Key", (KeyCode)102, "Key used to open the radial menu.");
MenuColor = ((BaseUnityPlugin)plugin).Config.Bind<Color>("Radial Menu", "Menu Color", new Color(0f, 0f, 0f, 0.6f), "Background color of the radial menu.");
HoverColor = ((BaseUnityPlugin)plugin).Config.Bind<Color>("Radial Menu", "Hover Color", new Color(0.25f, 0.55f, 1f, 1f), "Hover color of the radial menu.");
OpenMenuKey.SettingChanged += delegate
{
this.OnContentChanged?.Invoke(Content);
};
MenuColor.SettingChanged += delegate
{
this.OnContentChanged?.Invoke(Content);
};
HoverColor.SettingChanged += delegate
{
this.OnContentChanged?.Invoke(Content);
};
}
private void LoadRadialContent()
{
logger.LogInfo((object)("Loading radial content from " + ContentFilePath + "."));
if (!File.Exists(ContentFilePath))
{
logger.LogWarning((object)"Radial content file not found. Creating default.");
Content = GetDefaultRadialContent();
SaveRadialContent();
return;
}
try
{
string text = File.ReadAllText(ContentFilePath);
Content = JsonConvert.DeserializeObject<RadialContent[]>(text);
}
catch (Exception ex)
{
logger.LogError((object)("Failed to load radial content: " + ex.Message));
Content = GetSyntaxErrorRadialContent(ex.Message);
}
}
private void SaveRadialContent()
{
try
{
string contents = JsonConvert.SerializeObject((object)Content, (Formatting)1, serializerSettings);
File.WriteAllText(ContentFilePath, contents);
logger.LogInfo((object)"Radial content saved successfully.");
}
catch (Exception ex)
{
logger.LogError((object)("Failed to save radial content: " + ex.Message));
}
}
private void StartWatchingContentFile()
{
string directoryName = Path.GetDirectoryName(ContentFilePath);
string fileName = Path.GetFileName(ContentFilePath);
contentWatcher = new FileSystemWatcher(directoryName, fileName)
{
NotifyFilter = (NotifyFilters.FileName | NotifyFilters.Size | NotifyFilters.LastWrite)
};
contentWatcher.Changed += delegate
{
ReloadContentDelayed();
};
contentWatcher.Renamed += delegate
{
ReloadContentDelayed();
};
contentWatcher.EnableRaisingEvents = true;
}
private void ReloadContentDelayed()
{
Task.Delay(200).ContinueWith(delegate
{
try
{
LoadRadialContent();
this.OnContentChanged?.Invoke(Content);
logger.LogInfo((object)"Radial content reloaded from file.");
}
catch (Exception ex)
{
logger.LogError((object)("Error reloading radial content: " + ex.Message));
}
});
}
private RadialContent[] GetSyntaxErrorRadialContent(string error)
{
return new RadialContent[2]
{
new RadialContent
{
Message = "Syntax Error"
},
new RadialContent
{
Message = "Full Error..",
Children = new RadialContent[1]
{
new RadialContent
{
Message = error
}
}
}
};
}
private RadialContent[] GetDefaultRadialContent()
{
return new RadialContent[7]
{
new RadialContent
{
Label = "HI..",
Children = new RadialContent[4]
{
new RadialContent
{
Message = "Hi"
},
new RadialContent
{
Message = "Hello"
},
new RadialContent
{
Message = "Heya"
},
new RadialContent
{
Message = "Greetings"
}
}
},
new RadialContent
{
Label = "Reactions..",
Children = new RadialContent[5]
{
new RadialContent
{
Label = "Thanks",
Message = "Thanks!"
},
new RadialContent
{
Message = "LOL"
},
new RadialContent
{
Label = "Haha",
Message = "Haha!"
},
new RadialContent
{
Label = "Wow",
Message = "Wow!"
},
new RadialContent
{
Message = "LMAO"
}
}
},
new RadialContent
{
Label = "I spot..",
Message = "I spot {$}.",
Children = new RadialContent[5]
{
new RadialContent
{
Label = "Valuable..",
Message = "{$} valuable",
Children = new RadialContent[4]
{
new RadialContent
{
Message = "Heavy"
},
new RadialContent
{
Message = "Expensive"
},
new RadialContent
{
Message = "Small"
},
new RadialContent
{
Message = "Big"
}
}
},
new RadialContent
{
Label = "Common..",
Children = new RadialContent[6]
{
new RadialContent
{
Message = "Animal"
},
new RadialContent
{
Message = "Duck"
},
new RadialContent
{
Message = "Gnome"
},
new RadialContent
{
Message = "Eye"
},
new RadialContent
{
Message = "Skull"
},
new RadialContent
{
Message = "Head"
}
}
},
new RadialContent
{
Label = "Human-like..",
Children = new RadialContent[5]
{
new RadialContent
{
Message = "Baby"
},
new RadialContent
{
Message = "Big guy"
},
new RadialContent
{
Message = "Stick lady"
},
new RadialContent
{
Label = "Blind",
Message = "Blind guy"
},
new RadialContent
{
Message = "Upscream"
}
}
},
new RadialContent
{
Label = "Supernatural..",
Children = new RadialContent[6]
{
new RadialContent
{
Message = "Shadow Child"
},
new RadialContent
{
Message = "Hugger"
},
new RadialContent
{
Message = "Spewer"
},
new RadialContent
{
Label = "Invisible",
Message = "Invisible dude"
},
new RadialContent
{
Message = "Laser guy"
},
new RadialContent
{
Message = "Alien"
}
}
},
new RadialContent
{
Label = "Other..",
Children = new RadialContent[2]
{
new RadialContent
{
Message = "Frog"
},
new RadialContent
{
Label = "Blowey",
Message = "Blowey guy"
}
}
}
}
},
new RadialContent
{
Message = "MONSTER"
},
new RadialContent
{
Message = "RUN"
},
new RadialContent
{
Label = "HELP..",
Message = "HELP {$}",
Children = new RadialContent[4]
{
new RadialContent
{
Label = "."
},
new RadialContent
{
Label = "carry",
Message = "carry please"
},
new RadialContent
{
Message = "kill"
},
new RadialContent
{
Message = "reach"
}
}
},
new RadialContent
{
Label = "Bye..",
Children = new RadialContent[2]
{
new RadialContent
{
Label = "Goodbye",
Message = "Goodbye!"
},
new RadialContent
{
Label = "Bye",
Message = "Bye!"
}
}
}
};
}
public void Dispose()
{
contentWatcher?.Dispose();
}
}
[GeneratedCode("System.Resources.Tools.StronglyTypedResourceBuilder", "17.0.0.0")]
[DebuggerNonUserCode]
[CompilerGenerated]
internal class Resources
{
private static ResourceManager resourceMan;
private static CultureInfo resourceCulture;
[EditorBrowsable(EditorBrowsableState.Advanced)]
internal static ResourceManager ResourceManager
{
get
{
if (resourceMan == null)
{
ResourceManager resourceManager = new ResourceManager("RadialQuickMessage.Resources", typeof(Resources).Assembly);
resourceMan = resourceManager;
}
return resourceMan;
}
}
[EditorBrowsable(EditorBrowsableState.Advanced)]
internal static CultureInfo Culture
{
get
{
return resourceCulture;
}
set
{
resourceCulture = value;
}
}
internal static byte[] RadialCenter
{
get
{
object @object = ResourceManager.GetObject("RadialCenter", resourceCulture);
return (byte[])@object;
}
}
internal static byte[] RadialCircle
{
get
{
object @object = ResourceManager.GetObject("RadialCircle", resourceCulture);
return (byte[])@object;
}
}
internal static byte[] RadialSeparator
{
get
{
object @object = ResourceManager.GetObject("RadialSeparator", resourceCulture);
return (byte[])@object;
}
}
internal Resources()
{
}
}
internal class Utils
{
public static Sprite CreateSpriteFromBytes(byte[] imageData)
{
//IL_0004: Unknown result type (might be due to invalid IL or missing references)
//IL_000a: Expected O, but got Unknown
//IL_0043: Unknown result type (might be due to invalid IL or missing references)
//IL_0044: Unknown result type (might be due to invalid IL or missing references)
Texture2D val = new Texture2D(2, 2, (TextureFormat)4, false);
ImageConversion.LoadImage(val, imageData);
Rect val2 = default(Rect);
((Rect)(ref val2))..ctor(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height);
Vector2 val3 = default(Vector2);
((Vector2)(ref val3))..ctor(0.5f, 0.5f);
return Sprite.Create(val, val2, val3);
}
public static void SetLayerRecursively(GameObject obj, int newLayer)
{
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
//IL_0021: Expected O, but got Unknown
obj.layer = newLayer;
foreach (Transform item in obj.transform)
{
Transform val = item;
SetLayerRecursively(((Component)val).gameObject, newLayer);
}
}
}
}
