using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using BepInEx;
using Microsoft.CodeAnalysis;
using Setting;
using UnityEngine;
using UnityEngine.SceneManagement;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyVersion("0.0.0.0")]
[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.Module, AllowMultiple = false, Inherited = false)]
internal sealed class RefSafetyRulesAttribute : Attribute
{
public readonly int Version;
public RefSafetyRulesAttribute(int P_0)
{
Version = P_0;
}
}
}
namespace Empress.CapsuleParade
{
[BepInPlugin("empress.paralives.capsuleparade", "Empress Capsule Parade", "1.0.0")]
public sealed class EmpressCapsuleParadePlugin : BaseUnityPlugin
{
public const string PluginGuid = "empress.paralives.capsuleparade";
public const string PluginName = "Empress Capsule Parade";
public const string PluginVersion = "1.0.0";
private void Awake()
{
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Expected O, but got Unknown
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
GameObject val = new GameObject("EmpressCapsuleParadeRuntime");
Object.DontDestroyOnLoad((Object)val);
((Object)val).hideFlags = (HideFlags)61;
val.AddComponent<EmpressCapsuleParadeRuntime>();
((BaseUnityPlugin)this).Logger.LogInfo((object)"Empress Capsule Parade 1.0.0 loaded");
}
}
public sealed class EmpressCapsuleParadeRuntime : MonoBehaviour
{
private readonly Dictionary<int, EmpressCapsuleState> states = new Dictionary<int, EmpressCapsuleState>();
private readonly List<int> cleanup = new List<int>();
private Material femaleMaterial;
private Material maleMaterial;
private Material noneMaterial;
private float nextScan;
private float nextErrorLog;
private void Awake()
{
CreateMaterials();
}
private void LateUpdate()
{
if (Time.unscaledTime < nextScan)
{
return;
}
nextScan = Time.unscaledTime + 0.2f;
try
{
CharacterVisual[] array = Resources.FindObjectsOfTypeAll<CharacterVisual>();
for (int i = 0; i < array.Length; i++)
{
SyncVisual(array[i]);
}
CleanupStates();
}
catch (Exception ex)
{
if (Time.unscaledTime >= nextErrorLog)
{
nextErrorLog = Time.unscaledTime + 5f;
Debug.LogWarning((object)("Empress Capsule Parade sync failed: " + ex.Message));
}
}
}
private void SyncVisual(CharacterVisual visual)
{
//IL_001d: 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_00ef: Unknown result type (might be due to invalid IL or missing references)
//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
//IL_011f: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)visual == (Object)null || (Object)(object)((Component)visual).gameObject == (Object)null)
{
return;
}
Scene scene = ((Component)visual).gameObject.scene;
if (((Scene)(ref scene)).IsValid())
{
int instanceID = ((Object)visual).GetInstanceID();
if (!states.TryGetValue(instanceID, out var value) || (Object)(object)value.Capsule == (Object)null)
{
value = CreateState(visual);
states[instanceID] = value;
}
value.Visual = visual;
AssetCharacter character = GetCharacter(visual.CharacterGUID);
EmpressCapsuleSize size = GetSize(character);
Material material = GetMaterial(character);
if ((Object)(object)value.Renderer != (Object)null && (Object)(object)value.Renderer.sharedMaterial != (Object)(object)material)
{
value.Renderer.sharedMaterial = material;
}
Transform transform = value.Capsule.transform;
transform.SetParent(((Component)visual).transform, false);
transform.localPosition = new Vector3(0f, size.Height * 0.5f, 0f);
transform.localRotation = Quaternion.identity;
transform.localScale = new Vector3(size.Diameter, size.Height * 0.5f, size.Diameter);
value.Capsule.SetActive(visual.IsVisible && ((Component)visual).gameObject.activeInHierarchy);
HideOriginalRenderers(visual, transform);
}
}
private EmpressCapsuleState CreateState(CharacterVisual visual)
{
GameObject val = GameObject.CreatePrimitive((PrimitiveType)1);
((Object)val).name = "EmpressCapsule";
val.transform.SetParent(((Component)visual).transform, false);
val.layer = ((Component)visual).gameObject.layer;
Collider component = val.GetComponent<Collider>();
if ((Object)(object)component != (Object)null)
{
Object.Destroy((Object)(object)component);
}
Renderer component2 = val.GetComponent<Renderer>();
if ((Object)(object)component2 != (Object)null)
{
component2.sharedMaterial = noneMaterial;
component2.receiveShadows = true;
}
return new EmpressCapsuleState
{
Visual = visual,
Capsule = val,
Renderer = component2
};
}
private void HideOriginalRenderers(CharacterVisual visual, Transform capsuleTransform)
{
SkinnedMeshRenderer[] componentsInChildren = ((Component)visual).GetComponentsInChildren<SkinnedMeshRenderer>(true);
foreach (SkinnedMeshRenderer val in componentsInChildren)
{
if ((Object)(object)val != (Object)null && !((Component)val).transform.IsChildOf(capsuleTransform))
{
((Renderer)val).enabled = false;
}
}
MeshRenderer[] componentsInChildren2 = ((Component)visual).GetComponentsInChildren<MeshRenderer>(true);
foreach (MeshRenderer val2 in componentsInChildren2)
{
if ((Object)(object)val2 != (Object)null && !((Component)val2).transform.IsChildOf(capsuleTransform) && !IsSelectionRenderer(visual, val2))
{
((Renderer)val2).enabled = false;
}
}
}
private bool IsSelectionRenderer(CharacterVisual visual, MeshRenderer renderer)
{
if ((Object)(object)visual.SelectionObject == (Object)null)
{
return false;
}
return (Object)(object)renderer == (Object)(object)visual.SelectionObject.Renderer;
}
private AssetCharacter GetCharacter(ulong guid)
{
if (guid == 0L || (Object)(object)AssetManager.Instance == (Object)null)
{
return null;
}
return AssetManager.Instance.GetCharacter(guid);
}
private EmpressCapsuleSize GetSize(AssetCharacter character)
{
string stageName = GetStageName(character);
if (Contains(stageName, "baby"))
{
return new EmpressCapsuleSize(0.48f, 0.34f);
}
if (Contains(stageName, "toddler"))
{
return new EmpressCapsuleSize(0.82f, 0.44f);
}
if (Contains(stageName, "child"))
{
return new EmpressCapsuleSize(1.18f, 0.5f);
}
if (Contains(stageName, "preteen"))
{
return new EmpressCapsuleSize(1.42f, 0.54f);
}
if (Contains(stageName, "teen"))
{
return new EmpressCapsuleSize(1.58f, 0.58f);
}
if (Contains(stageName, "youngadult"))
{
return new EmpressCapsuleSize(1.76f, 0.62f);
}
if (Contains(stageName, "adult"))
{
return new EmpressCapsuleSize(1.72f, 0.62f);
}
if (Contains(stageName, "elder"))
{
return new EmpressCapsuleSize(1.66f, 0.6f);
}
float num = ((character != null) ? character.Data.Age : 18f);
if (num < 2f)
{
return new EmpressCapsuleSize(0.48f, 0.34f);
}
if (num < 5f)
{
return new EmpressCapsuleSize(0.82f, 0.44f);
}
if (num < 9f)
{
return new EmpressCapsuleSize(1.18f, 0.5f);
}
if (num < 13f)
{
return new EmpressCapsuleSize(1.42f, 0.54f);
}
if (num < 18f)
{
return new EmpressCapsuleSize(1.58f, 0.58f);
}
if (num < 40f)
{
return new EmpressCapsuleSize(1.76f, 0.62f);
}
if (num < 65f)
{
return new EmpressCapsuleSize(1.72f, 0.62f);
}
return new EmpressCapsuleSize(1.66f, 0.6f);
}
private string GetStageName(AssetCharacter character)
{
if (character == null)
{
return string.Empty;
}
try
{
LifeStage currentLifeStageOfCharacter = LifeStageManager.Instance.GetCurrentLifeStageOfCharacter(character);
return (currentLifeStageOfCharacter != null && currentLifeStageOfCharacter.DisplayName != null) ? currentLifeStageOfCharacter.DisplayName : string.Empty;
}
catch
{
return string.Empty;
}
}
private bool Contains(string value, string fragment)
{
if (value != null)
{
return value.IndexOf(fragment, StringComparison.OrdinalIgnoreCase) >= 0;
}
return false;
}
private Material GetMaterial(AssetCharacter character)
{
if ((Object)(object)femaleMaterial == (Object)null || (Object)(object)maleMaterial == (Object)null || (Object)(object)noneMaterial == (Object)null)
{
CreateMaterials();
}
ulong num = ((character != null) ? character.Data.Gender : 0);
Genders val = Settings.Get<Genders>();
if (val != null)
{
if (num == val.FemaleGender)
{
return femaleMaterial;
}
if (num == val.MaleGender)
{
return maleMaterial;
}
}
return noneMaterial;
}
private void CreateMaterials()
{
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
//IL_0045: 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)
femaleMaterial = CreateMaterial("EmpressCapsulePink", new Color(1f, 0.22f, 0.66f, 1f));
maleMaterial = CreateMaterial("EmpressCapsuleBlue", new Color(0.18f, 0.47f, 1f, 1f));
noneMaterial = CreateMaterial("EmpressCapsuleWhite", new Color(1f, 1f, 1f, 1f));
}
private Material CreateMaterial(string name, Color color)
{
//IL_0048: Unknown result type (might be due to invalid IL or missing references)
//IL_004e: Expected O, but got Unknown
//IL_0056: 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_0088: Unknown result type (might be due to invalid IL or missing references)
Shader val = Shader.Find("Universal Render Pipeline/Lit");
if ((Object)(object)val == (Object)null)
{
val = Shader.Find("Standard");
}
if ((Object)(object)val == (Object)null)
{
val = Shader.Find("Unlit/Color");
}
if ((Object)(object)val == (Object)null)
{
val = Shader.Find("Sprites/Default");
}
Material val2 = new Material(val);
((Object)val2).name = name;
val2.color = color;
if (val2.HasProperty("_BaseColor"))
{
val2.SetColor("_BaseColor", color);
}
if (val2.HasProperty("_Color"))
{
val2.SetColor("_Color", color);
}
if (val2.HasProperty("_Smoothness"))
{
val2.SetFloat("_Smoothness", 0.55f);
}
if (val2.HasProperty("_Metallic"))
{
val2.SetFloat("_Metallic", 0f);
}
return val2;
}
private void CleanupStates()
{
cleanup.Clear();
foreach (KeyValuePair<int, EmpressCapsuleState> state in states)
{
if ((Object)(object)state.Value.Visual == (Object)null || (Object)(object)state.Value.Capsule == (Object)null)
{
cleanup.Add(state.Key);
}
}
for (int i = 0; i < cleanup.Count; i++)
{
states.Remove(cleanup[i]);
}
}
private void OnDestroy()
{
DestroyMaterial(femaleMaterial);
DestroyMaterial(maleMaterial);
DestroyMaterial(noneMaterial);
}
private void DestroyMaterial(Material material)
{
if ((Object)(object)material != (Object)null)
{
Object.Destroy((Object)(object)material);
}
}
}
internal sealed class EmpressCapsuleState
{
public CharacterVisual Visual;
public GameObject Capsule;
public Renderer Renderer;
}
internal struct EmpressCapsuleSize
{
public float Height;
public float Diameter;
public EmpressCapsuleSize(float height, float diameter)
{
Height = height;
Diameter = diameter;
}
}
}
