using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("TripleProjectiles")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("0.1.0.0")]
[assembly: AssemblyInformationalVersion("0.1.0+24662fadeff5955ed4ca55468e1621967bbb8e1a")]
[assembly: AssemblyProduct("TripleProjectiles")]
[assembly: AssemblyTitle("TripleProjectiles")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.1.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;
}
}
}
[BepInPlugin("com.adwamogus.tripleprojectiles", "Triple Projectiles", "1.0.0")]
public class TripleProjectilesPlugin : BaseUnityPlugin
{
[CompilerGenerated]
private sealed class <CloneProjectile>d__13 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public GameObject gameObject;
public string sourceMethod;
private ProjectileCloneMarker <marker>5__1;
private List<ProjectileCloneMarker> <projectileClones>5__2;
private float <currentAngle>5__3;
private float <angleStepSize>5__4;
private Rigidbody2D <originalRB>5__5;
private int <i>5__6;
private GameObject <newObject>5__7;
private ProjectileCloneMarker <newMarker>5__8;
private string[] <>s__9;
private int <>s__10;
private string <keyword>5__11;
private Vector2 <originalVelocity>5__12;
private int <i>5__13;
private ProjectileCloneMarker <clone>5__14;
private Rigidbody2D <rb>5__15;
private float <angle>5__16;
private Vector2 <newVel>5__17;
private float <baseAngle>5__18;
private int <i>5__19;
private ProjectileCloneMarker <clone>5__20;
private float <angle>5__21;
private Exception <ex>5__22;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <CloneProjectile>d__13(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<marker>5__1 = null;
<projectileClones>5__2 = null;
<originalRB>5__5 = null;
<newObject>5__7 = null;
<newMarker>5__8 = null;
<>s__9 = null;
<keyword>5__11 = null;
<clone>5__14 = null;
<rb>5__15 = null;
<clone>5__20 = null;
<ex>5__22 = null;
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_0030: Expected O, but got Unknown
//IL_0120: Unknown result type (might be due to invalid IL or missing references)
//IL_0130: Unknown result type (might be due to invalid IL or missing references)
//IL_02b9: Unknown result type (might be due to invalid IL or missing references)
//IL_02be: Unknown result type (might be due to invalid IL or missing references)
//IL_03fa: Unknown result type (might be due to invalid IL or missing references)
//IL_03ff: Unknown result type (might be due to invalid IL or missing references)
//IL_0403: Unknown result type (might be due to invalid IL or missing references)
//IL_0470: Unknown result type (might be due to invalid IL or missing references)
//IL_032c: Unknown result type (might be due to invalid IL or missing references)
//IL_0337: Unknown result type (might be due to invalid IL or missing references)
//IL_033c: Unknown result type (might be due to invalid IL or missing references)
//IL_0348: Unknown result type (might be due to invalid IL or missing references)
//IL_0389: Unknown result type (might be due to invalid IL or missing references)
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<>2__current = (object)new WaitForSeconds(0.05f);
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
if ((Object)(object)gameObject == (Object)null)
{
Log("[" + sourceMethod + "] object is null");
return false;
}
if ((Object)(object)gameObject.GetComponent<ProjectileCloneMarker>() != (Object)null || Multiplier.Value <= 1)
{
return false;
}
Log("[" + sourceMethod + "] Cloning " + ((Object)gameObject).name);
try
{
<marker>5__1 = gameObject.AddComponent<ProjectileCloneMarker>();
<marker>5__1.isOriginal = true;
<projectileClones>5__2 = new List<ProjectileCloneMarker>();
<projectileClones>5__2.Add(<marker>5__1);
<i>5__6 = 0;
while (<i>5__6 < Multiplier.Value - 1)
{
<newObject>5__7 = Object.Instantiate<GameObject>(((Component)<marker>5__1).gameObject, ((Component)<marker>5__1).transform.position, ((Component)<marker>5__1).transform.rotation, ((Component)<marker>5__1).transform.parent);
<newMarker>5__8 = <newObject>5__7.GetComponent<ProjectileCloneMarker>();
if ((Object)(object)<newMarker>5__8 == (Object)null)
{
<newMarker>5__8 = <newObject>5__7.AddComponent<ProjectileCloneMarker>();
}
<newMarker>5__8.isOriginal = false;
<projectileClones>5__2.Add(<newMarker>5__8);
<newObject>5__7 = null;
<newMarker>5__8 = null;
<i>5__6++;
}
<>s__9 = TPBlacklist.RigidbodyIgnore;
for (<>s__10 = 0; <>s__10 < <>s__9.Length; <>s__10++)
{
<keyword>5__11 = <>s__9[<>s__10];
if (((Object)gameObject).name.Contains(<keyword>5__11))
{
return false;
}
<keyword>5__11 = null;
}
<>s__9 = null;
<currentAngle>5__3 = -(MaxSpread.Value / 2);
<angleStepSize>5__4 = MaxSpread.Value / (Multiplier.Value - 1);
<originalRB>5__5 = ((Component)<marker>5__1).GetComponent<Rigidbody2D>();
if ((Object)(object)<originalRB>5__5 != (Object)null)
{
<originalVelocity>5__12 = <originalRB>5__5.linearVelocity;
<i>5__13 = 0;
while (<i>5__13 < <projectileClones>5__2.Count)
{
<clone>5__14 = <projectileClones>5__2[<i>5__13];
<rb>5__15 = ((Component)<clone>5__14).GetComponent<Rigidbody2D>();
if (!((Object)(object)<rb>5__15 == (Object)null))
{
<angle>5__16 = <currentAngle>5__3 + <angleStepSize>5__4 * (float)<i>5__13;
<newVel>5__17 = Rotate(<originalVelocity>5__12, <angle>5__16);
<rb>5__15.linearVelocity = <newVel>5__17;
((Component)<clone>5__14).transform.rotation = Quaternion.Euler(0f, 0f, Mathf.Atan2(<newVel>5__17.y, <newVel>5__17.x) * 57.29578f);
<clone>5__14 = null;
<rb>5__15 = null;
}
<i>5__13++;
}
}
else if (!OnlyClonePhysicsProjectiles.Value)
{
Quaternion rotation = ((Component)<marker>5__1).transform.rotation;
<baseAngle>5__18 = ((Quaternion)(ref rotation)).eulerAngles.z;
<i>5__19 = 0;
while (<i>5__19 < <projectileClones>5__2.Count)
{
<clone>5__20 = <projectileClones>5__2[<i>5__19];
<angle>5__21 = <currentAngle>5__3 + <angleStepSize>5__4 * (float)<i>5__19;
((Component)<clone>5__20).transform.rotation = Quaternion.Euler(0f, 0f, <baseAngle>5__18 + <angle>5__21);
<clone>5__20 = null;
<i>5__19++;
}
}
<marker>5__1 = null;
<projectileClones>5__2 = null;
<originalRB>5__5 = null;
}
catch (Exception ex)
{
<ex>5__22 = ex;
Log(<ex>5__22.ToString());
}
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 string Name = "Triple Projectiles";
public static ConfigEntry<int> Multiplier;
public static ConfigEntry<int> MaxSpread;
public static ConfigEntry<bool> debugLog;
public static ConfigEntry<bool> debugLogDestroy;
public static ConfigEntry<bool> EnablePlayerProjectiles;
public static ConfigEntry<bool> OnlyClonePhysicsProjectiles;
private static ManualLogSource logger;
private static List<string> blacklisted = new List<string>();
private void Awake()
{
((BaseUnityPlugin)this).Logger.LogInfo((object)("Plugin " + Name + " has loaded!"));
logger = ((BaseUnityPlugin)this).Logger;
Multiplier = ((BaseUnityPlugin)this).Config.Bind<int>("General", "Multiplier", 3, "Projectile * Multiplier = the amount of projectiles spawned");
MaxSpread = ((BaseUnityPlugin)this).Config.Bind<int>("General", "MaxSpread", 60, "Spreads the clones in MaxSpread degrees");
EnablePlayerProjectiles = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "EnablePlayerProjectiles", false, "Enables player projectiles (tools)");
OnlyClonePhysicsProjectiles = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "OnlyClonePhysicsProjectiles", false, "Disables cloning of static objects like flame walls or tentacles in the lost lace fight.");
debugLog = ((BaseUnityPlugin)this).Config.Bind<bool>("Debug", "DebugLog", false, "For development");
debugLogDestroy = ((BaseUnityPlugin)this).Config.Bind<bool>("Debug", "debugLogDestroy", false, "For development");
Harmony.CreateAndPatchAll(typeof(TripleProjectilesPlugin), (string)null);
}
public static void Log(string msg)
{
bool flag = true;
if (logger != null)
{
logger.LogInfo((object)msg);
return;
}
logger = Logger.CreateLogSource(Name);
logger.LogInfo((object)msg);
}
[HarmonyPostfix]
[HarmonyPatch(typeof(ObjectPool), "Spawn", new Type[]
{
typeof(GameObject),
typeof(Transform),
typeof(Vector3),
typeof(Quaternion)
})]
private static void SpawnPostfix(GameObject __result)
{
try
{
FilterObject(__result, "ObjectPool.Spawn");
}
catch (Exception ex)
{
Log(ex.ToString());
}
}
private static void FilterObject(GameObject __result, string sourceMethod)
{
string[] generalBlacklist = TPBlacklist.GeneralBlacklist;
foreach (string text in generalBlacklist)
{
if (((Object)__result).name.Contains(text))
{
if (debugLog.Value && !blacklisted.Contains(((Object)__result).name))
{
blacklisted.Add(((Object)__result).name);
Log("[GeneralBlacklist] " + ((Object)__result).name + " was blacklisted by keyword " + text);
}
return;
}
}
if (!EnablePlayerProjectiles.Value)
{
string[] playerBlacklist = TPBlacklist.PlayerBlacklist;
foreach (string text2 in playerBlacklist)
{
if (((Object)__result).name.Contains(text2))
{
if (debugLog.Value && !blacklisted.Contains(((Object)__result).name))
{
blacklisted.Add(((Object)__result).name);
Log("[PlayerBlacklist] " + ((Object)__result).name + " was blacklisted by keyword " + text2);
}
return;
}
}
}
((MonoBehaviour)CoroutineRunner.Instance).StartCoroutine(CloneProjectile(__result, sourceMethod));
}
[IteratorStateMachine(typeof(<CloneProjectile>d__13))]
private static IEnumerator CloneProjectile(GameObject gameObject, string sourceMethod)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <CloneProjectile>d__13(0)
{
gameObject = gameObject,
sourceMethod = sourceMethod
};
}
private static Vector2 Rotate(Vector2 v, float degrees)
{
//IL_0017: Unknown result type (might be due to invalid IL or missing references)
//IL_001f: Unknown result type (might be due to invalid IL or missing references)
//IL_0028: 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_0039: Unknown result type (might be due to invalid IL or missing references)
//IL_003e: Unknown result type (might be due to invalid IL or missing references)
//IL_0041: Unknown result type (might be due to invalid IL or missing references)
float num = degrees * (MathF.PI / 180f);
float num2 = Mathf.Sin(num);
float num3 = Mathf.Cos(num);
return new Vector2(v.x * num3 - v.y * num2, v.x * num2 + v.y * num3);
}
private static void LogAllComponents(GameObject gameObject)
{
//IL_007f: Unknown result type (might be due to invalid IL or missing references)
//IL_0086: Expected O, but got Unknown
Log("--- Components on " + ((Object)gameObject).name + " ---");
Component[] components = gameObject.GetComponents<Component>();
Component[] array = components;
foreach (Component val in array)
{
if ((Object)(object)val != (Object)null)
{
Log(((object)val).GetType().Name);
}
else
{
Log("Missing (null) Component found!");
}
}
foreach (Transform item in gameObject.transform)
{
Transform val2 = item;
Log("[" + ((Object)gameObject).name + "] has child: " + ((Object)((Component)val2).gameObject).name);
components = ((Component)val2).GetComponents<Component>();
Log("--- Components on " + ((Object)val2).name + " ---");
Component[] array2 = components;
foreach (Component val3 in array2)
{
if ((Object)(object)val3 != (Object)null)
{
Log(((object)val3).GetType().Name);
}
else
{
Log("Missing (null) Component found!");
}
}
}
}
}
public class ProjectileCloneMarker : MonoBehaviour
{
public bool isOriginal = false;
private void OnDisable()
{
if (isOriginal)
{
if (TripleProjectilesPlugin.debugLogDestroy.Value)
{
TripleProjectilesPlugin.Log("[Original] Destroying Component");
}
Object.Destroy((Object)(object)this);
}
else
{
if (TripleProjectilesPlugin.debugLogDestroy.Value)
{
TripleProjectilesPlugin.Log("[Clone] Destroying GameObject");
}
Object.Destroy((Object)(object)((Component)this).gameObject);
}
}
}
public class CoroutineRunner : MonoBehaviour
{
private static CoroutineRunner? _instance;
public static CoroutineRunner Instance
{
get
{
//IL_0016: Unknown result type (might be due to invalid IL or missing references)
//IL_001c: Expected O, but got Unknown
if ((Object)(object)_instance == (Object)null)
{
GameObject val = new GameObject("TPCoroutineRunner");
_instance = val.AddComponent<CoroutineRunner>();
Object.DontDestroyOnLoad((Object)(object)val);
}
return _instance;
}
}
}
public static class TPBlacklist
{
public static readonly string[] GeneralBlacklist = new string[42]
{
"Audio", "Effect", "thread_spines", "Silk_Recharge_glow", "Silk Chunk", "hornet", "Spatter White", "Splash", "Dripper White", "Prompt",
"Impact", "Strike Nail", "Geo Get", "blood", "Pt", "Threaded Corpse Steam", "Shell Shard", "Hit Particles", "standard_health_hit", "Block Hit v2",
"Geo", "Dust Land Small R", "White Flash", "HP Up Particles", "dive_in", "Hit Flash Black", "Wanderer_Precision_strike", "double health hit", "Hornet", "Conch Projectile",
"first_weaver_tele_flash", "Thread Sphere Slash", "Block Hit Dull", "water_maggot_follow", "hero_maggoted_effect", "Block Hit Silent", "hunter_combo_damage_effect", "Boss Death Antic", "Boss Death Explosion", "cog_dancer_parry_flash",
"Hit Lines Generic", "Collectable Get Msg"
};
public static readonly string[] PlayerBlacklist = new string[6] { "Drill Down Black Rock Hit", "Clockwork Hatchling", "Weaver Bomb", "Tool", "Hero Wisp Fireball", "Revenge Crystal Hornet" };
public static readonly string[] RigidbodyIgnore = new string[0];
}
namespace BepInEx
{
[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
[Conditional("CodeGeneration")]
internal sealed class BepInAutoPluginAttribute : Attribute
{
public BepInAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
{
}
}
}
namespace BepInEx.Preloader.Core.Patching
{
[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
[Conditional("CodeGeneration")]
internal sealed class PatcherAutoPluginAttribute : Attribute
{
public PatcherAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
{
}
}
}
