using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using TMPro;
using UnityEngine;
using UnityEngine.SceneManagement;
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: AssemblyCompany("AtlyssChatBubbleFix")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("AtlyssChatBubbleFix")]
[assembly: AssemblyTitle("AtlyssChatBubbleFix")]
[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 AtlyssChatBubbleFix
{
internal enum BubbleAnchorMode
{
AutoHybrid,
HeadBoneOnly,
MeshBoundsOnly,
ControllerOnly
}
internal enum BubbleAnchorPath
{
None,
HeadBone,
MeshBounds,
Controller
}
internal static class BubbleAnchorResolver
{
internal static bool TryResolve(ChatBubbleState state, ChatBubbleConfig config, out Vector3 anchor, out BubbleAnchorPath path)
{
//IL_0001: 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_005e: Unknown result type (might be due to invalid IL or missing references)
//IL_0074: 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)
//IL_0093: Unknown result type (might be due to invalid IL or missing references)
//IL_009d: Unknown result type (might be due to invalid IL or missing references)
//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
anchor = default(Vector3);
path = BubbleAnchorPath.None;
BubbleAnchorMode value = config.AnchorMode.Value;
bool num = value == BubbleAnchorMode.AutoHybrid || value == BubbleAnchorMode.HeadBoneOnly;
bool flag = value == BubbleAnchorMode.AutoHybrid || value == BubbleAnchorMode.MeshBoundsOnly;
Bounds bounds = default(Bounds);
bool flag2 = (flag || value == BubbleAnchorMode.AutoHybrid || value == BubbleAnchorMode.HeadBoneOnly) && PlayerRendererCache.TryGetBounds(state.Player, state.Renderers, out bounds);
if (num && TryResolveHead(state.Player, config, flag2, bounds, out anchor))
{
path = BubbleAnchorPath.HeadBone;
return true;
}
if (flag && flag2)
{
anchor = new Vector3(((Bounds)(ref bounds)).center.x, ((Bounds)(ref bounds)).max.y + BoundsPadding(config), ((Bounds)(ref bounds)).center.z);
path = BubbleAnchorPath.MeshBounds;
return true;
}
if (TryResolveController(state.Player, config, out anchor))
{
path = BubbleAnchorPath.Controller;
return true;
}
return false;
}
private static bool TryResolveHead(Player player, ChatBubbleConfig config, bool hasBounds, Bounds bounds, out Vector3 anchor)
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0051: 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_005e: Unknown result type (might be due to invalid IL or missing references)
//IL_006a: 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_0080: 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)
anchor = default(Vector3);
if ((Object)(object)player == (Object)null)
{
return false;
}
Transform val = null;
try
{
PlayerVisual pVisual = player._pVisual;
if ((Object)(object)pVisual != (Object)null && (Object)(object)pVisual._playerRaceModel != (Object)null)
{
val = pVisual._playerRaceModel._headBoneTransform;
}
}
catch
{
}
if ((Object)(object)val == (Object)null)
{
return false;
}
Vector3 position;
try
{
position = val.position;
}
catch
{
return false;
}
if (!IsUsable(position))
{
return false;
}
anchor = position + Vector3.up * HeadPadding(config);
if (hasBounds)
{
float num = ((Bounds)(ref bounds)).max.y + BoundsPadding(config);
if (anchor.y < num)
{
anchor.y = num;
}
}
return true;
}
private static bool TryResolveController(Player player, ChatBubbleConfig config, out Vector3 anchor)
{
//IL_0001: 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)
//IL_0084: 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_0095: Unknown result type (might be due to invalid IL or missing references)
//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
//IL_00aa: 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_00c3: Unknown result type (might be due to invalid IL or missing references)
//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
//IL_00ce: 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_0071: 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)
anchor = default(Vector3);
if ((Object)(object)player == (Object)null)
{
return false;
}
CharacterController val = null;
try
{
PlayerMove pMove = player._pMove;
if ((Object)(object)pMove != (Object)null)
{
val = pMove._playerController;
}
}
catch
{
}
if ((Object)(object)val == (Object)null)
{
try
{
val = ((Component)player).GetComponent<CharacterController>();
}
catch
{
return false;
}
}
if ((Object)(object)val == (Object)null)
{
return false;
}
Transform transform;
try
{
transform = ((Component)val).transform;
}
catch
{
return false;
}
Vector3 val2;
try
{
val2 = transform.TransformPoint(val.center);
}
catch
{
val2 = transform.position;
}
Vector3 lossyScale = transform.lossyScale;
float num = val.height * Mathf.Max(0.01f, Mathf.Abs(lossyScale.y));
anchor = val2 + Vector3.up * (num * 0.5f + ControllerPadding(config));
return IsUsable(anchor);
}
private static float HeadPadding(ChatBubbleConfig config)
{
return ClampHeight(config.HeadPaddingMeters.Value);
}
private static float BoundsPadding(ChatBubbleConfig config)
{
return ClampHeight(config.BoundsPaddingMeters.Value);
}
private static float ControllerPadding(ChatBubbleConfig config)
{
return ClampHeight(config.ControllerFallbackPaddingMeters.Value);
}
private static float ClampHeight(float value)
{
return Mathf.Clamp(value, 0.25f, 12f);
}
private static bool IsUsable(Vector3 value)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
if (IsUsable(value.x) && IsUsable(value.y))
{
return IsUsable(value.z);
}
return false;
}
private static bool IsUsable(float value)
{
if (!float.IsNaN(value))
{
return !float.IsInfinity(value);
}
return false;
}
}
internal static class ChatBehaviourPatches
{
[HarmonyPatch(typeof(ChatBehaviour), "Awake")]
[HarmonyPostfix]
private static void AfterAwake(ChatBehaviour __instance)
{
try
{
ChatBubblePlugin.Registry?.Add(__instance);
}
catch (Exception ex)
{
ChatBubblePlugin.Log.LogWarning((object)("[Patch] ChatBehaviour.Awake failed: " + ex.Message));
}
}
[HarmonyPatch(typeof(ChatBehaviour), "Update")]
[HarmonyPostfix]
private static void AfterUpdate(ChatBehaviour __instance)
{
try
{
ChatBubblePlugin.Registry?.Add(__instance);
}
catch
{
}
}
[HarmonyPatch(typeof(ChatBehaviour), "OnDestroy")]
[HarmonyPostfix]
private static void AfterDestroy(ChatBehaviour __instance)
{
try
{
ChatBubblePlugin.Registry?.Remove(__instance);
}
catch
{
}
}
}
internal static class ChatBubbleAccess
{
private static readonly FieldInfo? BubbleObjectField = AccessTools.Field(typeof(ChatBehaviour), "_chatBubbleObject");
private static readonly FieldInfo? PlayerField = AccessTools.Field(typeof(ChatBehaviour), "_player");
private static readonly FieldInfo? MaxOnscreenField = AccessTools.Field(typeof(ChatBehaviour), "maxOnscreenMessages") ?? AccessTools.Field(typeof(ChatBehaviour), "_maxOnscreenMessages");
internal static GameObject? GetBubbleObject(ChatBehaviour chat)
{
if ((Object)(object)chat == (Object)null || BubbleObjectField == null)
{
return null;
}
try
{
object? value = BubbleObjectField.GetValue(chat);
return (GameObject?)((value is GameObject) ? value : null);
}
catch
{
return null;
}
}
internal static Player? GetPlayer(ChatBehaviour chat)
{
if ((Object)(object)chat == (Object)null)
{
return null;
}
try
{
object? obj = PlayerField?.GetValue(chat);
Player val = (Player)((obj is Player) ? obj : null);
if ((Object)(object)val != (Object)null)
{
return val;
}
}
catch
{
}
try
{
return ((Component)chat).GetComponent<Player>();
}
catch
{
return null;
}
}
internal static void SendLocalMessage(ChatBehaviour chat, string message)
{
if ((Object)(object)chat == (Object)null)
{
return;
}
try
{
try
{
MaxOnscreenField?.SetValue(chat, 50);
}
catch
{
}
chat.Init_GameLogicMessage(message);
}
catch (Exception ex)
{
ChatBubblePlugin.Log.LogWarning((object)("[Commands] Failed to print local message: " + ex.Message));
}
}
internal static void CloseChat(ChatBehaviour chat)
{
if ((Object)(object)chat == (Object)null)
{
return;
}
try
{
string[] obj = new string[5] { "Init_ChatFocusFalse", "Set_ChatFocusFalse", "Close_Chat", "Deactivate_Chat", "Exit_Chat" };
Type type = ((object)chat).GetType();
string[] array = obj;
foreach (string text in array)
{
MethodInfo methodInfo = AccessTools.Method(type, text, (Type[])null, (Type[])null);
if (!(methodInfo == null))
{
methodInfo.Invoke(chat, null);
return;
}
}
AccessTools.Field(type, "_focusedInChat")?.SetValue(chat, false);
}
catch
{
}
}
}
[HarmonyPatch(typeof(ChatBehaviour), "Send_ChatMessage")]
internal static class ChatBubbleCommands
{
private static readonly string[] Prefixes = new string[4] { "/bubblefix", "/chatbubble", "/cbfix", "/bubble" };
[HarmonyPrefix]
private static bool Prefix(ChatBehaviour __instance, string _message)
{
try
{
if (string.IsNullOrWhiteSpace(_message))
{
return true;
}
string text = _message.Trim();
string text2 = null;
string[] prefixes = Prefixes;
foreach (string text3 in prefixes)
{
if (text.StartsWith(text3, StringComparison.OrdinalIgnoreCase) && (text.Length == text3.Length || char.IsWhiteSpace(text[text3.Length])))
{
text2 = text3;
break;
}
}
if (text2 == null)
{
return true;
}
string text4 = text.Substring(text2.Length).Trim();
Handle(__instance, string.IsNullOrEmpty(text4) ? "status" : text4);
ChatBubbleAccess.CloseChat(__instance);
return false;
}
catch (Exception ex)
{
ChatBubblePlugin.Log.LogWarning((object)("[Commands] Command failed: " + ex.Message));
return false;
}
}
private static void Handle(ChatBehaviour chat, string args)
{
string[] array = args.Split(new char[2] { ' ', '\t' }, 2, StringSplitOptions.RemoveEmptyEntries);
string text = ((array.Length == 0) ? "status" : array[0].ToLowerInvariant());
string rest = ((array.Length > 1) ? array[1].Trim() : string.Empty);
switch (text)
{
case "enable":
case "on":
ChatBubblePlugin.ModConfig.Enabled.Value = true;
((BaseUnityPlugin)ChatBubblePlugin.Instance).Config.Save();
Reply(chat, "enabled.");
break;
case "off":
case "disable":
ChatBubblePlugin.ModConfig.Enabled.Value = false;
((BaseUnityPlugin)ChatBubblePlugin.Instance).Config.Save();
Reply(chat, "disabled.");
break;
case "toggle":
ChatBubblePlugin.ModConfig.Enabled.Value = !ChatBubblePlugin.ModConfig.Enabled.Value;
((BaseUnityPlugin)ChatBubblePlugin.Instance).Config.Save();
Reply(chat, ChatBubblePlugin.ModConfig.Enabled.Value ? "enabled." : "disabled.");
break;
case "mode":
HandleMode(chat, rest);
break;
case "accessories":
case "accessory":
HandleAccessories(chat, rest);
break;
case "offset":
case "height":
case "gap":
case "clearance":
HandleGap(chat, rest);
break;
case "bubble-size":
case "bubblesize":
case "scale":
case "bubble-scale":
HandleScale(chat, rest, "bubble-size", ChatBubblePlugin.ModConfig.BubbleScale);
break;
case "icon-size":
case "icon-scale":
case "iconsize":
HandleScale(chat, rest, "icon-size", ChatBubblePlugin.ModConfig.IconScale);
break;
case "inspect":
Reply(chat, ChatBubblePlugin.Registry.DescribeVisuals());
break;
case "debug":
ChatBubblePlugin.ModConfig.DebugLogging.Value = !ChatBubblePlugin.ModConfig.DebugLogging.Value;
((BaseUnityPlugin)ChatBubblePlugin.Instance).Config.Save();
Reply(chat, ChatBubblePlugin.ModConfig.DebugLogging.Value ? "debug logging enabled." : "debug logging disabled.");
break;
case "status":
Reply(chat, ChatBubblePlugin.Registry.Describe());
break;
case "help":
case "?":
Reply(chat, "commands: /bubblefix on|off|toggle|status|inspect|debug, /bubblefix mode auto|head|bounds|controller, /bubblefix accessories on|off, /bubblefix height 4.6, /bubblefix bubble-size 1.0, /bubblefix icon-size 1.0.");
break;
default:
Reply(chat, "unknown command. Use /bubblefix help.");
break;
}
}
private static void HandleMode(ChatBehaviour chat, string rest)
{
if (string.IsNullOrWhiteSpace(rest))
{
Reply(chat, $"mode={ChatBubblePlugin.ModConfig.AnchorMode.Value}.");
return;
}
BubbleAnchorMode bubbleAnchorMode;
switch (rest.Trim().ToLowerInvariant())
{
case "auto":
case "hybrid":
case "autohybrid":
bubbleAnchorMode = BubbleAnchorMode.AutoHybrid;
break;
case "head":
case "bone":
case "headbone":
bubbleAnchorMode = BubbleAnchorMode.HeadBoneOnly;
break;
case "mesh":
case "bounds":
case "meshbounds":
bubbleAnchorMode = BubbleAnchorMode.MeshBoundsOnly;
break;
case "hitbox":
case "controller":
case "vanilla":
bubbleAnchorMode = BubbleAnchorMode.ControllerOnly;
break;
default:
Reply(chat, "usage: /bubblefix mode auto|head|bounds|controller.");
return;
}
ChatBubblePlugin.ModConfig.AnchorMode.Value = bubbleAnchorMode;
((BaseUnityPlugin)ChatBubblePlugin.Instance).Config.Save();
Reply(chat, $"mode set to {bubbleAnchorMode}.");
}
private static void HandleAccessories(ChatBehaviour chat, string rest)
{
if (string.IsNullOrWhiteSpace(rest))
{
Reply(chat, "accessories=" + (ChatBubblePlugin.ModConfig.IncludeAccessoriesInBounds.Value ? "on" : "off") + ".");
return;
}
bool flag;
switch (rest.Trim().ToLowerInvariant())
{
case "on":
case "true":
case "include":
flag = true;
break;
case "off":
case "false":
case "exclude":
flag = false;
break;
default:
Reply(chat, "usage: /bubblefix accessories on|off.");
return;
}
ChatBubblePlugin.ModConfig.IncludeAccessoriesInBounds.Value = flag;
ChatBubblePlugin.Registry.Clear();
((BaseUnityPlugin)ChatBubblePlugin.Instance).Config.Save();
Reply(chat, flag ? "accessory bounds enabled." : "accessory bounds disabled.");
}
private static void HandleGap(ChatBehaviour chat, string rest)
{
ChatBubbleConfig modConfig = ChatBubblePlugin.ModConfig;
if (string.IsNullOrWhiteSpace(rest))
{
Reply(chat, $"height head={modConfig.HeadPaddingMeters.Value:0.00}, bounds={modConfig.BoundsPaddingMeters.Value:0.00}, controller={modConfig.ControllerFallbackPaddingMeters.Value:0.00}.");
return;
}
if (!float.TryParse(rest.Trim(), NumberStyles.Float, CultureInfo.InvariantCulture, out var result))
{
Reply(chat, "usage: /bubblefix height 4.6");
return;
}
float value = Clamp(result, 0.25f, 12f);
modConfig.HeadPaddingMeters.Value = value;
modConfig.BoundsPaddingMeters.Value = value;
modConfig.ControllerFallbackPaddingMeters.Value = value;
((BaseUnityPlugin)ChatBubblePlugin.Instance).Config.Save();
Reply(chat, $"height set: head={modConfig.HeadPaddingMeters.Value:0.00}, bounds={modConfig.BoundsPaddingMeters.Value:0.00}, controller={modConfig.ControllerFallbackPaddingMeters.Value:0.00}.");
}
private static void HandleScale(ChatBehaviour chat, string rest, string label, ConfigEntry<float> entry)
{
if (string.IsNullOrWhiteSpace(rest))
{
Reply(chat, $"{label}={entry.Value:0.00}.");
return;
}
if (!float.TryParse(rest.Trim(), NumberStyles.Float, CultureInfo.InvariantCulture, out var result))
{
Reply(chat, "usage: /bubblefix " + label + " 1.0");
return;
}
float value = Clamp(result, 0.25f, 3f);
entry.Value = value;
((BaseUnityPlugin)ChatBubblePlugin.Instance).Config.Save();
Reply(chat, $"{label} set to {entry.Value:0.00}.");
}
private static void Reply(ChatBehaviour chat, string text)
{
ChatBubbleAccess.SendLocalMessage(chat, "<color=#80C8FF>[BubbleFix]</color> " + text);
}
private static float Clamp(float value, float min, float max)
{
if (value < min)
{
return min;
}
if (value > max)
{
return max;
}
return value;
}
}
internal sealed class ChatBubbleConfig
{
internal const int CurrentSpacingMigrationVersion = 2;
internal const float DefaultHeadPaddingMeters = 4.6f;
internal const float DefaultBoundsPaddingMeters = 3.8f;
internal const float DefaultControllerFallbackPaddingMeters = 5.4f;
internal const float HeightMinMeters = 0.25f;
internal const float HeightMaxMeters = 12f;
internal const float DefaultBubbleScale = 1f;
internal const float DefaultIconScale = 1f;
internal const float ScaleMin = 0.25f;
internal const float ScaleMax = 3f;
internal ConfigEntry<bool> Enabled { get; private set; }
internal ConfigEntry<BubbleAnchorMode> AnchorMode { get; private set; }
internal ConfigEntry<int> SpacingMigrationVersion { get; private set; }
internal ConfigEntry<float> HeadPaddingMeters { get; private set; }
internal ConfigEntry<float> BoundsPaddingMeters { get; private set; }
internal ConfigEntry<float> ControllerFallbackPaddingMeters { get; private set; }
internal ConfigEntry<bool> IncludeAccessoriesInBounds { get; private set; }
internal ConfigEntry<float> BubbleScale { get; private set; }
internal ConfigEntry<float> IconScale { get; private set; }
internal ConfigEntry<bool> ForceUpdateWhenOffscreen { get; private set; }
internal ConfigEntry<float> RendererRecacheSeconds { get; private set; }
internal ConfigEntry<float> SafetyScanSeconds { get; private set; }
internal ConfigEntry<float> SmoothingSeconds { get; private set; }
internal ConfigEntry<float> TeleportSnapDistance { get; private set; }
internal ConfigEntry<bool> DebugLogging { get; private set; }
internal static ChatBubbleConfig Bind(ConfigFile file)
{
//IL_0083: Unknown result type (might be due to invalid IL or missing references)
//IL_008d: Expected O, but got Unknown
//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
//IL_00c6: Expected O, but got Unknown
//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
//IL_00ff: Expected O, but got Unknown
//IL_014a: Unknown result type (might be due to invalid IL or missing references)
//IL_0154: Expected O, but got Unknown
//IL_0183: Unknown result type (might be due to invalid IL or missing references)
//IL_018d: Expected O, but got Unknown
//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
//IL_01e2: Expected O, but got Unknown
//IL_0211: Unknown result type (might be due to invalid IL or missing references)
//IL_021b: Expected O, but got Unknown
//IL_024a: Unknown result type (might be due to invalid IL or missing references)
//IL_0254: Expected O, but got Unknown
//IL_0283: Unknown result type (might be due to invalid IL or missing references)
//IL_028d: Expected O, but got Unknown
ChatBubbleConfig obj = new ChatBubbleConfig
{
Enabled = file.Bind<bool>("General", "Enabled", true, "Master switch for local chat bubble position correction."),
AnchorMode = file.Bind<BubbleAnchorMode>("Anchor", "AnchorMode", BubbleAnchorMode.AutoHybrid, "Anchor resolver mode: AutoHybrid, HeadBoneOnly, MeshBoundsOnly, or ControllerOnly."),
SpacingMigrationVersion = file.Bind<int>("Anchor", "SpacingMigrationVersion", 0, "Internal marker for one-time spacing default migrations."),
HeadPaddingMeters = file.Bind<float>("Anchor", "HeadPaddingMeters", 4.6f, new ConfigDescription("World-space clearance above the resolved head bone.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.25f, 12f), Array.Empty<object>())),
BoundsPaddingMeters = file.Bind<float>("Anchor", "BoundsPaddingMeters", 3.8f, new ConfigDescription("World-space clearance above renderer bounds.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.25f, 12f), Array.Empty<object>())),
ControllerFallbackPaddingMeters = file.Bind<float>("Anchor", "ControllerFallbackPaddingMeters", 5.4f, new ConfigDescription("World-space clearance above the CharacterController fallback.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.25f, 12f), Array.Empty<object>())),
IncludeAccessoriesInBounds = file.Bind<bool>("Visuals", "IncludeAccessoriesInBounds", false, "If true, hair, ears, horns, tails, wings, hats, and similar skinned accessories are included in bounds fallback."),
BubbleScale = file.Bind<float>("Visuals", "BubbleScale", 1f, new ConfigDescription("Local scale multiplier for the whole overhead chat bubble object.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.25f, 3f), Array.Empty<object>())),
IconScale = file.Bind<float>("Visuals", "IconScale", 1f, new ConfigDescription("Local scale multiplier for separate non-text icon renderers under the overhead chat bubble.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.25f, 3f), Array.Empty<object>())),
ForceUpdateWhenOffscreen = file.Bind<bool>("Visuals", "ForceUpdateWhenOffscreen", true, "If true, cached SkinnedMeshRenderers keep updating bounds while culled/offscreen."),
RendererRecacheSeconds = file.Bind<float>("Runtime", "RendererRecacheSeconds", 2f, new ConfigDescription("How often to refresh each player's cached SkinnedMeshRenderer list.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.25f, 10f), Array.Empty<object>())),
SafetyScanSeconds = file.Bind<float>("Runtime", "SafetyScanSeconds", 0.5f, new ConfigDescription("How often to scan for missed ChatBehaviour instances.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.1f, 5f), Array.Empty<object>())),
SmoothingSeconds = file.Bind<float>("Runtime", "SmoothingSeconds", 0.05f, new ConfigDescription("SmoothDamp time for visible bubble movement. Set 0 to snap instantly.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 0.5f), Array.Empty<object>())),
TeleportSnapDistance = file.Bind<float>("Runtime", "TeleportSnapDistance", 1f, new ConfigDescription("If the corrected target moves this far in one frame, snap instead of smoothing.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 10f), Array.Empty<object>())),
DebugLogging = file.Bind<bool>("Debug", "DebugLogging", false, "Write verbose resolver diagnostics to the BepInEx log.")
};
if (ApplySpacingMigration(obj))
{
file.Save();
}
return obj;
}
private static bool ApplySpacingMigration(ChatBubbleConfig config)
{
if (config.SpacingMigrationVersion.Value >= 2)
{
return false;
}
_ = RaiseToDefault(config.HeadPaddingMeters, 4.6f) | RaiseToDefault(config.BoundsPaddingMeters, 3.8f);
RaiseToDefault(config.ControllerFallbackPaddingMeters, 5.4f);
config.SpacingMigrationVersion.Value = 2;
return true;
}
private static bool RaiseToDefault(ConfigEntry<float> entry, float defaultValue)
{
if (entry.Value >= defaultValue)
{
return false;
}
entry.Value = defaultValue;
return true;
}
}
[BepInPlugin("dev.seth.atlysschatbubblefix", "ATLYSS Chat Bubble Fix", "1.0.0")]
public sealed class ChatBubblePlugin : BaseUnityPlugin
{
public const string PluginGuid = "dev.seth.atlysschatbubblefix";
public const string PluginName = "ATLYSS Chat Bubble Fix";
public const string PluginVersion = "1.0.0";
private Harmony? _harmony;
private ChatBubbleRuntime? _runtime;
internal static ChatBubblePlugin Instance { get; private set; }
internal static ManualLogSource Log { get; private set; }
internal static ChatBubbleConfig ModConfig { get; private set; }
internal static ChatBubbleRegistry Registry { get; private set; }
private void Awake()
{
//IL_0035: Unknown result type (might be due to invalid IL or missing references)
//IL_003b: Expected O, but got Unknown
//IL_006b: Unknown result type (might be due to invalid IL or missing references)
//IL_0075: Expected O, but got Unknown
Instance = this;
Log = ((BaseUnityPlugin)this).Logger;
ModConfig = ChatBubbleConfig.Bind(((BaseUnityPlugin)this).Config);
Registry = new ChatBubbleRegistry(ModConfig);
GameObject val = new GameObject("AtlyssChatBubbleFix_Runtime");
Object.DontDestroyOnLoad((Object)(object)val);
((Object)val).hideFlags = (HideFlags)61;
_runtime = val.AddComponent<ChatBubbleRuntime>();
_runtime.Initialize(Registry);
_harmony = new Harmony("dev.seth.atlysschatbubblefix");
_harmony.PatchAll(typeof(ChatBehaviourPatches));
_harmony.PatchAll(typeof(PlayerVisualPatches));
_harmony.PatchAll(typeof(ChatBubbleCommands));
VerifyHarmonyPatch("ChatBehaviour.Awake", AccessTools.Method(typeof(ChatBehaviour), "Awake", (Type[])null, (Type[])null));
VerifyHarmonyPatch("ChatBehaviour.Update", AccessTools.Method(typeof(ChatBehaviour), "Update", (Type[])null, (Type[])null));
VerifyHarmonyPatch("ChatBehaviour.Send_ChatMessage", AccessTools.Method(typeof(ChatBehaviour), "Send_ChatMessage", (Type[])null, (Type[])null));
VerifyHarmonyPatch("PlayerVisual.RenderPlayerModel", AccessTools.Method(typeof(PlayerVisual), "RenderPlayerModel", (Type[])null, (Type[])null));
Log.LogInfo((object)"ATLYSS Chat Bubble Fix 1.0.0 loaded. Pure client-side mode. Use /bubblefix status for diagnostics.");
}
private void OnDestroy()
{
try
{
Harmony? harmony = _harmony;
if (harmony != null)
{
harmony.UnpatchSelf();
}
Registry?.Clear();
if ((Object)(object)_runtime != (Object)null)
{
Object.Destroy((Object)(object)((Component)_runtime).gameObject);
_runtime = null;
}
}
catch
{
}
}
private static void VerifyHarmonyPatch(string label, MethodBase? target)
{
if (target == null)
{
Log.LogWarning((object)("[Patch] " + label + ": target missing."));
return;
}
Patches patchInfo = Harmony.GetPatchInfo(target);
if (HasOwnedPatch(patchInfo?.Prefixes) || HasOwnedPatch(patchInfo?.Postfixes) || HasOwnedPatch(patchInfo?.Finalizers) || HasOwnedPatch(patchInfo?.Transpilers))
{
Log.LogInfo((object)("[Patch] " + label + ": patched."));
}
else
{
Log.LogWarning((object)("[Patch] " + label + ": no dev.seth.atlysschatbubblefix patch found."));
}
}
private static bool HasOwnedPatch(IEnumerable<Patch>? patches)
{
if (patches == null)
{
return false;
}
foreach (Patch patch in patches)
{
if (patch.owner == "dev.seth.atlysschatbubblefix")
{
return true;
}
}
return false;
}
}
internal sealed class ChatBubbleRegistry
{
private readonly ChatBubbleConfig _config;
private readonly Dictionary<int, ChatBubbleState> _states = new Dictionary<int, ChatBubbleState>();
private float _nextScanTime;
private float _nextDebugSummaryTime;
private bool _loggedFirstRegistration;
private bool _loggedFirstCorrection;
private bool _loggedFirstScan;
private bool _loggedScanWithoutPlayers;
internal IReadOnlyCollection<ChatBubbleState> States => _states.Values;
internal ChatBubbleRegistry(ChatBubbleConfig config)
{
_config = config;
}
internal void Add(ChatBehaviour chat)
{
if ((Object)(object)chat == (Object)null)
{
return;
}
int instanceID = ((Object)chat).GetInstanceID();
if (_states.ContainsKey(instanceID))
{
return;
}
Player player = ChatBubbleAccess.GetPlayer(chat);
if (!((Object)(object)player == (Object)null))
{
ChatBubbleState chatBubbleState = new ChatBubbleState(chat, player);
RecacheRenderers(chatBubbleState);
_states[instanceID] = chatBubbleState;
if (_config.DebugLogging.Value)
{
ChatBubblePlugin.Log.LogInfo((object)$"[Registry] Add {chatBubbleState.DisplayName}, renderers={chatBubbleState.Renderers.Length}");
}
if (!_loggedFirstRegistration)
{
_loggedFirstRegistration = true;
ChatBubblePlugin.Log.LogInfo((object)$"[Runtime] Tracking chat bubbles. firstRenderers={chatBubbleState.Renderers.Length}, mode={_config.AnchorMode.Value}");
}
}
}
internal void Remove(ChatBehaviour chat)
{
if ((Object)(object)chat == (Object)null)
{
return;
}
int instanceID = ((Object)chat).GetInstanceID();
if (_states.TryGetValue(instanceID, out ChatBubbleState value))
{
RestoreVisualScale(value);
_states.Remove(instanceID);
if (_config.DebugLogging.Value)
{
ChatBubblePlugin.Log.LogInfo((object)$"[Registry] Remove {instanceID}");
}
}
}
internal void MarkVisualDirty(PlayerVisual visual)
{
if ((Object)(object)visual == (Object)null)
{
return;
}
foreach (ChatBubbleState value in _states.Values)
{
try
{
if ((Object)(object)value.Player != (Object)null && (Object)(object)value.Player._pVisual == (Object)(object)visual)
{
value.RendererCacheDirty = true;
}
}
catch
{
}
}
}
internal void Tick()
{
if (Time.time >= _nextScanTime)
{
_nextScanTime = Time.time + Mathf.Max(0.1f, _config.SafetyScanSeconds.Value);
SafetyScan();
}
int num = 0;
List<int> list = null;
foreach (KeyValuePair<int, ChatBubbleState> state in _states)
{
ChatBubbleState value = state.Value;
if ((Object)(object)value.Chat == (Object)null || (Object)(object)value.Player == (Object)null)
{
if (list == null)
{
list = new List<int>();
}
list.Add(state.Key);
continue;
}
if (value.RendererCacheDirty || Time.time >= value.NextRendererRecache || value.Renderers.Length == 0)
{
RecacheRenderers(value);
}
if (TryCorrect(value))
{
num++;
}
}
if (list != null)
{
foreach (int item in list)
{
_states.Remove(item);
}
}
if (_config.DebugLogging.Value && Time.time >= _nextDebugSummaryTime)
{
_nextDebugSummaryTime = Time.time + 3f;
ChatBubblePlugin.Log.LogInfo((object)$"[Runtime] tracked={_states.Count}, active={num}, enabled={_config.Enabled.Value}, mode={_config.AnchorMode.Value}");
}
}
internal string Describe()
{
int num = 0;
int num2 = 0;
Dictionary<BubbleAnchorPath, int> dictionary = new Dictionary<BubbleAnchorPath, int>();
foreach (ChatBubbleState value2 in _states.Values)
{
if (value2.LastWasActive)
{
num++;
}
num2 += value2.CorrectionsApplied;
dictionary.TryGetValue(value2.LastAnchorPath, out var value);
dictionary[value2.LastAnchorPath] = value + 1;
}
return $"enabled={_config.Enabled.Value}, mode={_config.AnchorMode.Value}, tracked={_states.Count}, active={num}, corrections={num2}, paths={FormatPaths(dictionary)}";
}
internal string DescribeVisuals()
{
int num = 0;
int num2 = 0;
int num3 = 0;
foreach (ChatBubbleState value in _states.Values)
{
if (value.LastWasActive)
{
num++;
}
if ((Object)(object)value.BubbleRoot != (Object)null)
{
num2++;
}
num3 += CountLiveTransforms(value.IconScaleTargets);
}
string text = ((num3 > 0) ? "yes" : "no");
return $"height head={_config.HeadPaddingMeters.Value:0.00}, bounds={_config.BoundsPaddingMeters.Value:0.00}, controller={_config.ControllerFallbackPaddingMeters.Value:0.00}; bubble-size={_config.BubbleScale.Value:0.00}, icon-size={_config.IconScale.Value:0.00}; tracked={_states.Count}, active={num}, bubbleRoots={num2}, iconTargets={num3}, separateIconTargets={text}.";
}
internal void Clear()
{
foreach (ChatBubbleState value in _states.Values)
{
RestoreVisualScale(value);
}
_states.Clear();
}
private void SafetyScan()
{
ChatBehaviour[] array;
try
{
array = Object.FindObjectsOfType<ChatBehaviour>();
}
catch
{
return;
}
int num = 0;
HashSet<int> hashSet = new HashSet<int>();
ChatBehaviour[] array2 = array;
foreach (ChatBehaviour val in array2)
{
if (!((Object)(object)val == (Object)null))
{
hashSet.Add(((Object)val).GetInstanceID());
if ((Object)(object)ChatBubbleAccess.GetPlayer(val) == (Object)null)
{
num++;
}
Add(val);
}
}
if (!_loggedFirstScan)
{
_loggedFirstScan = true;
ChatBubblePlugin.Log.LogInfo((object)$"[Runtime] Safety scan active. chatBehaviours={array.Length}, tracked={_states.Count}, missingPlayer={num}");
}
if (!_loggedScanWithoutPlayers && array.Length != 0 && _states.Count == 0 && num == array.Length)
{
_loggedScanWithoutPlayers = true;
ChatBubblePlugin.Log.LogInfo((object)$"[Runtime] ChatBehaviour objects found, but no Player owner was available yet. count={array.Length}");
}
List<int> list = null;
foreach (KeyValuePair<int, ChatBubbleState> state in _states)
{
if (!hashSet.Contains(state.Key) || (Object)(object)state.Value.Chat == (Object)null || (Object)(object)state.Value.Player == (Object)null)
{
if (list == null)
{
list = new List<int>();
}
list.Add(state.Key);
}
}
if (list == null)
{
return;
}
foreach (int item in list)
{
_states.Remove(item);
}
}
private void RecacheRenderers(ChatBubbleState state)
{
state.Renderers = PlayerRendererCache.Collect(state.Player, _config);
state.RendererCacheDirty = false;
state.NextRendererRecache = Time.time + Mathf.Max(0.25f, _config.RendererRecacheSeconds.Value);
}
private bool TryCorrect(ChatBubbleState state)
{
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
//IL_0029: Unknown result type (might be due to invalid IL or missing references)
//IL_0057: Unknown result type (might be due to invalid IL or missing references)
//IL_005c: 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_007f: Unknown result type (might be due to invalid IL or missing references)
//IL_00aa: 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_00b0: Unknown result type (might be due to invalid IL or missing references)
//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
GameObject bubbleObject = ChatBubbleAccess.GetBubbleObject(state.Chat);
if ((Object)(object)bubbleObject == (Object)null)
{
state.LastWasActive = false;
state.HasSmoothedWorldPosition = false;
state.SmoothVelocity = Vector3.zero;
return false;
}
if (!_config.Enabled.Value)
{
RestoreVisualScale(state);
state.LastWasActive = false;
state.HasSmoothedWorldPosition = false;
state.SmoothVelocity = Vector3.zero;
return false;
}
if (!bubbleObject.activeInHierarchy)
{
state.LastWasActive = false;
state.HasSmoothedWorldPosition = false;
state.SmoothVelocity = Vector3.zero;
return false;
}
if (!BubbleAnchorResolver.TryResolve(state, _config, out var anchor, out var path))
{
state.LastWasActive = true;
state.LastAnchorPath = BubbleAnchorPath.None;
return false;
}
Vector3 worldPosition = SmoothWorldPosition(state, anchor);
ApplyPosition(bubbleObject.transform, worldPosition);
ApplyVisualScale(state, bubbleObject);
state.LastWasActive = true;
state.LastAnchorPath = path;
state.CorrectionsApplied++;
if (!_loggedFirstCorrection)
{
_loggedFirstCorrection = true;
ChatBubblePlugin.Log.LogInfo((object)$"[Runtime] First chat bubble correction applied. path={path}, tracked={_states.Count}");
}
return true;
}
private Vector3 SmoothWorldPosition(ChatBubbleState state, Vector3 targetWorld)
{
//IL_0065: 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_0071: 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_007a: Unknown result type (might be due to invalid IL or missing references)
//IL_007f: Unknown result type (might be due to invalid IL or missing references)
//IL_0087: 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_004f: Unknown result type (might be due to invalid IL or missing references)
//IL_0054: Unknown result type (might be due to invalid IL or missing references)
float num = Mathf.Max(0f, _config.SmoothingSeconds.Value);
float num2 = Mathf.Max(0f, _config.TeleportSnapDistance.Value);
if (!state.HasSmoothedWorldPosition || num <= 0.0001f || (num2 > 0f && Vector3.Distance(state.SmoothedWorldPosition, targetWorld) >= num2))
{
state.HasSmoothedWorldPosition = true;
state.SmoothedWorldPosition = targetWorld;
state.SmoothVelocity = Vector3.zero;
return targetWorld;
}
state.SmoothedWorldPosition = Vector3.SmoothDamp(state.SmoothedWorldPosition, targetWorld, ref state.SmoothVelocity, num);
return state.SmoothedWorldPosition;
}
private static void ApplyPosition(Transform bubbleTransform, Vector3 worldPosition)
{
//IL_007d: 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_003d: Invalid comparison between Unknown and I4
//IL_0040: Unknown result type (might be due to invalid IL or missing references)
//IL_0046: Invalid comparison between Unknown and I4
//IL_0070: Unknown result type (might be due to invalid IL or missing references)
//IL_0071: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)bubbleTransform == (Object)null)
{
return;
}
RectTransform val = (RectTransform)(object)((bubbleTransform is RectTransform) ? bubbleTransform : null);
Canvas val2 = (((Object)(object)val != (Object)null) ? ((Component)val).GetComponentInParent<Canvas>() : null);
if ((Object)(object)val != (Object)null && (Object)(object)val2 != (Object)null && (int)val2.renderMode != 2)
{
Camera val3 = (((int)val2.renderMode == 1) ? val2.worldCamera : Camera.main);
if ((Object)(object)val3 == (Object)null)
{
val3 = Camera.main;
}
if ((Object)(object)val3 != (Object)null)
{
((Transform)val).position = val3.WorldToScreenPoint(worldPosition);
}
}
else
{
bubbleTransform.position = worldPosition;
}
}
private void ApplyVisualScale(ChatBubbleState state, GameObject bubble)
{
//IL_002e: 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_00bf: Unknown result type (might be due to invalid IL or missing references)
//IL_0139: Unknown result type (might be due to invalid IL or missing references)
//IL_013c: Unknown result type (might be due to invalid IL or missing references)
//IL_0121: Unknown result type (might be due to invalid IL or missing references)
//IL_0126: Unknown result type (might be due to invalid IL or missing references)
//IL_0130: Unknown result type (might be due to invalid IL or missing references)
Transform transform = bubble.transform;
if ((Object)(object)transform == (Object)null)
{
return;
}
if ((Object)(object)state.BubbleRoot != (Object)(object)transform)
{
RestoreVisualScale(state);
state.BubbleRoot = transform;
state.OriginalBubbleScale = transform.localScale;
state.IconScaleTargets = Array.Empty<Transform>();
state.OriginalIconScales.Clear();
state.VisualTargetsDirty = true;
}
if (state.VisualTargetsDirty || Time.time >= state.NextVisualRecache)
{
RefreshVisualTargets(state, transform);
state.NextVisualRecache = Time.time + Mathf.Max(0.5f, _config.RendererRecacheSeconds.Value);
}
float num = Clamp(_config.BubbleScale.Value, 0.25f, 3f);
transform.localScale = state.OriginalBubbleScale * num;
float num2 = Clamp(_config.IconScale.Value, 0.25f, 3f);
Transform[] iconScaleTargets = state.IconScaleTargets;
foreach (Transform val in iconScaleTargets)
{
if (!((Object)(object)val == (Object)null))
{
int instanceID = ((Object)val).GetInstanceID();
if (!state.OriginalIconScales.TryGetValue(instanceID, out var value))
{
value = val.localScale;
state.OriginalIconScales[instanceID] = value;
}
val.localScale = value * num2;
}
}
}
private static void RefreshVisualTargets(ChatBubbleState state, Transform root)
{
//IL_0064: Unknown result type (might be due to invalid IL or missing references)
List<Transform> list = new List<Transform>();
Transform[] componentsInChildren;
try
{
componentsInChildren = ((Component)root).GetComponentsInChildren<Transform>(true);
}
catch
{
state.IconScaleTargets = Array.Empty<Transform>();
state.VisualTargetsDirty = false;
return;
}
Transform[] array = componentsInChildren;
foreach (Transform val in array)
{
if (IsIconScaleTarget(root, val))
{
list.Add(val);
int instanceID = ((Object)val).GetInstanceID();
if (!state.OriginalIconScales.ContainsKey(instanceID))
{
state.OriginalIconScales[instanceID] = val.localScale;
}
}
}
state.IconScaleTargets = list.ToArray();
state.VisualTargetsDirty = false;
}
private static bool IsIconScaleTarget(Transform root, Transform target)
{
if ((Object)(object)target == (Object)null || (Object)(object)target == (Object)(object)root)
{
return false;
}
if (HasTextComponent(target))
{
return false;
}
try
{
if ((Object)(object)((Component)target).GetComponent<Image>() != (Object)null)
{
return true;
}
if ((Object)(object)((Component)target).GetComponent<RawImage>() != (Object)null)
{
return true;
}
if ((Object)(object)((Component)target).GetComponent<SpriteRenderer>() != (Object)null)
{
return true;
}
if ((Object)(object)((Component)target).GetComponent<Renderer>() != (Object)null)
{
return true;
}
}
catch
{
}
return false;
}
private static bool HasTextComponent(Transform target)
{
try
{
if ((Object)(object)((Component)target).GetComponent<TMP_Text>() != (Object)null)
{
return true;
}
if ((Object)(object)((Component)target).GetComponent<Text>() != (Object)null)
{
return true;
}
if ((Object)(object)((Component)target).GetComponent<InputField>() != (Object)null)
{
return true;
}
}
catch
{
}
return false;
}
private static void RestoreVisualScale(ChatBubbleState state)
{
//IL_0015: 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)
if ((Object)(object)state.BubbleRoot != (Object)null)
{
state.BubbleRoot.localScale = state.OriginalBubbleScale;
}
Transform[] iconScaleTargets = state.IconScaleTargets;
foreach (Transform val in iconScaleTargets)
{
if (!((Object)(object)val == (Object)null))
{
int instanceID = ((Object)val).GetInstanceID();
if (state.OriginalIconScales.TryGetValue(instanceID, out var value))
{
val.localScale = value;
}
}
}
state.BubbleRoot = null;
state.IconScaleTargets = Array.Empty<Transform>();
state.OriginalIconScales.Clear();
state.VisualTargetsDirty = true;
}
private static int CountLiveTransforms(Transform[] transforms)
{
if (transforms == null || transforms.Length == 0)
{
return 0;
}
int num = 0;
for (int i = 0; i < transforms.Length; i++)
{
if ((Object)(object)transforms[i] != (Object)null)
{
num++;
}
}
return num;
}
private static float Clamp(float value, float min, float max)
{
if (value < min)
{
return min;
}
if (value > max)
{
return max;
}
return value;
}
private static string FormatPaths(Dictionary<BubbleAnchorPath, int> paths)
{
if (paths.Count == 0)
{
return "none";
}
string text = string.Empty;
foreach (KeyValuePair<BubbleAnchorPath, int> path in paths)
{
if (path.Value > 0)
{
if (text.Length > 0)
{
text += ",";
}
text += $"{path.Key}:{path.Value}";
}
}
if (text.Length != 0)
{
return text;
}
return "none";
}
}
internal sealed class ChatBubbleRuntime : MonoBehaviour
{
private ChatBubbleRegistry? _registry;
internal void Initialize(ChatBubbleRegistry registry)
{
_registry = registry;
}
private void OnEnable()
{
//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)
SceneManager.activeSceneChanged += OnActiveSceneChanged;
Scene activeScene = SceneManager.GetActiveScene();
ChatBubblePlugin.Log.LogInfo((object)("[Runtime] Active scene: " + ((Scene)(ref activeScene)).name));
}
private void OnDisable()
{
SceneManager.activeSceneChanged -= OnActiveSceneChanged;
}
private void LateUpdate()
{
try
{
_registry?.Tick();
}
catch (Exception ex)
{
ChatBubblePlugin.Log.LogError((object)("[Runtime] LateUpdate failed: " + ex.Message));
}
}
private static void OnActiveSceneChanged(Scene previous, Scene current)
{
ChatBubblePlugin.Log.LogInfo((object)("[Runtime] Active scene changed: " + ((Scene)(ref previous)).name + " -> " + ((Scene)(ref current)).name));
}
}
internal sealed class ChatBubbleState
{
internal Vector3 SmoothVelocity;
internal ChatBehaviour Chat { get; }
internal Player Player { get; }
internal int InstanceId { get; }
internal SkinnedMeshRenderer[] Renderers { get; set; } = Array.Empty<SkinnedMeshRenderer>();
internal float NextRendererRecache { get; set; }
internal bool RendererCacheDirty { get; set; } = true;
internal bool HasSmoothedWorldPosition { get; set; }
internal Vector3 SmoothedWorldPosition { get; set; }
internal BubbleAnchorPath LastAnchorPath { get; set; }
internal bool LastWasActive { get; set; }
internal int CorrectionsApplied { get; set; }
internal Transform? BubbleRoot { get; set; }
internal Vector3 OriginalBubbleScale { get; set; } = Vector3.one;
internal Transform[] IconScaleTargets { get; set; } = Array.Empty<Transform>();
internal Dictionary<int, Vector3> OriginalIconScales { get; } = new Dictionary<int, Vector3>();
internal bool VisualTargetsDirty { get; set; } = true;
internal float NextVisualRecache { get; set; }
internal string DisplayName
{
get
{
try
{
string name = ((Object)Player).name;
if (!string.IsNullOrWhiteSpace(name))
{
return name;
}
}
catch
{
}
return "Player";
}
}
internal ChatBubbleState(ChatBehaviour chat, Player player)
{
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
Chat = chat;
Player = player;
InstanceId = ((Object)chat).GetInstanceID();
}
}
internal static class PlayerRendererCache
{
private static readonly string[] AccessoryNameFragments = new string[22]
{
"tail", "hair", "ear", "horn", "leaf", "wing", "antler", "fluff", "fur", "mane",
"feather", "hat", "hood", "cap", "helmet", "crown", "headwear", "headgear", "scarf", "cape",
"cloak", "mantle"
};
internal static SkinnedMeshRenderer[] Collect(Player player, ChatBubbleConfig config)
{
if ((Object)(object)player == (Object)null)
{
return Array.Empty<SkinnedMeshRenderer>();
}
SkinnedMeshRenderer[] componentsInChildren;
try
{
componentsInChildren = ((Component)player).GetComponentsInChildren<SkinnedMeshRenderer>(true);
}
catch
{
return Array.Empty<SkinnedMeshRenderer>();
}
if (componentsInChildren == null || componentsInChildren.Length == 0)
{
return Array.Empty<SkinnedMeshRenderer>();
}
List<SkinnedMeshRenderer> list = new List<SkinnedMeshRenderer>(componentsInChildren.Length);
bool value = config.IncludeAccessoriesInBounds.Value;
bool value2 = config.ForceUpdateWhenOffscreen.Value;
SkinnedMeshRenderer[] array = componentsInChildren;
foreach (SkinnedMeshRenderer val in array)
{
if ((Object)(object)val == (Object)null || (Object)(object)val.sharedMesh == (Object)null || (!value && IsAccessoryRenderer((Renderer)(object)val)))
{
continue;
}
if (value2)
{
try
{
val.updateWhenOffscreen = true;
}
catch
{
}
}
list.Add(val);
}
return list.ToArray();
}
internal static bool TryGetBounds(Player player, SkinnedMeshRenderer[] renderers, out Bounds bounds)
{
//IL_0001: 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_006f: Unknown result type (might be due to invalid IL or missing references)
//IL_0074: 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)
//IL_0085: Unknown result type (might be due to invalid IL or missing references)
//IL_0087: Unknown result type (might be due to invalid IL or missing references)
//IL_0098: Unknown result type (might be due to invalid IL or missing references)
//IL_00a9: 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_00cb: Unknown result type (might be due to invalid IL or missing references)
//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
//IL_00ef: 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_0102: Unknown result type (might be due to invalid IL or missing references)
//IL_010c: Unknown result type (might be due to invalid IL or missing references)
//IL_0113: Unknown result type (might be due to invalid IL or missing references)
//IL_0118: 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_0134: Unknown result type (might be due to invalid IL or missing references)
//IL_0159: Unknown result type (might be due to invalid IL or missing references)
//IL_0166: Unknown result type (might be due to invalid IL or missing references)
//IL_014b: Unknown result type (might be due to invalid IL or missing references)
//IL_014d: Unknown result type (might be due to invalid IL or missing references)
bounds = default(Bounds);
if ((Object)(object)player == (Object)null || renderers == null || renderers.Length == 0)
{
return false;
}
Vector3 position;
try
{
position = ((Component)player).transform.position;
}
catch
{
return false;
}
bool flag = false;
foreach (SkinnedMeshRenderer val in renderers)
{
if ((Object)(object)val == (Object)null || !((Renderer)val).enabled || !((Component)val).gameObject.activeInHierarchy)
{
continue;
}
Bounds bounds2;
try
{
bounds2 = ((Renderer)val).bounds;
}
catch
{
continue;
}
Vector3 size = ((Bounds)(ref bounds2)).size;
if (!IsUsable(size.x) || !IsUsable(size.y) || !IsUsable(size.z) || size.x > 50f || size.y > 50f || size.z > 50f)
{
continue;
}
Vector2 val2 = new Vector2(((Bounds)(ref bounds2)).center.x - position.x, ((Bounds)(ref bounds2)).center.z - position.z);
if (!(((Vector2)(ref val2)).magnitude > 10f) && !(Mathf.Abs(((Bounds)(ref bounds2)).center.y - position.y) > 30f))
{
if (!flag)
{
bounds = bounds2;
flag = true;
}
else
{
((Bounds)(ref bounds)).Encapsulate(((Bounds)(ref bounds2)).min);
((Bounds)(ref bounds)).Encapsulate(((Bounds)(ref bounds2)).max);
}
}
}
return flag;
}
private static bool IsAccessoryRenderer(Renderer renderer)
{
string name = ((Object)renderer).name ?? string.Empty;
string name2 = (((Object)(object)((Component)renderer).gameObject != (Object)null) ? ((Object)((Component)renderer).gameObject).name : string.Empty);
if (!NameMatchesAccessory(name))
{
return NameMatchesAccessory(name2);
}
return true;
}
private static bool NameMatchesAccessory(string name)
{
if (string.IsNullOrEmpty(name))
{
return false;
}
string text = name.ToLowerInvariant();
string[] accessoryNameFragments = AccessoryNameFragments;
foreach (string value in accessoryNameFragments)
{
if (text.Contains(value))
{
return true;
}
}
return false;
}
private static bool IsUsable(float value)
{
if (!float.IsNaN(value) && !float.IsInfinity(value))
{
return value > 0.001f;
}
return false;
}
}
internal static class PlayerVisualPatches
{
[HarmonyPatch(typeof(PlayerVisual), "RenderPlayerModel")]
[HarmonyPostfix]
private static void AfterRenderPlayerModel(PlayerVisual __instance)
{
try
{
ChatBubblePlugin.Registry?.MarkVisualDirty(__instance);
}
catch (Exception ex)
{
ChatBubblePlugin.Log.LogWarning((object)("[Patch] PlayerVisual.RenderPlayerModel failed: " + ex.Message));
}
}
}
}
