using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using PluginConfig.API;
using PluginConfig.API.Decorators;
using PluginConfig.API.Fields;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyCompany("TokenSkulls")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("TokenSkulls")]
[assembly: AssemblyTitle("TokenSkulls")]
[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.Module, AllowMultiple = false, Inherited = false)]
internal sealed class RefSafetyRulesAttribute : Attribute
{
public readonly int Version;
public RefSafetyRulesAttribute(int P_0)
{
Version = P_0;
}
}
}
namespace TokenSkulls
{
internal sealed class ConfigUI
{
private const float PosRange = 5f;
private const float RotRange = 180f;
private const float ScaleMin = 0.05f;
private const float ScaleMax = 10f;
private const string IconFile = "icon.png";
private PluginConfigurator config;
private BoolField enabledField;
public Action<bool> OnEnabledChanged;
public Action OnPlacementChanged;
public bool IsEnabled => enabledField == null || enabledField.value;
public void Setup()
{
//IL_0060: Unknown result type (might be due to invalid IL or missing references)
//IL_006a: Expected O, but got Unknown
//IL_007b: Unknown result type (might be due to invalid IL or missing references)
//IL_0085: Expected O, but got Unknown
//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
//IL_00b6: Expected O, but got Unknown
//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
//IL_00cd: Expected O, but got Unknown
//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
//IL_00f5: Expected O, but got Unknown
config = PluginConfigurator.Create("Token Skulls", "com.scout.tokenskulls");
Sprite val = LoadIcon("icon.png");
if ((Object)(object)val != (Object)null)
{
config.image = val;
}
enabledField = new BoolField(config.rootPanel, "Enabled", "enabled", true);
ConfigDivision settings = new ConfigDivision(config.rootPanel, "settings");
((ConfigField)settings).hidden = !enabledField.value;
enabledField.onValueChange += (BoolValueChangeEventDelegate)delegate(BoolValueChangeEvent e)
{
((ConfigField)settings).hidden = !e.value;
OnEnabledChanged?.Invoke(e.value);
};
ConfigPanel panel = new ConfigPanel((ConfigPanel)(object)settings, "World Skull Placement", "world_settings");
BuildPlacement(panel, "world", TokenSkullsPlugin.World);
ConfigPanel panel2 = new ConfigPanel((ConfigPanel)(object)settings, "Held Skull Placement", "held_settings");
BuildPlacement(panel2, "held", TokenSkullsPlugin.Held);
}
private Sprite LoadIcon(string fileName)
{
//IL_0043: Unknown result type (might be due to invalid IL or missing references)
//IL_0049: Expected O, but got Unknown
//IL_006a: Unknown result type (might be due to invalid IL or missing references)
//IL_0079: Unknown result type (might be due to invalid IL or missing references)
string path = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), fileName);
if (!File.Exists(path))
{
TokenSkullsPlugin.Log.LogWarning((object)"No icon which how???");
return null;
}
byte[] array = File.ReadAllBytes(path);
Texture2D val = new Texture2D(2, 2);
ImageConversion.LoadImage(val, array);
return Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f));
}
private void BuildPlacement(ConfigPanel panel, string prefix, TokenSkullsPlugin.Placement p)
{
//IL_0016: Unknown result type (might be due to invalid IL or missing references)
//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
//IL_018e: Unknown result type (might be due to invalid IL or missing references)
new ConfigHeader(panel, "Position Offset", 20);
Slider(panel, "Position X", prefix + "_pos_x", p.posX, -5f, 5f, 2, delegate(float v)
{
p.posX = v;
});
Slider(panel, "Position Y", prefix + "_pos_y", p.posY, -5f, 5f, 2, delegate(float v)
{
p.posY = v;
});
Slider(panel, "Position Z", prefix + "_pos_z", p.posZ, -5f, 5f, 2, delegate(float v)
{
p.posZ = v;
});
new ConfigHeader(panel, "Rotation Offset", 20);
Slider(panel, "Rotation X", prefix + "_rot_x", p.rotX, -180f, 180f, 1, delegate(float v)
{
p.rotX = v;
});
Slider(panel, "Rotation Y", prefix + "_rot_y", p.rotY, -180f, 180f, 1, delegate(float v)
{
p.rotY = v;
});
Slider(panel, "Rotation Z", prefix + "_rot_z", p.rotZ, -180f, 180f, 1, delegate(float v)
{
p.rotZ = v;
});
new ConfigHeader(panel, "Size Multiplier", 20);
Slider(panel, "Scale", prefix + "_scale", p.scale, 0.05f, 10f, 2, delegate(float v)
{
p.scale = v;
});
}
private void Slider(ConfigPanel panel, string label, string guid, float def, float min, float max, int decimals, Action<float> apply)
{
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_002c: Expected O, but got Unknown
//IL_0034: Unknown result type (might be due to invalid IL or missing references)
//IL_003e: Expected O, but got Unknown
FloatSliderField val = new FloatSliderField(panel, label, guid, new Tuple<float, float>(min, max), def, decimals);
val.onValueChange += (OnValueChangeEventDelegate)delegate(FloatSliderValueChangeEvent e)
{
apply(e.newValue);
OnPlacementChanged?.Invoke();
};
apply(val.value);
}
}
[BepInPlugin("com.scout.tokenskulls", "Token Skulls", "1.0.0")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
public sealed class TokenSkullsPlugin : BaseUnityPlugin
{
private class Variant
{
public GameObject prefab;
public Vector3 pos;
public Quaternion rot;
public Vector3 scale;
}
public class Placement
{
public float posX;
public float posY;
public float posZ;
public float rotX;
public float rotY;
public float rotZ;
public float scale = 1f;
public Vector3 PosOffset => new Vector3(posX, posY, posZ);
public Vector3 RotOffset => new Vector3(rotX, rotY, rotZ);
}
private class SkullTag : MonoBehaviour
{
public Transform clone;
public Renderer hidden;
public Variant variant;
public bool wasHeld;
}
public const string GUID = "com.scout.tokenskulls";
public const string NAME = "Token Skulls";
public const string VERSION = "1.0.0";
private const string BundleFile = "tokenskulls.bundle";
private const string PrefabRed = "TokenSkullRed";
private const string PrefabBlue = "TokenSkullBlue";
private const string PrefabSingle = "TokenSkull";
public static readonly Placement World = new Placement();
public static readonly Placement Held = new Placement();
private static Variant redVariant;
private static Variant blueVariant;
private static bool modelReady;
private static bool placementDirty;
private static bool warnedNoAnchor;
private static readonly List<SkullTag> live = new List<SkullTag>();
private static ConfigUI ui;
internal static ManualLogSource Log;
private Harmony harmony;
private static bool IsEnabled => ui != null && ui.IsEnabled;
private void Awake()
{
//IL_009d: Unknown result type (might be due to invalid IL or missing references)
//IL_00a7: Expected O, but got Unknown
Log = ((BaseUnityPlugin)this).Logger;
ui = new ConfigUI();
ui.Setup();
ui.OnEnabledChanged = OnEnabledToggled;
ui.OnPlacementChanged = delegate
{
placementDirty = true;
};
LoadModel();
if (!modelReady)
{
Log.LogError((object)"Model never loaded");
return;
}
try
{
harmony = new Harmony("com.scout.tokenskulls");
harmony.PatchAll();
Log.LogInfo((object)"Patched Skull.Awake");
}
catch (Exception arg)
{
Log.LogError((object)$"Harmony patch failed: {arg}");
}
}
private Variant TryLoad(AssetBundle bundle, string name)
{
//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_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_0078: 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)
GameObject val = bundle.LoadAsset<GameObject>(name);
if ((Object)(object)val == (Object)null)
{
return null;
}
if (val.GetComponentsInChildren<Renderer>(true).Length == 0)
{
Log.LogWarning((object)(name + " has no renderers anywhere"));
return null;
}
return new Variant
{
prefab = val,
pos = val.transform.localPosition,
rot = val.transform.localRotation,
scale = val.transform.localScale
};
}
private void LoadModel()
{
string directoryName = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
string text = Path.Combine(directoryName, "tokenskulls.bundle");
if (!File.Exists(text))
{
Log.LogError((object)("Bundle missing in " + text));
return;
}
AssetBundle val = AssetBundle.LoadFromFile(text);
if ((Object)(object)val == (Object)null)
{
Log.LogError((object)"Bundle failed to load");
return;
}
redVariant = TryLoad(val, "TokenSkullRed");
blueVariant = TryLoad(val, "TokenSkullBlue");
Variant variant = TryLoad(val, "TokenSkull");
if (redVariant == null)
{
redVariant = variant ?? blueVariant;
}
if (blueVariant == null)
{
blueVariant = variant ?? redVariant;
}
if (redVariant == null || blueVariant == null)
{
Log.LogError((object)("No prefabs, need TokenSkullRed and TokenSkullBlue. Bundle only has: " + string.Join(", ", val.GetAllAssetNames())));
return;
}
if ((Object)(object)redVariant.prefab == (Object)(object)blueVariant.prefab)
{
Log.LogWarning((object)"Only one prefab found, add TokenSkullRed and TokenSkullBlue");
}
modelReady = true;
Log.LogInfo((object)("Loaded " + ((Object)redVariant.prefab).name + " and " + ((Object)blueVariant.prefab).name));
}
internal static void OnSkullAwake(Skull skull)
{
if (modelReady && IsEnabled && Object.op_Implicit((Object)(object)skull))
{
Dress(skull);
}
}
private static void Dress(Skull skull)
{
Transform val = ((IEnumerable<Transform>)((Component)skull).GetComponentsInChildren<Transform>(true)).FirstOrDefault((Func<Transform, bool>)((Transform t) => ((Object)t).name == "NewSkull"));
if (!Object.op_Implicit((Object)(object)val))
{
if (!warnedNoAnchor)
{
warnedNoAnchor = true;
Log.LogWarning((object)(((Object)skull).name + " has no NewSkull child"));
}
}
else if (!Object.op_Implicit((Object)(object)((Component)val).GetComponent<SkullTag>()))
{
Variant variant = (((Object)skull).name.ToLower().Contains("red") ? redVariant : blueVariant);
SkullTag skullTag = ((Component)val).gameObject.AddComponent<SkullTag>();
skullTag.variant = variant;
skullTag.hidden = ((Component)val).GetComponent<Renderer>();
if (Object.op_Implicit((Object)(object)skullTag.hidden))
{
skullTag.hidden.enabled = false;
}
GameObject val2 = Object.Instantiate<GameObject>(variant.prefab, val, false);
((Object)val2).name = "TokenSkullModel";
skullTag.clone = val2.transform;
live.Add(skullTag);
Place(skullTag, force: true);
}
}
private static void Place(SkullTag tag, bool force)
{
//IL_005b: 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_0066: Unknown result type (might be due to invalid IL or missing references)
//IL_0073: Unknown result type (might be due to invalid IL or missing references)
//IL_0079: Unknown result type (might be due to invalid IL or missing references)
//IL_007e: Unknown result type (might be due to invalid IL or missing references)
//IL_0083: Unknown result type (might be due to invalid IL or missing references)
//IL_0090: 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)
bool flag = ((Object)((Component)tag).transform.root).name == "Player";
if (force || flag != tag.wasHeld)
{
tag.wasHeld = flag;
Placement placement = (flag ? Held : World);
Variant variant = tag.variant;
Transform clone = tag.clone;
clone.localPosition = variant.pos + placement.PosOffset;
clone.localRotation = variant.rot * Quaternion.Euler(placement.RotOffset);
clone.localScale = variant.scale * placement.scale;
}
}
private void Update()
{
if (live.Count == 0)
{
placementDirty = false;
return;
}
bool force = placementDirty;
for (int num = live.Count - 1; num >= 0; num--)
{
SkullTag skullTag = live[num];
if (!Object.op_Implicit((Object)(object)skullTag) || !Object.op_Implicit((Object)(object)skullTag.clone))
{
live.RemoveAt(num);
}
else
{
if (Object.op_Implicit((Object)(object)skullTag.hidden) && skullTag.hidden.enabled)
{
skullTag.hidden.enabled = false;
}
Place(skullTag, force);
}
}
placementDirty = false;
}
private static void OnEnabledToggled(bool on)
{
if (!modelReady)
{
return;
}
if (on)
{
Skull[] array = Object.FindObjectsOfType<Skull>();
foreach (Skull val in array)
{
if (Object.op_Implicit((Object)(object)val))
{
Dress(val);
}
}
}
else
{
RestoreAll();
}
}
private static void RestoreAll()
{
foreach (SkullTag item in live)
{
if (Object.op_Implicit((Object)(object)item))
{
if (Object.op_Implicit((Object)(object)item.clone))
{
Object.Destroy((Object)(object)((Component)item.clone).gameObject);
}
if (Object.op_Implicit((Object)(object)item.hidden))
{
item.hidden.enabled = true;
}
Object.Destroy((Object)(object)item);
}
}
live.Clear();
}
}
[HarmonyPatch(typeof(Skull), "Awake")]
internal static class SkullAwakePatch
{
private static void Postfix(Skull __instance)
{
TokenSkullsPlugin.OnSkullAwake(__instance);
}
}
}
