using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
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 Photon.Pun;
using UnityEngine;
using UnityEngine.Events;
[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: AssemblyCompany("Omniscye")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+ee6d99a477f142df0010e7f5c8c3bd67b4b5b005")]
[assembly: AssemblyProduct("MergedUpgrades")]
[assembly: AssemblyTitle("MergedUpgrades")]
[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 Empress.Synthesis
{
[BepInPlugin("Empress.Synthesis", "Empress Synthesis", "1.0.0")]
public class SynthesisPlugin : BaseUnityPlugin
{
internal static SynthesisPlugin Instance { get; private set; }
internal static ManualLogSource Logger => Instance._logger;
private ManualLogSource _logger => ((BaseUnityPlugin)this).Logger;
internal Harmony? Harmony { get; set; }
private void Awake()
{
//IL_0041: Unknown result type (might be due to invalid IL or missing references)
//IL_0046: Unknown result type (might be due to invalid IL or missing references)
//IL_0048: Expected O, but got Unknown
//IL_004d: Expected O, but got Unknown
Instance = this;
((Component)this).gameObject.transform.parent = null;
((Object)((Component)this).gameObject).hideFlags = (HideFlags)61;
if (Harmony == null)
{
Harmony val = new Harmony(((BaseUnityPlugin)this).Info.Metadata.GUID);
Harmony val2 = val;
Harmony = val;
}
Harmony.PatchAll();
((MonoBehaviour)this).StartCoroutine(SynthesisAudio.LoadNearDll(((BaseUnityPlugin)this).Info.Location));
Logger.LogInfo((object)$"{((BaseUnityPlugin)this).Info.Metadata.GUID} v{((BaseUnityPlugin)this).Info.Metadata.Version} loaded");
}
private void OnDestroy()
{
Harmony? harmony = Harmony;
if (harmony != null)
{
harmony.UnpatchSelf();
}
}
}
[HarmonyPatch(typeof(ItemUpgrade), "Start")]
internal static class Patch_ItemUpgrade_Start
{
private static void Postfix(ItemUpgrade __instance)
{
if (!Object.op_Implicit((Object)(object)((Component)__instance).gameObject.GetComponent<SynthesisNode>()))
{
((Component)__instance).gameObject.AddComponent<SynthesisNode>();
}
}
}
[HarmonyPatch(typeof(ItemAttributes), "ShowInfo")]
internal static class Patch_ItemAttributes_ShowInfo_NameMirror
{
private static void Prefix(ref string ___itemName, string ___instanceName)
{
if (!string.IsNullOrEmpty(___instanceName))
{
int num = ___instanceName.IndexOf('/');
___itemName = ((num >= 0) ? ___instanceName.Substring(0, num) : ___instanceName);
}
}
}
[HarmonyPatch(typeof(ItemAttributes), "ShowingInfo")]
internal static class Patch_ItemAttributes_ShowingInfo_NameMirror
{
private static void Prefix(ref string ___itemName, string ___instanceName)
{
if (!string.IsNullOrEmpty(___instanceName))
{
int num = ___instanceName.IndexOf('/');
___itemName = ((num >= 0) ? ___instanceName.Substring(0, num) : ___instanceName);
}
}
}
public enum KnownUpgrade
{
None,
Energy,
SprintSpeed,
Health,
GrabStrength,
ExtraJump,
TumbleWings,
GrabRange,
GrabThrow,
CrouchRest,
TumbleClimb
}
public class SynthesisNode : MonoBehaviour
{
public bool merged;
private float lastImpact;
private PhysGrabObjectImpactDetector impact;
private Rigidbody rb;
private PhotonView pv;
private ItemAttributes attrs;
private ItemUpgrade baseUpgrade;
public KnownUpgrade Type;
private void Awake()
{
//IL_007b: Unknown result type (might be due to invalid IL or missing references)
//IL_0085: Expected O, but got Unknown
impact = ((Component)this).GetComponent<PhysGrabObjectImpactDetector>();
rb = ((Component)this).GetComponent<Rigidbody>();
pv = ((Component)this).GetComponent<PhotonView>();
attrs = ((Component)this).GetComponent<ItemAttributes>();
baseUpgrade = ((Component)this).GetComponent<ItemUpgrade>();
Type = SynthesisUtil.ResolveType(((Component)this).gameObject);
if ((Object)(object)impact != (Object)null)
{
UnityEvent onAllImpacts = impact.onAllImpacts;
if (onAllImpacts != null)
{
onAllImpacts.AddListener(new UnityAction(OnImpact));
}
}
if (Object.op_Implicit((Object)(object)pv) && !Object.op_Implicit((Object)(object)((Component)pv).gameObject.GetComponent<SynthesisNetwork>()))
{
((Component)pv).gameObject.AddComponent<SynthesisNetwork>();
}
}
private void OnDestroy()
{
//IL_0036: Unknown result type (might be due to invalid IL or missing references)
//IL_0040: Expected O, but got Unknown
if ((Object)(object)impact != (Object)null && impact.onAllImpacts != null)
{
impact.onAllImpacts.RemoveListener(new UnityAction(OnImpact));
}
}
private void OnImpact()
{
lastImpact = Time.time;
}
private void Update()
{
//IL_0032: Unknown result type (might be due to invalid IL or missing references)
if (merged || Time.time - lastImpact > 0.25f)
{
return;
}
Collider[] array = Physics.OverlapSphere(((Component)this).transform.position, 0.6f, -1, (QueryTriggerInteraction)1);
for (int i = 0; i < array.Length; i++)
{
GameObject val = (Object.op_Implicit((Object)(object)array[i].attachedRigidbody) ? ((Component)array[i].attachedRigidbody).gameObject : ((Component)array[i]).gameObject);
if ((Object)(object)val == (Object)(object)((Component)this).gameObject)
{
continue;
}
SynthesisNode component = val.GetComponent<SynthesisNode>();
if (Object.op_Implicit((Object)(object)component) && !component.merged && component.Type != 0 && Type != 0 && SynthesisUtil.CanInitiate())
{
merged = true;
component.merged = true;
if (Object.op_Implicit((Object)(object)pv) && pv.ViewID != 0)
{
SynthesisUtil.BeginMergeNetwork(pv, component.pv);
}
else
{
((MonoBehaviour)this).StartCoroutine(SynthesisUtil.AnimateAndMergeLocal(this, component));
}
break;
}
}
}
}
public class SynthesisNetwork : MonoBehaviourPun
{
[PunRPC]
public void RPC_Synthesize(int otherViewId)
{
((MonoBehaviour)this).StartCoroutine(SynthesisUtil.AnimateAndMergeRPC(((MonoBehaviourPun)this).photonView, otherViewId));
}
}
public static class SynthesisUtil
{
[CompilerGenerated]
private sealed class <AnimateAndMergeLocal>d__4 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public SynthesisNode a;
public SynthesisNode b;
private GameObject <host>5__1;
private GameObject <other>5__2;
private string <name>5__3;
private float <hue>5__4;
private KnownUpgrade[] <parts>5__5;
private ItemAttributes <ia>5__6;
private PhotonView <pv>5__7;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <AnimateAndMergeLocal>d__4(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<host>5__1 = null;
<other>5__2 = null;
<name>5__3 = null;
<parts>5__5 = null;
<ia>5__6 = null;
<pv>5__7 = null;
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0104: Unknown result type (might be due to invalid IL or missing references)
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<host>5__1 = ((Component)a).gameObject;
<other>5__2 = ((Component)b).gameObject;
<name>5__3 = ComposeName(<host>5__1, <other>5__2);
<hue>5__4 = ComputeHue(((Object)(object)a != (Object)null) ? a.Type : KnownUpgrade.None, ((Object)(object)b != (Object)null) ? b.Type : KnownUpgrade.None);
<parts>5__5 = BuildParts(a, b);
<>2__current = AnimatePair(<host>5__1, <other>5__2);
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
if (Object.op_Implicit((Object)(object)<other>5__2))
{
<other>5__2.SetActive(false);
}
SynthesisAudio.Play(<host>5__1.transform.position);
ApplySynthesis(<host>5__1, <name>5__3, <hue>5__4, <parts>5__5);
if (Object.op_Implicit((Object)(object)PunManager.instance) && <host>5__1.TryGetComponent<ItemAttributes>(ref <ia>5__6) && <host>5__1.TryGetComponent<PhotonView>(ref <pv>5__7))
{
PunManager.instance.SetItemName(<name>5__3, <ia>5__6, <pv>5__7.ViewID);
}
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();
}
}
[CompilerGenerated]
private sealed class <AnimateAndMergeRPC>d__3 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public PhotonView hostPv;
public int otherViewId;
private GameObject <host>5__1;
private PhotonView <otherPv>5__2;
private GameObject <other>5__3;
private SynthesisNode <hostNode>5__4;
private SynthesisNode <otherNode>5__5;
private string <name>5__6;
private float <hue>5__7;
private KnownUpgrade[] <parts>5__8;
private ItemAttributes <ia>5__9;
private PhotonView <pv>5__10;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <AnimateAndMergeRPC>d__3(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<host>5__1 = null;
<otherPv>5__2 = null;
<other>5__3 = null;
<hostNode>5__4 = null;
<otherNode>5__5 = null;
<name>5__6 = null;
<parts>5__8 = null;
<ia>5__9 = null;
<pv>5__10 = null;
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0186: Unknown result type (might be due to invalid IL or missing references)
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<host>5__1 = (Object.op_Implicit((Object)(object)hostPv) ? ((Component)hostPv).gameObject : null);
<otherPv>5__2 = ((otherViewId != 0) ? PhotonView.Find(otherViewId) : null);
<other>5__3 = (Object.op_Implicit((Object)(object)<otherPv>5__2) ? ((Component)<otherPv>5__2).gameObject : null);
if (!Object.op_Implicit((Object)(object)<host>5__1))
{
return false;
}
<hostNode>5__4 = <host>5__1.GetComponent<SynthesisNode>();
<otherNode>5__5 = (Object.op_Implicit((Object)(object)<other>5__3) ? <other>5__3.GetComponent<SynthesisNode>() : null);
<name>5__6 = ComposeName(<host>5__1, <other>5__3);
<hue>5__7 = ComputeHue(((Object)(object)<hostNode>5__4 != (Object)null) ? <hostNode>5__4.Type : KnownUpgrade.None, ((Object)(object)<otherNode>5__5 != (Object)null) ? <otherNode>5__5.Type : KnownUpgrade.None);
<parts>5__8 = BuildParts(<hostNode>5__4, <otherNode>5__5);
<>2__current = AnimatePair(<host>5__1, <other>5__3);
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
if (Object.op_Implicit((Object)(object)<other>5__3))
{
<other>5__3.SetActive(false);
}
SynthesisAudio.Play(<host>5__1.transform.position);
ApplySynthesis(<host>5__1, <name>5__6, <hue>5__7, <parts>5__8);
if (Object.op_Implicit((Object)(object)PunManager.instance) && <host>5__1.TryGetComponent<ItemAttributes>(ref <ia>5__9) && <host>5__1.TryGetComponent<PhotonView>(ref <pv>5__10))
{
PunManager.instance.SetItemName(<name>5__6, <ia>5__9, <pv>5__10.ViewID);
}
if (Object.op_Implicit((Object)(object)<hostNode>5__4))
{
<hostNode>5__4.Type = KnownUpgrade.None;
}
if (Object.op_Implicit((Object)(object)<otherNode>5__5))
{
<otherNode>5__5.Type = KnownUpgrade.None;
}
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();
}
}
[CompilerGenerated]
private sealed class <AnimatePair>d__9 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public GameObject a;
public GameObject b;
private float <start>5__1;
private float <dur>5__2;
private Rigidbody <rbA>5__3;
private Rigidbody <rbB>5__4;
private bool <gA>5__5;
private bool <gB>5__6;
private Vector3 <pA>5__7;
private Vector3 <pB>5__8;
private Vector3 <center>5__9;
private float <t>5__10;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <AnimatePair>d__9(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<rbA>5__3 = null;
<rbB>5__4 = null;
<>1__state = -2;
}
private bool MoveNext()
{
//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
//IL_01c8: Unknown result type (might be due to invalid IL or missing references)
//IL_01cd: Unknown result type (might be due to invalid IL or missing references)
//IL_01d7: Unknown result type (might be due to invalid IL or missing references)
//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
//IL_01e7: Unknown result type (might be due to invalid IL or missing references)
//IL_020f: Unknown result type (might be due to invalid IL or missing references)
//IL_0215: Unknown result type (might be due to invalid IL or missing references)
//IL_021a: Unknown result type (might be due to invalid IL or missing references)
//IL_0224: Unknown result type (might be due to invalid IL or missing references)
//IL_0229: Unknown result type (might be due to invalid IL or missing references)
//IL_0234: Unknown result type (might be due to invalid IL or missing references)
//IL_025b: Unknown result type (might be due to invalid IL or missing references)
//IL_028e: Unknown result type (might be due to invalid IL or missing references)
//IL_0115: Unknown result type (might be due to invalid IL or missing references)
//IL_0103: Unknown result type (might be due to invalid IL or missing references)
//IL_011a: Unknown result type (might be due to invalid IL or missing references)
//IL_0154: Unknown result type (might be due to invalid IL or missing references)
//IL_012e: Unknown result type (might be due to invalid IL or missing references)
//IL_0133: Unknown result type (might be due to invalid IL or missing references)
//IL_013d: Unknown result type (might be due to invalid IL or missing references)
//IL_0142: 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_0160: 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_016b: Unknown result type (might be due to invalid IL or missing references)
//IL_0175: Unknown result type (might be due to invalid IL or missing references)
//IL_017a: Unknown result type (might be due to invalid IL or missing references)
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<start>5__1 = Time.time;
<dur>5__2 = 1.2f;
<rbA>5__3 = (Object.op_Implicit((Object)(object)a) ? a.GetComponent<Rigidbody>() : null);
<rbB>5__4 = (Object.op_Implicit((Object)(object)b) ? b.GetComponent<Rigidbody>() : null);
<gA>5__5 = Object.op_Implicit((Object)(object)<rbA>5__3) && <rbA>5__3.useGravity;
<gB>5__6 = Object.op_Implicit((Object)(object)<rbB>5__4) && <rbB>5__4.useGravity;
if (Object.op_Implicit((Object)(object)<rbA>5__3))
{
<rbA>5__3.useGravity = false;
}
if (Object.op_Implicit((Object)(object)<rbB>5__4))
{
<rbB>5__4.useGravity = false;
}
<pA>5__7 = (Object.op_Implicit((Object)(object)a) ? a.transform.position : Vector3.zero);
<pB>5__8 = (Object.op_Implicit((Object)(object)b) ? b.transform.position : (<pA>5__7 + Vector3.right * 0.4f));
<center>5__9 = (<pA>5__7 + <pB>5__8) * 0.5f;
break;
case 1:
<>1__state = -1;
break;
}
if (Time.time - <start>5__1 < <dur>5__2)
{
<t>5__10 = Mathf.InverseLerp(0f, <dur>5__2, Time.time - <start>5__1);
if (Object.op_Implicit((Object)(object)a))
{
a.transform.position = Vector3.Lerp(<pA>5__7, <center>5__9 + Vector3.up * 0.5f, <t>5__10);
}
if (Object.op_Implicit((Object)(object)b))
{
b.transform.position = Vector3.Lerp(<pB>5__8, <center>5__9 + Vector3.up * 0.5f, <t>5__10);
}
if (Object.op_Implicit((Object)(object)a))
{
a.transform.Rotate(Vector3.up, 360f * Time.deltaTime, (Space)0);
}
if (Object.op_Implicit((Object)(object)b))
{
b.transform.Rotate(Vector3.up, 360f * Time.deltaTime, (Space)0);
}
<>2__current = null;
<>1__state = 1;
return true;
}
if (Object.op_Implicit((Object)(object)<rbA>5__3))
{
<rbA>5__3.useGravity = <gA>5__5;
}
if (Object.op_Implicit((Object)(object)<rbB>5__4))
{
<rbB>5__4.useGravity = <gB>5__6;
}
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 static bool CanInitiate()
{
if (SemiFunc.IsMultiplayer())
{
return PhotonNetwork.IsMasterClient;
}
return true;
}
public static KnownUpgrade ResolveType(GameObject go)
{
if (Object.op_Implicit((Object)(object)go.GetComponent<ItemUpgradePlayerEnergy>()))
{
return KnownUpgrade.Energy;
}
if (Object.op_Implicit((Object)(object)go.GetComponent<ItemUpgradePlayerSprintSpeed>()))
{
return KnownUpgrade.SprintSpeed;
}
if (Object.op_Implicit((Object)(object)go.GetComponent<ItemUpgradePlayerHealth>()))
{
return KnownUpgrade.Health;
}
if (Object.op_Implicit((Object)(object)go.GetComponent<ItemUpgradePlayerGrabStrength>()))
{
return KnownUpgrade.GrabStrength;
}
if (Object.op_Implicit((Object)(object)go.GetComponent<ItemUpgradePlayerExtraJump>()))
{
return KnownUpgrade.ExtraJump;
}
if (Object.op_Implicit((Object)(object)go.GetComponent<ItemUpgradePlayerTumbleWings>()))
{
return KnownUpgrade.TumbleWings;
}
if (Object.op_Implicit((Object)(object)go.GetComponent<ItemUpgradePlayerGrabRange>()))
{
return KnownUpgrade.GrabRange;
}
if (Object.op_Implicit((Object)(object)go.GetComponent<ItemUpgradePlayerGrabThrow>()))
{
return KnownUpgrade.GrabThrow;
}
if (Object.op_Implicit((Object)(object)go.GetComponent<ItemUpgradePlayerCrouchRest>()))
{
return KnownUpgrade.CrouchRest;
}
if (Object.op_Implicit((Object)(object)go.GetComponent<ItemUpgradePlayerTumbleClimb>()))
{
return KnownUpgrade.TumbleClimb;
}
return KnownUpgrade.None;
}
public static void BeginMergeNetwork(PhotonView host, PhotonView other)
{
if (Object.op_Implicit((Object)(object)host))
{
if (!Object.op_Implicit((Object)(object)((Component)host).gameObject.GetComponent<SynthesisNetwork>()))
{
((Component)host).gameObject.AddComponent<SynthesisNetwork>();
}
host.RPC("RPC_Synthesize", (RpcTarget)0, new object[1] { Object.op_Implicit((Object)(object)other) ? other.ViewID : 0 });
}
}
[IteratorStateMachine(typeof(<AnimateAndMergeRPC>d__3))]
public static IEnumerator AnimateAndMergeRPC(PhotonView hostPv, int otherViewId)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <AnimateAndMergeRPC>d__3(0)
{
hostPv = hostPv,
otherViewId = otherViewId
};
}
[IteratorStateMachine(typeof(<AnimateAndMergeLocal>d__4))]
public static IEnumerator AnimateAndMergeLocal(SynthesisNode a, SynthesisNode b)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <AnimateAndMergeLocal>d__4(0)
{
a = a,
b = b
};
}
private static string ComposeName(GameObject a, GameObject b)
{
string text = ResolveItemName(a);
string text2 = ResolveItemName(b);
if (string.CompareOrdinal(text, text2) > 0)
{
string text3 = text;
text = text2;
text2 = text3;
}
return text + " + " + text2;
}
private static string ResolveItemName(GameObject go)
{
if (!Object.op_Implicit((Object)(object)go))
{
return "Item";
}
ItemAttributes val = default(ItemAttributes);
if (go.TryGetComponent<ItemAttributes>(ref val) && Object.op_Implicit((Object)(object)val) && Object.op_Implicit((Object)(object)val.item))
{
return val.item.itemName;
}
return ((Object)go).name;
}
private static float ComputeHue(KnownUpgrade a, KnownUpgrade b)
{
float num = (float)a * 0.1619f + (float)b * 0.3271f + 0.137f;
return Mathf.Repeat(num, 1f);
}
private static KnownUpgrade[] BuildParts(SynthesisNode a, SynthesisNode b)
{
List<KnownUpgrade> list = new List<KnownUpgrade>(2);
if ((Object)(object)a != (Object)null)
{
list.Add(a.Type);
}
if ((Object)(object)b != (Object)null)
{
list.Add(b.Type);
}
return list.ToArray();
}
[IteratorStateMachine(typeof(<AnimatePair>d__9))]
private static IEnumerator AnimatePair(GameObject a, GameObject b)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <AnimatePair>d__9(0)
{
a = a,
b = b
};
}
private static void ApplySynthesis(GameObject host, string newName, float hueShift, KnownUpgrade[] parts)
{
//IL_003e: Unknown result type (might be due to invalid IL or missing references)
//IL_0048: Expected O, but got Unknown
//IL_008c: Unknown result type (might be due to invalid IL or missing references)
//IL_0096: Expected O, but got Unknown
if (Object.op_Implicit((Object)(object)host))
{
ItemUpgrade val = host.GetComponent<ItemUpgrade>();
if (!Object.op_Implicit((Object)(object)val))
{
val = host.AddComponent<ItemUpgrade>();
}
if (val.upgradeEvent == null)
{
val.upgradeEvent = new UnityEvent();
}
((UnityEventBase)val.upgradeEvent).RemoveAllListeners();
SynthesisCombinedUpgrade synthesisCombinedUpgrade = host.GetComponent<SynthesisCombinedUpgrade>();
if (!Object.op_Implicit((Object)(object)synthesisCombinedUpgrade))
{
synthesisCombinedUpgrade = host.AddComponent<SynthesisCombinedUpgrade>();
}
synthesisCombinedUpgrade.parts = parts;
synthesisCombinedUpgrade.applied = false;
val.upgradeEvent.AddListener(new UnityAction(synthesisCombinedUpgrade.PerformUpgrade));
ApplyHue(host, hueShift);
}
}
private static void ApplyHue(GameObject host, float hueShift)
{
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
//IL_001b: Expected O, but got Unknown
//IL_0056: Unknown result type (might be due to invalid IL or missing references)
//IL_0049: Unknown result type (might be due to invalid IL or missing references)
//IL_005b: Unknown result type (might be due to invalid IL or missing references)
//IL_005d: Unknown result type (might be due to invalid IL or missing references)
//IL_0081: Unknown result type (might be due to invalid IL or missing references)
//IL_0086: Unknown result type (might be due to invalid IL or missing references)
//IL_008e: Unknown result type (might be due to invalid IL or missing references)
Renderer[] componentsInChildren = host.GetComponentsInChildren<Renderer>(true);
float num = default(float);
float num2 = default(float);
float num3 = default(float);
foreach (Renderer val in componentsInChildren)
{
MaterialPropertyBlock val2 = new MaterialPropertyBlock();
val.GetPropertyBlock(val2);
Color val3 = ((Object.op_Implicit((Object)(object)val.sharedMaterial) && val.sharedMaterial.HasProperty("_Color")) ? val.sharedMaterial.color : Color.white);
Color.RGBToHSV(val3, ref num, ref num2, ref num3);
num = Mathf.Repeat(num + hueShift, 1f);
Color val4 = Color.HSVToRGB(num, num2, num3);
val2.SetColor("_Color", val4);
val.SetPropertyBlock(val2);
}
}
}
public class SynthesisCombinedUpgrade : MonoBehaviour
{
public KnownUpgrade[] parts = Array.Empty<KnownUpgrade>();
public bool applied;
private ItemToggle toggle;
private void Awake()
{
toggle = ((Component)this).GetComponent<ItemToggle>();
}
public void PerformUpgrade()
{
//IL_019b: Unknown result type (might be due to invalid IL or missing references)
//IL_01a5: Expected O, but got Unknown
if (applied || !Object.op_Implicit((Object)(object)toggle) || (Object)(object)PunManager.instance == (Object)null)
{
return;
}
PlayerAvatar val = SemiFunc.PlayerAvatarGetFromPhotonID(toggle.playerTogglePhotonID);
if (!Object.op_Implicit((Object)(object)val))
{
return;
}
string text = SemiFunc.PlayerGetSteamID(val);
for (int i = 0; i < parts.Length; i++)
{
switch (parts[i])
{
case KnownUpgrade.Energy:
PunManager.instance.UpgradePlayerEnergy(text, 1);
break;
case KnownUpgrade.SprintSpeed:
PunManager.instance.UpgradePlayerSprintSpeed(text, 1);
break;
case KnownUpgrade.Health:
PunManager.instance.UpgradePlayerHealth(text, 1);
break;
case KnownUpgrade.GrabStrength:
PunManager.instance.UpgradePlayerGrabStrength(text, 1);
break;
case KnownUpgrade.ExtraJump:
PunManager.instance.UpgradePlayerExtraJump(text, 1);
break;
case KnownUpgrade.TumbleWings:
PunManager.instance.UpgradePlayerTumbleWings(text, 1);
break;
case KnownUpgrade.GrabRange:
PunManager.instance.UpgradePlayerGrabRange(text, 1);
break;
case KnownUpgrade.GrabThrow:
PunManager.instance.UpgradePlayerThrowStrength(text, 1);
break;
case KnownUpgrade.CrouchRest:
PunManager.instance.UpgradePlayerCrouchRest(text, 1);
break;
case KnownUpgrade.TumbleClimb:
PunManager.instance.UpgradePlayerTumbleClimb(text, 1);
break;
}
}
applied = true;
ItemUpgrade component = ((Component)this).GetComponent<ItemUpgrade>();
if ((Object)(object)component != (Object)null && component.upgradeEvent != null)
{
component.upgradeEvent.RemoveListener(new UnityAction(PerformUpgrade));
}
}
}
public static class SynthesisAudio
{
[CompilerGenerated]
private sealed class <LoadNearDll>d__1 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public string dllLocation;
private string <dir>5__1;
private string[] <oggs>5__2;
private string[] <wavs>5__3;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <LoadNearDll>d__1(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<dir>5__1 = null;
<oggs>5__2 = null;
<wavs>5__3 = null;
<>1__state = -2;
}
private bool MoveNext()
{
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<dir>5__1 = "";
try
{
<dir>5__1 = Path.GetDirectoryName(dllLocation);
}
catch
{
}
if (string.IsNullOrEmpty(<dir>5__1) || !Directory.Exists(<dir>5__1))
{
return false;
}
<oggs>5__2 = Directory.GetFiles(<dir>5__1, "*.ogg", SearchOption.TopDirectoryOnly);
if (<oggs>5__2 != null && <oggs>5__2.Length != 0)
{
<>2__current = LoadOgg(<oggs>5__2[0]);
<>1__state = 1;
return true;
}
break;
case 1:
<>1__state = -1;
if (Object.op_Implicit((Object)(object)clip))
{
return false;
}
break;
}
<wavs>5__3 = Directory.GetFiles(<dir>5__1, "*.wav", SearchOption.TopDirectoryOnly);
if (<wavs>5__3 != null && <wavs>5__3.Length != 0)
{
clip = WavLoader.Load(<wavs>5__3[0]);
}
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();
}
}
[CompilerGenerated]
private sealed class <LoadOgg>d__2 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public string path;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <LoadOgg>d__2(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
if (<>1__state != 0)
{
return false;
}
<>1__state = -1;
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();
}
}
private static AudioClip clip;
[IteratorStateMachine(typeof(<LoadNearDll>d__1))]
public static IEnumerator LoadNearDll(string dllLocation)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <LoadNearDll>d__1(0)
{
dllLocation = dllLocation
};
}
[IteratorStateMachine(typeof(<LoadOgg>d__2))]
private static IEnumerator LoadOgg(string path)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <LoadOgg>d__2(0)
{
path = path
};
}
public static void Play(Vector3 pos)
{
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
if (Object.op_Implicit((Object)(object)clip))
{
AudioSource.PlayClipAtPoint(clip, pos);
}
}
}
internal static class WavLoader
{
public static AudioClip Load(string path)
{
try
{
using FileStream input = File.OpenRead(path);
using BinaryReader binaryReader = new BinaryReader(input);
if (ReadTag(binaryReader) != "RIFF")
{
return null;
}
binaryReader.ReadInt32();
if (ReadTag(binaryReader) != "WAVE")
{
return null;
}
int num = 1;
int num2 = 44100;
int num3 = 16;
int num4 = 1;
byte[] array = null;
while (binaryReader.BaseStream.Position + 8 <= binaryReader.BaseStream.Length)
{
string text = ReadTag(binaryReader);
int num5 = binaryReader.ReadInt32();
if (text == "fmt ")
{
num4 = binaryReader.ReadInt16();
num = binaryReader.ReadInt16();
num2 = binaryReader.ReadInt32();
binaryReader.ReadInt32();
binaryReader.ReadInt16();
num3 = binaryReader.ReadInt16();
int num6 = num5 - 16;
if (num6 > 0)
{
binaryReader.ReadBytes(num6);
}
}
else if (text == "data")
{
array = binaryReader.ReadBytes(num5);
}
else
{
binaryReader.ReadBytes(num5);
}
}
if (array == null)
{
return null;
}
float[] array2;
if (num4 == 1 && num3 == 16)
{
int num7 = array.Length / 2;
array2 = new float[num7];
int num8 = 0;
int num9 = 0;
while (num9 < num7)
{
short num10 = (short)(array[num8] | (array[num8 + 1] << 8));
array2[num9] = (float)num10 / 32768f;
num9++;
num8 += 2;
}
}
else
{
if (num4 != 3 || num3 != 32)
{
return null;
}
int num11 = array.Length / 4;
array2 = new float[num11];
Buffer.BlockCopy(array, 0, array2, 0, array.Length);
}
int num12 = array2.Length / num;
AudioClip val = AudioClip.Create(Path.GetFileNameWithoutExtension(path), num12, num, num2, false);
val.SetData(array2, 0);
return val;
}
catch
{
return null;
}
}
private static string ReadTag(BinaryReader br)
{
byte[] array = br.ReadBytes(4);
if (array.Length < 4)
{
return "";
}
return new string(new char[4]
{
(char)array[0],
(char)array[1],
(char)array[2],
(char)array[3]
});
}
}
}
