using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
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;
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("UltraSilverCoins")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.3.0.0")]
[assembly: AssemblyInformationalVersion("0.3.0+0c7499bfac987385c91a77b83655a1aa459e2415")]
[assembly: AssemblyProduct("UltraSilverCoins")]
[assembly: AssemblyTitle("UltraSilverCoins")]
[assembly: AssemblyVersion("0.3.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 UltraSilverCoins
{
internal static class AltMarksmanChargeController
{
private static readonly MethodInfo CheckCoinChargesMethod = AccessTools.Method(typeof(Revolver), "CheckCoinCharges", (Type[])null, (Type[])null);
private static readonly FieldInfo CoinChargeField = AccessTools.Field(typeof(Revolver), "coinCharge");
internal static float MaxCharge => (float)SilverCoinsConfig.CoinCharges * 100f;
private static float ChargePerSecond => 100f / SilverCoinsConfig.RechargeSeconds;
internal static bool Active { get; private set; }
internal static void OnRevolverEnabled(Revolver revolver)
{
if (!((Object)(object)revolver == (Object)null) && revolver.gunVariation == 1)
{
Active = revolver.altVersion;
if (revolver.altVersion)
{
EnforceAltMarksman(revolver);
InvokeCheckCoinCharges(revolver);
}
else
{
RestorePanelVisibility(revolver);
}
}
}
internal static void OnRevolverDisabled(Revolver revolver)
{
if (Plugin.IsAltMarksman(revolver))
{
Active = false;
}
}
internal static void ClampCharge(WeaponCharges charges)
{
if (!((Object)(object)charges == (Object)null))
{
if (charges.rev1charge > MaxCharge)
{
charges.rev1charge = MaxCharge;
}
if (charges.rev1charge < 0f)
{
charges.rev1charge = 0f;
}
}
}
internal static void EnforceAltMarksman(Revolver revolver)
{
if (Plugin.IsAltMarksman(revolver))
{
Active = true;
WeaponCharges weaponCharges = GetWeaponCharges();
ClampCharge(weaponCharges);
SetCoinCharge(revolver, ((Object)(object)weaponCharges == (Object)null) ? 0f : weaponCharges.rev1charge);
}
}
internal static void RechargeAltMarksman(WeaponCharges charges, float amount, float previousRev1Charge)
{
if (!((Object)(object)charges == (Object)null))
{
float num = Mathf.Min(previousRev1Charge, MaxCharge);
charges.rev1charge = Mathf.MoveTowards(num, MaxCharge, ChargePerSecond * Mathf.Max(0f, amount));
ClampCharge(charges);
}
}
internal static void UpdateMarksmanDisplay(Revolver revolver)
{
//IL_0130: 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)
if ((Object)(object)revolver == (Object)null || revolver.gunVariation != 1)
{
return;
}
if (!revolver.altVersion)
{
RestorePanelVisibility(revolver);
return;
}
Image[] coinPanels = revolver.coinPanels;
if (coinPanels == null || coinPanels.Length == 0)
{
return;
}
WeaponCharges weaponCharges = GetWeaponCharges();
ClampCharge(weaponCharges);
float num = (((Object)(object)weaponCharges == (Object)null) ? 0f : weaponCharges.rev1charge);
SetCoinCharge(revolver, num);
bool[] coinPanelsCharged = revolver.coinPanelsCharged;
int num2 = Mathf.Clamp(SilverCoinsConfig.CoinCharges, 1, coinPanels.Length);
HashSet<Transform> hashSet = new HashSet<Transform>();
for (int i = 0; i < coinPanels.Length && i < num2; i++)
{
if ((Object)(object)coinPanels[i] != (Object)null && (Object)(object)((Component)coinPanels[i]).transform.parent != (Object)null)
{
hashSet.Add(((Component)coinPanels[i]).transform.parent);
}
}
for (int j = 0; j < coinPanels.Length; j++)
{
Image val = coinPanels[j];
if (!((Object)(object)val == (Object)null))
{
bool flag = j < num2;
ApplySlotVisibility(val, flag, hashSet);
if (!flag)
{
SetCharged(coinPanelsCharged, j, charged: false);
continue;
}
float num3 = (val.fillAmount = Mathf.Clamp01(num / 100f - (float)j));
((Graphic)val).color = ((num3 >= 1f) ? SilverCoinStyle.SilverColor : Color.gray);
SetCharged(coinPanelsCharged, j, num3 >= 1f);
}
}
}
private static void ApplySlotVisibility(Image panel, bool visible, HashSet<Transform> visibleParents)
{
Transform parent = ((Component)panel).transform.parent;
if (visible)
{
if ((Object)(object)parent != (Object)null && !((Component)parent).gameObject.activeSelf)
{
((Component)parent).gameObject.SetActive(true);
}
((Component)panel).gameObject.SetActive(true);
((Behaviour)panel).enabled = true;
return;
}
panel.fillAmount = 0f;
((Behaviour)panel).enabled = false;
((Component)panel).gameObject.SetActive(false);
if ((Object)(object)parent != (Object)null && !visibleParents.Contains(parent))
{
((Component)parent).gameObject.SetActive(false);
}
}
private static void RestorePanelVisibility(Revolver revolver)
{
Image[] array = revolver?.coinPanels;
if (array == null)
{
return;
}
for (int i = 0; i < array.Length; i++)
{
if ((Object)(object)array[i] != (Object)null)
{
Transform parent = ((Component)array[i]).transform.parent;
if ((Object)(object)parent != (Object)null && !((Component)parent).gameObject.activeSelf)
{
((Component)parent).gameObject.SetActive(true);
}
((Component)array[i]).gameObject.SetActive(true);
((Behaviour)array[i]).enabled = true;
}
}
}
private static void SetCharged(bool[] chargedPanels, int index, bool charged)
{
if (chargedPanels != null && index >= 0 && index < chargedPanels.Length)
{
chargedPanels[index] = charged;
}
}
private static void InvokeCheckCoinCharges(Revolver revolver)
{
CheckCoinChargesMethod?.Invoke(revolver, null);
}
private static void SetCoinCharge(Revolver revolver, float charge)
{
CoinChargeField?.SetValue(revolver, Mathf.Clamp(charge, 0f, MaxCharge));
}
private static WeaponCharges GetWeaponCharges()
{
return MonoSingleton<WeaponCharges>.Instance;
}
}
[BepInPlugin("ultrasilvercoins.kiyroprower.ultrakill", "UltraSilverCoins", "0.3.0")]
[BepInProcess("ULTRAKILL.exe")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
public sealed class Plugin : BaseUnityPlugin
{
public const string PluginGuid = "ultrasilvercoins.kiyroprower.ultrakill";
public const string PluginName = "UltraSilverCoins";
public const string PluginVersion = "0.3.0";
public const string PluginConfiguratorGuid = "com.eternalUnion.pluginConfigurator";
internal static ManualLogSource Log;
private Harmony harmony;
private void Awake()
{
//IL_001c: Unknown result type (might be due to invalid IL or missing references)
//IL_0026: Expected O, but got Unknown
Log = ((BaseUnityPlugin)this).Logger;
SilverCoinsConfig.Initialize(((BaseUnityPlugin)this).Logger);
harmony = new Harmony("ultrasilvercoins.kiyroprower.ultrakill");
harmony.PatchAll();
((BaseUnityPlugin)this).Logger.LogInfo((object)"UltraSilverCoins 0.3.0 loaded.");
}
private void OnDestroy()
{
Harmony obj = harmony;
if (obj != null)
{
obj.UnpatchSelf();
}
}
internal static bool IsAltMarksman(Revolver revolver)
{
if ((Object)(object)revolver != (Object)null && revolver.gunVariation == 1)
{
return revolver.altVersion;
}
return false;
}
internal static bool IsAltMarksmanWeapon(GameObject weapon)
{
Revolver revolver = default(Revolver);
if ((Object)(object)weapon != (Object)null && weapon.TryGetComponent<Revolver>(ref revolver))
{
return IsAltMarksman(revolver);
}
return false;
}
}
internal sealed class SilverBeamMarker : MonoBehaviour
{
}
internal sealed class SilverCoinBehaviour : MonoBehaviour
{
private const float MinBounceSpeedSqr = 0.01f;
private const float TripleTimeDelay = 0.35f;
private const float TripleTimeEndDelay = 0.417f;
private const float DoubleTimeDelay = 1f;
private static readonly FieldInfo CurrentChargeField = AccessTools.Field(typeof(Coin), "currentCharge");
private static bool continuationPending;
private static int continuationShotsRemaining;
private static int continuationSolidBouncesRemaining;
private static Vector3 vanillaCoinScale = Vector3.zero;
private bool initialized;
private int shotsRemaining = MaxShots;
private int solidBouncesRemaining = MaxSolidBounces;
private Vector3 lastVelocity;
private Rigidbody cachedBody;
private static int MaxShots => SilverCoinsConfig.BounceTimes;
private static float ScaleMultiplier => SilverCoinsConfig.CoinSizeScale;
private static float BounceVelocity => SilverCoinsConfig.BounceForce;
private static int MaxSolidBounces => SilverCoinsConfig.SolidBounces;
internal static SilverCoinBehaviour Attach(Coin coin)
{
if ((Object)(object)coin == (Object)null)
{
return null;
}
SilverCoinBehaviour silverCoinBehaviour = default(SilverCoinBehaviour);
if (!((Component)coin).TryGetComponent<SilverCoinBehaviour>(ref silverCoinBehaviour))
{
silverCoinBehaviour = ((Component)coin).gameObject.AddComponent<SilverCoinBehaviour>();
}
silverCoinBehaviour.Initialize(coin);
return silverCoinBehaviour;
}
internal static bool TryGet(Coin coin, out SilverCoinBehaviour behaviour)
{
behaviour = null;
if ((Object)(object)coin != (Object)null)
{
return ((Component)coin).TryGetComponent<SilverCoinBehaviour>(ref behaviour);
}
return false;
}
internal void Initialize(Coin coin)
{
//IL_002f: 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_0046: Unknown result type (might be due to invalid IL or missing references)
//IL_004b: Unknown result type (might be due to invalid IL or missing references)
if (!initialized && !((Object)(object)coin == (Object)null))
{
initialized = true;
shotsRemaining = MaxShots;
solidBouncesRemaining = MaxSolidBounces;
if (vanillaCoinScale == Vector3.zero)
{
vanillaCoinScale = ((Component)coin).transform.localScale;
}
ApplySilverScale(coin);
SilverCoinStyle.ApplyCoin(((Component)coin).gameObject);
}
}
private void FixedUpdate()
{
//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)
if (solidBouncesRemaining > 0)
{
Rigidbody val = ResolveBody();
if ((Object)(object)val != (Object)null && !val.isKinematic)
{
lastVelocity = val.velocity;
}
}
}
internal void HandleReflectFinished(Coin coin)
{
if (!((Object)(object)coin == (Object)null) && !((Component)coin).gameObject.activeSelf)
{
shotsRemaining--;
if (shotsRemaining > 0)
{
RemoveCollectorsTargeting(((Component)coin).gameObject);
ReviveAndBounce(coin);
}
}
}
internal static void RecordContinuation(Coin coin)
{
if (TryGet(coin, out var behaviour))
{
continuationPending = true;
continuationShotsRemaining = behaviour.shotsRemaining;
continuationSolidBouncesRemaining = behaviour.solidBouncesRemaining;
}
}
internal static void HandleCloneContinuation(Coin coin)
{
if (TryGet(coin, out var behaviour))
{
behaviour.initialized = true;
if (continuationPending)
{
behaviour.shotsRemaining = continuationShotsRemaining;
behaviour.solidBouncesRemaining = continuationSolidBouncesRemaining;
continuationPending = false;
}
ApplySilverScale(coin);
SilverCoinStyle.ApplyCoin(((Component)coin).gameObject);
ApplyBounceVelocity(coin);
}
}
private static void ApplySilverScale(Coin coin)
{
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
//IL_0021: Unknown result type (might be due to invalid IL or missing references)
//IL_002b: Unknown result type (might be due to invalid IL or missing references)
if (!((Object)(object)coin == (Object)null) && !(vanillaCoinScale == Vector3.zero))
{
((Component)coin).transform.localScale = vanillaCoinScale * ScaleMultiplier;
}
}
private static void ApplyBounceVelocity(Coin coin)
{
//IL_002f: Unknown result type (might be due to invalid IL or missing references)
//IL_0039: Unknown result type (might be due to invalid IL or missing references)
Rigidbody val = (((Object)(object)coin.rb != (Object)null) ? coin.rb : ((Component)coin).GetComponent<Rigidbody>());
if ((Object)(object)val != (Object)null && !val.isKinematic)
{
val.velocity = Vector3.up * BounceVelocity;
}
}
internal bool TryBounceOffSolid(Coin coin, Collision collision)
{
//IL_007f: Unknown result type (might be due to invalid IL or missing references)
//IL_0077: 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_0097: Unknown result type (might be due to invalid IL or missing references)
//IL_009c: Unknown result type (might be due to invalid IL or missing references)
//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
//IL_00af: 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_00d2: Unknown result type (might be due to invalid IL or missing references)
//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
//IL_00de: Unknown result type (might be due to invalid IL or missing references)
//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
if (solidBouncesRemaining <= 0 || collision == null || collision.contactCount == 0)
{
return false;
}
if (!LayerMaskDefaults.IsMatchingLayer(collision.gameObject.layer, (LMD)1))
{
return false;
}
Rigidbody val = (((Object)(object)coin != (Object)null && (Object)(object)coin.rb != (Object)null) ? coin.rb : ResolveBody());
if ((Object)(object)val == (Object)null || val.isKinematic)
{
return false;
}
Vector3 val2 = ((((Vector3)(ref lastVelocity)).sqrMagnitude > 0.01f) ? lastVelocity : val.velocity);
if (((Vector3)(ref val2)).sqrMagnitude < 0.01f)
{
return false;
}
ContactPoint contact = collision.GetContact(0);
Vector3 normal = ((ContactPoint)(ref contact)).normal;
Vector3 val3 = Vector3.Reflect(val2, normal);
if (Vector3.Dot(val3, normal) < 0f)
{
val3 = normal * ((Vector3)(ref val2)).magnitude;
}
val.velocity = val3;
val.angularVelocity = Vector3.zero;
lastVelocity = val3;
solidBouncesRemaining--;
return true;
}
private Rigidbody ResolveBody()
{
if ((Object)(object)cachedBody == (Object)null)
{
cachedBody = ((Component)this).GetComponent<Rigidbody>();
}
return cachedBody;
}
private static void RemoveCollectorsTargeting(GameObject coinObject)
{
CoinCollector[] array = Object.FindObjectsOfType<CoinCollector>();
for (int i = 0; i < array.Length; i++)
{
if ((Object)(object)array[i] != (Object)null && (Object)(object)array[i].coin == (Object)(object)coinObject)
{
Object.Destroy((Object)(object)((Component)array[i]).gameObject);
}
}
}
private void ReviveAndBounce(Coin coin)
{
//IL_0076: 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_008c: 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)
GameObject gameObject = ((Component)coin).gameObject;
gameObject.SetActive(true);
coin.shot = false;
coin.shotByEnemy = false;
coin.hitTimes = 1;
coin.doubled = false;
Collider[] components = ((Component)coin).GetComponents<Collider>();
for (int i = 0; i < components.Length; i++)
{
components[i].enabled = true;
}
Rigidbody val = (((Object)(object)coin.rb != (Object)null) ? coin.rb : ((Component)coin).GetComponent<Rigidbody>());
if ((Object)(object)val != (Object)null)
{
val.isKinematic = false;
val.velocity = Vector3.zero;
val.angularVelocity = Vector3.zero;
val.AddForce(Vector3.up * BounceVelocity, (ForceMode)2);
}
((MonoBehaviour)coin).CancelInvoke("GetDeleted");
((MonoBehaviour)coin).Invoke("GetDeleted", 5f);
RestartChargeGlowWindow(coin);
ApplySilverScale(coin);
SilverCoinStyle.ApplyCoin(gameObject);
}
private static void RestartChargeGlowWindow(Coin coin)
{
DestroyCurrentCharge(coin);
((MonoBehaviour)coin).CancelInvoke("TripleTime");
((MonoBehaviour)coin).CancelInvoke("TripleTimeEnd");
((MonoBehaviour)coin).CancelInvoke("DoubleTime");
((MonoBehaviour)coin).Invoke("TripleTime", 0.35f);
((MonoBehaviour)coin).Invoke("TripleTimeEnd", 0.417f);
((MonoBehaviour)coin).Invoke("DoubleTime", 1f);
}
private static void DestroyCurrentCharge(Coin coin)
{
object? obj = CurrentChargeField?.GetValue(coin);
GameObject val = (GameObject)((obj is GameObject) ? obj : null);
if ((Object)(object)val != (Object)null)
{
Object.Destroy((Object)(object)val);
CurrentChargeField.SetValue(coin, null);
}
}
}
internal static class SilverCoinsConfig
{
[CompilerGenerated]
private static class <>O
{
public static PostBoolValueChangeEvent <0>__UpdateExperimentalVisibility;
}
public const string PluginGuid = "ultrasilvercoins.kiyroprower.ultrakill";
private const int DefaultCoinCharges = 2;
private const float DefaultRechargeSeconds = 6.5f;
private const int DefaultBounceTimes = 2;
private const float DefaultBounceForce = 25f;
private const float DefaultCoinSizeScale = 1.25f;
private const int DefaultSolidBounces = 0;
private const int MinCoinCharges = 1;
private const int MaxCoinCharges = 4;
private const int MinBounceTimes = 1;
private const int MaxBounceTimes = 10;
private const float MinRechargeSeconds = 0.1f;
private const float MaxRechargeSeconds = 60f;
private const float MinBounceForce = 0f;
private const float MaxBounceForce = 200f;
private const float MinCoinSizeScale = 0.1f;
private const float MaxCoinSizeScale = 5f;
private const int MinSolidBounces = 0;
private const int MaxSolidBounces = 10;
private static PluginConfigurator _configurator;
private static ManualLogSource _log;
private static ConfigHeader _experimentalHeader;
private static ConfigHeader _railgunThunderboltDescription;
public static IntField CoinChargesField { get; private set; }
public static FloatField RechargeTimeField { get; private set; }
public static IntField BounceTimesField { get; private set; }
public static FloatField BounceForceField { get; private set; }
public static FloatField CoinSizeScaleField { get; private set; }
public static IntField SolidBouncesField { get; private set; }
public static BoolField SuperSecretSettingsField { get; private set; }
public static BoolField RailgunThunderboltField { get; private set; }
public static int CoinCharges
{
get
{
if (CoinChargesField != null)
{
return Mathf.Clamp(CoinChargesField.value, 1, 4);
}
return 2;
}
}
public static float RechargeSeconds
{
get
{
if (RechargeTimeField != null)
{
return Mathf.Max(0.1f, RechargeTimeField.value);
}
return 6.5f;
}
}
public static int BounceTimes
{
get
{
if (BounceTimesField != null)
{
return Mathf.Clamp(BounceTimesField.value, 1, 10);
}
return 2;
}
}
public static float BounceForce
{
get
{
if (BounceForceField != null)
{
return Mathf.Max(0f, BounceForceField.value);
}
return 25f;
}
}
public static float CoinSizeScale
{
get
{
if (CoinSizeScaleField != null)
{
return Mathf.Max(0.1f, CoinSizeScaleField.value);
}
return 1.25f;
}
}
public static int SolidBounces
{
get
{
if (SolidBouncesField != null)
{
return Mathf.Clamp(SolidBouncesField.value, 0, 10);
}
return 0;
}
}
public static bool SuperSecretSettings
{
get
{
if (SuperSecretSettingsField != null)
{
return SuperSecretSettingsField.value;
}
return false;
}
}
public static bool RailgunThunderbolt
{
get
{
if (SuperSecretSettings && RailgunThunderboltField != null)
{
return RailgunThunderboltField.value;
}
return false;
}
}
public static void Initialize(ManualLogSource log)
{
_log = log;
try
{
CreateMenu();
}
catch (Exception ex)
{
ManualLogSource log2 = _log;
if (log2 != null)
{
log2.LogWarning((object)("PluginConfigurator menu could not be initialized: " + ex.GetType().Name + ": " + ex.Message));
}
}
}
private static void CreateMenu()
{
//IL_0034: Unknown result type (might be due to invalid IL or missing references)
//IL_003e: Expected O, but got Unknown
//IL_0064: Unknown result type (might be due to invalid IL or missing references)
//IL_006e: Expected O, but got Unknown
//IL_0089: Unknown result type (might be due to invalid IL or missing references)
//IL_0093: Expected O, but got Unknown
//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
//IL_00c3: Expected O, but got Unknown
//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
//IL_00f3: Expected O, but got Unknown
//IL_010e: Unknown result type (might be due to invalid IL or missing references)
//IL_0118: Expected O, but got Unknown
//IL_0130: Unknown result type (might be due to invalid IL or missing references)
//IL_013a: Expected O, but got Unknown
//IL_014e: Unknown result type (might be due to invalid IL or missing references)
//IL_0158: Expected O, but got Unknown
//IL_0164: Unknown result type (might be due to invalid IL or missing references)
//IL_016e: Expected O, but got Unknown
//IL_0192: Unknown result type (might be due to invalid IL or missing references)
//IL_0197: Unknown result type (might be due to invalid IL or missing references)
//IL_019d: Expected O, but got Unknown
if (_configurator == null)
{
_configurator = PluginConfigurator.Create("Ultra Silver Coins", "ultrasilvercoins.kiyroprower.ultrakill");
ConfigPanel rootPanel = _configurator.rootPanel;
CoinChargesField = new IntField(rootPanel, "Alt-Marksman Coin Charges", "ultrasilvercoins.coinCharges", 2, 1, 4);
AddDescription(rootPanel, "How many coins the Alt-Marksman revolver can hold and throw.");
RechargeTimeField = new FloatField(rootPanel, "Alt-Marksman Coin Recharge Time", "ultrasilvercoins.rechargeTime", 6.5f, 0.1f, 60f);
AddDescription(rootPanel, "Seconds to recharge a single coin charge.");
BounceTimesField = new IntField(rootPanel, "Coin Bounce Times", "ultrasilvercoins.bounceTimes", 2, 1, 10);
AddDescription(rootPanel, "How many times a silver coin can be shot before it is consumed.");
BounceForceField = new FloatField(rootPanel, "Coin Bounce Force", "ultrasilvercoins.bounceForce", 25f, 0f, 200f);
AddDescription(rootPanel, "Upward velocity applied to a silver coin each time it bounces.");
CoinSizeScaleField = new FloatField(rootPanel, "Coin Size Scale", "ultrasilvercoins.coinSizeScale", 1.25f, 0.1f, 5f);
AddDescription(rootPanel, "Size multiplier applied to silver coins.");
SolidBouncesField = new IntField(rootPanel, "Coin Solid Bounces", "ultrasilvercoins.solidBounces", 0, 0, 10);
AddDescription(rootPanel, "How many times a silver coin ricochets off solid surfaces instead of vanishing on impact. Set to 0 to disable.");
SuperSecretSettingsField = new BoolField(rootPanel, "Super Secret Settings", "ultrasilvercoins.superSecretSettings", false);
AddDescription(rootPanel, "Reveals experimental, untested, goofy silver coin options. Everything below is off by default.");
_experimentalHeader = new ConfigHeader(rootPanel, "Experimental Silver Coin Mechanics", 18);
RailgunThunderboltField = new BoolField(rootPanel, "Railgun Coin Thunderbolt", "ultrasilvercoins.railgunThunderbolt", false);
_railgunThunderboltDescription = AddDescription(rootPanel, "Shoot a silver coin with the Railcannon and the reflected beam calls a Ferryman thunderbolt down on each enemy it hits. The blast will not hurt you.");
BoolField superSecretSettingsField = SuperSecretSettingsField;
object obj = <>O.<0>__UpdateExperimentalVisibility;
if (obj == null)
{
PostBoolValueChangeEvent val = UpdateExperimentalVisibility;
<>O.<0>__UpdateExperimentalVisibility = val;
obj = (object)val;
}
superSecretSettingsField.postValueChangeEvent += (PostBoolValueChangeEvent)obj;
UpdateExperimentalVisibility(SuperSecretSettings);
}
}
private static void UpdateExperimentalVisibility(bool visible)
{
bool hidden = !visible;
if (_experimentalHeader != null)
{
((ConfigField)_experimentalHeader).hidden = hidden;
}
if (RailgunThunderboltField != null)
{
((ConfigField)RailgunThunderboltField).hidden = hidden;
}
if (_railgunThunderboltDescription != null)
{
((ConfigField)_railgunThunderboltDescription).hidden = hidden;
}
}
private static ConfigHeader AddDescription(ConfigPanel root, string text)
{
//IL_0004: Unknown result type (might be due to invalid IL or missing references)
//IL_0009: 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_0015: Expected O, but got Unknown
return new ConfigHeader(root, text, 14)
{
textColor = Color.gray
};
}
}
internal static class SilverCoinStyle
{
internal static readonly Color SilverColor = new Color(0.78f, 0.82f, 0.88f, 1f);
private static readonly Color SilverEmission = new Color(0.55f, 0.65f, 0.85f, 1f);
private static readonly Color TransparentSilver = new Color(0.78f, 0.82f, 0.88f, 0f);
private const string CoinTexture2Resource = "UltraSilverCoins.Assets.coin01_2.png";
private const string CoinTexture3Resource = "UltraSilverCoins.Assets.coin01_3.png";
private const string MuzzleFlashSilverResource = "UltraSilverCoins.Assets.muzzleflashsilver.png";
private static bool attemptedTextureLoad;
private static Texture2D coinTexture2;
private static Texture2D coinTexture3;
private static Texture2D muzzleFlashSilverTexture;
private static Sprite silverMuzzleFlashSprite;
internal static void ApplyCoin(GameObject coinObject)
{
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
//IL_003f: Unknown result type (might be due to invalid IL or missing references)
//IL_004d: 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_0084: Unknown result type (might be due to invalid IL or missing references)
if (!((Object)(object)coinObject == (Object)null))
{
MeshRenderer[] componentsInChildren = coinObject.GetComponentsInChildren<MeshRenderer>(true);
for (int i = 0; i < componentsInChildren.Length; i++)
{
ApplyRendererMaterials((Renderer)(object)componentsInChildren[i], SilverColor, replaceCoinTextures: true);
}
TrailRenderer[] componentsInChildren2 = coinObject.GetComponentsInChildren<TrailRenderer>(true);
for (int j = 0; j < componentsInChildren2.Length; j++)
{
componentsInChildren2[j].startColor = SilverColor;
componentsInChildren2[j].endColor = TransparentSilver;
ApplyRendererMaterials((Renderer)(object)componentsInChildren2[j], SilverColor);
}
Light[] componentsInChildren3 = coinObject.GetComponentsInChildren<Light>(true);
for (int k = 0; k < componentsInChildren3.Length; k++)
{
componentsInChildren3[k].color = SilverColor;
}
}
}
internal static void ApplySpentCoin(GameObject coinObject)
{
//IL_0099: Unknown result type (might be due to invalid IL or missing references)
//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)coinObject == (Object)null)
{
return;
}
EnsureCoinTexturesLoaded();
Texture2D val = coinTexture3 ?? coinTexture2;
if ((Object)(object)val == (Object)null)
{
return;
}
MeshRenderer[] componentsInChildren = coinObject.GetComponentsInChildren<MeshRenderer>(true);
for (int i = 0; i < componentsInChildren.Length; i++)
{
if ((Object)(object)componentsInChildren[i] == (Object)null)
{
continue;
}
Material material = ((Renderer)componentsInChildren[i]).material;
if (!((Object)(object)material == (Object)null))
{
if (material.HasProperty("_MainTex"))
{
material.SetTexture("_MainTex", (Texture)(object)val);
}
if (material.HasProperty("_BaseMap"))
{
material.SetTexture("_BaseMap", (Texture)(object)val);
}
if (material.HasProperty("_Color"))
{
material.SetColor("_Color", Color.white);
}
if (material.HasProperty("_BaseColor"))
{
material.SetColor("_BaseColor", Color.white);
}
}
}
}
internal static void ApplyBeam(GameObject beamObject)
{
//IL_002c: Unknown result type (might be due to invalid IL or missing references)
//IL_003a: 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_0071: 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_008d: Unknown result type (might be due to invalid IL or missing references)
//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
//IL_00df: Unknown result type (might be due to invalid IL or missing references)
//IL_0109: Unknown result type (might be due to invalid IL or missing references)
//IL_010e: Unknown result type (might be due to invalid IL or missing references)
//IL_0112: Unknown result type (might be due to invalid IL or missing references)
//IL_0117: Unknown result type (might be due to invalid IL or missing references)
if (!((Object)(object)beamObject == (Object)null))
{
SilverBeamMarker silverBeamMarker = default(SilverBeamMarker);
if (!beamObject.TryGetComponent<SilverBeamMarker>(ref silverBeamMarker))
{
beamObject.AddComponent<SilverBeamMarker>();
}
LineRenderer[] componentsInChildren = beamObject.GetComponentsInChildren<LineRenderer>(true);
for (int i = 0; i < componentsInChildren.Length; i++)
{
componentsInChildren[i].startColor = SilverColor;
componentsInChildren[i].endColor = SilverColor;
ApplyRendererMaterials((Renderer)(object)componentsInChildren[i], SilverColor);
}
TrailRenderer[] componentsInChildren2 = beamObject.GetComponentsInChildren<TrailRenderer>(true);
for (int j = 0; j < componentsInChildren2.Length; j++)
{
componentsInChildren2[j].startColor = SilverColor;
componentsInChildren2[j].endColor = TransparentSilver;
ApplyRendererMaterials((Renderer)(object)componentsInChildren2[j], SilverColor);
}
Renderer[] componentsInChildren3 = beamObject.GetComponentsInChildren<Renderer>(true);
for (int k = 0; k < componentsInChildren3.Length; k++)
{
ApplyRendererMaterials(componentsInChildren3[k], SilverColor);
}
Light[] componentsInChildren4 = beamObject.GetComponentsInChildren<Light>(true);
for (int l = 0; l < componentsInChildren4.Length; l++)
{
componentsInChildren4[l].color = SilverColor;
}
ParticleSystem[] componentsInChildren5 = beamObject.GetComponentsInChildren<ParticleSystem>(true);
for (int m = 0; m < componentsInChildren5.Length; m++)
{
MainModule main = componentsInChildren5[m].main;
((MainModule)(ref main)).startColor = new MinMaxGradient(SilverColor);
}
}
}
internal static void ApplyEffect(GameObject effectObject)
{
if (!((Object)(object)effectObject == (Object)null))
{
RecolorEffect(effectObject);
SilverEffectTint silverEffectTint = default(SilverEffectTint);
if (!effectObject.TryGetComponent<SilverEffectTint>(ref silverEffectTint))
{
effectObject.AddComponent<SilverEffectTint>();
}
}
}
internal static void RecolorEffect(GameObject effectObject)
{
//IL_004a: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)effectObject == (Object)null)
{
return;
}
Renderer[] componentsInChildren = effectObject.GetComponentsInChildren<Renderer>(true);
foreach (Renderer obj in componentsInChildren)
{
TintSpriteRenderer((SpriteRenderer)(object)((obj is SpriteRenderer) ? obj : null));
}
Light[] componentsInChildren2 = effectObject.GetComponentsInChildren<Light>(true);
for (int j = 0; j < componentsInChildren2.Length; j++)
{
if ((Object)(object)componentsInChildren2[j] != (Object)null)
{
componentsInChildren2[j].color = SilverColor;
}
}
ParticleSystem[] componentsInChildren3 = effectObject.GetComponentsInChildren<ParticleSystem>(true);
for (int k = 0; k < componentsInChildren3.Length; k++)
{
RecolorParticleSystem(componentsInChildren3[k]);
}
}
internal static void TintSpriteRenderer(SpriteRenderer spriteRenderer)
{
//IL_006a: 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_008f: 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_0042: Unknown result type (might be due to invalid IL or missing references)
//IL_0047: Unknown result type (might be due to invalid IL or missing references)
//IL_0058: 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)
if ((Object)(object)spriteRenderer == (Object)null)
{
return;
}
if (IsMuzzleFlashSprite(spriteRenderer.sprite))
{
Sprite val = GetSilverMuzzleFlashSprite(spriteRenderer.sprite);
if ((Object)(object)val != (Object)null && (Object)(object)spriteRenderer.sprite != (Object)(object)val)
{
spriteRenderer.sprite = val;
}
Color color = spriteRenderer.color;
spriteRenderer.color = new Color(1f, 1f, 1f, color.a);
}
else
{
Color color2 = spriteRenderer.color;
spriteRenderer.color = new Color(SilverColor.r, SilverColor.g, SilverColor.b, color2.a);
}
}
private static bool IsMuzzleFlashSprite(Sprite sprite)
{
if ((Object)(object)sprite == (Object)null)
{
return false;
}
if ((Object)(object)sprite == (Object)(object)silverMuzzleFlashSprite)
{
return true;
}
string text = (((Object)sprite).name ?? string.Empty).ToLowerInvariant();
string text2 = (((Object)(object)sprite.texture != (Object)null) ? (((Object)sprite.texture).name ?? string.Empty).ToLowerInvariant() : string.Empty);
if (!text.Contains("muzzleflash"))
{
return text2.Contains("muzzleflash");
}
return true;
}
private static Sprite GetSilverMuzzleFlashSprite(Sprite original)
{
//IL_0100: Unknown result type (might be due to invalid IL or missing references)
//IL_0105: 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_004d: Unknown result type (might be due to invalid IL or missing references)
//IL_0060: Unknown result type (might be due to invalid IL or missing references)
//IL_0065: Unknown result type (might be due to invalid IL or missing references)
//IL_0082: 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_00af: 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_00bf: Unknown result type (might be due to invalid IL or missing references)
//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)silverMuzzleFlashSprite != (Object)null)
{
return silverMuzzleFlashSprite;
}
Texture2D val = GetMuzzleFlashSilverTexture();
if ((Object)(object)val == (Object)null)
{
return null;
}
float num = 100f;
Vector2 val2 = default(Vector2);
((Vector2)(ref val2))..ctor(0.5f, 0.5f);
if ((Object)(object)original != (Object)null)
{
Rect rect = original.rect;
if (((Rect)(ref rect)).width > 0f)
{
rect = original.rect;
if (((Rect)(ref rect)).height > 0f && original.pixelsPerUnit > 0f)
{
rect = original.rect;
float num2 = ((Rect)(ref rect)).width / original.pixelsPerUnit;
if (num2 > 0f)
{
num = (float)((Texture)val).width / num2;
}
float x = original.pivot.x;
rect = original.rect;
float num3 = x / ((Rect)(ref rect)).width;
float y = original.pivot.y;
rect = original.rect;
((Vector2)(ref val2))..ctor(num3, y / ((Rect)(ref rect)).height);
}
}
}
silverMuzzleFlashSprite = Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), val2, num);
((Object)silverMuzzleFlashSprite).name = "muzzleflashsilver_sprite";
return silverMuzzleFlashSprite;
}
internal static void RecolorParticleSystem(ParticleSystem particles)
{
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
//IL_0015: 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)
//IL_0025: Unknown result type (might be due to invalid IL or missing references)
//IL_002a: 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_004d: Unknown result type (might be due to invalid IL or missing references)
//IL_0038: Unknown result type (might be due to invalid IL or missing references)
//IL_003d: 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_0060: Unknown result type (might be due to invalid IL or missing references)
if (!((Object)(object)particles == (Object)null))
{
MainModule main = particles.main;
((MainModule)(ref main)).startColor = RecolorGradient(((MainModule)(ref main)).startColor);
ColorOverLifetimeModule colorOverLifetime = particles.colorOverLifetime;
if (((ColorOverLifetimeModule)(ref colorOverLifetime)).enabled)
{
((ColorOverLifetimeModule)(ref colorOverLifetime)).color = RecolorGradient(((ColorOverLifetimeModule)(ref colorOverLifetime)).color);
}
ColorBySpeedModule colorBySpeed = particles.colorBySpeed;
if (((ColorBySpeedModule)(ref colorBySpeed)).enabled)
{
((ColorBySpeedModule)(ref colorBySpeed)).color = RecolorGradient(((ColorBySpeedModule)(ref colorBySpeed)).color);
}
}
}
private static MinMaxGradient RecolorGradient(MinMaxGradient source)
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
//IL_0022: Expected I4, but got Unknown
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_002b: Unknown result type (might be due to invalid IL or missing references)
//IL_0030: Unknown result type (might be due to invalid IL or missing references)
//IL_0060: Unknown result type (might be due to invalid IL or missing references)
//IL_0038: Unknown result type (might be due to invalid IL or missing references)
//IL_003d: Unknown result type (might be due to invalid IL or missing references)
//IL_0044: 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_004e: 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_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)
ParticleSystemGradientMode mode = ((MinMaxGradient)(ref source)).mode;
switch ((int)mode)
{
case 0:
return new MinMaxGradient(WithSilverRgb(((MinMaxGradient)(ref source)).color));
case 2:
return new MinMaxGradient(WithSilverRgb(((MinMaxGradient)(ref source)).colorMin), WithSilverRgb(((MinMaxGradient)(ref source)).colorMax));
case 1:
case 4:
return new MinMaxGradient(RecolorGradientKeys(((MinMaxGradient)(ref source)).gradient));
case 3:
return new MinMaxGradient(RecolorGradientKeys(((MinMaxGradient)(ref source)).gradientMin), RecolorGradientKeys(((MinMaxGradient)(ref source)).gradientMax));
default:
return new MinMaxGradient(SilverColor);
}
}
private static Gradient RecolorGradientKeys(Gradient source)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_0006: Expected O, but got Unknown
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
//IL_001c: Unknown result type (might be due to invalid IL or missing references)
//IL_0021: Unknown result type (might be due to invalid IL or missing references)
//IL_0028: Unknown result type (might be due to invalid IL or missing references)
//IL_0032: 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_004e: Unknown result type (might be due to invalid IL or missing references)
//IL_0053: Unknown result type (might be due to invalid IL or missing references)
//IL_0064: Unknown result type (might be due to invalid IL or missing references)
//IL_0069: 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_008c: 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)
Gradient val = new Gradient();
if (source == null)
{
val.SetKeys((GradientColorKey[])(object)new GradientColorKey[2]
{
new GradientColorKey(SilverColor, 0f),
new GradientColorKey(SilverColor, 1f)
}, (GradientAlphaKey[])(object)new GradientAlphaKey[2]
{
new GradientAlphaKey(1f, 0f),
new GradientAlphaKey(0f, 1f)
});
return val;
}
GradientColorKey[] colorKeys = source.colorKeys;
for (int i = 0; i < colorKeys.Length; i++)
{
colorKeys[i].color = SilverColor;
}
val.mode = source.mode;
val.SetKeys(colorKeys, source.alphaKeys);
return val;
}
private static Color WithSilverRgb(Color original)
{
//IL_001e: Unknown result type (might be due to invalid IL or missing references)
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
return new Color(SilverColor.r, SilverColor.g, SilverColor.b, original.a);
}
private static void ApplyRendererMaterials(Renderer renderer, Color color, bool replaceCoinTextures = false)
{
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
if (!((Object)(object)renderer == (Object)null))
{
Material[] materials = renderer.materials;
for (int i = 0; i < materials.Length; i++)
{
ApplyMaterial(materials[i], color, replaceCoinTextures);
}
}
}
private static void ApplyMaterial(Material material, Color color, bool replaceCoinTextures = false)
{
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
//IL_0030: Unknown result type (might be due to invalid IL or missing references)
//IL_0017: Unknown result type (might be due to invalid IL or missing references)
//IL_001c: 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_0062: 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)
if (!((Object)(object)material == (Object)null))
{
Color val = color;
if (replaceCoinTextures && ApplyCoinTexture(material))
{
val = Color.white;
}
if (material.HasProperty("_Color"))
{
material.SetColor("_Color", val);
}
if (material.HasProperty("_BaseColor"))
{
material.SetColor("_BaseColor", val);
}
if (material.HasProperty("_TintColor"))
{
material.SetColor("_TintColor", val);
}
if (material.HasProperty("_EmissionColor"))
{
material.SetColor("_EmissionColor", SilverEmission);
material.EnableKeyword("_EMISSION");
}
}
}
private static bool ApplyCoinTexture(Material material)
{
EnsureCoinTexturesLoaded();
if ((Object)(object)coinTexture2 == (Object)null && (Object)(object)coinTexture3 == (Object)null)
{
return false;
}
Texture val = (material.HasProperty("_MainTex") ? material.GetTexture("_MainTex") : null);
string obj = ((Object)material).name ?? string.Empty;
string text = (((Object)(object)val == (Object)null) ? string.Empty : (((Object)val).name ?? string.Empty));
string text2 = (obj + " " + text).ToLowerInvariant();
Texture2D val2 = null;
if (text2.Contains("coin01_3"))
{
val2 = coinTexture3 ?? coinTexture2;
}
else if (text2.Contains("coin01_2"))
{
val2 = coinTexture2 ?? coinTexture3;
}
else if (text2.Contains("coin"))
{
val2 = coinTexture2 ?? coinTexture3;
}
if ((Object)(object)val2 == (Object)null)
{
return false;
}
bool result = false;
if (material.HasProperty("_MainTex"))
{
material.SetTexture("_MainTex", (Texture)(object)val2);
result = true;
}
if (material.HasProperty("_BaseMap"))
{
material.SetTexture("_BaseMap", (Texture)(object)val2);
result = true;
}
return result;
}
private static void EnsureCoinTexturesLoaded()
{
if (!attemptedTextureLoad)
{
attemptedTextureLoad = true;
coinTexture2 = LoadEmbeddedTexture("UltraSilverCoins.Assets.coin01_2.png", "coin01_2_silver");
coinTexture3 = LoadEmbeddedTexture("UltraSilverCoins.Assets.coin01_3.png", "coin01_3_silver");
muzzleFlashSilverTexture = LoadEmbeddedTexture("UltraSilverCoins.Assets.muzzleflashsilver.png", "muzzleflashsilver");
}
}
private static Texture2D GetMuzzleFlashSilverTexture()
{
//IL_0027: Unknown result type (might be due to invalid IL or missing references)
EnsureCoinTexturesLoaded();
if ((Object)(object)muzzleFlashSilverTexture == (Object)null)
{
ManualLogSource log = Plugin.Log;
if (log != null)
{
log.LogWarning((object)"[UltraSilverCoins] muzzleflashsilver texture unavailable; using solid silver fallback.");
}
muzzleFlashSilverTexture = CreateSolidTexture(SilverColor);
}
return muzzleFlashSilverTexture;
}
private static Texture2D CreateSolidTexture(Color color)
{
//IL_0004: Unknown result type (might be due to invalid IL or missing references)
//IL_000a: Expected O, but got Unknown
//IL_002e: Unknown result type (might be due to invalid IL or missing references)
//IL_002f: Unknown result type (might be due to invalid IL or missing references)
Texture2D val = new Texture2D(4, 4, (TextureFormat)4, false);
((Object)val).name = "muzzleflashsilver_fallback";
Color[] array = (Color[])(object)new Color[((Texture)val).width * ((Texture)val).height];
for (int i = 0; i < array.Length; i++)
{
array[i] = color;
}
val.SetPixels(array);
val.Apply();
((Texture)val).wrapMode = (TextureWrapMode)1;
((Texture)val).filterMode = (FilterMode)1;
return val;
}
private static Texture2D LoadEmbeddedTexture(string resourceName, string textureName)
{
//IL_005a: Unknown result type (might be due to invalid IL or missing references)
//IL_0060: Expected O, but got Unknown
using Stream stream = Assembly.GetExecutingAssembly().GetManifestResourceStream(resourceName);
if (stream == null)
{
ManualLogSource log = Plugin.Log;
if (log != null)
{
log.LogWarning((object)("[UltraSilverCoins] embedded resource missing: " + resourceName));
}
return null;
}
byte[] array;
using (MemoryStream memoryStream = new MemoryStream())
{
stream.CopyTo(memoryStream);
array = memoryStream.ToArray();
}
Texture2D val = new Texture2D(2, 2, (TextureFormat)4, false);
((Object)val).name = textureName;
if (!ImageConversion.LoadImage(val, array, false))
{
ManualLogSource log2 = Plugin.Log;
if (log2 != null)
{
log2.LogWarning((object)$"[UltraSilverCoins] ImageConversion.LoadImage failed for {textureName} ({array.Length} bytes)");
}
Object.Destroy((Object)(object)val);
return null;
}
((Texture)val).wrapMode = (TextureWrapMode)1;
((Texture)val).filterMode = (FilterMode)1;
ManualLogSource log3 = Plugin.Log;
if (log3 != null)
{
log3.LogInfo((object)$"[UltraSilverCoins] loaded texture {textureName}: {((Texture)val).width}x{((Texture)val).height} ({array.Length} bytes)");
}
return val;
}
}
internal sealed class SilverEffectTint : MonoBehaviour
{
private void LateUpdate()
{
SilverCoinStyle.RecolorEffect(((Component)this).gameObject);
}
}
internal sealed class SilverThunderboltBeam : MonoBehaviour
{
private readonly HashSet<EnemyIdentifier> struckEnemies = new HashSet<EnemyIdentifier>();
internal bool TryRegisterHit(EnemyIdentifier enemy)
{
if ((Object)(object)enemy != (Object)null)
{
return struckEnemies.Add(enemy);
}
return false;
}
}
internal static class SilverThunderbolt
{
private static readonly FieldInfo LightningBoltField = AccessTools.Field(typeof(Ferryman), "lightningBolt");
private static LightningStrikeExplosive boltPrefab;
internal static void TagBeam(GameObject beam)
{
SilverThunderboltBeam silverThunderboltBeam = default(SilverThunderboltBeam);
if ((Object)(object)beam != (Object)null && !beam.TryGetComponent<SilverThunderboltBeam>(ref silverThunderboltBeam))
{
beam.AddComponent<SilverThunderboltBeam>();
}
}
internal static void Strike(Vector3 position)
{
//IL_0024: 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_0049: Unknown result type (might be due to invalid IL or missing references)
LightningStrikeExplosive val = ResolvePrefab();
if ((Object)(object)val == (Object)null || (Object)(object)val.normal == (Object)null)
{
return;
}
Explosion[] componentsInChildren = Object.Instantiate<GameObject>(val.normal, position, Quaternion.identity).GetComponentsInChildren<Explosion>(true);
for (int i = 0; i < componentsInChildren.Length; i++)
{
if ((Object)(object)componentsInChildren[i] != (Object)null)
{
componentsInChildren[i].canHit = (AffectedSubjects)2;
}
}
}
private static LightningStrikeExplosive ResolvePrefab()
{
if ((Object)(object)boltPrefab != (Object)null)
{
return boltPrefab;
}
if (LightningBoltField == null)
{
return null;
}
DefaultReferenceManager instance = MonoSingleton<DefaultReferenceManager>.Instance;
if ((Object)(object)instance == (Object)null || (Object)(object)instance.ferryman == (Object)null)
{
ManualLogSource log = Plugin.Log;
if (log != null)
{
log.LogWarning((object)"[UltraSilverCoins] Ferryman reference unavailable; cannot summon a thunderbolt yet.");
}
return null;
}
Ferryman componentInChildren = instance.ferryman.GetComponentInChildren<Ferryman>(true);
if ((Object)(object)componentInChildren == (Object)null)
{
return null;
}
object? value = LightningBoltField.GetValue(componentInChildren);
boltPrefab = (LightningStrikeExplosive)((value is LightningStrikeExplosive) ? value : null);
return boltPrefab;
}
}
}
namespace UltraSilverCoins.Patches
{
[HarmonyPatch(typeof(Coin), "Start")]
internal static class CoinStartPatch
{
private static void Postfix(Coin __instance)
{
if (Plugin.IsAltMarksmanWeapon(__instance.sourceWeapon))
{
if (SilverCoinBehaviour.TryGet(__instance, out var _))
{
SilverCoinBehaviour.HandleCloneContinuation(__instance);
}
else
{
SilverCoinBehaviour.Attach(__instance);
}
}
}
}
[HarmonyPatch(typeof(Coin), "Punchflection")]
internal static class CoinPunchflectionPatch
{
private static void Prefix(Coin __instance)
{
SilverCoinBehaviour.RecordContinuation(__instance);
}
}
[HarmonyPatch(typeof(Coin), "Bounce")]
internal static class CoinBouncePatch
{
private static void Prefix(Coin __instance)
{
SilverCoinBehaviour.RecordContinuation(__instance);
}
}
[HarmonyPatch(typeof(Coin), "OnCollisionEnter")]
internal static class CoinOnCollisionEnterPatch
{
private static bool Prefix(Coin __instance, Collision collision)
{
if (SilverCoinBehaviour.TryGet(__instance, out var behaviour) && behaviour.TryBounceOffSolid(__instance, collision))
{
return false;
}
return true;
}
}
[HarmonyPatch(typeof(Coin), "DelayedReflectRevolver")]
internal static class CoinDelayedReflectRevolverPatch
{
private static void Prefix(Coin __instance, GameObject beam)
{
//IL_0033: Unknown result type (might be due to invalid IL or missing references)
//IL_0039: Invalid comparison between Unknown and I4
RevolverBeam val = default(RevolverBeam);
if (!((Object)(object)beam == (Object)null) && SilverCoinBehaviour.TryGet(__instance, out var _) && beam.TryGetComponent<RevolverBeam>(ref val))
{
if (Plugin.IsAltMarksmanWeapon(val.sourceWeapon))
{
SilverCoinStyle.ApplyBeam(beam);
}
else if ((int)val.beamType == 1 && SilverCoinsConfig.RailgunThunderbolt)
{
SilverThunderbolt.TagBeam(beam);
}
}
}
}
[HarmonyPatch(typeof(Coin), "GetDeleted")]
internal static class CoinGetDeletedPatch
{
private static void Postfix(Coin __instance)
{
if (SilverCoinBehaviour.TryGet(__instance, out var _))
{
SilverCoinStyle.ApplySpentCoin(((Component)__instance).gameObject);
}
}
}
[HarmonyPatch(typeof(RevolverBeam), "ExecuteHits")]
internal static class RevolverBeamExecuteHitsPatch
{
private static void Postfix(RevolverBeam __instance, PhysicsCastResult currentHit)
{
//IL_0014: Unknown result type (might be due to invalid IL or missing references)
//IL_0052: Unknown result type (might be due to invalid IL or missing references)
//IL_0053: Unknown result type (might be due to invalid IL or missing references)
SilverThunderboltBeam silverThunderboltBeam = default(SilverThunderboltBeam);
if ((Object)(object)__instance == (Object)null || !((Component)__instance).TryGetComponent<SilverThunderboltBeam>(ref silverThunderboltBeam))
{
return;
}
Transform transform = currentHit.transform;
if (!((Object)(object)transform == (Object)null))
{
EnemyIdentifierIdentifier componentInParent = ((Component)transform).GetComponentInParent<EnemyIdentifierIdentifier>();
if (!((Object)(object)componentInParent == (Object)null) && !((Object)(object)componentInParent.eid == (Object)null) && silverThunderboltBeam.TryRegisterHit(componentInParent.eid))
{
SilverThunderbolt.Strike(currentHit.point);
}
}
}
}
[HarmonyPatch(typeof(Coin), "ReflectRevolver")]
internal static class CoinReflectRevolverPatch
{
private static void Postfix(Coin __instance)
{
if (SilverCoinBehaviour.TryGet(__instance, out var behaviour))
{
behaviour.HandleReflectFinished(__instance);
}
}
}
[HarmonyPatch(typeof(Coin), "SpawnBeam")]
internal static class CoinSpawnBeamPatch
{
private static void Postfix(Coin __instance, GameObject __result)
{
if ((Object)(object)__result != (Object)null && SilverCoinBehaviour.TryGet(__instance, out var _))
{
SilverCoinStyle.ApplyBeam(__result);
}
}
}
internal static class CoinChargeEffectTint
{
private static readonly FieldInfo CurrentChargeField = AccessTools.Field(typeof(Coin), "currentCharge");
internal static void Apply(Coin coin)
{
if (SilverCoinBehaviour.TryGet(coin, out var _))
{
object? obj = CurrentChargeField?.GetValue(coin);
SilverCoinStyle.ApplyEffect((GameObject)((obj is GameObject) ? obj : null));
}
}
}
[HarmonyPatch(typeof(Coin), "TripleTime")]
internal static class CoinTripleTimePatch
{
private static void Postfix(Coin __instance)
{
CoinChargeEffectTint.Apply(__instance);
}
}
[HarmonyPatch(typeof(Coin), "DoubleTime")]
internal static class CoinDoubleTimePatch
{
private static void Postfix(Coin __instance)
{
CoinChargeEffectTint.Apply(__instance);
}
}
[HarmonyPatch(typeof(RevolverBeam), "Start")]
internal static class RevolverBeamStartPatch
{
private static void Postfix(RevolverBeam __instance)
{
SilverBeamMarker silverBeamMarker = default(SilverBeamMarker);
if ((Object)(object)__instance != (Object)null && ((Component)__instance).TryGetComponent<SilverBeamMarker>(ref silverBeamMarker))
{
SilverCoinStyle.ApplyBeam(((Component)__instance).gameObject);
}
}
}
[HarmonyPatch(typeof(Revolver), "OnEnable")]
internal static class RevolverOnEnablePatch
{
private static void Postfix(Revolver __instance)
{
AltMarksmanChargeController.OnRevolverEnabled(__instance);
}
}
[HarmonyPatch(typeof(Revolver), "OnDisable")]
internal static class RevolverOnDisablePatch
{
private static void Postfix(Revolver __instance)
{
AltMarksmanChargeController.OnRevolverDisabled(__instance);
}
}
[HarmonyPatch(typeof(Revolver), "CheckCoinCharges")]
internal static class RevolverCheckCoinChargesPatch
{
private static void Prefix(Revolver __instance)
{
if (Plugin.IsAltMarksman(__instance))
{
AltMarksmanChargeController.ClampCharge(MonoSingleton<WeaponCharges>.Instance);
}
}
private static void Postfix(Revolver __instance)
{
AltMarksmanChargeController.UpdateMarksmanDisplay(__instance);
}
}
[HarmonyPatch(typeof(Revolver), "Update")]
internal static class RevolverUpdatePatch
{
private static void Prefix(Revolver __instance)
{
AltMarksmanChargeController.EnforceAltMarksman(__instance);
}
}
[HarmonyPatch(typeof(Revolver), "ThrowCoin")]
internal static class RevolverThrowCoinPatch
{
private static void Postfix(Revolver __instance)
{
if (Plugin.IsAltMarksman(__instance))
{
AltMarksmanChargeController.ClampCharge(MonoSingleton<WeaponCharges>.Instance);
}
}
}
[HarmonyPatch(typeof(WeaponCharges), "Charge")]
internal static class WeaponChargesChargePatch
{
private static void Prefix(WeaponCharges __instance, ref float __state)
{
__state = __instance.rev1charge;
}
private static void Postfix(WeaponCharges __instance, float amount, float __state)
{
if (AltMarksmanChargeController.Active)
{
AltMarksmanChargeController.RechargeAltMarksman(__instance, amount, __state);
}
}
}
[HarmonyPatch(typeof(WeaponCharges), "MaxCharges")]
internal static class WeaponChargesMaxChargesPatch
{
private static void Postfix(WeaponCharges __instance)
{
if (AltMarksmanChargeController.Active)
{
AltMarksmanChargeController.ClampCharge(__instance);
}
}
}
}
