using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using Microsoft.CodeAnalysis;
using PerfectRandom.Sulfur.Core;
using PerfectRandom.Sulfur.Core.Input;
using PerfectRandom.Sulfur.Core.UI;
using PerfectRandom.Sulfur.Gameplay.Input;
using Ryuka.Sulfur.NativeUI;
using SULFURTogether.Api;
using TMPro;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.InputSystem;
using UnityEngine.InputSystem.Controls;
using UnityEngine.InputSystem.LowLevel;
using UnityEngine.UI;
using de.nemophila.sulfur.simplechat.Api;
using de.nemophila.sulfur.simplechat.Localization;
using de.nemophila.sulfur.simplechat.Networking;
using de.nemophila.sulfur.simplechat.UI;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyCompany("SULFUR SimpleChat")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("SULFUR SimpleChat")]
[assembly: AssemblyTitle("SULFUR SimpleChat")]
[assembly: AssemblyVersion("1.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[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]
[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]
[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 de.nemophila.sulfur.simplechat
{
internal static class ModInfo
{
public const string Guid = "de.nemophila.sulfur.simplechat";
public const string Name = "SULFUR SimpleChat";
public const string Version = "0.1.7";
public const string TogetherGuid = "com.ryuka.sulfur.together";
public const string TogetherMinimumVersion = "1.2.3";
public const string NativeUiGuid = "ryuka.sulfur.nativeui";
public const string NativeUiMinimumVersion = "0.10.1";
public const string ChannelId = "de.nemophila.sulfur.simplechat.v1";
}
[BepInPlugin("de.nemophila.sulfur.simplechat", "SULFUR SimpleChat", "0.1.7")]
[BepInDependency("com.ryuka.sulfur.together", "1.2.3")]
[BepInDependency("ryuka.sulfur.nativeui", "0.10.1")]
public sealed class Plugin : BaseUnityPlugin
{
private ChatHud? hud;
private ChatController? controller;
private ConfigEntry<Key>? openChatKey;
private void Awake()
{
//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
Loc.Initialize(((BaseUnityPlugin)this).Info.Location);
openChatKey = ((BaseUnityPlugin)this).Config.Bind<Key>("Input", "OpenChatKey", (Key)35, "Keyboard key used to open SimpleChat during normal gameplay.");
hud = new ChatHud((MonoBehaviour)(object)this, ((BaseUnityPlugin)this).Logger, () => openChatKey.Value);
SimpleChatApi.Bind(delegate(string message)
{
if (hud == null)
{
return false;
}
hud.AddSystemText(message);
return true;
});
controller = new ChatController(((BaseUnityPlugin)this).Logger, hud);
hud.CanAttemptOpen = controller.CanAttemptOpen;
hud.CanOpen = controller.CanOpen;
hud.OpenDenied = controller.NotifyOpenDenied;
hud.Submit = controller.SubmitLocal;
((BaseUnityPlugin)this).Logger.LogInfo((object)("SULFUR SimpleChat v0.1.7 loaded. OpenChatKey=" + ((object)openChatKey.Value/*cast due to .constrained prefix*/).ToString()));
}
private void Update()
{
float unscaledTime = Time.unscaledTime;
controller?.Tick(unscaledTime);
hud?.Tick(unscaledTime);
}
private void LateUpdate()
{
hud?.LateTick(Time.unscaledTime);
}
private void OnDestroy()
{
SimpleChatApi.Unbind();
controller?.Dispose();
controller = null;
hud?.Dispose();
hud = null;
}
}
}
namespace de.nemophila.sulfur.simplechat.UI
{
internal sealed class ChatHud
{
private sealed class DisplayEntry
{
private bool isChat;
private bool isRawSystem;
private string key = "";
private string fallback = "";
private object[] args = Array.Empty<object>();
private string name = "";
private string text = "";
public float AddedAt { get; set; }
public static DisplayEntry Chat(string name, string text)
{
return new DisplayEntry
{
isChat = true,
name = (name ?? ""),
text = (text ?? "")
};
}
public static DisplayEntry System(string key, string fallback, object[] args)
{
return new DisplayEntry
{
key = (key ?? ""),
fallback = (fallback ?? ""),
args = (args ?? Array.Empty<object>())
};
}
public static DisplayEntry SystemText(string text)
{
return new DisplayEntry
{
isRawSystem = true,
text = (text ?? "")
};
}
public string Render()
{
if (isChat)
{
return Loc.Format("chat.line", "{0}: {1}", name, text);
}
if (isRawSystem)
{
return text;
}
return Loc.Format(key, fallback, args);
}
}
private const int HistoryLimit = 50;
private const int PassiveLineCount = 6;
private const int FocusedLineCount = 12;
private const float PassiveHoldSeconds = 8f;
private const float PassiveFadeSeconds = 2f;
private const int FocusActivationAttempts = 3;
private readonly MonoBehaviour runner;
private readonly ManualLogSource log;
private readonly Func<Key> openKeyProvider;
private readonly GameInputCapture inputCapture;
private readonly ModernTextInputBridge textInput;
private readonly List<DisplayEntry> entries = new List<DisplayEntry>();
private GameObject canvasObject;
private RectTransform overlayRoot;
private CanvasGroup historyGroup;
private Image historyBackground;
private TextMeshProUGUI historyText;
private GameObject inputRoot;
private TMP_InputField inputField;
private TextMeshProUGUI inputText;
private TextMeshProUGUI placeholderText;
private Coroutine? activationCoroutine;
private bool focused;
private float newestEntryTime = float.NegativeInfinity;
private float nextFontRefresh;
private int lastLanguageVersion = -1;
private Key? warnedInvalidOpenKey;
private Vector2 lastHistorySize = new Vector2(-1f, -1f);
private bool clearOnActivation;
public Func<bool>? CanAttemptOpen { private get; set; }
public Func<bool>? CanOpen { private get; set; }
public Action? OpenDenied { private get; set; }
public Func<string, bool>? Submit { private get; set; }
public ChatHud(MonoBehaviour runner, ManualLogSource log, Func<Key> openKeyProvider)
{
//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)
this.runner = runner;
this.log = log;
this.openKeyProvider = openKeyProvider;
inputCapture = new GameInputCapture(log);
textInput = new ModernTextInputBridge(log);
Build();
}
public void Tick(float now)
{
//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
//IL_01d3: Unknown result type (might be due to invalid IL or missing references)
//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
//IL_01de: Unknown result type (might be due to invalid IL or missing references)
//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)canvasObject == (Object)null)
{
return;
}
if (focused && activationCoroutine == null)
{
if (!inputCapture.IsOwnershipValid)
{
log.LogDebug((object)"Closing chat because game input ownership changed.");
EndFocus();
}
else if ((Object)(object)EventSystem.current == (Object)null || !inputField.isFocused || (Object)(object)EventSystem.current.currentSelectedGameObject != (Object)(object)((Component)inputField).gameObject)
{
log.LogDebug((object)"Chat input focus was lost; scheduling recovery.");
ScheduleActivation(clearText: false);
}
}
Keyboard current = Keyboard.current;
if (current != null)
{
if (!focused && IsOpenKeyPressed(current))
{
Func<bool>? canAttemptOpen = CanAttemptOpen;
if (canAttemptOpen == null || canAttemptOpen())
{
TryBeginFocus();
}
}
else if (focused && ((ButtonControl)current.escapeKey).wasPressedThisFrame)
{
if (!textInput.ShouldConsumeCommandThisFrame)
{
EndFocus();
}
}
else if (focused && (((ButtonControl)current.enterKey).wasPressedThisFrame || ((ButtonControl)current.numpadEnterKey).wasPressedThisFrame) && !textInput.ShouldConsumeCommandThisFrame)
{
string text = inputField.text;
Func<string, bool>? submit = Submit;
if (submit != null && submit(text))
{
EndFocus();
}
else
{
ScheduleActivation(clearText: false);
}
}
}
if (Loc.LanguageVersion != lastLanguageVersion)
{
lastLanguageVersion = Loc.LanguageVersion;
((TMP_Text)placeholderText).text = Loc.Get("input.placeholder", "Type a message...");
RebuildHistory();
RefreshFont();
nextFontRefresh = now + 1f;
}
if (now >= nextFontRefresh)
{
nextFontRefresh = now + 1f;
RefreshFont();
}
Rect rect = ((TMP_Text)historyText).rectTransform.rect;
Vector2 val = ((Rect)(ref rect)).size - lastHistorySize;
if (((Vector2)(ref val)).sqrMagnitude > 0.25f)
{
RebuildHistory();
}
UpdateVisibility(now);
}
public void LateTick(float now)
{
textInput.LateTick(now);
}
public void AddChat(string displayName, string text)
{
AddEntry(DisplayEntry.Chat(displayName, text));
}
public void AddSystem(string key, string fallback, params object[] args)
{
AddEntry(DisplayEntry.System(key, fallback, args));
}
public void AddSystemText(string text)
{
AddEntry(DisplayEntry.SystemText(text));
}
public void Clear()
{
entries.Clear();
newestEntryTime = float.NegativeInfinity;
if (focused)
{
EndFocus();
}
RebuildHistory();
}
public void Dispose()
{
if (activationCoroutine != null)
{
runner.StopCoroutine(activationCoroutine);
activationCoroutine = null;
}
inputCapture.Release();
textInput.Dispose();
focused = false;
if ((Object)(object)canvasObject != (Object)null)
{
Object.Destroy((Object)(object)canvasObject);
}
}
private void AddEntry(DisplayEntry entry)
{
entry.AddedAt = Time.unscaledTime;
entries.Add(entry);
if (entries.Count > 50)
{
entries.RemoveAt(0);
}
newestEntryTime = entry.AddedAt;
RebuildHistory();
}
private void TryBeginFocus()
{
if (!focused && inputCapture.TryCapture(out var _))
{
Func<bool>? canOpen = CanOpen;
if (canOpen == null || !canOpen())
{
inputCapture.Release();
OpenDenied?.Invoke();
return;
}
if ((Object)(object)EventSystem.current == (Object)null)
{
inputCapture.Release();
AddSystem("system.input_unavailable", "The game UI input system is not ready.");
return;
}
string text = (((Object)(object)EventSystem.current.currentInputModule != (Object)null) ? ((object)EventSystem.current.currentInputModule).GetType().FullName : "<none>");
log.LogDebug((object)("Opening chat input. EventSystem=" + ((object)EventSystem.current).GetType().FullName + " InputModule=" + text + "."));
focused = true;
inputRoot.SetActive(true);
((Selectable)inputField).interactable = true;
inputField.SetTextWithoutNotify("");
inputField.ForceLabelUpdate();
RebuildHistory();
ScheduleActivation(clearText: true);
}
}
private void ScheduleActivation(bool clearText)
{
clearOnActivation = clearText;
if (activationCoroutine == null)
{
activationCoroutine = runner.StartCoroutine(ActivateOnNextFrame());
}
}
private IEnumerator ActivateOnNextFrame()
{
yield return null;
if (!focused || (Object)(object)inputField == (Object)null)
{
activationCoroutine = null;
yield break;
}
if (clearOnActivation)
{
inputField.SetTextWithoutNotify("");
}
inputField.ForceLabelUpdate();
for (int attempt = 1; attempt <= 3; attempt++)
{
EventSystem current = EventSystem.current;
if ((Object)(object)current == (Object)null)
{
break;
}
current.SetSelectedGameObject(((Component)inputField).gameObject);
((Selectable)inputField).Select();
inputField.ActivateInputField();
inputField.ForceLabelUpdate();
yield return null;
if (!focused)
{
activationCoroutine = null;
yield break;
}
if (inputField.isFocused && (Object)(object)EventSystem.current != (Object)null && (Object)(object)EventSystem.current.currentSelectedGameObject == (Object)(object)((Component)inputField).gameObject)
{
activationCoroutine = null;
textInput.Begin(inputField);
log.LogDebug((object)("Chat input focus activated on attempt " + attempt + "."));
yield break;
}
}
activationCoroutine = null;
log.LogWarning((object)("Chat input focus could not be activated after " + 3 + " attempts."));
FailFocusActivation();
}
private void EndFocus()
{
if (focused)
{
if (activationCoroutine != null)
{
runner.StopCoroutine(activationCoroutine);
activationCoroutine = null;
}
focused = false;
textInput.End();
inputField.DeactivateInputField(false);
if ((Object)(object)EventSystem.current != (Object)null && (Object)(object)EventSystem.current.currentSelectedGameObject == (Object)(object)((Component)inputField).gameObject)
{
EventSystem.current.SetSelectedGameObject((GameObject)null);
}
inputField.SetTextWithoutNotify("");
inputRoot.SetActive(false);
inputCapture.Release();
RebuildHistory();
}
}
private void UpdateVisibility(float now)
{
if (focused)
{
historyGroup.alpha = 1f;
((Behaviour)historyBackground).enabled = true;
return;
}
float num = now - newestEntryTime;
float num2 = ((num <= 8f) ? 1f : (1f - (num - 8f) / 2f));
historyGroup.alpha = Mathf.Clamp01(num2);
((Behaviour)historyBackground).enabled = false;
}
private void RebuildHistory()
{
//IL_001a: 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_0023: 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_002a: Unknown result type (might be due to invalid IL or missing references)
//IL_002b: Unknown result type (might be due to invalid IL or missing references)
//IL_0089: Unknown result type (might be due to invalid IL or missing references)
//IL_0096: 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_00b6: Unknown result type (might be due to invalid IL or missing references)
//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)historyText == (Object)null)
{
return;
}
Rect rect = ((TMP_Text)historyText).rectTransform.rect;
Vector2 val = (lastHistorySize = ((Rect)(ref rect)).size);
int num = (focused ? 12 : 6);
string text = "";
int num2 = 0;
int num3 = entries.Count - 1;
while (num3 >= 0 && num2 < num)
{
string text2 = entries[num3].Render();
string text3 = ((text.Length == 0) ? text2 : (text2 + "\n" + text));
if (val.x > 1f && val.y > 1f && ((TMP_Text)historyText).GetPreferredValues(text3, val.x, float.PositiveInfinity).y > val.y - 1f && num2 > 0)
{
break;
}
text = text3;
num2++;
num3--;
}
((TMP_Text)historyText).text = text;
}
private void RefreshFont()
{
TextMeshProUGUI[] array = Object.FindObjectsByType<TextMeshProUGUI>((FindObjectsSortMode)0);
Dictionary<TMP_FontAsset, int> dictionary = new Dictionary<TMP_FontAsset, int>();
foreach (TextMeshProUGUI val in array)
{
if (!((Object)(object)val == (Object)null) && !((Object)(object)((TMP_Text)val).font == (Object)null) && !((TMP_Text)val).transform.IsChildOf((Transform)(object)overlayRoot))
{
dictionary.TryGetValue(((TMP_Text)val).font, out var value);
dictionary[((TMP_Text)val).font] = value + 1;
}
}
string probe = BuildFontProbe();
Dictionary<TMP_FontAsset, int> dictionary2 = new Dictionary<TMP_FontAsset, int>();
TextMeshProUGUI val2 = null;
int num = int.MaxValue;
int num2 = -1;
int num3 = int.MaxValue;
foreach (TextMeshProUGUI val3 in array)
{
if (!((Object)(object)val3 == (Object)null) && !((Object)(object)((TMP_Text)val3).font == (Object)null) && !((TMP_Text)val3).transform.IsChildOf((Transform)(object)overlayRoot))
{
TMP_FontAsset font = ((TMP_Text)val3).font;
if (!dictionary2.TryGetValue(font, out var value2))
{
value2 = (dictionary2[font] = CountMissingGlyphs(font, probe));
}
int num5 = dictionary[font];
int instanceID = ((Object)font).GetInstanceID();
if (value2 <= num && (value2 != num || num5 >= num2) && (value2 != num || num5 != num2 || instanceID < num3))
{
val2 = val3;
num = value2;
num2 = num5;
num3 = instanceID;
}
}
}
TMP_FontAsset val4 = (((Object)(object)val2 != (Object)null) ? ((TMP_Text)val2).font : TMP_Settings.defaultFontAsset);
if (!((Object)(object)val4 == (Object)null))
{
Material material = (((Object)(object)val2 != (Object)null) ? ((TMP_Text)val2).fontSharedMaterial : null);
if (ApplyFont(historyText, val4, material) | ApplyFont(inputText, val4, material) | ApplyFont(placeholderText, val4, material))
{
RebuildHistory();
}
}
}
private string BuildFontProbe()
{
StringBuilder stringBuilder = new StringBuilder();
HashSet<int> seen = new HashSet<int>();
AppendFontProbe(stringBuilder, seen, ((Object)(object)placeholderText != (Object)null) ? ((TMP_Text)placeholderText).text : "");
AppendFontProbe(stringBuilder, seen, ((Object)(object)historyText != (Object)null) ? ((TMP_Text)historyText).text : "");
AppendFontProbe(stringBuilder, seen, ((Object)(object)inputField != (Object)null) ? inputField.text : "");
return stringBuilder.ToString();
}
private static void AppendFontProbe(StringBuilder probe, HashSet<int> seen, string value)
{
if (string.IsNullOrEmpty(value))
{
return;
}
for (int i = 0; i < value.Length; i++)
{
char c = value[i];
int num;
if (char.IsHighSurrogate(c) && i + 1 < value.Length && char.IsLowSurrogate(value[i + 1]))
{
num = char.ConvertToUtf32(c, value[++i]);
}
else
{
if (char.IsSurrogate(c) || char.IsWhiteSpace(c) || char.IsControl(c))
{
continue;
}
num = c;
}
if (seen.Add(num))
{
probe.Append(char.ConvertFromUtf32(num));
}
}
}
private static int CountMissingGlyphs(TMP_FontAsset font, string probe)
{
if (probe.Length == 0)
{
return 0;
}
try
{
uint[] array = default(uint[]);
font.HasCharacters(probe, ref array, true, false);
return (array != null) ? array.Length : 0;
}
catch (Exception)
{
return int.MaxValue;
}
}
private void Build()
{
//IL_0040: Unknown result type (might be due to invalid IL or missing references)
//IL_004a: Expected O, but got Unknown
//IL_008e: Unknown result type (might be due to invalid IL or missing references)
//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
//IL_00c0: Expected O, but got Unknown
//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
//IL_0109: Unknown result type (might be due to invalid IL or missing references)
//IL_0123: Unknown result type (might be due to invalid IL or missing references)
//IL_013d: Unknown result type (might be due to invalid IL or missing references)
canvasObject = new GameObject("SULFUR SimpleChat Canvas", new Type[4]
{
typeof(RectTransform),
typeof(Canvas),
typeof(CanvasScaler),
typeof(GraphicRaycaster)
});
Object.DontDestroyOnLoad((Object)(object)canvasObject);
Canvas component = canvasObject.GetComponent<Canvas>();
component.renderMode = (RenderMode)0;
component.sortingOrder = 5000;
CanvasScaler component2 = canvasObject.GetComponent<CanvasScaler>();
component2.uiScaleMode = (ScaleMode)1;
component2.referenceResolution = new Vector2(1920f, 1080f);
component2.matchWidthOrHeight = 0.5f;
GameObject val = new GameObject("Chat Overlay", new Type[1] { typeof(RectTransform) });
val.transform.SetParent(canvasObject.transform, false);
overlayRoot = val.GetComponent<RectTransform>();
overlayRoot.anchorMin = Vector2.zero;
overlayRoot.anchorMax = Vector2.zero;
overlayRoot.pivot = Vector2.zero;
overlayRoot.anchoredPosition = new Vector2(32f, 96f);
overlayRoot.sizeDelta = new Vector2(800f, 390f);
BuildHistory();
BuildInput();
((TMP_Text)placeholderText).text = Loc.Get("input.placeholder", "Type a message...");
RefreshFont();
lastLanguageVersion = Loc.LanguageVersion;
UpdateVisibility(Time.unscaledTime);
}
private void BuildHistory()
{
//IL_003f: Unknown result type (might be due to invalid IL or missing references)
//IL_0045: Expected O, but got Unknown
//IL_0068: 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_0092: Unknown result type (might be due to invalid IL or missing references)
//IL_009c: Unknown result type (might be due to invalid IL or missing references)
//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
//IL_0145: Unknown result type (might be due to invalid IL or missing references)
//IL_014b: Expected O, but got Unknown
//IL_0164: Unknown result type (might be due to invalid IL or missing references)
//IL_016f: Unknown result type (might be due to invalid IL or missing references)
//IL_0184: Unknown result type (might be due to invalid IL or missing references)
//IL_0198: Unknown result type (might be due to invalid IL or missing references)
//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
//IL_021e: Unknown result type (might be due to invalid IL or missing references)
//IL_0223: Unknown result type (might be due to invalid IL or missing references)
//IL_0238: Unknown result type (might be due to invalid IL or missing references)
GameObject val = new GameObject("History", new Type[4]
{
typeof(RectTransform),
typeof(CanvasRenderer),
typeof(Image),
typeof(CanvasGroup)
});
val.transform.SetParent((Transform)(object)overlayRoot, false);
RectTransform component = val.GetComponent<RectTransform>();
component.anchorMin = new Vector2(0f, 0f);
component.anchorMax = new Vector2(1f, 1f);
component.offsetMin = new Vector2(0f, 50f);
component.offsetMax = Vector2.zero;
historyBackground = val.GetComponent<Image>();
((Graphic)historyBackground).color = new Color(0.03f, 0.025f, 0.02f, 0.72f);
((Graphic)historyBackground).raycastTarget = false;
historyGroup = val.GetComponent<CanvasGroup>();
historyGroup.blocksRaycasts = false;
historyGroup.interactable = false;
GameObject val2 = new GameObject("Messages", new Type[4]
{
typeof(RectTransform),
typeof(CanvasRenderer),
typeof(TextMeshProUGUI),
typeof(Shadow)
});
val2.transform.SetParent(val.transform, false);
RectTransform component2 = val2.GetComponent<RectTransform>();
component2.anchorMin = Vector2.zero;
component2.anchorMax = Vector2.one;
component2.offsetMin = new Vector2(14f, 10f);
component2.offsetMax = new Vector2(-14f, -10f);
historyText = val2.GetComponent<TextMeshProUGUI>();
((TMP_Text)historyText).fontSize = 21f;
((Graphic)historyText).color = Color.white;
((TMP_Text)historyText).alignment = (TextAlignmentOptions)1025;
((TMP_Text)historyText).richText = false;
((Graphic)historyText).raycastTarget = false;
((TMP_Text)historyText).textWrappingMode = (TextWrappingModes)1;
((TMP_Text)historyText).overflowMode = (TextOverflowModes)3;
Shadow component3 = val2.GetComponent<Shadow>();
component3.effectColor = Color32.op_Implicit(new Color32((byte)10, (byte)8, (byte)6, (byte)220));
component3.effectDistance = new Vector2(1.5f, -1.5f);
component3.useGraphicAlpha = true;
}
private void BuildInput()
{
//IL_0040: Unknown result type (might be due to invalid IL or missing references)
//IL_004a: Expected O, but got Unknown
//IL_0077: Unknown result type (might be due to invalid IL or missing references)
//IL_008c: Unknown result type (might be due to invalid IL or missing references)
//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
//IL_00b5: 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_010f: Unknown result type (might be due to invalid IL or missing references)
//IL_0114: Unknown result type (might be due to invalid IL or missing references)
//IL_0132: Unknown result type (might be due to invalid IL or missing references)
//IL_013d: 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_0167: Unknown result type (might be due to invalid IL or missing references)
//IL_0178: Unknown result type (might be due to invalid IL or missing references)
//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
//IL_02a0: Unknown result type (might be due to invalid IL or missing references)
//IL_02c4: Unknown result type (might be due to invalid IL or missing references)
//IL_02d6: Unknown result type (might be due to invalid IL or missing references)
//IL_02e4: Unknown result type (might be due to invalid IL or missing references)
inputRoot = new GameObject("Input", new Type[4]
{
typeof(RectTransform),
typeof(CanvasRenderer),
typeof(Image),
typeof(TMP_InputField)
});
inputRoot.transform.SetParent((Transform)(object)overlayRoot, false);
RectTransform component = inputRoot.GetComponent<RectTransform>();
component.anchorMin = new Vector2(0f, 0f);
component.anchorMax = new Vector2(1f, 0f);
component.pivot = new Vector2(0.5f, 0f);
component.sizeDelta = new Vector2(0f, 42f);
Image component2 = inputRoot.GetComponent<Image>();
((Graphic)component2).color = new Color(0.07f, 0.055f, 0.035f, 0.96f);
GameObject val = new GameObject("Text Area", new Type[2]
{
typeof(RectTransform),
typeof(RectMask2D)
});
val.transform.SetParent(inputRoot.transform, false);
RectTransform component3 = val.GetComponent<RectTransform>();
component3.anchorMin = Vector2.zero;
component3.anchorMax = Vector2.one;
component3.offsetMin = new Vector2(13f, 5f);
component3.offsetMax = new Vector2(-13f, -5f);
inputText = CreateInputText("Text", component3, Color.white, (FontStyles)0);
placeholderText = CreateInputText("Placeholder", component3, new Color(1f, 1f, 1f, 0.45f), (FontStyles)2);
inputField = inputRoot.GetComponent<TMP_InputField>();
((Selectable)inputField).targetGraphic = (Graphic)(object)component2;
inputField.textViewport = component3;
inputField.textComponent = (TMP_Text)(object)inputText;
inputField.placeholder = (Graphic)(object)placeholderText;
inputField.contentType = (ContentType)0;
inputField.lineType = (LineType)0;
inputField.characterLimit = 256;
inputField.richText = false;
inputField.shouldHideMobileInput = true;
inputField.shouldHideSoftKeyboard = true;
inputField.shouldActivateOnSelect = true;
inputField.onFocusSelectAll = false;
inputField.resetOnDeActivation = false;
inputField.restoreOriginalTextOnEscape = false;
inputField.customCaretColor = true;
inputField.caretColor = new Color(1f, 0.72f, 0.28f, 1f);
inputField.selectionColor = new Color(1f, 0.55f, 0.1f, 0.35f);
TMP_InputField obj = inputField;
Navigation navigation = default(Navigation);
((Navigation)(ref navigation)).mode = (Mode)0;
((Selectable)obj).navigation = navigation;
((TMP_Text)inputText).text = "";
inputField.SetTextWithoutNotify("");
inputField.ForceLabelUpdate();
inputRoot.SetActive(false);
}
private unsafe bool IsOpenKeyPressed(Keyboard keyboard)
{
//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_000c: 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)
//IL_0036: Unknown result type (might be due to invalid IL or missing references)
//IL_003a: Unknown result type (might be due to invalid IL or missing references)
//IL_003f: Unknown result type (might be due to invalid IL or missing references)
//IL_004e: Unknown result type (might be due to invalid IL or missing references)
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
Key val = openKeyProvider();
if ((int)val == 0)
{
return false;
}
try
{
bool wasPressedThisFrame = ((ButtonControl)keyboard[val]).wasPressedThisFrame;
warnedInvalidOpenKey = null;
return wasPressedThisFrame;
}
catch (Exception ex)
{
if (warnedInvalidOpenKey != (Key?)val)
{
warnedInvalidOpenKey = val;
log.LogWarning((object)("Configured OpenChatKey '" + ((object)(*(Key*)(&val))/*cast due to .constrained prefix*/).ToString() + "' is unavailable: " + ex.Message));
}
return false;
}
}
private void FailFocusActivation()
{
if (focused)
{
focused = false;
textInput.End();
inputField.DeactivateInputField(false);
if ((Object)(object)EventSystem.current != (Object)null && (Object)(object)EventSystem.current.currentSelectedGameObject == (Object)(object)((Component)inputField).gameObject)
{
EventSystem.current.SetSelectedGameObject((GameObject)null);
}
inputField.SetTextWithoutNotify("");
inputRoot.SetActive(false);
inputCapture.Release();
RebuildHistory();
AddSystem("system.focus_failed", "The chat input field could not receive keyboard focus.");
}
}
private static bool ApplyFont(TextMeshProUGUI text, TMP_FontAsset font, Material? material)
{
bool result = false;
if ((Object)(object)((TMP_Text)text).font != (Object)(object)font)
{
((TMP_Text)text).font = font;
result = true;
}
if ((Object)(object)material != (Object)null && (Object)(object)((TMP_Text)text).fontSharedMaterial != (Object)(object)material)
{
((TMP_Text)text).fontSharedMaterial = material;
result = true;
}
return result;
}
private static TextMeshProUGUI CreateInputText(string name, RectTransform parent, Color color, FontStyles style)
{
//IL_002e: Unknown result type (might be due to invalid IL or missing references)
//IL_0033: Unknown result type (might be due to invalid IL or missing references)
//IL_0040: Unknown result type (might be due to invalid IL or missing references)
//IL_0047: Unknown result type (might be due to invalid IL or missing references)
//IL_0052: Unknown result type (might be due to invalid IL or missing references)
//IL_005d: Unknown result type (might be due to invalid IL or missing references)
//IL_0067: Unknown result type (might be due to invalid IL or missing references)
//IL_0082: Unknown result type (might be due to invalid IL or missing references)
//IL_0089: Unknown result type (might be due to invalid IL or missing references)
GameObject val = new GameObject(name, new Type[3]
{
typeof(RectTransform),
typeof(CanvasRenderer),
typeof(TextMeshProUGUI)
});
val.transform.SetParent((Transform)(object)parent, false);
RectTransform component = val.GetComponent<RectTransform>();
component.anchorMin = Vector2.zero;
component.anchorMax = Vector2.one;
component.offsetMin = Vector2.zero;
component.offsetMax = Vector2.zero;
TextMeshProUGUI component2 = val.GetComponent<TextMeshProUGUI>();
((TMP_Text)component2).fontSize = 21f;
((Graphic)component2).color = color;
((TMP_Text)component2).fontStyle = style;
((TMP_Text)component2).alignment = (TextAlignmentOptions)4097;
((TMP_Text)component2).richText = false;
((Graphic)component2).raycastTarget = false;
((TMP_Text)component2).textWrappingMode = (TextWrappingModes)0;
((TMP_Text)component2).overflowMode = (TextOverflowModes)0;
return component2;
}
}
internal enum InputCaptureFailure
{
None,
NoActiveInputReader,
GameplayUnavailable
}
internal sealed class GameInputCapture
{
private struct MapState
{
private bool ui;
private bool inventory;
private bool cinematic;
private bool loading;
private bool devTools;
public static MapState Capture(PlayerInputActions source)
{
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
//IL_0020: 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_0035: Unknown result type (might be due to invalid IL or missing references)
//IL_003a: 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_0060: Unknown result type (might be due to invalid IL or missing references)
//IL_0065: Unknown result type (might be due to invalid IL or missing references)
MapState result = default(MapState);
UIActions uI = source.UI;
result.ui = ((UIActions)(ref uI)).enabled;
InventoryActions val = source.Inventory;
result.inventory = ((InventoryActions)(ref val)).enabled;
CinematicActions val2 = source.Cinematic;
result.cinematic = ((CinematicActions)(ref val2)).enabled;
LoadingActions val3 = source.Loading;
result.loading = ((LoadingActions)(ref val3)).enabled;
DevToolsActions val4 = source.DevTools;
result.devTools = ((DevToolsActions)(ref val4)).enabled;
return result;
}
public override bool Equals(object obj)
{
if (!(obj is MapState mapState))
{
return false;
}
if (ui == mapState.ui && inventory == mapState.inventory && cinematic == mapState.cinematic && loading == mapState.loading)
{
return devTools == mapState.devTools;
}
return false;
}
public override int GetHashCode()
{
return (int)(((((((uint)((ui ? 1 : 0) * 397) ^ (inventory ? 1u : 0u)) * 397) ^ (cinematic ? 1u : 0u)) * 397) ^ (loading ? 1u : 0u)) * 397) ^ (devTools ? 1 : 0);
}
}
private readonly ManualLogSource log;
private InputReader? reader;
private PlayerInputActions? actions;
private bool onFootWasEnabled;
private bool fKeysWereEnabled;
private MapState otherMaps;
private float nextUnavailableLogTime;
private float nextRecoveryLogTime;
public bool IsCaptured => actions != null;
public bool IsOwnershipValid
{
get
{
if (actions != null && (Object)(object)reader != (Object)null && reader.inputActions == actions)
{
return otherMaps.Equals(MapState.Capture(actions));
}
return false;
}
}
public GameInputCapture(ManualLogSource log)
{
this.log = log;
}
public bool TryCapture(out InputCaptureFailure failure)
{
//IL_0092: 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_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_00c6: Unknown result type (might be due to invalid IL or missing references)
//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
if (IsCaptured)
{
failure = InputCaptureFailure.None;
return true;
}
GameManager instance = StaticInstance<GameManager>.Instance;
InputReader val = (((Object)(object)instance != (Object)null) ? instance.InputReader : null);
PlayerInputActions val2 = (((Object)(object)val != (Object)null) ? val.inputActions : null);
if ((Object)(object)instance == (Object)null || (Object)(object)val == (Object)null || !((Component)val).gameObject.activeInHierarchy || val2 == null)
{
failure = InputCaptureFailure.NoActiveInputReader;
LogUnavailable("Chat input capture ignored: no active player InputReader.");
return false;
}
if (!TryPrepareSafeGameplay(instance, val2))
{
failure = InputCaptureFailure.GameplayUnavailable;
LogUnavailableState(instance, val2);
return false;
}
reader = val;
actions = val2;
OnFootActions onFoot = val2.OnFoot;
onFootWasEnabled = ((OnFootActions)(ref onFoot)).enabled;
FKeysActions fKeys = val2.FKeys;
fKeysWereEnabled = ((FKeysActions)(ref fKeys)).enabled;
otherMaps = MapState.Capture(val2);
onFoot = val2.OnFoot;
((OnFootActions)(ref onFoot)).Disable();
fKeys = val2.FKeys;
((FKeysActions)(ref fKeys)).Disable();
failure = InputCaptureFailure.None;
log.LogDebug((object)"Chat input captured: OnFoot and FKeys disabled.");
return true;
}
public void Release()
{
//IL_0062: Unknown result type (might be due to invalid IL or missing references)
//IL_0067: Unknown result type (might be due to invalid IL or missing references)
//IL_007b: Unknown result type (might be due to invalid IL or missing references)
//IL_0080: Unknown result type (might be due to invalid IL or missing references)
PlayerInputActions val = actions;
InputReader val2 = reader;
actions = null;
reader = null;
if (val != null && !((Object)(object)val2 == (Object)null))
{
if (val2.inputActions != val || !otherMaps.Equals(MapState.Capture(val)))
{
log.LogDebug((object)"Chat input release delegated to the game because input ownership changed.");
return;
}
OnFootActions onFoot = val.OnFoot;
SetMapEnabled(((OnFootActions)(ref onFoot)).Get(), onFootWasEnabled);
FKeysActions fKeys = val.FKeys;
SetMapEnabled(((FKeysActions)(ref fKeys)).Get(), fKeysWereEnabled);
log.LogDebug((object)("Chat input released: OnFoot=" + onFootWasEnabled + " FKeys=" + fKeysWereEnabled + "."));
}
}
private static void SetMapEnabled(InputActionMap map, bool enabled)
{
if (enabled)
{
map.Enable();
}
else
{
map.Disable();
}
}
private bool TryPrepareSafeGameplay(GameManager manager, PlayerInputActions source)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0007: Invalid comparison between Unknown and I4
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
//IL_0017: Unknown result type (might be due to invalid IL or missing references)
//IL_0022: Unknown result type (might be due to invalid IL or missing references)
//IL_0027: Unknown result type (might be due to invalid IL or missing references)
//IL_0033: Unknown result type (might be due to invalid IL or missing references)
//IL_0038: 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)
//IL_0049: Unknown result type (might be due to invalid IL or missing references)
//IL_0066: Unknown result type (might be due to invalid IL or missing references)
//IL_006b: Unknown result type (might be due to invalid IL or missing references)
//IL_0076: Unknown result type (might be due to invalid IL or missing references)
//IL_007b: Unknown result type (might be due to invalid IL or missing references)
//IL_0089: Unknown result type (might be due to invalid IL or missing references)
//IL_008e: Unknown result type (might be due to invalid IL or missing references)
//IL_009f: Unknown result type (might be due to invalid IL or missing references)
//IL_00a4: 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)
//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
//IL_014a: Unknown result type (might be due to invalid IL or missing references)
//IL_014f: Unknown result type (might be due to invalid IL or missing references)
//IL_015b: 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)
if ((int)manager.gameState == 3 && (int)manager.currentLocks == 0)
{
InventoryActions inventory = source.Inventory;
if (!((InventoryActions)(ref inventory)).enabled)
{
CinematicActions cinematic = source.Cinematic;
if (!((CinematicActions)(ref cinematic)).enabled)
{
LoadingActions loading = source.Loading;
if (!((LoadingActions)(ref loading)).enabled)
{
DevToolsActions devTools = source.DevTools;
if (!((DevToolsActions)(ref devTools)).enabled && !IsGameUiOpen(manager) && !IsTextInputFocused())
{
UIActions uI = source.UI;
bool enabled = ((UIActions)(ref uI)).enabled;
OnFootActions onFoot = source.OnFoot;
bool flag = !((OnFootActions)(ref onFoot)).enabled;
FKeysActions fKeys = source.FKeys;
bool flag2 = !((FKeysActions)(ref fKeys)).enabled;
if (enabled)
{
uI = source.UI;
((UIActions)(ref uI)).Disable();
}
if (flag || flag2)
{
onFoot = source.OnFoot;
((OnFootActions)(ref onFoot)).Enable();
fKeys = source.FKeys;
((FKeysActions)(ref fKeys)).Enable();
}
if ((enabled || flag || flag2) && Time.unscaledTime >= nextRecoveryLogTime)
{
nextRecoveryLogTime = Time.unscaledTime + 2f;
log.LogWarning((object)("Recovered stale gameplay input maps before opening chat: UI=" + enabled + " OnFootDisabled=" + flag + " FKeysDisabled=" + flag2 + "."));
}
onFoot = source.OnFoot;
if (((OnFootActions)(ref onFoot)).enabled)
{
uI = source.UI;
return !((UIActions)(ref uI)).enabled;
}
return false;
}
}
}
}
}
return false;
}
private static bool IsGameUiOpen(GameManager manager)
{
CanvasManager canvasManager = manager.canvasManager;
if ((Object)(object)canvasManager != (Object)null && (((Object)(object)canvasManager.pauseMenu != (Object)null && ((Component)canvasManager.pauseMenu).gameObject.activeInHierarchy) || ((Object)(object)canvasManager.optionsScreen != (Object)null && canvasManager.optionsScreen.IsShown)))
{
return true;
}
UIManager instance = StaticInstance<UIManager>.Instance;
if ((Object)(object)instance != (Object)null && (Object)(object)instance.InventoryUI != (Object)null && instance.InventoryUI.IsOpened)
{
return true;
}
if ((Object)(object)manager.PlayerScript != (Object)null && (Object)(object)manager.PlayerScript.dialogController != (Object)null)
{
return (Object)(object)manager.PlayerScript.dialogController.CurrentSpeakable != (Object)null;
}
return false;
}
private static bool IsTextInputFocused()
{
GameObject val = (((Object)(object)EventSystem.current != (Object)null) ? EventSystem.current.currentSelectedGameObject : null);
TMP_InputField val2 = (((Object)(object)val != (Object)null) ? val.GetComponentInParent<TMP_InputField>() : null);
if ((Object)(object)val2 != (Object)null)
{
return val2.isFocused;
}
return false;
}
private void LogUnavailableState(GameManager manager, PlayerInputActions actions)
{
//IL_0037: Unknown result type (might be due to invalid IL or missing references)
//IL_003c: Unknown result type (might be due to invalid IL or missing references)
//IL_0056: Unknown result type (might be due to invalid IL or missing references)
//IL_005b: Unknown result type (might be due to invalid IL or missing references)
//IL_0075: Unknown result type (might be due to invalid IL or missing references)
//IL_007a: Unknown result type (might be due to invalid IL or missing references)
//IL_0096: Unknown result type (might be due to invalid IL or missing references)
//IL_009b: Unknown result type (might be due to invalid IL or missing references)
//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
//IL_00be: Unknown result type (might be due to invalid IL or missing references)
//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
//IL_0101: Unknown result type (might be due to invalid IL or missing references)
//IL_0106: Unknown result type (might be due to invalid IL or missing references)
//IL_0125: Unknown result type (might be due to invalid IL or missing references)
//IL_012a: Unknown result type (might be due to invalid IL or missing references)
//IL_0149: Unknown result type (might be due to invalid IL or missing references)
//IL_014e: Unknown result type (might be due to invalid IL or missing references)
if (!(Time.unscaledTime < nextUnavailableLogTime))
{
nextUnavailableLogTime = Time.unscaledTime + 2f;
ManualLogSource obj = log;
string[] obj2 = new string[19]
{
"Chat input capture ignored: GameState=",
((object)manager.gameState/*cast due to .constrained prefix*/).ToString(),
" Locks=",
((object)manager.currentLocks/*cast due to .constrained prefix*/).ToString(),
" OnFoot=",
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null
};
OnFootActions onFoot = actions.OnFoot;
obj2[5] = ((OnFootActions)(ref onFoot)).enabled.ToString();
obj2[6] = " FKeys=";
FKeysActions fKeys = actions.FKeys;
obj2[7] = ((FKeysActions)(ref fKeys)).enabled.ToString();
obj2[8] = " UI=";
UIActions uI = actions.UI;
obj2[9] = ((UIActions)(ref uI)).enabled.ToString();
obj2[10] = " Inventory=";
InventoryActions inventory = actions.Inventory;
obj2[11] = ((InventoryActions)(ref inventory)).enabled.ToString();
obj2[12] = " Cinematic=";
CinematicActions cinematic = actions.Cinematic;
obj2[13] = ((CinematicActions)(ref cinematic)).enabled.ToString();
obj2[14] = " Loading=";
LoadingActions loading = actions.Loading;
obj2[15] = ((LoadingActions)(ref loading)).enabled.ToString();
obj2[16] = " DevTools=";
DevToolsActions devTools = actions.DevTools;
obj2[17] = ((DevToolsActions)(ref devTools)).enabled.ToString();
obj2[18] = ".";
obj.LogDebug((object)string.Concat(obj2));
}
}
private void LogUnavailable(string message)
{
if (!(Time.unscaledTime < nextUnavailableLogTime))
{
nextUnavailableLogTime = Time.unscaledTime + 2f;
log.LogDebug((object)message);
}
}
}
internal sealed class ModernTextInputBridge : IDisposable
{
private const float BackspaceInitialDelay = 0.45f;
private const float BackspaceRepeatInterval = 0.05f;
private readonly ManualLogSource log;
private readonly StringBuilder pendingCharacters = new StringBuilder();
private TMP_InputField? input;
private Keyboard? keyboard;
private bool active;
private bool composing;
private int compositionInteractionFrame = -1;
private bool pendingText;
private TextEditState pendingTextBaseline;
private bool pendingSpace;
private TextEditState pendingSpaceBaseline;
private bool pendingBackspace;
private bool pendingBackspaceIsInitial;
private TextEditState pendingBackspaceBaseline;
private bool backspaceHeld;
private bool backspaceRepeatStarted;
private float nextBackspaceRepeat;
private TextEditState lastLateState;
private bool hasLastLateState;
private int textFallbackCount;
private int spaceFallbackCount;
private int backspaceFallbackCount;
private int lastSpacePressFrame = -1;
private int lastBackspacePressFrame = -1;
private bool candidatePositionFailureLogged;
public bool ShouldConsumeCommandThisFrame
{
get
{
if (active)
{
if (!composing)
{
return compositionInteractionFrame == Time.frameCount;
}
return true;
}
return false;
}
}
public ModernTextInputBridge(ManualLogSource log)
{
this.log = log;
}
public void Begin(TMP_InputField field)
{
input = field;
active = true;
composing = false;
compositionInteractionFrame = -1;
candidatePositionFailureLogged = false;
lastSpacePressFrame = -1;
ClearPendingEdits();
BindKeyboard(Keyboard.current);
RefreshFocus();
InputSystem.onAfterUpdate -= OnAfterInputUpdate;
InputSystem.onAfterUpdate += OnAfterInputUpdate;
lastLateState = Snapshot();
hasLastLateState = true;
}
public void RefreshFocus()
{
if (!active)
{
return;
}
BindKeyboard(Keyboard.current);
try
{
Keyboard? obj = keyboard;
if (obj != null)
{
obj.SetIMEEnabled(true);
}
}
catch (Exception ex)
{
log.LogDebug((object)("Could not refresh IME state: " + ex.Message));
}
}
public void LateTick(float now)
{
if (active && !((Object)(object)input == (Object)null))
{
if (keyboard != Keyboard.current)
{
BindKeyboard(Keyboard.current);
}
ResolvePendingText();
ResolvePendingSpace();
ResolvePendingBackspace();
TextEditState textEditState = Snapshot();
if (backspaceHeld && backspaceRepeatStarted && hasLastLateState && textEditState != lastLateState)
{
nextBackspaceRepeat = now + 0.05f;
}
lastLateState = textEditState;
hasLastLateState = true;
UpdateCandidatePosition();
}
}
public void End()
{
if (active || keyboard != null)
{
active = false;
InputSystem.onAfterUpdate -= OnAfterInputUpdate;
UnbindKeyboard();
input = null;
composing = false;
compositionInteractionFrame = -1;
backspaceHeld = false;
backspaceRepeatStarted = false;
hasLastLateState = false;
ClearPendingEdits();
}
}
public void Dispose()
{
End();
}
private void BindKeyboard(Keyboard? next)
{
if (keyboard == next)
{
return;
}
UnbindKeyboard();
keyboard = next;
if (keyboard == null || !active)
{
return;
}
keyboard.onTextInput += OnTextInput;
keyboard.onIMECompositionChange += OnImeCompositionChange;
try
{
keyboard.SetIMEEnabled(true);
log.LogDebug((object)("Modern text input attached. Layout=" + keyboard.keyboardLayout + " IMESelected=" + keyboard.imeSelected.isPressed + "."));
}
catch (Exception ex)
{
log.LogDebug((object)("Could not enable modern IME input: " + ex.Message));
}
}
private void UnbindKeyboard()
{
Keyboard val = keyboard;
keyboard = null;
if (val == null)
{
return;
}
val.onTextInput -= OnTextInput;
val.onIMECompositionChange -= OnImeCompositionChange;
try
{
val.SetIMEEnabled(false);
}
catch (Exception ex)
{
log.LogDebug((object)("Could not disable modern IME input: " + ex.Message));
}
}
private void OnTextInput(char character)
{
if (CanEdit() && !char.IsControl(character))
{
if (!pendingText)
{
pendingTextBaseline = Snapshot();
pendingText = true;
}
pendingCharacters.Append(character);
}
}
private unsafe void OnImeCompositionChange(IMECompositionString composition)
{
if (active)
{
bool num = composing;
composing = ((object)(*(IMECompositionString*)(&composition))/*cast due to .constrained prefix*/).ToString().Length != 0;
if (num || composing)
{
compositionInteractionFrame = Time.frameCount;
}
}
}
private void OnAfterInputUpdate()
{
if (!CanEdit())
{
return;
}
Keyboard val = keyboard;
if (val == null)
{
return;
}
float unscaledTime = Time.unscaledTime;
bool wasPressedThisFrame = ((ButtonControl)val.backspaceKey).wasPressedThisFrame;
bool wasReleasedThisFrame = ((ButtonControl)val.backspaceKey).wasReleasedThisFrame;
if (composing || compositionInteractionFrame == Time.frameCount)
{
pendingSpace = false;
if (wasReleasedThisFrame)
{
backspaceHeld = false;
backspaceRepeatStarted = false;
pendingBackspace = false;
}
return;
}
if (((ButtonControl)val.spaceKey).wasPressedThisFrame && lastSpacePressFrame != Time.frameCount)
{
lastSpacePressFrame = Time.frameCount;
pendingSpaceBaseline = Snapshot();
pendingSpace = true;
}
if (wasPressedThisFrame)
{
if (lastBackspacePressFrame != Time.frameCount)
{
lastBackspacePressFrame = Time.frameCount;
pendingBackspaceBaseline = Snapshot();
pendingBackspace = true;
pendingBackspaceIsInitial = true;
backspaceHeld = !wasReleasedThisFrame;
backspaceRepeatStarted = false;
nextBackspaceRepeat = unscaledTime + 0.45f;
}
else if (wasReleasedThisFrame)
{
backspaceHeld = false;
}
}
else if (wasReleasedThisFrame)
{
backspaceHeld = false;
backspaceRepeatStarted = false;
pendingBackspace = false;
}
else if (backspaceHeld && ((ButtonControl)val.backspaceKey).isPressed && !pendingBackspace && unscaledTime >= nextBackspaceRepeat)
{
pendingBackspaceBaseline = Snapshot();
pendingBackspace = true;
pendingBackspaceIsInitial = false;
backspaceRepeatStarted = true;
nextBackspaceRepeat = unscaledTime + 0.05f;
}
}
private void ResolvePendingText()
{
if (!pendingText || (Object)(object)input == (Object)null)
{
return;
}
string value = pendingCharacters.ToString();
TextEditState textEditState = Snapshot();
TextEditState textEditState2 = TextEdit.InsertIfUnchanged(pendingTextBaseline, textEditState, value, input.characterLimit);
if (textEditState2 != textEditState)
{
Apply(textEditState2);
textFallbackCount++;
if (textFallbackCount == 1)
{
log.LogDebug((object)"Modern text-input fallback activated.");
}
}
pendingText = false;
pendingCharacters.Clear();
}
private void ResolvePendingSpace()
{
if (!pendingSpace || (Object)(object)input == (Object)null)
{
return;
}
if (composing || compositionInteractionFrame == Time.frameCount)
{
pendingSpace = false;
return;
}
TextEditState textEditState = Snapshot();
TextEditState textEditState2 = TextEdit.InsertIfUnchanged(pendingSpaceBaseline, textEditState, " ", input.characterLimit);
if (textEditState2 != textEditState)
{
Apply(textEditState2);
spaceFallbackCount++;
if (spaceFallbackCount == 1)
{
log.LogDebug((object)"Modern Space fallback activated.");
}
}
pendingSpace = false;
}
private void ResolvePendingBackspace()
{
if (!pendingBackspace)
{
return;
}
TextEditState textEditState = TextEdit.DeleteBackward(pendingBackspaceBaseline);
if (Snapshot() == pendingBackspaceBaseline && textEditState != pendingBackspaceBaseline)
{
Apply(textEditState);
backspaceFallbackCount++;
if (backspaceFallbackCount == 1)
{
log.LogDebug((object)"Modern Backspace fallback activated.");
}
}
if (!pendingBackspaceIsInitial)
{
backspaceRepeatStarted = true;
}
pendingBackspace = false;
}
private bool CanEdit()
{
if (active && (Object)(object)input != (Object)null)
{
return input.isFocused;
}
return false;
}
private TextEditState Snapshot()
{
TMP_InputField val = input;
if ((Object)(object)val == (Object)null)
{
return new TextEditState("", 0, 0);
}
return new TextEditState(val.text, val.selectionStringAnchorPosition, val.selectionStringFocusPosition);
}
private void Apply(TextEditState state)
{
TMP_InputField val = input;
if (!((Object)(object)val == (Object)null))
{
val.SetTextWithoutNotify(state.Text);
val.selectionStringAnchorPosition = state.Anchor;
val.selectionStringFocusPosition = state.Focus;
val.ForceLabelUpdate();
((UnityEvent<string>)(object)val.onValueChanged).Invoke(state.Text);
}
}
private void UpdateCandidatePosition()
{
//IL_0062: Unknown result type (might be due to invalid IL or missing references)
//IL_0067: Unknown result type (might be due to invalid IL or missing references)
//IL_006c: Unknown result type (might be due to invalid IL or missing references)
//IL_006e: Unknown result type (might be due to invalid IL or missing references)
//IL_007a: Unknown result type (might be due to invalid IL or missing references)
//IL_0081: 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)
//IL_0046: Unknown result type (might be due to invalid IL or missing references)
TMP_InputField val = input;
Keyboard val2 = keyboard;
if ((Object)(object)val == (Object)null || val2 == null || !val.isFocused)
{
return;
}
try
{
TMP_Text textComponent = val.textComponent;
TextMeshProUGUI val3 = (TextMeshProUGUI)(object)((textComponent is TextMeshProUGUI) ? textComponent : null);
Vector2 val4;
if ((Object)(object)val3 != (Object)null && TryGetCaretScreenPosition(val, val3, out var screenPosition))
{
val4 = screenPosition;
}
else
{
Vector3[] array = (Vector3[])(object)new Vector3[4];
val.textViewport.GetWorldCorners(array);
val4 = RectTransformUtility.WorldToScreenPoint((Camera)null, array[0]);
}
val2.SetIMECursorPosition(new Vector2(val4.x, (float)Screen.height - val4.y));
}
catch (Exception ex)
{
if (!candidatePositionFailureLogged)
{
candidatePositionFailureLogged = true;
log.LogDebug((object)("Could not update IME candidate position: " + ex.Message));
}
}
}
private static bool TryGetCaretScreenPosition(TMP_InputField field, TextMeshProUGUI text, out Vector2 screenPosition)
{
//IL_0039: Unknown result type (might be due to invalid IL or missing references)
//IL_003e: Unknown result type (might be due to invalid IL or missing references)
//IL_0043: Unknown result type (might be due to invalid IL or missing references)
//IL_0083: Unknown result type (might be due to invalid IL or missing references)
//IL_0088: Unknown result type (might be due to invalid IL or missing references)
//IL_008a: 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_00d6: 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_00df: Unknown result type (might be due to invalid IL or missing references)
//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
//IL_00a7: 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)
//IL_0094: Unknown result type (might be due to invalid IL or missing references)
//IL_009c: Unknown result type (might be due to invalid IL or missing references)
field.ForceLabelUpdate();
((TMP_Text)text).ForceMeshUpdate(false, false);
TMP_TextInfo textInfo = ((TMP_Text)text).textInfo;
int characterCount = textInfo.characterCount;
if (characterCount == 0)
{
Vector3[] array = (Vector3[])(object)new Vector3[4];
field.textViewport.GetWorldCorners(array);
screenPosition = RectTransformUtility.WorldToScreenPoint((Camera)null, array[0]);
return true;
}
int selectionStringFocusPosition = field.selectionStringFocusPosition;
float num = textInfo.characterInfo[0].origin;
float baseLine = textInfo.characterInfo[0].baseLine;
for (int i = 0; i < characterCount; i++)
{
TMP_CharacterInfo val = textInfo.characterInfo[i];
if (val.index >= selectionStringFocusPosition)
{
num = val.origin;
baseLine = val.baseLine;
break;
}
num = val.xAdvance;
baseLine = val.baseLine;
}
Vector3 val2 = ((Transform)((TMP_Text)text).rectTransform).TransformPoint(new Vector3(num, baseLine, 0f));
screenPosition = RectTransformUtility.WorldToScreenPoint((Camera)null, val2);
return true;
}
private void ClearPendingEdits()
{
pendingText = false;
pendingCharacters.Clear();
pendingSpace = false;
pendingBackspace = false;
pendingBackspaceIsInitial = false;
}
}
internal readonly struct TextEditState : IEquatable<TextEditState>
{
public string Text { get; }
public int Anchor { get; }
public int Focus { get; }
public TextEditState(string text, int anchor, int focus)
{
Text = text ?? "";
Anchor = Clamp(anchor, 0, Text.Length);
Focus = Clamp(focus, 0, Text.Length);
}
public bool Equals(TextEditState other)
{
if (string.Equals(Text, other.Text, StringComparison.Ordinal) && Anchor == other.Anchor)
{
return Focus == other.Focus;
}
return false;
}
public override bool Equals(object? obj)
{
if (obj is TextEditState other)
{
return Equals(other);
}
return false;
}
public override int GetHashCode()
{
return (((StringComparer.Ordinal.GetHashCode(Text ?? "") * 397) ^ Anchor) * 397) ^ Focus;
}
public static bool operator ==(TextEditState left, TextEditState right)
{
return left.Equals(right);
}
public static bool operator !=(TextEditState left, TextEditState right)
{
return !left.Equals(right);
}
private static int Clamp(int value, int minimum, int maximum)
{
if (value < minimum)
{
return minimum;
}
if (value <= maximum)
{
return value;
}
return maximum;
}
}
internal static class TextEdit
{
public static TextEditState InsertIfUnchanged(TextEditState baseline, TextEditState current, string value, int characterLimit)
{
if (!(current == baseline))
{
return current;
}
return Insert(baseline, value, characterLimit);
}
public static TextEditState Insert(TextEditState state, string value, int characterLimit)
{
if (string.IsNullOrEmpty(value))
{
return state;
}
int num = Math.Min(state.Anchor, state.Focus);
int num2 = Math.Max(state.Anchor, state.Focus);
int num3 = state.Text.Length - (num2 - num);
int maximumLength = ((characterLimit <= 0) ? int.MaxValue : Math.Max(0, characterLimit - num3));
string text = TruncateUtf16(value, maximumLength);
if (text.Length == 0 && num == num2)
{
return state;
}
string text2 = state.Text.Remove(num, num2 - num).Insert(num, text);
int num4 = num + text.Length;
return new TextEditState(text2, num4, num4);
}
public static TextEditState DeleteBackward(TextEditState state)
{
int num = Math.Min(state.Anchor, state.Focus);
int num2 = Math.Max(state.Anchor, state.Focus);
if (num != num2)
{
return new TextEditState(state.Text.Remove(num, num2 - num), num, num);
}
int focus = state.Focus;
if (focus <= 0 || state.Text.Length == 0)
{
return state;
}
int num3 = PreviousTextElementStart(state.Text, focus);
return new TextEditState(state.Text.Remove(num3, focus - num3), num3, num3);
}
private static int PreviousTextElementStart(string text, int caret)
{
int[] array = StringInfo.ParseCombiningCharacters(text);
int result = 0;
for (int i = 0; i < array.Length && array[i] < caret; i++)
{
result = array[i];
}
return result;
}
private static string TruncateUtf16(string value, int maximumLength)
{
if (maximumLength >= value.Length)
{
return value;
}
if (maximumLength <= 0)
{
return "";
}
int num = maximumLength;
if (num < value.Length && num > 0 && char.IsHighSurrogate(value[num - 1]) && char.IsLowSurrogate(value[num]))
{
num--;
}
return value.Substring(0, num);
}
}
}
namespace de.nemophila.sulfur.simplechat.Networking
{
internal sealed class ChatController : IDisposable
{
private sealed class RateBucket
{
public float Tokens;
public float LastRefill;
}
private const float MembershipPollInterval = 0.5f;
private const int HelloAttemptLimit = 5;
private const float HelloRetryInterval = 1f;
private const float RateLimitBurst = 5f;
private const float RateLimitRefillPerSecond = 1f;
private readonly ManualLogSource log;
private readonly ChatHud hud;
private readonly TogetherNameResolver nameResolver;
private readonly Dictionary<string, string> hostMembers = new Dictionary<string, string>(StringComparer.Ordinal);
private readonly Dictionary<string, RateBucket> rateBuckets = new Dictionary<string, RateBucket>(StringComparer.Ordinal);
private IExternalChannelRegistration? registration;
private SessionRole role;
private bool sessionActive;
private string localPeerId = "";
private ulong sequence;
private ulong lastReceivedSequence;
private bool welcomed;
private bool handshakeFailed;
private int helloAttempts;
private float nextHelloTime;
private float nextMembershipPoll;
private bool transportReady;
private bool unavailableNoticeShown;
public ChatController(ManualLogSource log, ChatHud hud)
{
this.log = log;
this.hud = hud;
nameResolver = new TogetherNameResolver(log);
int num = ReadExternalChannelApiVersion();
if (num != 1)
{
log.LogError((object)("Unsupported SULFUR Together external-channel API version: " + num));
return;
}
try
{
registration = NetExternalChannel.Register("de.nemophila.sulfur.simplechat.v1", (Action<string, byte[]>)OnReceive);
transportReady = true;
}
catch (Exception ex)
{
log.LogError((object)("Failed to register the SimpleChat network channel: " + ex));
}
}
public void Tick(float now)
{
//IL_0017: Unknown result type (might be due to invalid IL or missing references)
//IL_001c: 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_0036: Unknown result type (might be due to invalid IL or missing references)
//IL_0038: Unknown result type (might be due to invalid IL or missing references)
//IL_0061: Unknown result type (might be due to invalid IL or missing references)
//IL_0067: Invalid comparison between Unknown and I4
//IL_0087: Unknown result type (might be due to invalid IL or missing references)
//IL_008d: Invalid comparison between Unknown and I4
bool flag = transportReady && NetSessionInfo.IsSessionActive;
SessionRole val = (SessionRole)(flag ? ((int)NetSessionInfo.Role) : 0);
string text = (flag ? NetSessionInfo.LocalPeerId : "");
if (flag != sessionActive || val != role || text != localPeerId)
{
BeginSession(flag, val, text, now);
}
if (sessionActive)
{
if ((int)role == 1 && now >= nextMembershipPoll)
{
nextMembershipPoll = now + 0.5f;
PollHostMembership();
}
else if ((int)role == 2)
{
TickClientHandshake(now);
}
}
}
public bool CanOpen()
{
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
//IL_0019: Invalid comparison between Unknown and I4
//IL_001c: Unknown result type (might be due to invalid IL or missing references)
//IL_0022: Invalid comparison between Unknown and I4
if (!transportReady || !sessionActive)
{
return false;
}
if ((int)role != 1)
{
if ((int)role == 2)
{
return welcomed;
}
return false;
}
return true;
}
public bool CanAttemptOpen()
{
if (handshakeFailed)
{
return false;
}
if (!transportReady || !sessionActive)
{
return !unavailableNoticeShown;
}
return true;
}
public void NotifyOpenDenied()
{
if (!transportReady)
{
if (!unavailableNoticeShown)
{
unavailableNoticeShown = true;
hud.AddSystem("system.transport_unavailable", "SimpleChat could not connect to SULFUR Together.");
}
}
else if (!sessionActive)
{
if (!unavailableNoticeShown)
{
unavailableNoticeShown = true;
hud.AddSystem("system.offline", "Chat is available in an active SULFUR Together session.");
}
}
else if (!handshakeFailed)
{
hud.AddSystem("system.connecting", "SimpleChat is connecting to the host...");
}
}
public bool SubmitLocal(string input)
{
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_002c: Invalid comparison between Unknown and I4
string normalized;
ChatErrorCode chatErrorCode = ChatTextPolicy.Validate(input, out normalized);
if (chatErrorCode != ChatErrorCode.None)
{
ShowError(chatErrorCode);
return false;
}
if (!CanOpen())
{
NotifyOpenDenied();
return false;
}
if ((int)role == 1)
{
return AcceptHostSubmission((localPeerId.Length == 0) ? "host" : localPeerId, normalized, sendRemoteError: false);
}
if (!Send(ChatPacket.Submit(normalized), (ExternalTarget)0))
{
hud.AddSystem("system.send_failed", "The message could not be sent.");
return false;
}
return true;
}
public void Dispose()
{
((IDisposable)registration)?.Dispose();
registration = null;
transportReady = false;
}
private void BeginSession(bool active, SessionRole newRole, string newLocalPeerId, float now)
{
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
//IL_0009: 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)
//IL_008b: Invalid comparison between Unknown and I4
sessionActive = active;
role = newRole;
localPeerId = newLocalPeerId ?? "";
sequence = 0uL;
lastReceivedSequence = 0uL;
welcomed = false;
handshakeFailed = false;
helloAttempts = 0;
nextHelloTime = now;
nextMembershipPoll = now;
unavailableNoticeShown = false;
hostMembers.Clear();
rateBuckets.Clear();
hud.Clear();
if (sessionActive && (int)role == 1)
{
SeedHostMembership();
}
}
private void TickClientHandshake(float now)
{
if (!welcomed && !handshakeFailed && !(now < nextHelloTime))
{
if (helloAttempts >= 5)
{
handshakeFailed = true;
hud.AddSystem("system.handshake_failed", "No response was received from the host's SimpleChat.");
}
else
{
Send(ChatPacket.Hello("0.1.7"), (ExternalTarget)0);
helloAttempts++;
nextHelloTime = now + 1f;
}
}
}
private void OnReceive(string senderPeerId, byte[] payload)
{
//IL_001d: Unknown result type (might be due to invalid IL or missing references)
//IL_0023: Invalid comparison between Unknown and I4
//IL_0058: Unknown result type (might be due to invalid IL or missing references)
//IL_005e: Invalid comparison between Unknown and I4
//IL_0038: Unknown result type (might be due to invalid IL or missing references)
//IL_003e: Invalid comparison between Unknown and I4
//IL_006a: Unknown result type (might be due to invalid IL or missing references)
//IL_0070: Invalid comparison between Unknown and I4
if (!sessionActive)
{
return;
}
if (!ChatProtocol.TryDecode(payload, out ChatPacket packet, out ChatDecodeError error) || packet == null)
{
if (error == ChatDecodeError.UnsupportedVersion)
{
if ((int)role == 1 && IsConnectedMember(senderPeerId))
{
SendError(senderPeerId, ChatErrorCode.ProtocolMismatch);
}
else if ((int)role == 2 && IsTrustedHost(senderPeerId))
{
handshakeFailed = true;
ShowError(ChatErrorCode.ProtocolMismatch);
}
}
}
else if ((int)role == 1)
{
HandleHostPacket(senderPeerId, packet);
}
else if ((int)role == 2 && IsTrustedHost(senderPeerId))
{
HandleClientPacket(packet);
}
}
private void HandleHostPacket(string senderPeerId, ChatPacket packet)
{
if (!IsConnectedMember(senderPeerId))
{
SendError(senderPeerId, ChatErrorCode.NotSessionMember);
return;
}
switch (packet.Kind)
{
case ChatPacketKind.Hello:
Send(ChatPacket.Welcome(sequence), (ExternalTarget)2, senderPeerId);
break;
case ChatPacketKind.Submit:
AcceptHostSubmission(senderPeerId, packet.Text, sendRemoteError: true);
break;
}
}
private void HandleClientPacket(ChatPacket packet)
{
switch (packet.Kind)
{
case ChatPacketKind.Welcome:
lastReceivedSequence = packet.Sequence;
welcomed = true;
handshakeFailed = false;
break;
case ChatPacketKind.Chat:
if (welcomed && AcceptSequence(packet.Sequence))
{
hud.AddChat(ChatTextPolicy.CleanDisplayName(packet.DisplayName, packet.PeerId), packet.Text);
}
break;
case ChatPacketKind.Presence:
if (welcomed && AcceptSequence(packet.Sequence))
{
string text = ChatTextPolicy.CleanDisplayName(packet.DisplayName, packet.PeerId);
if (packet.Joined)
{
hud.AddSystem("system.joined", "{0} joined the session.", text);
}
else
{
hud.AddSystem("system.left", "{0} left the session.", text);
}
}
break;
case ChatPacketKind.Error:
if (packet.ErrorCode == ChatErrorCode.ProtocolMismatch)
{
handshakeFailed = true;
}
ShowError(packet.ErrorCode);
break;
case ChatPacketKind.Submit:
break;
}
}
private bool AcceptHostSubmission(string senderPeerId, string input, bool sendRemoteError)
{
string normalized;
ChatErrorCode chatErrorCode = ChatTextPolicy.Validate(input, out normalized);
if (chatErrorCode != ChatErrorCode.None)
{
RejectSubmission(senderPeerId, chatErrorCode, sendRemoteError);
return false;
}
if (!TryConsumeRateToken(senderPeerId, Time.unscaledTime))
{
RejectSubmission(senderPeerId, ChatErrorCode.RateLimited, sendRemoteError);
return false;
}
string displayName = nameResolver.Resolve(senderPeerId);
ChatPacket packet = ChatPacket.Chat(NextSequence(), senderPeerId, displayName, normalized);
Send(packet, (ExternalTarget)1);
hud.AddChat(displayName, normalized);
return true;
}
private void RejectSubmission(string peerId, ChatErrorCode errorCode, bool remote)
{
if (remote)
{
SendError(peerId, errorCode);
}
else
{
ShowError(errorCode);
}
}
private void SeedHostMembership()
{
//IL_001a: 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)
Dictionary<string, string> connectedNames = nameResolver.GetConnectedNames();
foreach (ExternalPeer peer in NetSessionInfo.Peers)
{
ExternalPeer current = peer;
string peerId = ((ExternalPeer)(ref current)).PeerId;
hostMembers[peerId] = (connectedNames.TryGetValue(peerId, out var value) ? value : ChatTextPolicy.CleanDisplayName(null, peerId));
}
}
private void PollHostMembership()
{
//IL_0025: Unknown result type (might be due to invalid IL or missing references)
//IL_002a: Unknown result type (might be due to invalid IL or missing references)
Dictionary<string, string> connectedNames = nameResolver.GetConnectedNames();
Dictionary<string, string> dictionary = new Dictionary<string, string>(StringComparer.Ordinal);
foreach (ExternalPeer peer in NetSessionInfo.Peers)
{
ExternalPeer current = peer;
string peerId = ((ExternalPeer)(ref current)).PeerId;
dictionary[peerId] = (connectedNames.TryGetValue(peerId, out var value) ? value : ChatTextPolicy.CleanDisplayName(null, peerId));
}
foreach (KeyValuePair<string, string> item in dictionary)
{
if (!hostMembers.ContainsKey(item.Key))
{
PublishPresence(joined: true, item.Key, item.Value);
}
}
foreach (KeyValuePair<string, string> hostMember in hostMembers)
{
if (!dictionary.ContainsKey(hostMember.Key))
{
PublishPresence(joined: false, hostMember.Key, hostMember.Value);
rateBuckets.Remove(hostMember.Key);
}
}
hostMembers.Clear();
foreach (KeyValuePair<string, string> item2 in dictionary)
{
hostMembers[item2.Key] = item2.Value;
}
}
private void PublishPresence(bool joined, string peerId, string displayName)
{
ulong num = NextSequence();
Send(ChatPacket.Presence(num, joined, peerId, displayName), (ExternalTarget)1);
if (joined)
{
hud.AddSystem("system.joined", "{0} joined the session.", displayName);
}
else
{
hud.AddSystem("system.left", "{0} left the session.", displayName);
}
}
private bool AcceptSequence(ulong candidate)
{
if (candidate <= lastReceivedSequence)
{
return false;
}
lastReceivedSequence = candidate;
return true;
}
private ulong NextSequence()
{
sequence = ((sequence == ulong.MaxValue) ? 1 : (sequence + 1));
return sequence;
}
private bool TryConsumeRateToken(string peerId, float now)
{
if (!rateBuckets.TryGetValue(peerId, out RateBucket value))
{
value = new RateBucket
{
Tokens = 5f,
LastRefill = now
};
rateBuckets[peerId] = value;
}
float num = Mathf.Max(0f, now - value.LastRefill);
value.Tokens = Mathf.Min(5f, value.Tokens + num * 1f);
value.LastRefill = now;
if (value.Tokens < 1f)
{
return false;
}
value.Tokens -= 1f;
return true;
}
private bool IsConnectedMember(string peerId)
{
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
foreach (ExternalPeer peer in NetSessionInfo.Peers)
{
ExternalPeer current = peer;
if (string.Equals(((ExternalPeer)(ref current)).PeerId, peerId, StringComparison.Ordinal))
{
return true;
}
}
return false;
}
private static bool IsTrustedHost(string senderPeerId)
{
return string.Equals(senderPeerId, "host", StringComparison.Ordinal);
}
private void SendError(string peerId, ChatErrorCode errorCode)
{
Send(ChatPacket.Error(errorCode), (ExternalTarget)2, peerId);
}
private bool Send(ChatPacket packet, ExternalTarget target, string? targetPeerId = null)
{
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
try
{
byte[] array = ChatProtocol.Encode(packet);
return NetExternalChannel.Send("de.nemophila.sulfur.simplechat.v1", array, (ExternalDelivery)0, target, targetPeerId);
}
catch (Exception ex)
{
log.LogWarning((object)("SimpleChat send failed: " + ex.Message));
return false;
}
}
private void ShowError(ChatErrorCode errorCode)
{
switch (errorCode)
{
case ChatErrorCode.Empty:
hud.AddSystem("error.empty", "Enter a message first.");
break;
case ChatErrorCode.TooLong:
hud.AddSystem("error.too_long", "The message is too long (maximum 256 characters).");
break;
case ChatErrorCode.InvalidCharacters:
hud.AddSystem("error.invalid_characters", "The message contains unsupported control characters.");
break;
case ChatErrorCode.RateLimited:
hud.AddSystem("error.rate_limited", "You are sending messages too quickly.");
break;
case ChatErrorCode.NotSessionMember:
hud.AddSystem("error.not_member", "The host no longer recognizes this session member.");
break;
case ChatErrorCode.ProtocolMismatch:
hud.AddSystem("error.protocol", "The host is running an incompatible SimpleChat protocol.");
break;
default:
hud.AddSystem("error.unknown", "The message was rejected by the host.");
break;
}
}
private static int ReadExternalChannelApiVersion()
{
object obj = typeof(NetExternalChannel).GetField("ApiVersion", BindingFlags.Static | BindingFlags.Public)?.GetRawConstantValue();
if (obj is int)
{
return (int)obj;
}
return -1;
}
}
internal enum ChatPacketKind : byte
{
Hello = 1,
Welcome,
Submit,
Chat,
Presence,
Error
}
internal enum ChatErrorCode : byte
{
None,
Empty,
TooLong,
InvalidCharacters,
RateLimited,
NotSessionMember,
ProtocolMismatch
}
internal enum ChatDecodeError
{
None,
Malformed,
UnsupportedVersion
}
internal sealed class ChatPacket
{
public ChatPacketKind Kind { get; private set; }
public string ModVersion { get; private set; } = "";
public ulong Sequence { get; private set; }
public string PeerId { get; private set; } = "";
public string DisplayName { get; private set; } = "";
public string Text { get; private set; } = "";
public bool Joined { get; private set; }
public ChatErrorCode ErrorCode { get; private set; }
public static ChatPacket Hello(string modVersion)
{
return new ChatPacket
{
Kind = ChatPacketKind.Hello,
ModVersion = (modVersion ?? "")
};
}
public static ChatPacket Welcome(ulong sequence)
{
return new ChatPacket
{
Kind = ChatPacketKind.Welcome,
Sequence = sequence
};
}
public static ChatPacket Submit(string text)
{
return new ChatPacket
{
Kind = ChatPacketKind.Submit,
Text = (text ?? "")
};
}
public static ChatPacket Chat(ulong sequence, string peerId, string displayName, string text)
{
return new ChatPacket
{
Kind = ChatPacketKind.Chat,
Sequence = sequence,
PeerId = (peerId ?? ""),
DisplayName = (displayName ?? ""),
Text = (text ?? "")
};
}
public static ChatPacket Presence(ulong sequence, bool joined, string peerId, string displayName)
{
return new ChatPacket
{
Kind = ChatPacketKind.Presence,
Sequence = sequence,
Joined = joined,
PeerId = (peerId ?? ""),
DisplayName = (displayName ?? "")
};
}
public static ChatPacket Error(ChatErrorCode code)
{
return new ChatPacket
{
Kind = ChatPacketKind.Error,
ErrorCode = code
};
}
internal static ChatPacket FromWire(ChatPacketKind kind, string modVersion, ulong sequence, string peerId, string displayName, string text, bool joined, ChatErrorCode errorCode)
{
return new ChatPacket
{
Kind = kind,
ModVersion = modVersion,
Sequence = sequence,
PeerId = peerId,
DisplayName = displayName,
Text = text,
Joined = joined,
ErrorCode = errorCode
};
}
}
internal static class ChatProtocol
{
private const uint Magic = 1396918356u;
private const ushort ProtocolVersion = 1;
public const int MaxPacketBytes = 4096;
private static readonly Encoding Utf8 = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false, throwOnInvalidBytes: true);
public static byte[] Encode(ChatPacket packet)
{
if (packet == null)
{
throw new ArgumentNullException("packet");
}
using MemoryStream memoryStream = new MemoryStream();
using BinaryWriter binaryWriter = new BinaryWriter(memoryStream, Utf8);
binaryWriter.Write(1396918356u);
binaryWriter.Write((ushort)1);
binaryWriter.Write((byte)packet.Kind);
switch (packet.Kind)
{
case ChatPacketKind.Hello:
binaryWriter.Write(packet.ModVersion);
break;
case ChatPacketKind.Welcome:
binaryWriter.Write(packet.Sequence);
break;
case ChatPacketKind.Submit:
binaryWriter.Write(packet.Text);
break;
case ChatPacketKind.Chat:
binaryWriter.Write(packet.Sequence);
binaryWriter.Write(packet.PeerId);
binaryWriter.Write(packet.DisplayName);
binaryWriter.Write(packet.Text);
break;
case ChatPacketKind.Presence:
binaryWriter.Write(packet.Sequence);
binaryWriter.Write(packet.Joined);
binaryWriter.Write(packet.PeerId);
binaryWriter.Write(packet.DisplayName);
break;
case ChatPacketKind.Error:
binaryWriter.Write((byte)packet.ErrorCode);
break;
default:
throw new InvalidDataException("Unknown chat packet kind: " + packet.Kind);
}
binaryWriter.Flush();
byte[] array = memoryStream.ToArray();
if (array.Length > 4096)
{
throw new InvalidDataException("Chat packet exceeds the size limit.");
}
return array;
}
public static bool TryDecode(byte[] payload, out ChatPacket? packet, out ChatDecodeError error)
{
packet = null;
error = ChatDecodeError.Malformed;
if (payload == null || payload.Length < 7 || payload.Length > 4096)
{
return false;
}
try
{
using MemoryStream memoryStream = new MemoryStream(payload, writable: false);
using BinaryReader binaryReader = new BinaryReader(memoryStream, Utf8);
if (binaryReader.ReadUInt32() != 1396918356)
{
return false;
}
if (binaryReader.ReadUInt16() != 1)
{
error = ChatDecodeError.UnsupportedVersion;
return false;
}
ChatPacketKind chatPacketKind = (ChatPacketKind)binaryReader.ReadByte();
string modVersion = "";
ulong sequence = 0uL;
string peerId = "";
string displayName = "";
string text = "";
bool joined = false;
ChatErrorCode errorCode = ChatErrorCode.None;
switch (chatPacketKind)
{
case ChatPacketKind.Hello:
modVersion = ReadLimitedString(binaryReader, 64);
break;
case ChatPacketKind.Welcome:
sequence = binaryReader.ReadUInt64();
break;
case ChatPacketKind.Submit:
text = ReadLimitedString(binaryReader, 2048);
break;
case ChatPacketKind.Chat:
sequence = binaryReader.ReadUInt64();
peerId = ReadLimitedString(binaryReader, 128);
displayName = ReadLimitedString(binaryReader, 256);
text = ReadLimitedString(binaryReader, 2048);
break;
case ChatPacketKind.Presence:
sequence = binaryReader.ReadUInt64();
joined = binaryReader.ReadBoolean();
peerId = ReadLimitedString(binaryReader, 128);
displayName = ReadLimitedString(binaryReader, 256);
break;
case ChatPacketKind.Error:
errorCode = (ChatErrorCode)binaryReader.ReadByte();
break;
default:
return false;
}
if (memoryStream.Position != memoryStream.Length)
{
return false;
}
packet = ChatPacket.FromWire(chatPacketKind, modVersion, sequence, peerId, displayName, text, joined, errorCode);
error = ChatDecodeError.None;
return true;
}
catch (Exception)
{
packet = null;
error = ChatDecodeError.Malformed;
return false;
}
}
private static string ReadLimitedString(BinaryReader reader, int maxCharacters)
{
string text = reader.ReadString();
if (text.Length > maxCharacters)
{
throw new InvalidDataException("String exceeds the chat protocol limit.");
}
return text;
}
}
internal static class ChatTextPolicy
{
public const int MaxCharacters = 256;
public const int MaxUtf8Bytes = 1024;
private static readonly Encoding StrictUtf8 = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false, throwOnInvalidBytes: true);
public static ChatErrorCode Validate(string? input, out string normalized)
{
normalized = (input ?? "").Trim();
if (normalized.Length == 0)
{
return ChatErrorCode.Empty;
}
if (normalized.Length > 256)
{
return ChatErrorCode.TooLong;
}
try
{
if (StrictUtf8.GetByteCount(normalized) > 1024)
{
return ChatErrorCode.TooLong;
}
}
catch (EncoderFallbackException)
{
return ChatErrorCode.InvalidCharacters;
}
for (int i = 0; i < normalized.Length; i++)
{
char c = normalized[i];
UnicodeCategory unicodeCategory = char.GetUnicodeCategory(c);
if (char.IsControl(c) || unicodeCategory == UnicodeCategory.LineSeparator || unicodeCategory == UnicodeCategory.ParagraphSeparator)
{
return ChatErrorCode.InvalidCharacters;
}
}
return ChatErrorCode.None;
}
public static string CleanDisplayName(string? value, string peerId)
{
string text = (string.IsNullOrWhiteSpace(value) ? peerId : value);
StringBuilder stringBuilder = new StringBuilder(Math.Min(text.Length, 48));
for (int i = 0; i < text.Length; i++)
{
if (stringBuilder.Length >= 48)
{
break;
}
char c = text[i];
UnicodeCategory unicodeCategory = char.GetUnicodeCategory(c);
if (char.IsControl(c) || unicodeCategory == UnicodeCategory.LineSeparator || unicodeCategory == UnicodeCategory.ParagraphSeparator)
{
stringBuilder.Append(' ');
}
else
{
stringBuilder.Append(c);
}
}
string text2 = stringBuilder.ToString().Trim();
if (text2.Length != 0)
{
return text2;
}
if (!string.IsNullOrWhiteSpace(peerId))
{
return peerId;
}
return "Unknown";
}
}
internal sealed class TogetherNameResolver
{
private readonly ManualLogSource log;
private readonly PropertyInfo? serviceProperty;
private Type? cachedServiceType;
private PropertyInfo? snapshotProperty;
private Type? cachedPeerType;
private PropertyInfo? peerIdProperty;
private PropertyInfo? playerNameProperty;
private PropertyInfo? isConnectedProperty;
private bool warned;
public TogetherNameResolver(ManualLogSource log)
{
this.log = log;
serviceProperty = typeof(NetSessionInfo).Assembly.GetType("SULFURTogether.Networking.CoopConnection", throwOnError: false)?.GetProperty("Service", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
}
public Dictionary<string, string> GetConnectedNames()
{
Dictionary<string, string> dictionary = new Dictionary<string, string>(StringComparer.Ordinal);
try
{
object obj = serviceProperty?.GetValue(null, null);
if (obj == null)
{
return dictionary;
}
PrepareServiceMetadata(obj.GetType());
if (!(snapshotProperty?.GetValue(obj, null) is IEnumerable enumerable))
{
return dictionary;
}
foreach (object item in enumerable)
{
if (item == null)
{
continue;
}
PreparePeerMetadata(item.GetType());
object obj2 = isConnectedProperty?.GetValue(item, null);
if (obj2 is bool && (bool)obj2)
{
string text = (peerIdProperty?.GetValue(item, null) as string) ?? "";
if (text.Length != 0)
{
string value = playerNameProperty?.GetValue(item, null) as string;
dictionary[text] = ChatTextPolicy.CleanDisplayName(value, text);
}
}
}
warned = false;
}
catch (Exception ex)
{
if (!warned)
{
warned = true;
log.LogWarning((object)("Could not read SULFUR Together player names; peer ids will be shown instead. " + ex.GetType().Name + ": " + ex.Message));
}
}
return dictionary;
}
public string Resolve(string peerId)
{
if (!GetConnectedNames().TryGetValue(peerId, out string value))
{
return ChatTextPolicy.CleanDisplayName(null, peerId);
}
return value;
}
private void PrepareServiceMetadata(Type serviceType)
{
if (!(cachedServiceType == serviceType))
{
cachedServiceType = serviceType;
snapshotProperty = serviceType.GetProperty("SessionSnapshot", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
if (snapshotProperty == null)
{
throw new MissingMemberException(serviceType.FullName, "SessionSnapshot");
}
}
}
private void PreparePeerMetadata(Type peerType)
{
if (!(cachedPeerType == peerType))
{
cachedPeerType = peerType;
peerIdProperty = peerType.GetProperty("PeerId", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
playerNameProperty = peerType.GetProperty("PlayerName", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
isConnectedProperty = peerType.GetProperty("IsConnected", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
if (peerIdProperty == null || playerNameProperty == null || isConnectedProperty == null)
{
throw new MissingMemberException(peerType.FullName, "PeerId/PlayerName/IsConnected");
}
}
}
}
}
namespace de.nemophila.sulfur.simplechat.Localization
{
internal static class Loc
{
public static int LanguageVersion => SulfurLocalization.LanguageVersion;
public static void Initialize(string assemblyLocation)
{
SulfurLocalization.LoadPluginLocalization("de.nemophila.sulfur.simplechat", assemblyLocation);
SulfurLocalization.RefreshCurrentLanguage(true);
}
public static string Get(string key, string fallback)
{
return SulfurLocalization.Get("de.nemophila.sulfur.simplechat", key, fallback);
}
public static string Format(string key, string fallback, params object[] args)
{
string format = Get(key, fallback);
try
{
return string.Format(format, args);
}
catch (FormatException)
{
return string.Format(fallback, args);
}
}
}
}
namespace de.nemophila.sulfur.simplechat.Api
{
public static class SimpleChatApi
{
public const int ApiVersion = 1;
private static Func<string, bool>? addSystemMessage;
public static bool TryAddSystemMessage(string message)
{
if (ChatTextPolicy.Validate(message, out string normalized) != ChatErrorCode.None)
{
return false;
}
return addSystemMessage?.Invoke(normalized) ?? false;
}
internal static void Bind(Func<string, bool> handler)
{
addSystemMessage = handler;
}
internal static void Unbind()
{
addSystemMessage = null;
}
}
}
