using System;
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.Logging;
using EZDamage.Controllers;
using EZDamage.Data;
using GameNetcodeStuff;
using HarmonyLib;
using LethalNetworkAPI;
using Microsoft.CodeAnalysis;
using Unity.Netcode;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("EZDamage")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("EZDamage")]
[assembly: AssemblyTitle("EZDamage")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
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;
}
}
}
namespace EZDamage
{
public static class API
{
public static void DamagePlayers(Vector3 center, float radius = 1f, int damage = 1, CauseOfDeath causeOfDeath = 0)
{
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
PlayerDamageData playerDamageData = default(PlayerDamageData);
playerDamageData.center = new SVector3(center);
playerDamageData.radius = radius;
playerDamageData.damage = damage;
playerDamageData.causeOfDeath = ((object)(CauseOfDeath)(ref causeOfDeath)).ToString();
PlayerDamageData playerDamageData2 = playerDamageData;
EZDamage.PlayerDamageMessage.SendServer(playerDamageData2);
}
public static void DamageEnemies(Vector3 center, float radius = 1f, int damage = 1)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
DamageController.DamageOrKillEnemiesInRadius(center, radius, damage);
}
public static void KillPlayers(Vector3 center, float radius = 1f, CauseOfDeath causeOfDeath = 0)
{
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
PlayerDamageData playerDamageData = default(PlayerDamageData);
playerDamageData.center = new SVector3(center);
playerDamageData.radius = radius;
playerDamageData.damage = -1;
playerDamageData.causeOfDeath = ((object)(CauseOfDeath)(ref causeOfDeath)).ToString();
PlayerDamageData playerDamageData2 = playerDamageData;
EZDamage.PlayerDamageMessage.SendServer(playerDamageData2);
}
public static void KillEnemies(Vector3 center, float radius = 1f)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
DamageController.DamageOrKillEnemiesInRadius(center, radius, -1);
}
public static void DamageEverything(Vector3 center, float radius = 1f, int damage = 1, CauseOfDeath causeOfDeath = 0)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0004: 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)
DamagePlayers(center, radius, damage, causeOfDeath);
DamageEnemies(center, radius, damage);
}
public static void KillEverything(Vector3 center, float radius = 1f, CauseOfDeath causeOfDeath = 0)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0004: 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)
DamagePlayers(center, radius, -1, causeOfDeath);
DamageEnemies(center, radius, -1);
}
}
[BepInPlugin("com.jacobot5.EZDamage", "EZDamage", "1.0.0")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
public class EZDamage : BaseUnityPlugin
{
public const string GUID = "com.jacobot5.EZDamage";
public const string NAME = "EZDamage";
public const string VERSION = "1.0.0";
private readonly Harmony harmony = new Harmony("com.jacobot5.EZDamage");
internal static ManualLogSource Log;
internal static LNetworkMessage<PlayerDamageData> PlayerDamageMessage { get; private set; }
private void Awake()
{
Log = Logger.CreateLogSource("com.jacobot5.EZDamage");
Log.LogInfo((object)"EZDamage has awoken.");
PlayerDamageMessage = LNetworkMessage<PlayerDamageData>.Connect("EZDamage_Strike", (Action<PlayerDamageData, ulong>)null, (Action<PlayerDamageData>)null, (Action<PlayerDamageData, ulong>)null);
PlayerDamageMessage.OnServerReceived += OnDamageServer;
PlayerDamageMessage.OnClientReceived += OnDamageClient;
}
private void OnDamageServer(PlayerDamageData data, ulong sender)
{
PlayerDamageMessage.SendClients(data);
}
private void OnDamageClient(PlayerDamageData data)
{
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
DamageController.DamageOrKillPlayersInRadius(data.center.ToVector3(), data.radius, data.damage, data.causeOfDeath);
}
}
}
namespace EZDamage.Data
{
[Serializable]
public struct SVector3
{
public float x;
public float y;
public float z;
public SVector3(Vector3 v)
{
//IL_0002: 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_001a: Unknown result type (might be due to invalid IL or missing references)
x = v.x;
y = v.y;
z = v.z;
}
public Vector3 ToVector3()
{
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
return new Vector3(x, y, z);
}
}
[Serializable]
public struct PlayerDamageData
{
public SVector3 center;
public float radius;
public int damage;
public string causeOfDeath;
}
}
namespace EZDamage.Controllers
{
public class DamageController
{
public static int combinedLayers = 1084754248;
public static void DamageOrKillPlayersInRadius(Vector3 center, float radius, int damage, string deathString)
{
//IL_0015: 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_000f: 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_00a8: Unknown result type (might be due to invalid IL or missing references)
//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
//IL_007d: Unknown result type (might be due to invalid IL or missing references)
//IL_0087: 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_0091: 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)
CauseOfDeath result;
CauseOfDeath val = ((!Enum.TryParse<CauseOfDeath>(deathString, out result)) ? ((CauseOfDeath)0) : result);
Collider[] array = Physics.OverlapSphere(center, radius, combinedLayers, (QueryTriggerInteraction)2);
Collider[] array2 = array;
foreach (Collider val2 in array2)
{
PlayerControllerB component = ((Component)val2).GetComponent<PlayerControllerB>();
if ((Object)(object)component != (Object)null && !component.isPlayerDead && (Object)(object)component == (Object)(object)GameNetworkManager.Instance.localPlayerController)
{
if (damage == -1)
{
component.KillPlayer(Vector3.down * 17f, true, val, 0, default(Vector3));
}
else
{
component.DamagePlayer(damage, true, true, val, 0, false, Vector3.down * 17f);
}
}
}
}
public static void DamageOrKillEnemiesInRadius(Vector3 center, float radius, int damage)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
Collider[] array = Physics.OverlapSphere(center, radius, combinedLayers, (QueryTriggerInteraction)2);
Collider[] array2 = array;
foreach (Collider val in array2)
{
EnemyAICollisionDetect component = ((Component)val).GetComponent<EnemyAICollisionDetect>();
if (!((Object)(object)component != (Object)null) || !((Object)(object)component.mainScript != (Object)null))
{
continue;
}
EnemyAI mainScript = component.mainScript;
if (!((NetworkBehaviour)mainScript).IsOwner || mainScript.isEnemyDead || !mainScript.enemyType.canDie)
{
continue;
}
if (damage == -1)
{
mainScript.KillEnemyOnOwnerClient(false);
continue;
}
IHittable val2 = (IHittable)(object)((mainScript is IHittable) ? mainScript : null);
if (val2 != null)
{
int num = Mathf.Clamp(damage / 25, 1, 5);
val2.Hit(num, Vector3.down, GameNetworkManager.Instance.localPlayerController, true, -1);
}
}
}
}
}
namespace System.Runtime.CompilerServices
{
[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
internal sealed class IgnoresAccessChecksToAttribute : Attribute
{
public IgnoresAccessChecksToAttribute(string assemblyName)
{
}
}
}
