using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: IgnoresAccessChecksTo("")]
[assembly: AssemblyCompany("Omniscye")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("TinyRepo")]
[assembly: AssemblyTitle("TinyRepo")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
internal sealed class NullableAttribute : Attribute
{
public readonly byte[] NullableFlags;
public NullableAttribute(byte P_0)
{
NullableFlags = new byte[1] { P_0 };
}
public NullableAttribute(byte[] P_0)
{
NullableFlags = P_0;
}
}
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
internal sealed class NullableContextAttribute : Attribute
{
public readonly byte Flag;
public NullableContextAttribute(byte P_0)
{
Flag = P_0;
}
}
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
internal sealed class RefSafetyRulesAttribute : Attribute
{
public readonly int Version;
public RefSafetyRulesAttribute(int P_0)
{
Version = P_0;
}
}
}
namespace REPO.TinyPlayers
{
public static class Entry
{
[RuntimeInitializeOnLoadMethod(/*Could not decode attribute arguments.*/)]
private static void Bootstrap()
{
TinyPlayersMod.Init();
}
}
[HarmonyPatch]
public static class TinyPlayersMod
{
private static Harmony _harmony;
private static bool _patched;
public static void Init()
{
//IL_0017: Unknown result type (might be due to invalid IL or missing references)
//IL_0021: Expected O, but got Unknown
if (!_patched)
{
_patched = true;
_harmony = new Harmony("repo.tinyplayers.toggle");
_harmony.PatchAll(typeof(TinyPlayersMod).Assembly);
Debug.Log((object)"[TinyPlayers] Harmony patches applied.");
}
}
[HarmonyPostfix]
[HarmonyPatch(typeof(RenderTextureMain), "Awake")]
private static void RenderTextureMain_Awake_Postfix(RenderTextureMain __instance)
{
TinyController tinyController = default(TinyController);
if (Object.op_Implicit((Object)(object)__instance) && !((Component)__instance).gameObject.TryGetComponent<TinyController>(ref tinyController))
{
((Component)__instance).gameObject.AddComponent<TinyController>();
}
}
}
public sealed class TinyController : MonoBehaviour
{
[CompilerGenerated]
private sealed class <AvatarKeepTinyLoop>d__4 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public TinyController <>4__this;
private WaitForSecondsRealtime <wait>5__1;
private PlayerAvatar[] <avatars>5__2;
private int <i>5__3;
private PlayerAvatar <p>5__4;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <AvatarKeepTinyLoop>d__4(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<wait>5__1 = null;
<avatars>5__2 = null;
<p>5__4 = null;
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0029: Unknown result type (might be due to invalid IL or missing references)
//IL_0033: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<wait>5__1 = new WaitForSecondsRealtime(0.75f);
break;
case 1:
<>1__state = -1;
<avatars>5__2 = null;
break;
}
if (<>4__this.ModEnabled)
{
<avatars>5__2 = Object.FindObjectsByType<PlayerAvatar>((FindObjectsSortMode)0);
<i>5__3 = 0;
while (<i>5__3 < <avatars>5__2.Length)
{
<p>5__4 = <avatars>5__2[<i>5__3];
if (Object.op_Implicit((Object)(object)<p>5__4) && ((Component)<p>5__4).gameObject.activeInHierarchy)
{
TinyAvatarUtil.AttachUniformScaler(<p>5__4, <>4__this.Factor);
<p>5__4 = null;
}
<i>5__3++;
}
<>2__current = <wait>5__1;
<>1__state = 1;
return true;
}
return false;
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
public bool ModEnabled = false;
[Range(0.05f, 1f)]
public float Factor = 0.3f;
private Coroutine _avatarLoop;
private void Update()
{
if (!Input.GetKeyDown((KeyCode)289))
{
return;
}
ModEnabled = !ModEnabled;
if (ModEnabled)
{
((MonoBehaviour)this).StopAllCoroutines();
_avatarLoop = ((MonoBehaviour)this).StartCoroutine(AvatarKeepTinyLoop());
Debug.Log((object)"[TinyPlayers] ENABLED");
return;
}
if (_avatarLoop != null)
{
((MonoBehaviour)this).StopCoroutine(_avatarLoop);
_avatarLoop = null;
}
TinyAvatarUtil.DetachAll();
Debug.Log((object)"[TinyPlayers] DISABLED");
}
[IteratorStateMachine(typeof(<AvatarKeepTinyLoop>d__4))]
private IEnumerator AvatarKeepTinyLoop()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <AvatarKeepTinyLoop>d__4(0)
{
<>4__this = this
};
}
private void OnDisable()
{
if (_avatarLoop != null)
{
((MonoBehaviour)this).StopCoroutine(_avatarLoop);
_avatarLoop = null;
}
TinyAvatarUtil.DetachAll();
}
private void OnGUI()
{
//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_002e: Unknown result type (might be due to invalid IL or missing references)
//IL_0034: Unknown result type (might be due to invalid IL or missing references)
//IL_0040: Expected O, but got Unknown
//IL_0083: 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_00a1: Unknown result type (might be due to invalid IL or missing references)
string text = (ModEnabled ? "Tiny Mode: ON (F8 to toggle)" : "Tiny Mode: OFF (F8 to toggle)");
GUIStyle val = new GUIStyle(GUI.skin.label)
{
fontSize = 12
};
val.normal.textColor = Color.black;
GUIStyle val2 = val;
Rect val3 = default(Rect);
((Rect)(ref val3))..ctor(10f, 10f, 400f, 30f);
GUI.Label(new Rect(((Rect)(ref val3)).x + 1f, ((Rect)(ref val3)).y + 1f, ((Rect)(ref val3)).width, ((Rect)(ref val3)).height), text, val2);
val2.normal.textColor = Color.green;
GUI.Label(val3, text, val2);
}
}
public sealed class AvatarUniformScaler : MonoBehaviour
{
public Transform Target;
public float Factor = 0.3f;
private Vector3 _origScale;
private bool _hasOrig;
public void Configure(Transform target, float factor)
{
//IL_0043: Unknown result type (might be due to invalid IL or missing references)
//IL_0048: Unknown result type (might be due to invalid IL or missing references)
Target = target;
Factor = Mathf.Clamp(factor, 0.05f, 1f);
if (Object.op_Implicit((Object)(object)Target) && !_hasOrig)
{
_origScale = Target.localScale;
_hasOrig = true;
}
((Behaviour)this).enabled = true;
}
private void LateUpdate()
{
//IL_003d: Unknown result type (might be due to invalid IL or missing references)
//IL_0042: 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_0048: 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)
if (!Object.op_Implicit((Object)(object)Target))
{
((Behaviour)this).enabled = false;
return;
}
Vector3 val = default(Vector3);
((Vector3)(ref val))..ctor(Factor, Factor, Factor);
Vector3 val2 = Target.localScale - val;
if (((Vector3)(ref val2)).sqrMagnitude > 1E-07f)
{
Target.localScale = val;
}
}
private void OnDisable()
{
//IL_0022: Unknown result type (might be due to invalid IL or missing references)
if (Object.op_Implicit((Object)(object)Target) && _hasOrig)
{
Target.localScale = _origScale;
}
}
private void OnDestroy()
{
//IL_0022: Unknown result type (might be due to invalid IL or missing references)
if (Object.op_Implicit((Object)(object)Target) && _hasOrig)
{
Target.localScale = _origScale;
}
}
}
internal static class TinyAvatarUtil
{
private static readonly string[] VISUALS_NAMES = new string[5] { "Player Visuals", "PlayerVisuals", "Player Visual", "Player_Visuals", "Visuals" };
private static readonly string[] RIG_NAMES = new string[6] { "[RIG]", "RIG", "Rig", "Armature", "Root", "RootTransform" };
private static readonly Dictionary<PlayerAvatar, Transform> _cachedTarget = new Dictionary<PlayerAvatar, Transform>();
public static void AttachUniformScaler(PlayerAvatar avatar, float factor)
{
//IL_0124: Unknown result type (might be due to invalid IL or missing references)
//IL_0129: 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_012f: Unknown result type (might be due to invalid IL or missing references)
//IL_0146: Unknown result type (might be due to invalid IL or missing references)
if (Object.op_Implicit((Object)(object)avatar))
{
if (!_cachedTarget.TryGetValue(avatar, out Transform value) || !Object.op_Implicit((Object)(object)value))
{
(Transform visuals, Transform rig, Transform usedRoot) tuple = ResolveAvatarRigLoose(((Component)avatar).transform);
Transform item = tuple.visuals;
Transform item2 = tuple.rig;
Transform item3 = tuple.usedRoot;
value = item2 ?? item ?? ((Component)avatar).transform;
_cachedTarget[avatar] = value;
Debug.Log((object)("[TinyPlayers] target -> root: " + ((item3 != null) ? ((Object)item3).name : null) + ", visuals: " + (Object.op_Implicit((Object)(object)item) ? ((Object)item).name : "<null>") + ", rig: " + (Object.op_Implicit((Object)(object)item2) ? ((Object)item2).name : "<null>") + ", use: " + ((Object)value).name));
}
AvatarUniformScaler avatarUniformScaler = ((Component)avatar).GetComponent<AvatarUniformScaler>() ?? ((Component)avatar).gameObject.AddComponent<AvatarUniformScaler>();
avatarUniformScaler.Configure(value, factor);
Vector3 val = default(Vector3);
((Vector3)(ref val))..ctor(factor, factor, factor);
Vector3 val2 = value.localScale - val;
if (((Vector3)(ref val2)).sqrMagnitude > 1E-07f)
{
value.localScale = val;
}
}
}
public static void DetachAll()
{
AvatarUniformScaler[] array = Object.FindObjectsByType<AvatarUniformScaler>((FindObjectsSortMode)0);
foreach (AvatarUniformScaler avatarUniformScaler in array)
{
if (Object.op_Implicit((Object)(object)avatarUniformScaler))
{
((Behaviour)avatarUniformScaler).enabled = false;
Object.Destroy((Object)(object)avatarUniformScaler);
}
}
_cachedTarget.Clear();
}
private static (Transform visuals, Transform rig, Transform usedRoot) ResolveAvatarRigLoose(Transform avatarNode)
{
if (!Object.op_Implicit((Object)(object)avatarNode))
{
return (null, null, null);
}
Transform val = FindNearestAncestorWhoseSubtreeHasLoose(avatarNode, VISUALS_NAMES) ?? avatarNode;
Transform val2 = FindLooseBFS(val, VISUALS_NAMES);
Transform val3 = (Object.op_Implicit((Object)(object)val2) ? FindLooseBFS(val2, RIG_NAMES) : null);
if (!Object.op_Implicit((Object)(object)val3))
{
val3 = FindLooseBFS(avatarNode, RIG_NAMES);
}
return (val2, val3, val);
}
private static string Normalize(string s)
{
if (string.IsNullOrEmpty(s))
{
return "";
}
IEnumerable<char> source = from ch in s.ToLowerInvariant()
where ch != ' ' && ch != '_' && ch != '-' && ch != '[' && ch != ']' && ch != '(' && ch != ')' && ch != '{' && ch != '}' && ch != '.'
select ch;
return new string(source.ToArray());
}
private static Transform FindLooseBFS(Transform root, params string[] names)
{
//IL_004e: Unknown result type (might be due to invalid IL or missing references)
//IL_0055: Expected O, but got Unknown
//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
//IL_00e9: Expected O, but got Unknown
if (!Object.op_Implicit((Object)(object)root))
{
return null;
}
string[] source = names.Select(Normalize).ToArray();
foreach (Transform item in root)
{
Transform val = item;
string cn2 = Normalize(((Object)val).name);
if (source.Any((string t) => t == cn2))
{
return val;
}
}
Queue<Transform> queue = new Queue<Transform>();
queue.Enqueue(root);
while (queue.Count > 0)
{
Transform val2 = queue.Dequeue();
foreach (Transform item2 in val2)
{
Transform val3 = item2;
string cn = Normalize(((Object)val3).name);
if (source.Any((string t) => t == cn || cn.Contains(t)))
{
return val3;
}
queue.Enqueue(val3);
}
}
return null;
}
private static Transform FindNearestAncestorWhoseSubtreeHasLoose(Transform start, params string[] names)
{
Transform val = start;
while ((Object)(object)val != (Object)null)
{
if (Object.op_Implicit((Object)(object)FindLooseBFS(val, names)))
{
return val;
}
val = val.parent;
}
return null;
}
}
[HarmonyPatch(typeof(PlayerAvatar), "Start")]
internal static class Patch_TinyPlayer_OnStart
{
private static void Postfix(PlayerAvatar __instance)
{
TinyController tinyController = Object.FindFirstObjectByType<TinyController>();
if (Object.op_Implicit((Object)(object)__instance) && !((Object)(object)tinyController == (Object)null) && tinyController.ModEnabled)
{
TinyAvatarUtil.AttachUniformScaler(__instance, tinyController.Factor);
}
}
}
}
namespace TinyRepo
{
[BepInPlugin("Omniscye.TinyRepo", "TinyRepo", "1.0")]
public class TinyRepo : BaseUnityPlugin
{
internal static TinyRepo Instance { get; private set; }
internal static ManualLogSource Logger => Instance._logger;
private ManualLogSource _logger => ((BaseUnityPlugin)this).Logger;
internal Harmony? Harmony { get; set; }
private void Awake()
{
Instance = this;
((Component)this).gameObject.transform.parent = null;
((Object)((Component)this).gameObject).hideFlags = (HideFlags)61;
Patch();
Logger.LogInfo((object)$"{((BaseUnityPlugin)this).Info.Metadata.GUID} v{((BaseUnityPlugin)this).Info.Metadata.Version} has loaded!");
}
internal void Patch()
{
//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_0021: Expected O, but got Unknown
//IL_0026: Expected O, but got Unknown
if (Harmony == null)
{
Harmony val = new Harmony(((BaseUnityPlugin)this).Info.Metadata.GUID);
Harmony val2 = val;
Harmony = val;
}
Harmony.PatchAll();
}
internal void Unpatch()
{
Harmony? harmony = Harmony;
if (harmony != null)
{
harmony.UnpatchSelf();
}
}
private void Update()
{
}
}
}
