Decompiled source of CodeRebirth v1.3.1

plugins/CodeRebirth/CodeRebirth.dll

Decompiled 2 weeks ago
using System;
using System.CodeDom.Compiler;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using CSync.Lib;
using CodeRebirth.NetcodePatcher;
using CodeRebirth.src.Content.Enemies;
using CodeRebirth.src.Content.Items;
using CodeRebirth.src.Content.Maps;
using CodeRebirth.src.Content.Unlockables;
using CodeRebirth.src.Content.Weapons;
using CodeRebirth.src.MiscScripts;
using CodeRebirth.src.MiscScripts.CustomPasses;
using CodeRebirth.src.ModCompats;
using CodeRebirth.src.Patches;
using CodeRebirth.src.Util;
using CullFactory.Behaviours.API;
using Dawn;
using Dawn.Internal;
using Dawn.Utils;
using DigitalRuby.ThunderAndLightning;
using Dusk;
using GameNetcodeStuff;
using HarmonyLib;
using IL.GameNetcodeStuff;
using LethalCompanyInputUtils.Api;
using LethalMoonUnlocks;
using Microsoft.CodeAnalysis;
using Mono.Cecil.Cil;
using MonoMod.Cil;
using MoreCompany.Cosmetics;
using MoreCounterplay;
using MoreShipUpgrades.UpgradeComponents.TierUpgrades.AttributeUpgrades;
using On;
using On.GameNetcodeStuff;
using OpenBodyCams;
using TMPro;
using TooManyEmotes.Patches;
using Unity.Netcode;
using Unity.Netcode.Components;
using UnityEngine;
using UnityEngine.AI;
using UnityEngine.Events;
using UnityEngine.Experimental.Rendering;
using UnityEngine.InputSystem;
using UnityEngine.InputSystem.Controls;
using UnityEngine.InputSystem.Utilities;
using UnityEngine.Rendering;
using UnityEngine.Rendering.HighDefinition;
using UnityEngine.Rendering.RendererUtils;
using UnityEngine.SceneManagement;
using UnityEngine.Serialization;
using UnityEngine.UI;
using UnityEngine.VFX;
using UnityEngine.Video;
using WeatherRegistry;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: IgnoresAccessChecksTo("AmazingAssets.TerrainToMesh")]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp-firstpass")]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: IgnoresAccessChecksTo("BaronDrakula.MoreCounterplay")]
[assembly: IgnoresAccessChecksTo("ClientNetworkTransform")]
[assembly: IgnoresAccessChecksTo("com.olegknyazev.softmask")]
[assembly: IgnoresAccessChecksTo("DissonanceVoip")]
[assembly: IgnoresAccessChecksTo("EasyTextEffects")]
[assembly: IgnoresAccessChecksTo("Facepunch Transport for Netcode for GameObjects")]
[assembly: IgnoresAccessChecksTo("Facepunch.Steamworks.Win64")]
[assembly: IgnoresAccessChecksTo("MoreShipUpgrades")]
[assembly: IgnoresAccessChecksTo("TooManyEmotes")]
[assembly: IgnoresAccessChecksTo("Unity.AI.Navigation")]
[assembly: IgnoresAccessChecksTo("Unity.Animation.Rigging")]
[assembly: IgnoresAccessChecksTo("Unity.Animation.Rigging.DocCodeExamples")]
[assembly: IgnoresAccessChecksTo("Unity.Burst")]
[assembly: IgnoresAccessChecksTo("Unity.Burst.Unsafe")]
[assembly: IgnoresAccessChecksTo("Unity.Collections")]
[assembly: IgnoresAccessChecksTo("Unity.Collections.LowLevel.ILSupport")]
[assembly: IgnoresAccessChecksTo("Unity.InputSystem")]
[assembly: IgnoresAccessChecksTo("Unity.InputSystem.ForUI")]
[assembly: IgnoresAccessChecksTo("Unity.Jobs")]
[assembly: IgnoresAccessChecksTo("Unity.Mathematics")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.Common")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.MetricTypes")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetStats")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetStatsMonitor.Component")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetStatsMonitor.Configuration")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetStatsMonitor.Implementation")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetStatsReporting")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetworkProfiler.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetworkSolutionInterface")]
[assembly: IgnoresAccessChecksTo("Unity.Netcode.Components")]
[assembly: IgnoresAccessChecksTo("Unity.Netcode.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.Networking.Transport")]
[assembly: IgnoresAccessChecksTo("Unity.ProBuilder.Csg")]
[assembly: IgnoresAccessChecksTo("Unity.ProBuilder")]
[assembly: IgnoresAccessChecksTo("Unity.ProBuilder.KdTree")]
[assembly: IgnoresAccessChecksTo("Unity.ProBuilder.Poly2Tri")]
[assembly: IgnoresAccessChecksTo("Unity.ProBuilder.Stl")]
[assembly: IgnoresAccessChecksTo("Unity.Profiling.Core")]
[assembly: IgnoresAccessChecksTo("Unity.RenderPipelines.Core.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.RenderPipelines.Core.ShaderLibrary")]
[assembly: IgnoresAccessChecksTo("Unity.RenderPipelines.HighDefinition.Config.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.RenderPipelines.HighDefinition.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.RenderPipelines.ShaderGraph.ShaderGraphLibrary")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Authentication")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Analytics")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Components")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Configuration")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Device")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Environments")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Environments.Internal")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Internal")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Networking")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Registration")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Scheduler")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Telemetry")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Threading")]
[assembly: IgnoresAccessChecksTo("Unity.Services.QoS")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Relay")]
[assembly: IgnoresAccessChecksTo("Unity.TextMeshPro")]
[assembly: IgnoresAccessChecksTo("Unity.Timeline")]
[assembly: IgnoresAccessChecksTo("Unity.VisualEffectGraph.Runtime")]
[assembly: IgnoresAccessChecksTo("UnityEngine.ARModule")]
[assembly: IgnoresAccessChecksTo("UnityEngine.NVIDIAModule")]
[assembly: IgnoresAccessChecksTo("UnityEngine.UI")]
[assembly: IgnoresAccessChecksTo("WeatherRegistry")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("CodeRebirth")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("Content mod that adds Custom Weathers, Items, Enemies and more.")]
[assembly: AssemblyFileVersion("1.3.1.0")]
[assembly: AssemblyInformationalVersion("1.3.1+91c8b43bfa5d74dd103fcdbed7d379f4d0cfa88a")]
[assembly: AssemblyProduct("CodeRebirth")]
[assembly: AssemblyTitle("CodeRebirth")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.3.1.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
[module: NetcodePatchedAssembly]
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;
		}
	}
}
public class MonarchBeamController : MonoBehaviour
{
	public Transform _raycastDirectionBeamTransform;

	public Transform _startBeamTransform;

	public AudioClip _beamSound;

	public VisualEffect? _monarchParticle;

	[SerializeField]
	private SkinnedMeshRenderer _wingMesh;

	[SerializeField]
	private Transform _endBeamTransform;

	public void OnValidate()
	{
		if (!((Object)(object)_monarchParticle == (Object)null))
		{
			_monarchParticle.SetSkinnedMeshRenderer("wingMesh", _wingMesh);
		}
	}

	public void Start()
	{
		if (!((Object)(object)_monarchParticle == (Object)null))
		{
			_monarchParticle.SetSkinnedMeshRenderer("wingMesh", _wingMesh);
		}
	}

	public void SetBeamPosition(Vector3 position)
	{
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		_endBeamTransform.position = position;
	}
}
public class SeeThroughCustomPass : CustomPass
{
	[SerializeField]
	public Material seeThroughMaterial = new Material(CodeRebirthUtils.Instance.WireframeMaterial);

	public LayerMask seeThroughLayer;

	public float maxVisibilityDistance = 20f;

	[SerializeField]
	private readonly Shader stencilShader = CodeRebirthUtils.Instance.SeeThroughShader;

	private Material? stencilMaterial;

	private ShaderTagId[] shaderTags = Array.Empty<ShaderTagId>();

	public override bool executeInSceneView => true;

	public void ConfigureMaterial(Color edgeColor, Color fillColor, float thickness)
	{
		//IL_000b: 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)
		seeThroughMaterial.SetColor("_EdgeColor", edgeColor);
		seeThroughMaterial.SetColor("_MainColor", fillColor);
		seeThroughMaterial.SetFloat("_WireframeVal", thickness);
	}

	public override void Setup(ScriptableRenderContext renderContext, CommandBuffer cmd)
	{
		//IL_001f: 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)
		//IL_0030: Unknown result type (might be due to invalid IL or missing references)
		//IL_0035: 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)
		//IL_0046: 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_0057: Unknown result type (might be due to invalid IL or missing references)
		stencilMaterial = CoreUtils.CreateEngineMaterial(stencilShader);
		shaderTags = (ShaderTagId[])(object)new ShaderTagId[4]
		{
			new ShaderTagId("Forward"),
			new ShaderTagId("ForwardOnly"),
			new ShaderTagId("SRPDefaultUnlit"),
			new ShaderTagId("FirstPass")
		};
	}

	public override void Execute(CustomPassContext ctx)
	{
		//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)
		//IL_0058: Unknown result type (might be due to invalid IL or missing references)
		//IL_0066: Unknown result type (might be due to invalid IL or missing references)
		//IL_0067: Unknown result type (might be due to invalid IL or missing references)
		//IL_006c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0094: 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_009a: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b7: 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)
		//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)stencilMaterial == (Object)null)
		{
			stencilMaterial = CoreUtils.CreateEngineMaterial(stencilShader);
		}
		stencilMaterial.SetInt("_StencilWriteMask", 64);
		seeThroughMaterial.SetFloat("_MaxVisibilityDistance", Mathf.Max(0f, maxVisibilityDistance));
		RenderObjects(ctx.renderContext, ctx.cmd, stencilMaterial, 0, (CompareFunction)4, ctx.cullingResults, ctx.hdCamera);
		StencilState value = default(StencilState);
		((StencilState)(ref value))..ctor(true, (byte)64, byte.MaxValue, (CompareFunction)3, (StencilOp)0, (StencilOp)0, (StencilOp)0);
		RenderObjects(ctx.renderContext, ctx.cmd, seeThroughMaterial, seeThroughMaterial.FindPass("ForwardOnly"), (CompareFunction)7, ctx.cullingResults, ctx.hdCamera, value);
	}

	public override IEnumerable<Material> RegisterMaterialForInspector()
	{
		yield return seeThroughMaterial;
	}

	private void RenderObjects(ScriptableRenderContext renderContext, CommandBuffer cmd, Material overrideMaterial, int passIndex, CompareFunction depthCompare, CullingResults cullingResult, HDCamera hdCamera, StencilState? overrideStencil = null)
	{
		//IL_0008: Unknown result type (might be due to invalid IL or missing references)
		//IL_0019: Unknown result type (might be due to invalid IL or missing references)
		//IL_0020: 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_002d: 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_006a: Unknown result type (might be due to invalid IL or missing references)
		//IL_006c: Unknown result type (might be due to invalid IL or missing references)
		//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_0082: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
		//IL_0093: Unknown result type (might be due to invalid IL or missing references)
		//IL_0098: 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_00a2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ac: 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)
		RendererListDesc val = default(RendererListDesc);
		((RendererListDesc)(ref val))..ctor(shaderTags, cullingResult, hdCamera.camera);
		val.rendererConfiguration = (PerObjectData)0;
		val.renderQueueRange = RenderQueueRange.opaque;
		val.sortingCriteria = (SortingCriteria)4;
		val.excludeObjectMotionVectors = false;
		val.overrideMaterial = overrideMaterial;
		val.overrideMaterialPassIndex = passIndex;
		val.layerMask = LayerMask.op_Implicit(seeThroughLayer);
		RenderStateBlock value = default(RenderStateBlock);
		((RenderStateBlock)(ref value))..ctor((RenderStateMask)4);
		((RenderStateBlock)(ref value)).depthState = new DepthState(false, depthCompare);
		val.stateBlock = value;
		RendererListDesc val2 = val;
		if (overrideStencil.HasValue)
		{
			RenderStateBlock value2 = val2.stateBlock.Value;
			((RenderStateBlock)(ref value2)).mask = (RenderStateMask)(((RenderStateBlock)(ref value2)).mask | 8);
			((RenderStateBlock)(ref value2)).stencilState = overrideStencil.Value;
			val2.stateBlock = value2;
		}
		CoreUtils.DrawRendererList(renderContext, cmd, ((ScriptableRenderContext)(ref renderContext)).CreateRendererList(val2));
	}

	public override void Cleanup()
	{
	}
}
internal class TIPS : CustomPass
{
	public Mesh? mesh;

	public float size = 5f;

	public float rotationSpeed = 5f;

	public float edgeDetectThreshold = 1f;

	public int edgeRadius = 2;

	public Color glowColor = Color.white;

	public const float kMaxDistance = 1000f;

	public Material tipsMeshMaterial;

	public Material fullscreenMaterial;

	private RTHandle tipsBuffer;

	private int compositingPass;

	private int blurPass;

	private static readonly int _TipsBuffer = Shader.PropertyToID("_TIPSBuffer");

	private static readonly int _BypassMeshDepth = Shader.PropertyToID("_BypassMeshDepth");

	private static readonly int _EdgeDetectThreshold = Shader.PropertyToID("_EdgeDetectThreshold");

	private static readonly int _GlowColor = Shader.PropertyToID("_GlowColor");

	private static readonly int _EdgeRadius = Shader.PropertyToID("_EdgeRadius");

	private static readonly int _Intensity = Shader.PropertyToID("_Intensity");

	public override void Setup(ScriptableRenderContext renderContext, CommandBuffer cmd)
	{
		//IL_0011: Unknown result type (might be due to invalid IL or missing references)
		//IL_0020: 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_0086: 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)
		tipsMeshMaterial = Resources.Load<Material>("Shader Graphs_TIPS_Effect");
		tipsBuffer = RTHandles.Alloc(Vector2.one, TextureXR.slices, (DepthBits)0, (GraphicsFormat)48, (FilterMode)0, (TextureWrapMode)0, TextureXR.dimension, false, false, true, false, 1, 0f, (MSAASamples)1, false, true, (RenderTextureMemoryless)0, (VRTextureUsage)0, "TIPS Buffer");
		if ((Object)(object)fullscreenMaterial != (Object)null)
		{
			compositingPass = fullscreenMaterial.FindPass("Compositing");
			blurPass = fullscreenMaterial.FindPass("Blur");
		}
		base.targetColorBuffer = (TargetBuffer)1;
		base.targetDepthBuffer = (TargetBuffer)1;
		base.clearFlags = (ClearFlag)7;
	}

	public override void Execute(CustomPassContext ctx)
	{
		//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
		//IL_0114: Unknown result type (might be due to invalid IL or missing references)
		//IL_0031: Unknown result type (might be due to invalid IL or missing references)
		//IL_0043: Unknown result type (might be due to invalid IL or missing references)
		//IL_006b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0070: 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)
		//IL_0080: Unknown result type (might be due to invalid IL or missing references)
		//IL_0085: 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_00b4: Unknown result type (might be due to invalid IL or missing references)
		//IL_013f: 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_0167: Unknown result type (might be due to invalid IL or missing references)
		//IL_0173: Unknown result type (might be due to invalid IL or missing references)
		//IL_018e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0194: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
		//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
		if (!((Object)(object)fullscreenMaterial == (Object)null))
		{
			if ((Object)(object)mesh != (Object)null && (Object)(object)tipsMeshMaterial != (Object)null)
			{
				Transform transform = ((Component)ctx.hdCamera.camera).transform;
				Matrix4x4 val = Matrix4x4.TRS(transform.position, Quaternion.Euler(0f, Time.realtimeSinceStartup * rotationSpeed, Time.realtimeSinceStartup * rotationSpeed * 0.5f), Vector3.one * size);
				tipsMeshMaterial.SetFloat(_Intensity, 0.2f / size * 1000f);
				ctx.cmd.DrawMesh(mesh, val, tipsMeshMaterial, 0, tipsMeshMaterial.FindPass("ForwardOnly"));
			}
			ctx.propertyBlock.SetFloat(_EdgeDetectThreshold, edgeDetectThreshold);
			ctx.propertyBlock.SetColor(_GlowColor, glowColor);
			ctx.propertyBlock.SetFloat(_EdgeRadius, (float)edgeRadius);
			ctx.propertyBlock.SetFloat(_BypassMeshDepth, ((Object)(object)mesh != (Object)null) ? 0f : size);
			CoreUtils.SetRenderTarget(ctx.cmd, tipsBuffer, (ClearFlag)1, 0, (CubemapFace)(-1), -1);
			CommandBuffer cmd = ctx.cmd;
			Material obj = fullscreenMaterial;
			int num = compositingPass;
			CoreUtils.DrawFullScreen(cmd, obj, ctx.propertyBlock, num);
			ctx.propertyBlock.SetTexture(_TipsBuffer, RTHandle.op_Implicit(tipsBuffer));
			CoreUtils.SetRenderTarget(ctx.cmd, ctx.cameraColorBuffer, (ClearFlag)0, 0, (CubemapFace)(-1), -1);
			CommandBuffer cmd2 = ctx.cmd;
			Material obj2 = fullscreenMaterial;
			num = blurPass;
			CoreUtils.DrawFullScreen(cmd2, obj2, ctx.propertyBlock, num);
		}
	}

	public override void Cleanup()
	{
		tipsBuffer.Release();
	}
}
namespace CodeRebirth
{
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "CodeRebirth";

		public const string PLUGIN_NAME = "CodeRebirth";

		public const string PLUGIN_VERSION = "1.3.1";
	}
	[GeneratedCode("DawnLib", "0.2.2")]
	public static class CodeRebirthEnemyKeys
	{
		public static NamespacedKey<DawnEnemyInfo> Guardsman = NamespacedKey<DawnEnemyInfo>.From("code_rebirth", "guardsman");

		public static NamespacedKey<DawnEnemyInfo> RealEnemySnailCat = NamespacedKey<DawnEnemyInfo>.From("code_rebirth", "real_enemy_snailcat");

		public static NamespacedKey<DawnEnemyInfo> CactusBudling = NamespacedKey<DawnEnemyInfo>.From("code_rebirth", "cactus_budling");

		public static NamespacedKey<DawnEnemyInfo> CarnivorousPlant = NamespacedKey<DawnEnemyInfo>.From("code_rebirth", "carnivorous_plant");

		public static NamespacedKey<DawnEnemyInfo> DriftwoodMenace = NamespacedKey<DawnEnemyInfo>.From("code_rebirth", "driftwood_menace");

		public static NamespacedKey<DawnEnemyInfo> Duck = NamespacedKey<DawnEnemyInfo>.From("code_rebirth", "duck");

		public static NamespacedKey<DawnEnemyInfo> Janitor = NamespacedKey<DawnEnemyInfo>.From("code_rebirth", "janitor");

		public static NamespacedKey<DawnEnemyInfo> RabbitMagician = NamespacedKey<DawnEnemyInfo>.From("code_rebirth", "rabbit_magician");

		public static NamespacedKey<DawnEnemyInfo> LordOfTheManor = NamespacedKey<DawnEnemyInfo>.From("code_rebirth", "lord_of_the_manor");

		public static NamespacedKey<DawnEnemyInfo> Mistress = NamespacedKey<DawnEnemyInfo>.From("code_rebirth", "mistress");

		public static NamespacedKey<DawnEnemyInfo> CutieFly = NamespacedKey<DawnEnemyInfo>.From("code_rebirth", "cutiefly");

		public static NamespacedKey<DawnEnemyInfo> Monarch = NamespacedKey<DawnEnemyInfo>.From("code_rebirth", "monarch");

		public static NamespacedKey<DawnEnemyInfo> Nancy = NamespacedKey<DawnEnemyInfo>.From("code_rebirth", "nancy");

		public static NamespacedKey<DawnEnemyInfo> PeaceKeeper = NamespacedKey<DawnEnemyInfo>.From("code_rebirth", "peace_keeper");

		public static NamespacedKey<DawnEnemyInfo> RedwoodTitan = NamespacedKey<DawnEnemyInfo>.From("code_rebirth", "redwood_titan");

		public static NamespacedKey<DawnEnemyInfo> Transporter = NamespacedKey<DawnEnemyInfo>.From("code_rebirth", "transporter");

		public static NamespacedKey<DawnEnemyInfo> Tornado = NamespacedKey<DawnEnemyInfo>.From("code_rebirth", "tornado");

		public static NamespacedKey<DawnEnemyInfo>? GetByReflection(string name)
		{
			return (NamespacedKey<DawnEnemyInfo>)(typeof(CodeRebirthEnemyKeys).GetField(name)?.GetValue(null));
		}
	}
	[GeneratedCode("DawnLib", "0.2.2")]
	public static class CodeRebirthWeatherKeys
	{
		public static NamespacedKey<DawnWeatherEffectInfo> MeteorShower = NamespacedKey<DawnWeatherEffectInfo>.From("code_rebirth", "meteor_shower");

		public static NamespacedKey<DawnWeatherEffectInfo> NightShift = NamespacedKey<DawnWeatherEffectInfo>.From("code_rebirth", "night_shift");

		public static NamespacedKey<DawnWeatherEffectInfo> Tornado = NamespacedKey<DawnWeatherEffectInfo>.From("code_rebirth", "tornado");

		public static NamespacedKey<DawnWeatherEffectInfo>? GetByReflection(string name)
		{
			return (NamespacedKey<DawnWeatherEffectInfo>)(typeof(CodeRebirthWeatherKeys).GetField(name)?.GetValue(null));
		}
	}
	[GeneratedCode("DawnLib", "0.2.2")]
	public static class CodeRebirthUnlockableItemKeys
	{
		public static NamespacedKey<DawnUnlockableItemInfo> PIGGY = NamespacedKey<DawnUnlockableItemInfo>.From("code_rebirth", "piggy");

		public static NamespacedKey<DawnUnlockableItemInfo> AIRCONTROL = NamespacedKey<DawnUnlockableItemInfo>.From("code_rebirth", "aircontrol");

		public static NamespacedKey<DawnUnlockableItemInfo> BEARTRAP = NamespacedKey<DawnUnlockableItemInfo>.From("code_rebirth", "beartrap");

		public static NamespacedKey<DawnUnlockableItemInfo> HERMIT = NamespacedKey<DawnUnlockableItemInfo>.From("code_rebirth", "hermit");

		public static NamespacedKey<DawnUnlockableItemInfo> CLEANER = NamespacedKey<DawnUnlockableItemInfo>.From("code_rebirth", "cleaner");

		public static NamespacedKey<DawnUnlockableItemInfo> MISSCRUISER = NamespacedKey<DawnUnlockableItemInfo>.From("code_rebirth", "miss_cruiser");

		public static NamespacedKey<DawnUnlockableItemInfo> BALD = NamespacedKey<DawnUnlockableItemInfo>.From("code_rebirth", "bald");

		public static NamespacedKey<DawnUnlockableItemInfo> PlantPot = NamespacedKey<DawnUnlockableItemInfo>.From("code_rebirth", "plantpot");

		public static NamespacedKey<DawnUnlockableItemInfo> LIZZIE = NamespacedKey<DawnUnlockableItemInfo>.From("code_rebirth", "lizzie");

		public static NamespacedKey<DawnUnlockableItemInfo> SEAMOne = NamespacedKey<DawnUnlockableItemInfo>.From("code_rebirth", "seamone");

		public static NamespacedKey<DawnUnlockableItemInfo> SWRDOne = NamespacedKey<DawnUnlockableItemInfo>.From("code_rebirth", "swrdone");

		public static NamespacedKey<DawnUnlockableItemInfo> SHRIMP = NamespacedKey<DawnUnlockableItemInfo>.From("code_rebirth", "shrimp");

		public static NamespacedKey<DawnUnlockableItemInfo> DAISY = NamespacedKey<DawnUnlockableItemInfo>.From("code_rebirth", "daisy");

		public static NamespacedKey<DawnUnlockableItemInfo>? GetByReflection(string name)
		{
			return (NamespacedKey<DawnUnlockableItemInfo>)(typeof(CodeRebirthUnlockableItemKeys).GetField(name)?.GetValue(null));
		}
	}
	[GeneratedCode("DawnLib", "0.2.2")]
	public static class CodeRebirthItemKeys
	{
		public static NamespacedKey<DawnItemInfo> CharredBaby = NamespacedKey<DawnItemInfo>.From("code_rebirth", "charred_baby");

		public static NamespacedKey<DawnItemInfo> CharredFork = NamespacedKey<DawnItemInfo>.From("code_rebirth", "charred_fork");

		public static NamespacedKey<DawnItemInfo> SapsuckerOmelette = NamespacedKey<DawnItemInfo>.From("code_rebirth", "sapsucker_omelette");

		public static NamespacedKey<DawnItemInfo> CharredSpork = NamespacedKey<DawnItemInfo>.From("code_rebirth", "charred_spork");

		public static NamespacedKey<DawnItemInfo> FlattenedBody = NamespacedKey<DawnItemInfo>.From("code_rebirth", "flattened_body");

		public static NamespacedKey<DawnItemInfo> SallyCube = NamespacedKey<DawnItemInfo>.From("code_rebirth", "sally_cube");

		public static NamespacedKey<DawnItemInfo> CreditPadOneZeroZerocc = NamespacedKey<DawnItemInfo>.From("code_rebirth", "credit_pad_onezerozerocc");

		public static NamespacedKey<DawnItemInfo> CreditPadFiveZeroZerocc = NamespacedKey<DawnItemInfo>.From("code_rebirth", "credit_pad_fivezerozerocc");

		public static NamespacedKey<DawnItemInfo> CreditPadOneZeroZeroZerocc = NamespacedKey<DawnItemInfo>.From("code_rebirth", "credit_pad_onezerozerozerocc");

		public static NamespacedKey<DawnItemInfo> RemoteDetonator = NamespacedKey<DawnItemInfo>.From("code_rebirth", "remote_detonator");

		public static NamespacedKey<DawnItemInfo> FogHorn = NamespacedKey<DawnItemInfo>.From("code_rebirth", "foghorn");

		public static NamespacedKey<DawnItemInfo> GuardsmanPhone = NamespacedKey<DawnItemInfo>.From("code_rebirth", "guardsman_phone");

		public static NamespacedKey<DawnItemInfo> InfiniKey = NamespacedKey<DawnItemInfo>.From("code_rebirth", "infinikey");

		public static NamespacedKey<DawnItemInfo> LifeformAnalyser = NamespacedKey<DawnItemInfo>.From("code_rebirth", "lifeform_analyser");

		public static NamespacedKey<DawnItemInfo> MoleDigger = NamespacedKey<DawnItemInfo>.From("code_rebirth", "mole_digger");

		public static NamespacedKey<DawnItemInfo> NitroglycerinCrate = NamespacedKey<DawnItemInfo>.From("code_rebirth", "nitroglycerin_crate");

		public static NamespacedKey<DawnItemInfo> Oxidizer = NamespacedKey<DawnItemInfo>.From("code_rebirth", "oxidizer");

		public static NamespacedKey<DawnItemInfo> RailSlugger = NamespacedKey<DawnItemInfo>.From("code_rebirth", "rail_slugger");

		public static NamespacedKey<DawnItemInfo> Rocky = NamespacedKey<DawnItemInfo>.From("code_rebirth", "rocky");

		public static NamespacedKey<DawnItemInfo> ShipUpgradeUnlocker = NamespacedKey<DawnItemInfo>.From("code_rebirth", "ship_upgrade_unlocker");

		public static NamespacedKey<DawnItemInfo> StoptimeWatch = NamespacedKey<DawnItemInfo>.From("code_rebirth", "stoptime_watch");

		public static NamespacedKey<DawnItemInfo> WalkieYellie = NamespacedKey<DawnItemInfo>.From("code_rebirth", "walkieyellie");

		public static NamespacedKey<DawnItemInfo> WayfarersWallet = NamespacedKey<DawnItemInfo>.From("code_rebirth", "wayfarers_wallet");

		public static NamespacedKey<DawnItemInfo> MelanieDrawing = NamespacedKey<DawnItemInfo>.From("code_rebirth", "melanie_drawing");

		public static NamespacedKey<DawnItemInfo> BloodyShreddedScraps = NamespacedKey<DawnItemInfo>.From("code_rebirth", "bloody_shredded_scraps");

		public static NamespacedKey<DawnItemInfo> JimothyCore = NamespacedKey<DawnItemInfo>.From("code_rebirth", "jimothy_core");

		public static NamespacedKey<DawnItemInfo> NormalShreddedScraps = NamespacedKey<DawnItemInfo>.From("code_rebirth", "normal_shredded_scraps");

		public static NamespacedKey<DawnItemInfo> FakeSnailCat = NamespacedKey<DawnItemInfo>.From("code_rebirth", "fake_snailcat");

		public static NamespacedKey<DawnItemInfo> SnailCat = NamespacedKey<DawnItemInfo>.From("code_rebirth", "snailcat");

		public static NamespacedKey<DawnItemInfo> Grape = NamespacedKey<DawnItemInfo>.From("code_rebirth", "grape");

		public static NamespacedKey<DawnItemInfo> LemonadePitcher = NamespacedKey<DawnItemInfo>.From("code_rebirth", "lemonade_pitcher");

		public static NamespacedKey<DawnItemInfo> PuppeteersNeedle = NamespacedKey<DawnItemInfo>.From("code_rebirth", "puppeteers_needle");

		public static NamespacedKey<DawnItemInfo> PuppeteersVoodoo = NamespacedKey<DawnItemInfo>.From("code_rebirth", "puppeteers_voodoo");

		public static NamespacedKey<DawnItemInfo> TalkingHead = NamespacedKey<DawnItemInfo>.From("code_rebirth", "talking_head");

		public static NamespacedKey<DawnItemInfo> Ceasefire = NamespacedKey<DawnItemInfo>.From("code_rebirth", "ceasefire");

		public static NamespacedKey<DawnItemInfo> Plushie = NamespacedKey<DawnItemInfo>.From("code_rebirth", "plushie");

		public static NamespacedKey<DawnItemInfo> ACUnitGalPlushie = NamespacedKey<DawnItemInfo>.From("code_rebirth", "acunit_gal_plushie");

		public static NamespacedKey<DawnItemInfo> CactusBudlingPlushie = NamespacedKey<DawnItemInfo>.From("code_rebirth", "cactus_budling_plushie");

		public static NamespacedKey<DawnItemInfo> CruiserGalPlushie = NamespacedKey<DawnItemInfo>.From("code_rebirth", "cruiser_gal_plushie");

		public static NamespacedKey<DawnItemInfo> DriftwoodMenacePlushie = NamespacedKey<DawnItemInfo>.From("code_rebirth", "driftwood_menace_plushie");

		public static NamespacedKey<DawnItemInfo> DuckPlushie = NamespacedKey<DawnItemInfo>.From("code_rebirth", "duck_plushie");

		public static NamespacedKey<DawnItemInfo> GuardsmanPlushie = NamespacedKey<DawnItemInfo>.From("code_rebirth", "guardsman_plushie");

		public static NamespacedKey<DawnItemInfo> JanitorPlushie = NamespacedKey<DawnItemInfo>.From("code_rebirth", "janitor_plushie");

		public static NamespacedKey<DawnItemInfo> ManorLordPlushie = NamespacedKey<DawnItemInfo>.From("code_rebirth", "manorlord_plushie");

		public static NamespacedKey<DawnItemInfo> MistressPlushie = NamespacedKey<DawnItemInfo>.From("code_rebirth", "mistress_plushie");

		public static NamespacedKey<DawnItemInfo> MonarchPlushie = NamespacedKey<DawnItemInfo>.From("code_rebirth", "monarch_plushie");

		public static NamespacedKey<DawnItemInfo> NancyPlushie = NamespacedKey<DawnItemInfo>.From("code_rebirth", "nancy_plushie");

		public static NamespacedKey<DawnItemInfo> PeaceKeeperPlushie = NamespacedKey<DawnItemInfo>.From("code_rebirth", "peacekeeper_plushie");

		public static NamespacedKey<DawnItemInfo> RabbitMagicianPlushie = NamespacedKey<DawnItemInfo>.From("code_rebirth", "rabbit_magician_plushie");

		public static NamespacedKey<DawnItemInfo> RedwoodTitanPlushie = NamespacedKey<DawnItemInfo>.From("code_rebirth", "redwood_titan_plushie");

		public static NamespacedKey<DawnItemInfo> SeamineTinkPlushie = NamespacedKey<DawnItemInfo>.From("code_rebirth", "seamine_tink_plushie");

		public static NamespacedKey<DawnItemInfo> ShockwaveBotPlushie = NamespacedKey<DawnItemInfo>.From("code_rebirth", "shockwave_bot_plushie");

		public static NamespacedKey<DawnItemInfo> SnailCatPlushie = NamespacedKey<DawnItemInfo>.From("code_rebirth", "snail_cat_plushie");

		public static NamespacedKey<DawnItemInfo> TerminalBotPlushie = NamespacedKey<DawnItemInfo>.From("code_rebirth", "terminal_bot_plushie");

		public static NamespacedKey<DawnItemInfo> TransporterPlushie = NamespacedKey<DawnItemInfo>.From("code_rebirth", "transporter_plushie");

		public static NamespacedKey<DawnItemInfo> Hoverboard = NamespacedKey<DawnItemInfo>.From("code_rebirth", "hoverboard");

		public static NamespacedKey<DawnItemInfo> ByrneJournalOne = NamespacedKey<DawnItemInfo>.From("code_rebirth", "byrne_journal_one");

		public static NamespacedKey<DawnItemInfo> ByrneJournalTwo = NamespacedKey<DawnItemInfo>.From("code_rebirth", "byrne_journal_two");

		public static NamespacedKey<DawnItemInfo> ByrneJournalThree = NamespacedKey<DawnItemInfo>.From("code_rebirth", "byrne_journal_three");

		public static NamespacedKey<DawnItemInfo> ByrneJournalFour = NamespacedKey<DawnItemInfo>.From("code_rebirth", "byrne_journal_four");

		public static NamespacedKey<DawnItemInfo> ByrneJournalFive = NamespacedKey<DawnItemInfo>.From("code_rebirth", "byrne_journal_five");

		public static NamespacedKey<DawnItemInfo> ByrneJournalSix = NamespacedKey<DawnItemInfo>.From("code_rebirth", "byrne_journal_six");

		public static NamespacedKey<DawnItemInfo> DirectorDiaryOne = NamespacedKey<DawnItemInfo>.From("code_rebirth", "director_diary_one");

		public static NamespacedKey<DawnItemInfo> DirectorDiaryTwo = NamespacedKey<DawnItemInfo>.From("code_rebirth", "director_diary_two");

		public static NamespacedKey<DawnItemInfo> DirectorDiaryThree = NamespacedKey<DawnItemInfo>.From("code_rebirth", "director_diary_three");

		public static NamespacedKey<DawnItemInfo> DirectorDiaryFour = NamespacedKey<DawnItemInfo>.From("code_rebirth", "director_diary_four");

		public static NamespacedKey<DawnItemInfo> DirectorDiaryFive = NamespacedKey<DawnItemInfo>.From("code_rebirth", "director_diary_five");

		public static NamespacedKey<DawnItemInfo> DirectorDiarySix = NamespacedKey<DawnItemInfo>.From("code_rebirth", "director_diary_six");

		public static NamespacedKey<DawnItemInfo> DirectorDiarySeven = NamespacedKey<DawnItemInfo>.From("code_rebirth", "director_diary_seven");

		public static NamespacedKey<DawnItemInfo> DirectorDiaryEight = NamespacedKey<DawnItemInfo>.From("code_rebirth", "director_diary_eight");

		public static NamespacedKey<DawnItemInfo> DirectorDiaryNine = NamespacedKey<DawnItemInfo>.From("code_rebirth", "director_diary_nine");

		public static NamespacedKey<DawnItemInfo> DirectorDiaryOneZero = NamespacedKey<DawnItemInfo>.From("code_rebirth", "director_diary_onezero");

		public static NamespacedKey<DawnItemInfo> ToDoList = NamespacedKey<DawnItemInfo>.From("code_rebirth", "todo_list");

		public static NamespacedKey<DawnItemInfo> CactusBudlingDocument = NamespacedKey<DawnItemInfo>.From("code_rebirth", "cactusbudlingdocument");

		public static NamespacedKey<DawnItemInfo> CutieMonarchDocument = NamespacedKey<DawnItemInfo>.From("code_rebirth", "cutiemonarchdocument");

		public static NamespacedKey<DawnItemInfo> DriftwoodMenaceDocument = NamespacedKey<DawnItemInfo>.From("code_rebirth", "driftwoodmenacedocument");

		public static NamespacedKey<DawnItemInfo> DuckDocument = NamespacedKey<DawnItemInfo>.From("code_rebirth", "duckdocument");

		public static NamespacedKey<DawnItemInfo> GuardsmanDocument = NamespacedKey<DawnItemInfo>.From("code_rebirth", "guardsmandocument");

		public static NamespacedKey<DawnItemInfo> IntroDocument = NamespacedKey<DawnItemInfo>.From("code_rebirth", "introdocument");

		public static NamespacedKey<DawnItemInfo> JanitorDocument = NamespacedKey<DawnItemInfo>.From("code_rebirth", "janitordocument");

		public static NamespacedKey<DawnItemInfo> MagicianDocument = NamespacedKey<DawnItemInfo>.From("code_rebirth", "magiciandocument");

		public static NamespacedKey<DawnItemInfo> ManorLordDocument = NamespacedKey<DawnItemInfo>.From("code_rebirth", "manorlorddocument");

		public static NamespacedKey<DawnItemInfo> MistressDocument = NamespacedKey<DawnItemInfo>.From("code_rebirth", "mistressdocument");

		public static NamespacedKey<DawnItemInfo> NancyDocument = NamespacedKey<DawnItemInfo>.From("code_rebirth", "nancydocument");

		public static NamespacedKey<DawnItemInfo> PeaceKeeperDocument = NamespacedKey<DawnItemInfo>.From("code_rebirth", "peacekeeperdocument");

		public static NamespacedKey<DawnItemInfo> RedwoodDocument = NamespacedKey<DawnItemInfo>.From("code_rebirth", "redwooddocument");

		public static NamespacedKey<DawnItemInfo> SnailCatDocument = NamespacedKey<DawnItemInfo>.From("code_rebirth", "snailcatdocument");

		public static NamespacedKey<DawnItemInfo> TransporterDocument = NamespacedKey<DawnItemInfo>.From("code_rebirth", "transporterdocument");

		public static NamespacedKey<DawnItemInfo> ComfortTape = NamespacedKey<DawnItemInfo>.From("code_rebirth", "comfort_tape");

		public static NamespacedKey<DawnItemInfo> OxydeTrainingTape = NamespacedKey<DawnItemInfo>.From("code_rebirth", "oxyde_training_tape");

		public static NamespacedKey<DawnItemInfo> HaemoglobinTablet = NamespacedKey<DawnItemInfo>.From("code_rebirth", "haemoglobin_tablet");

		public static NamespacedKey<DawnItemInfo> OxydeTablet = NamespacedKey<DawnItemInfo>.From("code_rebirth", "oxyde_tablet");

		public static NamespacedKey<DawnItemInfo> SnowGlobe = NamespacedKey<DawnItemInfo>.From("code_rebirth", "snow_globe");

		public static NamespacedKey<DawnItemInfo> Brrreaker = NamespacedKey<DawnItemInfo>.From("code_rebirth", "brrreaker");

		public static NamespacedKey<DawnItemInfo> MarrowSplitter = NamespacedKey<DawnItemInfo>.From("code_rebirth", "marrow_splitter");

		public static NamespacedKey<DawnItemInfo> SWATTer = NamespacedKey<DawnItemInfo>.From("code_rebirth", "swatter");

		public static NamespacedKey<DawnItemInfo> TomaHop = NamespacedKey<DawnItemInfo>.From("code_rebirth", "toma_hop");

		public static NamespacedKey<DawnItemInfo> Turbulence = NamespacedKey<DawnItemInfo>.From("code_rebirth", "turbulence");

		public static NamespacedKey<DawnItemInfo> KingRigo = NamespacedKey<DawnItemInfo>.From("code_rebirth", "kingrigo");

		public static NamespacedKey<DawnItemInfo> MeliciousMel = NamespacedKey<DawnItemInfo>.From("code_rebirth", "melicious_mel");

		public static NamespacedKey<DawnItemInfo> Xui = NamespacedKey<DawnItemInfo>.From("code_rebirth", "xui");

		public static NamespacedKey<DawnItemInfo> Accordion = NamespacedKey<DawnItemInfo>.From("code_rebirth", "accordion");

		public static NamespacedKey<DawnItemInfo> Guitar = NamespacedKey<DawnItemInfo>.From("code_rebirth", "guitar");

		public static NamespacedKey<DawnItemInfo> Recorder = NamespacedKey<DawnItemInfo>.From("code_rebirth", "recorder");

		public static NamespacedKey<DawnItemInfo> Violin = NamespacedKey<DawnItemInfo>.From("code_rebirth", "violin");

		public static NamespacedKey<DawnItemInfo> CruiserGalAssemblyParts = NamespacedKey<DawnItemInfo>.From("code_rebirth", "cruisergal_assembly_parts");

		public static NamespacedKey<DawnItemInfo> GoldenTomato = NamespacedKey<DawnItemInfo>.From("code_rebirth", "golden_tomato");

		public static NamespacedKey<DawnItemInfo> NormalTomato = NamespacedKey<DawnItemInfo>.From("code_rebirth", "normal_tomato");

		public static NamespacedKey<DawnItemInfo> WoodenSeed = NamespacedKey<DawnItemInfo>.From("code_rebirth", "wooden_seed");

		public static NamespacedKey<DawnItemInfo> JarofNineNineNine = NamespacedKey<DawnItemInfo>.From("code_rebirth", "jar_of_nineninenine");

		public static NamespacedKey<DawnItemInfo> SeamineGalAssemblyParts = NamespacedKey<DawnItemInfo>.From("code_rebirth", "seaminegal_assembly_parts");

		public static NamespacedKey<DawnItemInfo> ShockwaveGalAssemblyParts = NamespacedKey<DawnItemInfo>.From("code_rebirth", "shockwavegal_assembly_parts");

		public static NamespacedKey<DawnItemInfo> BlueShrimp = NamespacedKey<DawnItemInfo>.From("code_rebirth", "blue_shrimp");

		public static NamespacedKey<DawnItemInfo> TerminalGalAssemblyParts = NamespacedKey<DawnItemInfo>.From("code_rebirth", "terminalgal_assembly_parts");

		public static NamespacedKey<DawnItemInfo> AmethystCrystal = NamespacedKey<DawnItemInfo>.From("code_rebirth", "amethyst_crystal");

		public static NamespacedKey<DawnItemInfo> EmeraldCrystal = NamespacedKey<DawnItemInfo>.From("code_rebirth", "emerald_crystal");

		public static NamespacedKey<DawnItemInfo> QuartzCrystal = NamespacedKey<DawnItemInfo>.From("code_rebirth", "quartz_crystal");

		public static NamespacedKey<DawnItemInfo> RubyCrystal = NamespacedKey<DawnItemInfo>.From("code_rebirth", "ruby_crystal");

		public static NamespacedKey<DawnItemInfo> SapphireCrystal = NamespacedKey<DawnItemInfo>.From("code_rebirth", "sapphire_crystal");

		public static NamespacedKey<DawnItemInfo> TopazCrystal = NamespacedKey<DawnItemInfo>.From("code_rebirth", "topaz_crystal");

		public static NamespacedKey<DawnItemInfo>? GetByReflection(string name)
		{
			return (NamespacedKey<DawnItemInfo>)(typeof(CodeRebirthItemKeys).GetField(name)?.GetValue(null));
		}
	}
	[GeneratedCode("DawnLib", "0.2.2")]
	public static class CodeRebirthMapObjectKeys
	{
		public static NamespacedKey<DawnMapObjectInfo> FlashTurret = NamespacedKey<DawnMapObjectInfo>.From("code_rebirth", "flash_turret");

		public static NamespacedKey<DawnMapObjectInfo> FunctionalMicrowave = NamespacedKey<DawnMapObjectInfo>.From("code_rebirth", "functional_microwave");

		public static NamespacedKey<DawnMapObjectInfo> LaserTurret = NamespacedKey<DawnMapObjectInfo>.From("code_rebirth", "laser_turret");

		public static NamespacedKey<DawnMapObjectInfo> IndustrialFan = NamespacedKey<DawnMapObjectInfo>.From("code_rebirth", "industrial_fan");

		public static NamespacedKey<DawnMapObjectInfo> BugZapper = NamespacedKey<DawnMapObjectInfo>.From("code_rebirth", "bug_zapper");

		public static NamespacedKey<DawnMapObjectInfo> AirControlUnit = NamespacedKey<DawnMapObjectInfo>.From("code_rebirth", "air_control_unit");

		public static NamespacedKey<DawnMapObjectInfo> AutonomousCrane = NamespacedKey<DawnMapObjectInfo>.From("code_rebirth", "autonomous_crane");

		public static NamespacedKey<DawnMapObjectInfo> BoomTrap = NamespacedKey<DawnMapObjectInfo>.From("code_rebirth", "boom_trap");

		public static NamespacedKey<DawnMapObjectInfo> GrassBearTrap = NamespacedKey<DawnMapObjectInfo>.From("code_rebirth", "grass_bear_trap");

		public static NamespacedKey<DawnMapObjectInfo> GravelBearTrap = NamespacedKey<DawnMapObjectInfo>.From("code_rebirth", "gravel_bear_trap");

		public static NamespacedKey<DawnMapObjectInfo> SnowBearTrap = NamespacedKey<DawnMapObjectInfo>.From("code_rebirth", "snow_bear_trap");

		public static NamespacedKey<DawnMapObjectInfo> Biome = NamespacedKey<DawnMapObjectInfo>.From("code_rebirth", "biome");

		public static NamespacedKey<DawnMapObjectInfo> CompactorToby = NamespacedKey<DawnMapObjectInfo>.From("code_rebirth", "compactor_toby");

		public static NamespacedKey<DawnMapObjectInfo> OxydeCrashedShip = NamespacedKey<DawnMapObjectInfo>.From("code_rebirth", "oxyde_crashed_ship");

		public static NamespacedKey<DawnMapObjectInfo> GunslingerGreg = NamespacedKey<DawnMapObjectInfo>.From("code_rebirth", "gunslinger_greg");

		public static NamespacedKey<DawnMapObjectInfo> NormalMetalCrate = NamespacedKey<DawnMapObjectInfo>.From("code_rebirth", "normal_metal_crate");

		public static NamespacedKey<DawnMapObjectInfo> MimicMetalCrate = NamespacedKey<DawnMapObjectInfo>.From("code_rebirth", "mimic_metal_crate");

		public static NamespacedKey<DawnMapObjectInfo> MimicWoodenCrate = NamespacedKey<DawnMapObjectInfo>.From("code_rebirth", "mimic_wooden_crate");

		public static NamespacedKey<DawnMapObjectInfo> NormalWoodenCrate = NamespacedKey<DawnMapObjectInfo>.From("code_rebirth", "normal_wooden_crate");

		public static NamespacedKey<DawnMapObjectInfo> Merchant = NamespacedKey<DawnMapObjectInfo>.From("code_rebirth", "merchant");

		public static NamespacedKey<DawnMapObjectInfo> Money = NamespacedKey<DawnMapObjectInfo>.From("code_rebirth", "money");

		public static NamespacedKey<DawnMapObjectInfo> KamikazeJimothy = NamespacedKey<DawnMapObjectInfo>.From("code_rebirth", "kamikaze_jimothy");

		public static NamespacedKey<DawnMapObjectInfo> ShredderSarah = NamespacedKey<DawnMapObjectInfo>.From("code_rebirth", "shredder_sarah");

		public static NamespacedKey<DawnMapObjectInfo> EmergingCactusOne = NamespacedKey<DawnMapObjectInfo>.From("code_rebirth", "emerging_cactus_one");

		public static NamespacedKey<DawnMapObjectInfo> EmergingCactusTwo = NamespacedKey<DawnMapObjectInfo>.From("code_rebirth", "emerging_cactus_two");

		public static NamespacedKey<DawnMapObjectInfo> EmergingCactusThree = NamespacedKey<DawnMapObjectInfo>.From("code_rebirth", "emerging_cactus_three");

		public static NamespacedKey<DawnMapObjectInfo> TrashCan = NamespacedKey<DawnMapObjectInfo>.From("code_rebirth", "trash_can");

		public static NamespacedKey<DawnMapObjectInfo>? GetByReflection(string name)
		{
			return (NamespacedKey<DawnMapObjectInfo>)(typeof(CodeRebirthMapObjectKeys).GetField(name)?.GetValue(null));
		}
	}
	[GeneratedCode("DawnLib", "0.2.2")]
	public static class CodeRebirthAchievementKeys
	{
		public static NamespacedKey<DuskAchievementDefinition> LunchisServed = NamespacedKey<DuskAchievementDefinition>.From("code_rebirth", "lunch_is_served");

		public static NamespacedKey<DuskAchievementDefinition> ShortFuse = NamespacedKey<DuskAchievementDefinition>.From("code_rebirth", "short_fuse");

		public static NamespacedKey<DuskAchievementDefinition> Banzai = NamespacedKey<DuskAchievementDefinition>.From("code_rebirth", "banzai");

		public static NamespacedKey<DuskAchievementDefinition> GraveyardShift = NamespacedKey<DuskAchievementDefinition>.From("code_rebirth", "graveyard_shift");

		public static NamespacedKey<DuskAchievementDefinition> GreatestAsset = NamespacedKey<DuskAchievementDefinition>.From("code_rebirth", "greatest_asset");

		public static NamespacedKey<DuskAchievementDefinition> Internship = NamespacedKey<DuskAchievementDefinition>.From("code_rebirth", "internship");

		public static NamespacedKey<DuskAchievementDefinition> Crateapult = NamespacedKey<DuskAchievementDefinition>.From("code_rebirth", "crateapult");

		public static NamespacedKey<DuskAchievementDefinition> SafeAndSound = NamespacedKey<DuskAchievementDefinition>.From("code_rebirth", "safe_and_sound");

		public static NamespacedKey<DuskAchievementDefinition> Capitalism = NamespacedKey<DuskAchievementDefinition>.From("code_rebirth", "capitalism");

		public static NamespacedKey<DuskAchievementDefinition> FatWallet = NamespacedKey<DuskAchievementDefinition>.From("code_rebirth", "fat_wallet");

		public static NamespacedKey<DuskAchievementDefinition> MaydayMayday = NamespacedKey<DuskAchievementDefinition>.From("code_rebirth", "mayday_mayday");

		public static NamespacedKey<DuskAchievementDefinition> OhAPenny = NamespacedKey<DuskAchievementDefinition>.From("code_rebirth", "oh_a_penny");

		public static NamespacedKey<DuskAchievementDefinition> OutOfStock = NamespacedKey<DuskAchievementDefinition>.From("code_rebirth", "out_of_stock");

		public static NamespacedKey<DuskAchievementDefinition> YouMonster = NamespacedKey<DuskAchievementDefinition>.From("code_rebirth", "you_monster");

		public static NamespacedKey<DuskAchievementDefinition> WildWest = NamespacedKey<DuskAchievementDefinition>.From("code_rebirth", "wild_west");

		public static NamespacedKey<DuskAchievementDefinition> Bushwacked = NamespacedKey<DuskAchievementDefinition>.From("code_rebirth", "bushwacked");

		public static NamespacedKey<DuskAchievementDefinition> TrashTrashTrash = NamespacedKey<DuskAchievementDefinition>.From("code_rebirth", "trash_trash_trash");

		public static NamespacedKey<DuskAchievementDefinition> NightofBetrayal = NamespacedKey<DuskAchievementDefinition>.From("code_rebirth", "night_of_betrayal");

		public static NamespacedKey<DuskAchievementDefinition> Igotaheadache = NamespacedKey<DuskAchievementDefinition>.From("code_rebirth", "i_got_a_headache");

		public static NamespacedKey<DuskAchievementDefinition> PestControl = NamespacedKey<DuskAchievementDefinition>.From("code_rebirth", "pest_control");

		public static NamespacedKey<DuskAchievementDefinition> PeaceKept = NamespacedKey<DuskAchievementDefinition>.From("code_rebirth", "peace_kept");

		public static NamespacedKey<DuskAchievementDefinition> Timber = NamespacedKey<DuskAchievementDefinition>.From("code_rebirth", "timber");

		public static NamespacedKey<DuskAchievementDefinition> CompanyCertified = NamespacedKey<DuskAchievementDefinition>.From("code_rebirth", "company_certified");

		public static NamespacedKey<DuskAchievementDefinition> HappyFamily = NamespacedKey<DuskAchievementDefinition>.From("code_rebirth", "happy_family");

		public static NamespacedKey<DuskAchievementDefinition> HoardingBug = NamespacedKey<DuskAchievementDefinition>.From("code_rebirth", "hoarding_bug");

		public static NamespacedKey<DuskAchievementDefinition> Scalper = NamespacedKey<DuskAchievementDefinition>.From("code_rebirth", "scalper");

		public static NamespacedKey<DuskAchievementDefinition> SomeAssemblyRequired = NamespacedKey<DuskAchievementDefinition>.From("code_rebirth", "some_assembly_required");

		public static NamespacedKey<DuskAchievementDefinition> TheUprooted = NamespacedKey<DuskAchievementDefinition>.From("code_rebirth", "the_uprooted");

		public static NamespacedKey<DuskAchievementDefinition> MuMiaolan = NamespacedKey<DuskAchievementDefinition>.From("code_rebirth", "mu_miaolan");

		public static NamespacedKey<DuskAchievementDefinition>? GetByReflection(string name)
		{
			return (NamespacedKey<DuskAchievementDefinition>)(typeof(CodeRebirthAchievementKeys).GetField(name)?.GetValue(null));
		}
	}
}
namespace CodeRebirth.src
{
	public class CodeRebirthConfig
	{
		public ConfigEntry<bool> ConfigOxydeNeedsNightShift { get; private set; }

		public ConfigEntry<bool> ConfigOxydeEnabledFromStart { get; private set; }

		public ConfigEntry<bool> ConfigOxydeEnabled { get; private set; }

		public ConfigEntry<bool> ConfigDisableTrashCans { get; private set; }

		public ConfigEntry<bool> ConfigRemoveInteriorFog { get; private set; }

		public ConfigEntry<bool> ConfigDontTargetFarEnemies { get; private set; }

		public ConfigEntry<bool> ConfigHazardsDeleteBodies { get; private set; }

		public ConfigEntry<bool> ConfigOnlyOwnerDisablesGal { get; private set; }

		public ConfigEntry<bool> ConfigFloraEnabled { get; set; }

		public ConfigEntry<bool> ConfigRedwoodHeartEnabled { get; private set; }

		public ConfigEntry<bool> ConfigSnowGlobeMusic { get; private set; }

		public ConfigEntry<float> ConfigRedwoodNormalVolume { get; private set; }

		public ConfigEntry<float> ConfigRedwoodInShipVolume { get; private set; }

		public ConfigEntry<float> ConfigRedwoodSpeed { get; private set; }

		public ConfigEntry<float> ConfigRedwoodShipPadding { get; private set; }

		public ConfigEntry<float> ConfigRedwoodEyesight { get; private set; }

		public ConfigEntry<bool> ConfigRedwoodCanEatOldBirds { get; private set; }

		public ConfigEntry<float> ConfigMeteorShowerTimeToLeave { get; private set; }

		public ConfigEntry<float> ConfigTornadoInsideBeforeThrow { get; private set; }

		public ConfigEntry<float> ConfigTornadoPullStrength { get; private set; }

		public ConfigEntry<float> ConfigTornadoSpeed { get; private set; }

		public ConfigEntry<float> ConfigMeteorSpeed { get; private set; }

		public ConfigEntry<int> ConfigMinMeteorSpawnCount { get; private set; }

		public ConfigEntry<int> ConfigMaxMeteorSpawnCount { get; private set; }

		public ConfigEntry<float> ConfigTornadoInShipVolume { get; private set; }

		public ConfigEntry<float> ConfigTornadoDefaultVolume { get; private set; }

		public ConfigEntry<float> ConfigMeteorShowerMeteoriteSpawnChance { get; private set; }

		public ConfigEntry<float> ConfigMeteorShowerInShipVolume { get; private set; }

		public ConfigEntry<bool> ConfigMeteorHitShip { get; private set; }

		public ConfigEntry<float> ConfigMeteorsDefaultVolume { get; private set; }

		public ConfigEntry<float> ConfigTerminalScanFrequency { get; private set; }

		public ConfigEntry<float> ConfigTerminalScanRange { get; private set; }

		public ConfigEntry<float> ConfigSeamineScanFrequency { get; private set; }

		public ConfigEntry<float> ConfigSeamineScanRange { get; private set; }

		public ConfigEntry<bool> ConfigBearTrapsPopTires { get; private set; }

		public ConfigEntry<bool> ConfigOnlyOwnerSeesScanEffects { get; private set; }

		public ConfigEntry<int> ConfigSeamineTinkCharges { get; private set; }

		public ConfigEntry<bool> ConfigOnlyOwnerSeesScanEffectsTerminalGal { get; private set; }

		public ConfigEntry<float> ConfigTerminalBotFlyingVolume { get; private set; }

		public ConfigEntry<bool> ConfigCruiserGalAutomatic { get; private set; }

		public ConfigEntry<bool> ConfigTerminalBotAutomatic { get; private set; }

		public ConfigEntry<int> ConfigWoodenSeedTreeSpawnChance { get; private set; }

		public ConfigEntry<bool> ConfigShockwaveBotAutomatic { get; private set; }

		public ConfigEntry<float> ConfigShockwaveBotPropellerVolume { get; private set; }

		public ConfigEntry<bool> ConfigShockwaveHoldsFourItems { get; private set; }

		public ConfigEntry<int> ConfigShockwaveCharges { get; private set; }

		public ConfigEntry<bool> ConfigAllowPowerLevelChangesFromWeather { get; private set; }

		public ConfigEntry<bool> ConfigExtendedLogging { get; set; }

		public ConfigEntry<string> ConfigFloraGrassCurveSpawnWeight { get; set; }

		public ConfigEntry<string> ConfigFloraDesertCurveSpawnWeight { get; set; }

		public ConfigEntry<string> ConfigFloraSnowCurveSpawnWeight { get; set; }

		public ConfigEntry<float> ConfigSeamineTinkRidingBruceVolume { get; private set; }

		public ConfigEntry<bool> ConfigSeamineTinkAutomatic { get; private set; }

		public ConfigEntry<float> ConfigMicrowaveVolume { get; private set; }

		public ConfigEntry<float> ConfigBearTrapVolume { get; private set; }

		public ConfigEntry<float> ConfigLaserTurretVolume { get; private set; }

		public ConfigEntry<float> ConfigFlashTurretVolume { get; private set; }

		public ConfigEntry<float> ConfigBugZapperVolume { get; private set; }

		public ConfigEntry<float> ConfigACUVolume { get; private set; }

		public ConfigEntry<float> Config999GalHealCooldown { get; private set; }

		public ConfigEntry<int> Config999GalHealAmount { get; private set; }

		public ConfigEntry<float> Config999GalHealSpeed { get; private set; }

		public ConfigEntry<bool> Config999GalHealOnlyInteractedPlayer { get; private set; }

		public ConfigEntry<bool> Config999GalReviveNearbyDeadPlayers { get; private set; }

		public ConfigEntry<int> Config999GalHealTotalAmount { get; private set; }

		public ConfigEntry<int> Config999GalReviveCharges { get; private set; }

		public ConfigEntry<bool> Config999GalCompanyMoonRecharge { get; private set; }

		public ConfigEntry<float> Config999GalFailureChance { get; private set; }

		public ConfigEntry<bool> Config999GalScaleHealAndReviveWithPlayerCount { get; private set; }

		public ConfigEntry<float> ConfigAirControlUnitKnockbackPower { get; private set; }

		public ConfigEntry<int> ConfigAirControlUnitDamage { get; private set; }

		public ConfigEntry<bool> ConfigCleanUnusedConfigs { get; private set; }

		public ConfigEntry<bool> ConfigDebugMode { get; private set; }

		public void InitMainCodeRebirthConfig(ConfigFile configFile)
		{
			ConfigExtendedLogging = configFile.Bind<bool>("Debug Options", "Debug Mode | Extended Logging", false, "Whether ExtendedLogging is enabled.");
			ConfigDebugMode = configFile.Bind<bool>("Debug Options", "Debug Mode | Hazard Spawning Enabled", false, "Whether debug mode is enabled (for hazard spawning stuff).");
			ConfigRemoveInteriorFog = configFile.Bind<bool>("Debug Options", "Debug Mode | Remove Interior Fog", false, "Whether zeekerss' horrible interior fog is removed.");
			ConfigOxydeEnabled = configFile.Bind<bool>("Oxyde Options", "Oxyde | Enabled", true, "Whether Oxyde is enabled, keep in mind enabling this option enables the following parts of this mod automatically.\nThis includes but is not limited to the following: Janitor, Transporter, Most of the hazards, Wallet+Coins+Merchant.");
			ConfigOxydeEnabledFromStart = configFile.Bind<bool>("Oxyde Options", "Oxyde | Enabled from Start", false, "Whether Oxyde is enabled from the very start.");
			ConfigOxydeNeedsNightShift = configFile.Bind<bool>("Oxyde Options", "Oxyde | Needs Night Shift", true, "Whether Oxyde needs night shift (it'll still be forced to Night Shift is the weather is None on non-company days).");
			ConfigAllowPowerLevelChangesFromWeather = configFile.Bind<bool>("General", "Allow Power Level Changes From Weather", true, "Whether power level changes from CodeRebirth weathers are allowed.");
			ConfigOnlyOwnerDisablesGal = configFile.Bind<bool>("General", "Gal AI | Owner Power", false, "Whether only the current owner of the gal can disable her.");
			ConfigDontTargetFarEnemies = configFile.Bind<bool>("General", "Gal AI | Dont Stray Too Far", false, "Whether the Gal AI should stop targetting enemies when she is far from her owner's position.");
			ConfigHazardsDeleteBodies = configFile.Bind<bool>("General", "Hazards | Delete Bodies", true, "Whether hazards like IndustrialFan and LaserTurret should delete player bodies.");
			ConfigCleanUnusedConfigs = configFile.Bind<bool>("General", "Clean Unusued Configs", true, "Whether CodeRebirth should delete old confing information that are unused.");
			ConfigFloraGrassCurveSpawnWeight = configFile.Bind<string>("Flora Options", "Flora | Grass CurveSpawnWeight", "Vanilla - 0.00,30.00 ; 1.00,60.00 | Custom - 0.00,30.00 ; 1.00,60.00 | Oxyde - 0.00,0.00 ; 1.00,0.00", "MoonName - CurveSpawnWeight for Grass flora (moon tags also work).");
			ConfigFloraDesertCurveSpawnWeight = configFile.Bind<string>("Flora Options", "Flora | Desert CurveSpawnWeight", "Vanilla - 0.00,30.00 ; 1.00,60.00 | Custom - 0.00,30.00 ; 1.00,60.00 | Oxyde - 0.00,0.00 ; 1.00,0.00", "MoonName - CurveSpawnWeight for Desert flora (moon tags also work).");
			ConfigFloraSnowCurveSpawnWeight = configFile.Bind<string>("Flora Options", "Flora | Snow CurveSpawnWeight", "Vanilla - 0.00,30.00 ; 1.00,60.00 | Custom - 0.00,30.00 ; 1.00,60.00 | Oxyde - 0.00,0.00 ; 1.00,0.00", "MoonName - CurveSpawnWeight for Snowy flora (moon tags also work).");
		}

		public void InitCodeRebirthConfig(ConfigFile configFile)
		{
			//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01be: Expected O, but got Unknown
			//IL_0225: Unknown result type (might be due to invalid IL or missing references)
			//IL_022f: Expected O, but got Unknown
			//IL_04b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_04bd: Expected O, but got Unknown
			//IL_04ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f6: Expected O, but got Unknown
			//IL_0525: Unknown result type (might be due to invalid IL or missing references)
			//IL_052f: Expected O, but got Unknown
			//IL_055e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0568: Expected O, but got Unknown
			//IL_0597: Unknown result type (might be due to invalid IL or missing references)
			//IL_05a1: Expected O, but got Unknown
			//IL_05ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_05f6: Expected O, but got Unknown
			//IL_0625: Unknown result type (might be due to invalid IL or missing references)
			//IL_062f: Expected O, but got Unknown
			//IL_065e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0668: Expected O, but got Unknown
			//IL_0697: Unknown result type (might be due to invalid IL or missing references)
			//IL_06a1: Expected O, but got Unknown
			//IL_06ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_06f6: Expected O, but got Unknown
			//IL_071d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0727: Expected O, but got Unknown
			//IL_074e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0758: Expected O, but got Unknown
			//IL_0787: Unknown result type (might be due to invalid IL or missing references)
			//IL_0791: Expected O, but got Unknown
			//IL_07c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_07ca: Expected O, but got Unknown
			//IL_0815: Unknown result type (might be due to invalid IL or missing references)
			//IL_081f: Expected O, but got Unknown
			//IL_084e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0858: Expected O, but got Unknown
			//IL_0887: Unknown result type (might be due to invalid IL or missing references)
			//IL_0891: Expected O, but got Unknown
			ConfigDisableTrashCans = configFile.Bind<bool>("Janitor Options", "Janitor | Disable Trash Cans", false, "Whether trash cans are disabled (this is only visually, trash cans still exist).");
			ConfigMicrowaveVolume = configFile.Bind<float>("FunctionalMicrowave Options", "Functional Microwave | Volume", 1f, "The volume of the Functional Microwave.");
			ConfigBearTrapsPopTires = configFile.Bind<bool>("BearTrap Options", "Bear Trap | Pop Tires", true, "Whether the bear trap can pop tires.");
			ConfigBearTrapVolume = configFile.Bind<float>("BearTrap Options", "Bear Trap | Volume", 1f, "The volume of the Bear Trap.");
			ConfigLaserTurretVolume = configFile.Bind<float>("LaserTurret Options", "Laser Turret | Volume", 1f, "The volume of the Laser Turret.");
			ConfigFlashTurretVolume = configFile.Bind<float>("FlashTurret Options", "Flash Turret | Volume", 1f, "The volume of the Flash Turret.");
			ConfigBugZapperVolume = configFile.Bind<float>("BugZapper Options", "Bug Zapper | Volume", 1f, "The volume of the Bug Zapper.");
			ConfigAirControlUnitDamage = configFile.Bind<int>("AirControlUnit Options", "Air Control Unit | Damage", 15, "Damage that the ACUnit deals to a player on hit");
			ConfigAirControlUnitKnockbackPower = configFile.Bind<float>("AirControlUnit Options", "Air Control Unit | Knockback Power", 250f, "The knockback power of the ACUnit.");
			ConfigACUVolume = configFile.Bind<float>("AirControlUnit Options", "Air Control Unit | Volume", 1f, "The volume of the Air Control Unit.");
			ConfigCruiserGalAutomatic = configFile.Bind<bool>("Cruiser Gal Options", "Cruiser Gal | Automatic Behaviour", false, "Whether the Cruiser Gal will automatically wake up and choose the nearest player as the owner.");
			ConfigShockwaveCharges = configFile.Bind<int>("Shockwave Options", "Shockwave Gal | Charges", 10, "How many charges the Shockwave Gal has.");
			ConfigShockwaveHoldsFourItems = configFile.Bind<bool>("Shockwave Options", "Shockwave Gal | Holds Four Items", false, "Whether the Shockwave Gal holds four items regardless of singleplayer or multiplayer.");
			ConfigShockwaveBotPropellerVolume = configFile.Bind<float>("Shockwave Options", "Shockwave Gal | Propeller Volume", 0.75f, new ConfigDescription("Volume of the Shockwave Gal's propeller.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()));
			ConfigShockwaveBotAutomatic = configFile.Bind<bool>("Shockwave Options", "Shockwave Gal | Automatic Behaviour", false, "Whether the Shockwave Gal will automatically wake up and choose the nearest player as the owner.");
			ConfigSeamineTinkCharges = configFile.Bind<int>("Seamine Options", "Seamine Gal | Charges", 3, "How many charges the Seamine Gal has.");
			ConfigSeamineTinkRidingBruceVolume = configFile.Bind<float>("Seamine Options", "Seamine Gal | Riding Bruce Volume", 0.75f, new ConfigDescription("Volume of the Seamine Gal's Riding Bruce.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()));
			ConfigSeamineTinkAutomatic = configFile.Bind<bool>("Seamine Options", "Seamine Gal | Automatic Behaviour", false, "Whether the Seamine Gal will automatically wake up and choose the nearest player as the owner.");
			ConfigOnlyOwnerSeesScanEffects = configFile.Bind<bool>("Seamine Options", "Seamine Gal | Only Owner Sees Scan Effects", false, "Whether only the owner of the Seamine Gal can see the scan effects.");
			ConfigSeamineScanRange = configFile.Bind<float>("Seamine Options", "Seamine Gal | Scan Range", 50f, "Range of the Seamine Gal's scan.");
			ConfigSeamineScanFrequency = configFile.Bind<float>("Seamine Options", "Seamine Gal | Scan Frequency", 17.5f, "The average Frequency time of the Seamine Gal's scan in seconds.");
			ConfigTerminalBotAutomatic = configFile.Bind<bool>("Terminal Options", "Terminal Gal | Automatic Behaviour", false, "Whether the Terminal Gal will automatically wake up and choose the nearest player as the owner.");
			ConfigOnlyOwnerSeesScanEffectsTerminalGal = configFile.Bind<bool>("Terminal Options", "Terminal Gal | Only Owner Sees Scan Effects", false, "Whether only the owner of the Terminal Gal can see the scan effects.");
			ConfigTerminalScanRange = configFile.Bind<float>("Terminal Options", "Terminal Gal | Scan Range", 50f, "Range of the Terminal Gal's scan.");
			ConfigTerminalScanFrequency = configFile.Bind<float>("Terminal Options", "Terminal Gal | Scan Frequency", 17.5f, "The average Frequency time of the Terminal Gal's scan in seconds.");
			ConfigTerminalBotFlyingVolume = configFile.Bind<float>("Terminal Options", "Terminal Gal | Flying Volume", 0.75f, "Volume of the Terminal Gal's Flying animation.");
			Config999GalHealCooldown = configFile.Bind<float>("SCP 999 Gal Options", "SCP 999 Gal | Heal Cooldown", 10f, "Cooldown between heals by interacting on the gal.");
			Config999GalHealAmount = configFile.Bind<int>("SCP 999 Gal Options", "SCP 999 Gal | Heal Amount", 100, "Amount healed by interacting on the gal.");
			Config999GalHealSpeed = configFile.Bind<float>("SCP 999 Gal Options", "SCP 999 Gal | Heal Speed", 10f, "Speed of healing by interacting on the gal (amount of time in seconds it for the gal to finish healing).");
			Config999GalHealTotalAmount = configFile.Bind<int>("SCP 999 Gal Options", "SCP 999 Gal | Healing Capacity", 200, "How much healing the SCP 999 Gal has per orbit.");
			Config999GalReviveCharges = configFile.Bind<int>("SCP 999 Gal Options", "SCP 999 Gal | Revive Charges", 2, "How many revive charges the SCP 999 Gal has per orbit.");
			Config999GalCompanyMoonRecharge = configFile.Bind<bool>("SCP 999 Gal Options", "SCP 999 Gal | Company Moon Recharge", true, "Whether the SCP 999 Gal recharges once per visiting company moon on last day.");
			Config999GalFailureChance = configFile.Bind<float>("SCP 999 Gal Options", "SCP 999 Gal | Failure Chance", 15f, "Failure chance of the SCP 999 Gal.");
			Config999GalHealOnlyInteractedPlayer = configFile.Bind<bool>("SCP 999 Gal Options", "SCP 999 Gal | Heal Only Interacted Player", false, "Whether the gal can heal only the player that interacts with her.");
			Config999GalReviveNearbyDeadPlayers = configFile.Bind<bool>("SCP 999 Gal Options", "SCP 999 Gal | Revive Nearby Dead Players", true, "Whether the gal can revive nearby dead bodies.");
			Config999GalScaleHealAndReviveWithPlayerCount = configFile.Bind<bool>("SCP 999 Gal Options", "SCP 999 Gal | Scale Heal and Revive with Player Count", true, "Whether the gal scales the heals and revives with player count.");
			ConfigWoodenSeedTreeSpawnChance = configFile.Bind<int>("Farming Options", "Farming | Wooden Seed Tree Spawn Chance", 2, "Chance of the wooden seed to spawn from a broken tree");
			ConfigTornadoSpeed = configFile.Bind<float>("Tornado Options", "Tornados | Speed", 7f, new ConfigDescription("Speed of tornados.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 100f), Array.Empty<object>()));
			ConfigTornadoPullStrength = configFile.Bind<float>("Tornado Options", "Tornados | Pull Strength", 20f, new ConfigDescription("Pull strength of tornados.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 100f), Array.Empty<object>()));
			ConfigTornadoInsideBeforeThrow = configFile.Bind<float>("Tornado Options", "Tornados | Inside Before Throw", 10f, new ConfigDescription("Timer of being inside tornado before you get flung the hell out (50 if you never wanna be thrown).", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 50f), Array.Empty<object>()));
			ConfigTornadoDefaultVolume = configFile.Bind<float>("Tornado Options", "Tornados | Default Volume", 1f, new ConfigDescription("Default volume of tornados.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()));
			ConfigTornadoInShipVolume = configFile.Bind<float>("Tornado Options", "Tornados | Volume in Ship", 1f, new ConfigDescription("Volume of tornados in the ship.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()));
			ConfigRedwoodCanEatOldBirds = configFile.Bind<bool>("Redwood Options", "Redwood | Can Eat Old Birds", true, "Whether redwood can eat old birds.");
			ConfigRedwoodShipPadding = configFile.Bind<float>("Redwood Options", "Redwood | Ship Padding", 10f, new ConfigDescription("How far away the redwood usually stays from the ship.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 999f), Array.Empty<object>()));
			ConfigRedwoodSpeed = configFile.Bind<float>("Redwood Options", "Redwood | Speed", 5f, new ConfigDescription("Redwood speed.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 999f), Array.Empty<object>()));
			ConfigRedwoodEyesight = configFile.Bind<float>("Redwood Options", "Redwood | Eyesight", 40f, new ConfigDescription("Redwood eyesight.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 999f), Array.Empty<object>()));
			ConfigRedwoodNormalVolume = configFile.Bind<float>("Redwood Options", "Redwood | Normal Volume", 1f, new ConfigDescription("Redwood Normal volume.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()));
			ConfigRedwoodHeartEnabled = configFile.Bind<bool>("Redwood Options", "Redwood | Heart Enabled", true, "Whether redwood heart is enabled.");
			ConfigRedwoodInShipVolume = configFile.Bind<float>("Redwood Options", "Redwood | In Ship Volume", 0.75f, new ConfigDescription("Redwood in ship volume.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()));
			ConfigMaxMeteorSpawnCount = configFile.Bind<int>("MeteorShower Options", "Meteors | Max Spawn Count", 3, new ConfigDescription("Maximum number of meteors to spawn at once every spawn cycle.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 999), Array.Empty<object>()));
			ConfigMinMeteorSpawnCount = configFile.Bind<int>("MeteorShower Options", "Meteors | Min Spawn Count", 1, new ConfigDescription("Minimum number of meteors to spawn at once every spawn cycle.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 999), Array.Empty<object>()));
			ConfigMeteorSpeed = configFile.Bind<float>("MeteorShower Options", "Meteors | Speed", 50f, new ConfigDescription("Speed of meteors.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1000f), Array.Empty<object>()));
			ConfigMeteorShowerTimeToLeave = configFile.Bind<float>("MeteorShower Options", "MeteorShower | Time To Leave", 0.85f, new ConfigDescription("Normalised time it takes for the meteor shower to leave the moon, 1 being at 12PM~.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()));
			ConfigMeteorHitShip = configFile.Bind<bool>("MeteorShower Options", "MeteorShower | Meteor Strikes Ship", false, "Allows striking the ship with a meteor.");
			ConfigMeteorShowerMeteoriteSpawnChance = configFile.Bind<float>("MeteorShower Options", "MeteorShower | Meteorite Spawn Chance", 2.5f, new ConfigDescription("Chance of spawning a meteorite when a meteor is spawned (0 to 100 decimals included).", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 100f), Array.Empty<object>()));
			ConfigMeteorsDefaultVolume = configFile.Bind<float>("MeteorShower Options", "Meteors | Default Volume", 0.4f, new ConfigDescription("Default Volume of Meteors (between 0 and 1).", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()));
			ConfigMeteorShowerInShipVolume = configFile.Bind<float>("MeteorShower Options", "MeteorShower | Meteor Volume", 0.3f, new ConfigDescription("Multiplier of the meteors volume for when the player is in the ship and the ship door is closed.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()));
			ConfigSnowGlobeMusic = configFile.Bind<bool>("SnowGlobe Options", "Snow Globe | Music", true, "Enables/Disables the music in the snow globe.");
		}
	}
	public class IngameKeybinds : LcInputActions
	{
		[InputAction("<Keyboard>/r", Name = "PullChain")]
		public InputAction PullChain { get; set; }

		[InputAction("<Keyboard>/r", Name = "JumpBoost")]
		public InputAction JumpBoost { get; set; }

		[InputAction("<Keyboard>/r", Name = "PumpSlugger")]
		public InputAction PumpSlugger { get; set; }

		[InputAction("<Keyboard>/r", Name = "ExhaustFuel")]
		public InputAction ExhaustFuel { get; set; }

		[InputAction("<Keyboard>/w", Name = "HoverForward")]
		public InputAction HoverForward { get; set; }

		[InputAction("<Keyboard>/shift", Name = "SprintForward")]
		public InputAction SprintForward { get; set; }

		[InputAction("<Keyboard>/a", Name = "HoverLeft")]
		public InputAction HoverLeft { get; set; }

		[InputAction("<Keyboard>/s", Name = "HoverBackward")]
		public InputAction HoverBackward { get; set; }

		[InputAction("<Keyboard>/d", Name = "HoverRight")]
		public InputAction HoverRight { get; set; }

		[InputAction("<Keyboard>/space", Name = "HoverUp")]
		public InputAction HoverUp { get; set; }

		[InputAction("<Keyboard>/c", Name = "DropHoverboard")]
		public InputAction DropHoverboard { get; set; }

		[InputAction("<Keyboard>/f", Name = "SwitchMode")]
		public InputAction SwitchMode { get; set; }

		[InputAction(/*Could not decode attribute arguments.*/)]
		public InputAction MouseDelta { get; set; }

		[InputAction(/*Could not decode attribute arguments.*/)]
		public InputAction MarrowHealPlayer { get; set; }
	}
	[BepInPlugin("CodeRebirth", "CodeRebirth", "1.3.1")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class Plugin : BaseUnityPlugin
	{
		internal class MainAssets : AssetBundleLoader<MainAssets>
		{
			[LoadFromBundle("CodeRebirthUtils.prefab")]
			public GameObject UtilsPrefab { get; private set; }

			[LoadFromBundle("EmptyNetworkObject.prefab")]
			public GameObject EmptyNetworkObject { get; private set; }

			public MainAssets(AssetBundle bundle)
				: base(bundle)
			{
			}
		}

		internal static ManualLogSource Logger = null;

		internal static readonly Harmony _harmony = new Harmony("CodeRebirth");

		internal static IngameKeybinds InputActionsInstance = null;

		internal const ulong GLITCH_STEAM_ID = 9uL;

		public static ConfigFile configFile { get; private set; } = null;


		public static CodeRebirthConfig ModConfig { get; private set; } = null;


		public static DuskMod Mod { get; private set; } = null;


		internal static MainAssets Assets { get; private set; } = null;


		private void Awake()
		{
			Logger = ((BaseUnityPlugin)this).Logger;
			configFile = ((BaseUnityPlugin)this).Config;
			ModConfig = new CodeRebirthConfig();
			ModConfig.ConfigExtendedLogging = configFile.Bind<bool>("Debug Options", "Debug Mode | Extended Logging", false, "Whether ExtendedLogging is enabled.");
			_harmony.PatchAll(typeof(PlayerControllerBPatch));
			_harmony.PatchAll(typeof(EnemyAIPatch));
			_harmony.PatchAll(typeof(ShovelPatch));
			_harmony.PatchAll(typeof(DoorLockPatch));
			_harmony.PatchAll(typeof(MineshaftElevatorControllerPatch));
			_harmony.PatchAll(typeof(KeyItemPatch));
			_harmony.PatchAll(typeof(RoundManagerPatch));
			_harmony.PatchAll(typeof(StartOfRoundPatch));
			_harmony.PatchAll(typeof(NetworkBehaviourPatch));
			_harmony.PatchAll(typeof(HDAdditionalLightDataPatch));
			ItemDropshipPatch.Init();
			KnifeItemPatch.Init();
			PlayerControllerBPatch.Init();
			EnemyAIPatch.Init();
			ShovelPatch.Init();
			DoorLockPatch.Init();
			MineshaftElevatorControllerPatch.Init();
			SpikeTrapPatch.Init();
			EnemyAICollisionDetectPatch.Init();
			LandminePatch.Init();
			ShotgunItemPatch.Init();
			TurretPatch.Init();
			GameNetworkManagerPatch.Init();
			DeleteFileButtonPatch.Init();
			SoccerBallPropPatch.Init();
			InputActionsInstance = new IngameKeybinds();
			ModConfig.InitMainCodeRebirthConfig(configFile);
			AssetBundle val = AssetBundleUtils.LoadBundle(Assembly.GetExecutingAssembly(), "coderebirthasset");
			Assets = new MainAssets(val);
			Mod = DuskMod.RegisterMod((BaseUnityPlugin)(object)this, val);
			Mod.RegisterContentHandlers();
			ModConfig.InitCodeRebirthConfig(configFile);
			Logger.LogInfo((object)"Registering CodeRebirth content.");
			if (OpenBodyCamCompatibilityChecker.Enabled)
			{
				OpenBodyCamCompatibilityChecker.Init();
			}
			if (ModConfig.ConfigCleanUnusedConfigs.Value)
			{
				Logger.LogInfo((object)"Cleaning config");
				ConfigFileExtensions.ClearUnusedEntries(((BaseUnityPlugin)this).Config);
			}
			((BaseUnityPlugin)this).Config.Save();
			Logger.LogInfo((object)"Plugin CodeRebirth is loaded!");
		}

		internal static void ExtendedLogging(object text)
		{
			if (ModConfig.ConfigExtendedLogging.Value)
			{
				Logger.LogInfo(text);
			}
		}
	}
}
namespace CodeRebirth.src.Util
{
	public enum CodeRebirthStatusEffects
	{
		None,
		Water,
		Fire,
		Smoke
	}
	public class CodeRebirthPlayerManager : NetworkSingleton<CodeRebirthPlayerManager>
	{
		private bool previousDoorClosed;

		public static List<InteractTrigger> triggersTampered = new List<InteractTrigger>();

		internal static Dictionary<PlayerControllerB, CRPlayerData> dataForPlayer = new Dictionary<PlayerControllerB, CRPlayerData>();

		public static event EventHandler<bool>? OnDoorStateChange;

		public void Awake()
		{
			if ((Object)(object)StartOfRound.Instance != (Object)null)
			{
				previousDoorClosed = StartOfRound.Instance.hangarDoorsClosed;
			}
		}

		public void Update()
		{
			if ((Object)(object)StartOfRound.Instance == (Object)null)
			{
				return;
			}
			if (previousDoorClosed != StartOfRound.Instance.hangarDoorsClosed)
			{
				Plugin.ExtendedLogging("Door opened/closed!!");
				CodeRebirthPlayerManager.OnDoorStateChange?.Invoke(null, StartOfRound.Instance.hangarDoorsClosed);
			}
			previousDoorClosed = StartOfRound.Instance.hangarDoorsClosed;
			if (SlowDownEffect.isSlowDownEffectActive)
			{
				if (Object.op_Implicit((Object)(object)GameNetworkManager.Instance.localPlayerController.hoveringOverTrigger) && (Object)(object)GameNetworkManager.Instance.localPlayerController.currentTriggerInAnimationWith != (Object)null && !triggersTampered.Contains(GameNetworkManager.Instance.localPlayerController.currentTriggerInAnimationWith))
				{
					InteractTrigger currentTriggerInAnimationWith = GameNetworkManager.Instance.localPlayerController.currentTriggerInAnimationWith;
					currentTriggerInAnimationWith.timeToHold /= 5f;
					triggersTampered.Add(GameNetworkManager.Instance.localPlayerController.currentTriggerInAnimationWith);
				}
			}
			else
			{
				if (triggersTampered.Count <= 0)
				{
					return;
				}
				foreach (InteractTrigger item in triggersTampered)
				{
					item.timeToHold *= 5f;
				}
				triggersTampered.Clear();
			}
		}

		public static void RevivePlayer(PlayerControllerB player, Vector3 position)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			if (player.isPlayerDead)
			{
				if (((NetworkBehaviour)NetworkSingleton<CodeRebirthPlayerManager>.Instance).IsHost)
				{
					NetworkSingleton<CodeRebirthPlayerManager>.Instance.RevivePlayerClientRPC(PlayerControllerReference.op_Implicit(player), position);
				}
				else
				{
					NetworkSingleton<CodeRebirthPlayerManager>.Instance.RevivePlayerServerRPC(PlayerControllerReference.op_Implicit(player), position);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		private void RevivePlayerServerRPC(PlayerControllerReference playerRef, Vector3 position)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: 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_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val = default(ServerRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(479954577u, val, (RpcDelivery)0);
				bool flag = playerRef != null;
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val2)).WriteValueSafe<PlayerControllerReference>(ref playerRef, default(ForNetworkSerializable));
				}
				((FastBufferWriter)(ref val2)).WriteValueSafe(ref position);
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 479954577u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
				RevivePlayerClientRPC(playerRef, position);
			}
		}

		[ClientRpc]
		private void RevivePlayerClientRPC(PlayerControllerReference playerRef, Vector3 position)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: 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_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0302: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(3421960823u, val, (RpcDelivery)0);
				bool flag = playerRef != null;
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val2)).WriteValueSafe<PlayerControllerReference>(ref playerRef, default(ForNetworkSerializable));
				}
				((FastBufferWriter)(ref val2)).WriteValueSafe(ref position);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 3421960823u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
			PlayerControllerB val3 = PlayerControllerReference.op_Implicit(playerRef);
			val3.isInsideFactory = false;
			val3.isInElevator = true;
			val3.isInHangarShipRoom = true;
			val3.ResetPlayerBloodObjects(val3.isPlayerDead);
			val3.health = 5;
			val3.isClimbingLadder = false;
			val3.clampLooking = false;
			val3.inVehicleAnimation = false;
			val3.disableMoveInput = false;
			val3.disableLookInput = false;
			val3.disableInteract = false;
			val3.ResetZAndXRotation();
			((Collider)val3.thisController).enabled = true;
			if (val3.isPlayerDead)
			{
				((Collider)val3.thisController).enabled = true;
				val3.isPlayerDead = false;
				val3.isPlayerControlled = true;
				val3.health = 5;
				val3.hasBeenCriticallyInjured = false;
				val3.criticallyInjured = false;
				val3.playerBodyAnimator.SetBool("Limp", false);
				val3.TeleportPlayer(position, false, 0f, false, true);
				val3.parentedToElevatorLastFrame = false;
				val3.overrideGameOverSpectatePivot = null;
				StartOfRound.Instance.SetPlayerObjectExtrapolate(false);
				val3.setPositionOfDeadPlayer = false;
				val3.DisablePlayerModel(((Component)val3).gameObject, true, true);
				((Behaviour)val3.helmetLight).enabled = false;
				val3.Crouch(false);
				Animator playerBodyAnimator = val3.playerBodyAnimator;
				if (playerBodyAnimator != null)
				{
					playerBodyAnimator.SetBool("Limp", false);
				}
				val3.bleedingHeavily = false;
				if ((Object)(object)val3.deadBody != (Object)null)
				{
					((Behaviour)val3.deadBody).enabled = false;
					((Component)val3.deadBody).gameObject.SetActive(false);
				}
				val3.bleedingHeavily = true;
				val3.deadBody = null;
				val3.activatingItem = false;
				val3.twoHanded = false;
				val3.inShockingMinigame = false;
				val3.inSpecialInteractAnimation = false;
				val3.freeRotationInInteractAnimation = false;
				val3.disableSyncInAnimation = false;
				val3.inAnimationWithEnemy = null;
				val3.holdingWalkieTalkie = false;
				val3.speakingToWalkieTalkie = false;
				val3.isSinking = false;
				val3.isUnderwater = false;
				val3.sinkingValue = 0f;
				val3.statusEffectAudio.Stop();
				val3.DisableJetpackControlsLocally();
				val3.mapRadarDotAnimator.SetBool("dead", false);
				val3.hasBegunSpectating = false;
				val3.externalForceAutoFade = Vector3.zero;
				val3.hinderedMultiplier = 1f;
				val3.isMovementHindered = 0;
				val3.sourcesCausingSinking = 0;
				val3.reverbPreset = StartOfRound.Instance.shipReverb;
				SoundManager.Instance.earsRingingTimer = 0f;
				val3.voiceMuffledByEnemy = false;
				SoundManager.Instance.playerVoicePitchTargets[Array.IndexOf(StartOfRound.Instance.allPlayerScripts, val3)] = 1f;
				SoundManager.Instance.SetPlayerPitch(1f, Array.IndexOf(StartOfRound.Instance.allPlayerScripts, val3));
				if ((Object)(object)val3.currentVoiceChatIngameSettings == (Object)null)
				{
					StartOfRound.Instance.RefreshPlayerVoicePlaybackObjects();
				}
				if ((Object)(object)val3.currentVoiceChatIngameSettings != (Object)null)
				{
					if ((Object)(object)val3.currentVoiceChatIngameSettings.voiceAudio == (Object)null)
					{
						val3.currentVoiceChatIngameSettings.InitializeComponents();
					}
					if ((Object)(object)val3.currentVoiceChatIngameSettings.voiceAudio == (Object)null)
					{
						return;
					}
					((Component)val3.currentVoiceChatIngameSettings.voiceAudio).GetComponent<OccludeAudio>().overridingLowPass = false;
				}
				HUDManager.Instance.UpdateBoxesSpectateUI();
				HUDManager.Instance.UpdateSpectateBoxSpeakerIcons();
			}
			if ((Object)(object)GameNetworkManager.Instance.localPlayerController == (Object)(object)val3)
			{
				val3.bleedingHeavily = false;
				val3.criticallyInjured = false;
				val3.health = 5;
				HUDManager.Instance.UpdateHealthUI(5, true);
				Animator playerBodyAnimator2 = val3.playerBodyAnimator;
				if (playerBodyAnimator2 != null)
				{
					playerBodyAnimator2.SetBool("Limp", false);
				}
				val3.spectatedPlayerScript = null;
				StartOfRound.Instance.SetSpectateCameraToGameOverMode(false, val3);
				StartOfRound.Instance.SetPlayerObjectExtrapolate(false);
				((Behaviour)HUDManager.Instance.audioListenerLowPass).enabled = false;
				HUDManager.Instance.gasHelmetAnimator.SetBool("gasEmitting", false);
				HUDManager.Instance.RemoveSpectateUI();
				HUDManager.Instance.gameOverAnimator.SetTrigger("revive");
			}
			StartOfRound.Instance.allPlayersDead = false;
			StartOfRound instance = StartOfRound.Instance;
			instance.livingPlayers++;
			StartOfRound.Instance.UpdatePlayerVoiceEffects();
		}

		protected override void __initializeVariables()
		{
			base.__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			((NetworkBehaviour)this).__registerRpc(479954577u, new RpcReceiveHandler(__rpc_handler_479954577), "RevivePlayerServerRPC");
			((NetworkBehaviour)this).__registerRpc(3421960823u, new RpcReceiveHandler(__rpc_handler_3421960823), "RevivePlayerClientRPC");
			base.__initializeRpcs();
		}

		private static void __rpc_handler_479954577(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: 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)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				PlayerControllerReference playerRef = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe<PlayerControllerReference>(ref playerRef, default(ForNetworkSerializable));
				}
				Vector3 position = default(Vector3);
				((FastBufferReader)(ref reader)).ReadValueSafe(ref position);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((CodeRebirthPlayerManager)(object)target).RevivePlayerServerRPC(playerRef, position);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3421960823(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: 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)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				PlayerControllerReference playerRef = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe<PlayerControllerReference>(ref playerRef, default(ForNetworkSerializable));
				}
				Vector3 position = default(Vector3);
				((FastBufferReader)(ref reader)).ReadValueSafe(ref position);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((CodeRebirthPlayerManager)(object)target).RevivePlayerClientRPC(playerRef, position);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		protected internal override string __getTypeName()
		{
			return "CodeRebirthPlayerManager";
		}
	}
	public class CRPlayerData
	{
		public bool Water;

		public bool Fire;

		public bool Smoke;

		public bool ridingHoverboard;

		public bool flingingAway;

		public bool flung;

		public bool pseudoDead;

		public Hoverboard? hoverboardRiding;

		public List<Collider> playerColliders = new List<Collider>();
	}
	internal static class PlayerControllerBExtensions
	{
		internal enum ApplyEffectResults : sbyte
		{
			Applied,
			Removed,
			None
		}

		internal static ApplyEffectResults ApplyStatusEffect(this PlayerControllerB player, CodeRebirthStatusEffects effect, float range, float distance)
		{
			if (distance < range && !player.HasEffectActive(effect))
			{
				player.ApplyStatusEffect(effect, isActive: true);
				return ApplyEffectResults.Applied;
			}
			if (distance >= range && player.HasEffectActive(effect))
			{
				player.ApplyStatusEffect(effect, isActive: false);
				return ApplyEffectResults.Removed;
			}
			if (player.HasEffectActive(effect) && effect == CodeRebirthStatusEffects.Fire)
			{
				CodeRebirthUtils.Instance.FireyVolume.weight = Mathf.Clamp01(range / distance);
			}
			else if (player.HasEffectActive(effect) && effect == CodeRebirthStatusEffects.Smoke)
			{
				CodeRebirthUtils.Instance.SmokyVolume.weight = Mathf.Clamp01(range / distance);
			}
			return ApplyEffectResults.None;
		}

		internal static void ApplyStatusEffect(this PlayerControllerB player, CodeRebirthStatusEffects effect, bool isActive)
		{
			if (player.ContainsCRPlayerData())
			{
				CRPlayerData cRPlayerData = player.GetCRPlayerData();
				switch (effect)
				{
				case CodeRebirthStatusEffects.Water:
					cRPlayerData.Water = isActive;
					break;
				case CodeRebirthStatusEffects.Fire:
					CodeRebirthUtils.Instance.FireyVolume.weight = 0f;
					cRPlayerData.Fire = isActive;
					break;
				case CodeRebirthStatusEffects.Smoke:
					CodeRebirthUtils.Instance.SmokyVolume.weight = 0f;
					cRPlayerData.Smoke = isActive;
					break;
				}
			}
		}

		internal static bool HasEffectActive(this PlayerControllerB player, CodeRebirthStatusEffects effect)
		{
			if (!player.ContainsCRPlayerData())
			{
				return false;
			}
			CRPlayerData cRPlayerData = player.GetCRPlayerData();
			return effect switch
			{
				CodeRebirthStatusEffects.Water => cRPlayerData.Water, 
				CodeRebirthStatusEffects.Fire => cRPlayerData.Fire, 
				CodeRebirthStatusEffects.Smoke => cRPlayerData.Smoke, 
				_ => false, 
			};
		}

		internal static CRPlayerData GetCRPlayerData(this PlayerControllerB player)
		{
			return CodeRebirthPlayerManager.dataForPlayer[player];
		}

		internal static bool ContainsCRPlayerData(this PlayerControllerB player)
		{
			return CodeRebirthPlayerManager.dataForPlayer.ContainsKey(player);
		}

		internal static void AddCRPlayerData(this PlayerControllerB player)
		{
			CodeRebirthPlayerManager.dataForPlayer.Add(player, new CRPlayerData());
			player.GetCRPlayerData().playerColliders = new List<Collider>(((Component)player).GetComponentsInChildren<Collider>());
		}

		internal static bool IsPseudoDead(this PlayerControllerB player)
		{
			return player.GetCRPlayerData().pseudoDead;
		}

		internal static bool SetPseudoDead(this PlayerControllerB player, bool pseudoDead)
		{
			return player.GetCRPlayerData().pseudoDead = pseudoDead;
		}

		internal static Hoverboard? TryGetHoverboardRiding(this PlayerControllerB player)
		{
			return player.GetCRPlayerData().hoverboardRiding;
		}

		internal static void SetHoverboardRiding(this PlayerControllerB player, Hoverboard? hoverboard)
		{
			player.GetCRPlayerData().ridingHoverboard = Object.op_Implicit((Object)(object)hoverboard);
		}

		internal static bool IsRidingHoverboard(this PlayerControllerB player)
		{
			return player.GetCRPlayerData().ridingHoverboard;
		}

		internal static void SetRidingHoverboard(this PlayerControllerB player, bool ridingHoverboard)
		{
			player.GetCRPlayerData().ridingHoverboard = ridingHoverboard;
		}

		internal static bool HasFlung(this PlayerControllerB player)
		{
			return player.GetCRPlayerData().flung;
		}

		internal static void SetFlung(this PlayerControllerB player, bool flung)
		{
			player.GetCRPlayerData().flung = flung;
		}

		internal static bool IsFlingingAway(this PlayerControllerB player)
		{
			return player.GetCRPlayerData().flingingAway;
		}

		internal static void SetFlingingAway(this PlayerControllerB player, bool flingingAway)
		{
			player.GetCRPlayerData().flingingAway = flingingAway;
		}

		internal static IEnumerable<Collider> GetPlayerColliders(this PlayerControllerB player)
		{
			return player.GetCRPlayerData().playerColliders;
		}
	}
	internal class CodeRebirthUtils : NetworkBehaviour
	{
		public Material WireframeMaterial;

		public Shader SeeThroughShader;

		public Volume TimeSlowVolume;

		public Volume FireyVolume;

		public Volume SmokyVolume;

		public Volume CloseEyeVolume;

		public AnimationClip ModifiedShipLandAnimation;

		public AnimationClip ModifiedDangerousShipLeaveAnimation;

		public AnimationClip ModifiedShipLeaveAnimation;

		internal ES3Settings SaveSettings;

		internal ShipAnimator shipAnimator;

		internal StartMatchLever startMatchLever;

		internal Terminal shipTerminal;

		internal static HashSet<(Light light, HDAdditionalLightData hDAdditionalLightData)> currentRoundLightData = new HashSet<(Light, HDAdditionalLightData)>();

		internal Dictionary<EnemyType, float> enemyCoinDropRate = new Dictionary<EnemyType, float>();

		internal Random CRRandom = new Random();

		private int _indexToSpawn;

		internal static CodeRebirthUtils Instance { get; private set; } = null;


		public override

plugins/CodeRebirth/com.local.Rodriguez.DuskReplacementEntities.CodeRebirth.dll

Decompiled 2 weeks ago
using System;
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 CodeRebirth.src.Content.Enemies;
using CodeRebirth.src.Content.Items;
using CodeRebirth.src.Content.Maps;
using CodeRebirth.src.Content.Unlockables;
using Dawn.Utils;
using Microsoft.CodeAnalysis;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: IgnoresAccessChecksTo("AmazingAssets.TerrainToMesh")]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp-firstpass")]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: IgnoresAccessChecksTo("ClientNetworkTransform")]
[assembly: IgnoresAccessChecksTo("CodeRebirth")]
[assembly: IgnoresAccessChecksTo("com.olegknyazev.softmask")]
[assembly: IgnoresAccessChecksTo("DissonanceVoip")]
[assembly: IgnoresAccessChecksTo("EasyTextEffects")]
[assembly: IgnoresAccessChecksTo("Facepunch Transport for Netcode for GameObjects")]
[assembly: IgnoresAccessChecksTo("Facepunch.Steamworks.Win64")]
[assembly: IgnoresAccessChecksTo("Unity.AI.Navigation")]
[assembly: IgnoresAccessChecksTo("Unity.Animation.Rigging")]
[assembly: IgnoresAccessChecksTo("Unity.Animation.Rigging.DocCodeExamples")]
[assembly: IgnoresAccessChecksTo("Unity.Burst")]
[assembly: IgnoresAccessChecksTo("Unity.Burst.Unsafe")]
[assembly: IgnoresAccessChecksTo("Unity.Collections")]
[assembly: IgnoresAccessChecksTo("Unity.Collections.LowLevel.ILSupport")]
[assembly: IgnoresAccessChecksTo("Unity.InputSystem")]
[assembly: IgnoresAccessChecksTo("Unity.InputSystem.ForUI")]
[assembly: IgnoresAccessChecksTo("Unity.Jobs")]
[assembly: IgnoresAccessChecksTo("Unity.Mathematics")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.Common")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.MetricTypes")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetStats")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetStatsMonitor.Component")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetStatsMonitor.Configuration")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetStatsMonitor.Implementation")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetStatsReporting")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetworkProfiler.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetworkSolutionInterface")]
[assembly: IgnoresAccessChecksTo("Unity.Netcode.Components")]
[assembly: IgnoresAccessChecksTo("Unity.Netcode.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.Networking.Transport")]
[assembly: IgnoresAccessChecksTo("Unity.ProBuilder.Csg")]
[assembly: IgnoresAccessChecksTo("Unity.ProBuilder")]
[assembly: IgnoresAccessChecksTo("Unity.ProBuilder.KdTree")]
[assembly: IgnoresAccessChecksTo("Unity.ProBuilder.Poly2Tri")]
[assembly: IgnoresAccessChecksTo("Unity.ProBuilder.Stl")]
[assembly: IgnoresAccessChecksTo("Unity.Profiling.Core")]
[assembly: IgnoresAccessChecksTo("Unity.RenderPipelines.Core.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.RenderPipelines.Core.ShaderLibrary")]
[assembly: IgnoresAccessChecksTo("Unity.RenderPipelines.HighDefinition.Config.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.RenderPipelines.HighDefinition.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.RenderPipelines.ShaderGraph.ShaderGraphLibrary")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Authentication")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Analytics")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Components")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Configuration")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Device")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Environments")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Environments.Internal")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Internal")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Networking")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Registration")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Scheduler")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Telemetry")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Threading")]
[assembly: IgnoresAccessChecksTo("Unity.Services.QoS")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Relay")]
[assembly: IgnoresAccessChecksTo("Unity.TextMeshPro")]
[assembly: IgnoresAccessChecksTo("Unity.Timeline")]
[assembly: IgnoresAccessChecksTo("Unity.VisualEffectGraph.Runtime")]
[assembly: IgnoresAccessChecksTo("UnityEngine.ARModule")]
[assembly: IgnoresAccessChecksTo("UnityEngine.NVIDIAModule")]
[assembly: IgnoresAccessChecksTo("UnityEngine.UI")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("com.local.Rodriguez.DuskReplacementEntities.CodeRebirth")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("Dusk per-assembly replacements")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+5c4f5331356c9528b331a8af235ed2bb8062e5e7")]
[assembly: AssemblyProduct("com.local.Rodriguez.DuskReplacementEntities.CodeRebirth")]
[assembly: AssemblyTitle("com.local.Rodriguez.DuskReplacementEntities.CodeRebirth")]
[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 DuskReplacementEntities
{
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "com.local.Rodriguez.DuskReplacementEntities.CodeRebirth";

		public const string PLUGIN_NAME = "com.local.Rodriguez.DuskReplacementEntities.CodeRebirth";

		public const string PLUGIN_VERSION = "1.0.0";
	}
}
namespace Dusk
{
	[CreateAssetMenu(fileName = "New Enemy Replacement Definition", menuName = "Entity Replacements/Enemy Replacements/CodeRebirth.src.Content.Enemies.CactusBudling")]
	public class DuskEntityReplacementDefinition_CodeRebirth_src_Content_Enemies_CactusBudling : DuskEnemyReplacementDefinition<CactusBudling>
	{
		[Space(10f)]
		public AudioClipsWithTime _idleAudioClips = new AudioClipsWithTime();

		public AudioClip? spawnSound;

		public AudioClip? dieSFX;

		public AudioClip? potential_rollingSource;

		public AudioClip? potentialCreatureVoice;

		public AudioClip? potentialCreatureSFX;

		protected override void ApplyTyped(CactusBudling CactusBudling)
		{
			CactusBudling componentInChildren = ((Component)CactusBudling).gameObject.GetComponentInChildren<CactusBudling>();
			if (_idleAudioClips.audioClips.Length != 0)
			{
				((CodeRebirthEnemyAI)componentInChildren)._idleAudioClips = _idleAudioClips;
			}
			if ((Object)(object)componentInChildren._rollingSource.clip != (Object)null && (Object)(object)potential_rollingSource != (Object)null)
			{
				componentInChildren._rollingSource.clip = potential_rollingSource;
			}
			if ((Object)(object)((EnemyAI)componentInChildren).creatureVoice.clip != (Object)null && (Object)(object)potentialCreatureVoice != (Object)null)
			{
				((EnemyAI)componentInChildren).creatureVoice.clip = potentialCreatureVoice;
			}
			if ((Object)(object)((EnemyAI)componentInChildren).creatureSFX.clip != (Object)null && (Object)(object)potentialCreatureSFX != (Object)null)
			{
				((EnemyAI)componentInChildren).creatureSFX.clip = potentialCreatureSFX;
			}
			if ((Object)(object)spawnSound != (Object)null)
			{
				((CodeRebirthEnemyAI)componentInChildren).spawnSound = spawnSound;
			}
			if ((Object)(object)dieSFX != (Object)null)
			{
				((EnemyAI)componentInChildren).dieSFX = dieSFX;
			}
		}
	}
	[CreateAssetMenu(fileName = "New Enemy Replacement Definition", menuName = "Entity Replacements/Enemy Replacements/CodeRebirth.src.Content.Enemies.CutieFlyAI")]
	public class DuskEntityReplacementDefinition_CodeRebirth_src_Content_Enemies_CutieFlyAI : DuskEnemyReplacementDefinition<CutieFlyAI>
	{
		[Space(10f)]
		public AudioClipsWithTime _idleAudioClips = new AudioClipsWithTime();

		public AudioClip? spawnSound;

		public AudioClip? dieSFX;

		public AudioClip? potentialCreatureVoice;

		public AudioClip? potentialCreatureSFX;

		protected override void ApplyTyped(CutieFlyAI CutieFlyAI)
		{
			CutieFlyAI componentInChildren = ((Component)CutieFlyAI).gameObject.GetComponentInChildren<CutieFlyAI>();
			if (_idleAudioClips.audioClips.Length != 0)
			{
				((CodeRebirthEnemyAI)componentInChildren)._idleAudioClips = _idleAudioClips;
			}
			if ((Object)(object)((EnemyAI)componentInChildren).creatureVoice.clip != (Object)null && (Object)(object)potentialCreatureVoice != (Object)null)
			{
				((EnemyAI)componentInChildren).creatureVoice.clip = potentialCreatureVoice;
			}
			if ((Object)(object)((EnemyAI)componentInChildren).creatureSFX.clip != (Object)null && (Object)(object)potentialCreatureSFX != (Object)null)
			{
				((EnemyAI)componentInChildren).creatureSFX.clip = potentialCreatureSFX;
			}
			if ((Object)(object)spawnSound != (Object)null)
			{
				((CodeRebirthEnemyAI)componentInChildren).spawnSound = spawnSound;
			}
			if ((Object)(object)dieSFX != (Object)null)
			{
				((EnemyAI)componentInChildren).dieSFX = dieSFX;
			}
		}
	}
	[CreateAssetMenu(fileName = "New Enemy Replacement Definition", menuName = "Entity Replacements/Enemy Replacements/CodeRebirth.src.Content.Enemies.DriftwoodMenaceAI")]
	public class DuskEntityReplacementDefinition_CodeRebirth_src_Content_Enemies_DriftwoodMenaceAI : DuskEnemyReplacementDefinition<DriftwoodMenaceAI>
	{
		[Space(10f)]
		public AudioClipsWithTime _idleAudioClips = new AudioClipsWithTime();

		public AudioClip? screamSound;

		public AudioClip? spawnSound;

		public AudioClip? dieSFX;

		public AudioClip? potentialCreatureVoice;

		public AudioClip? potentialCreatureSFX;

		protected override void ApplyTyped(DriftwoodMenaceAI DriftwoodMenaceAI)
		{
			DriftwoodMenaceAI componentInChildren = ((Component)DriftwoodMenaceAI).gameObject.GetComponentInChildren<DriftwoodMenaceAI>();
			if (_idleAudioClips.audioClips.Length != 0)
			{
				((CodeRebirthEnemyAI)componentInChildren)._idleAudioClips = _idleAudioClips;
			}
			if ((Object)(object)((EnemyAI)componentInChildren).creatureVoice.clip != (Object)null && (Object)(object)potentialCreatureVoice != (Object)null)
			{
				((EnemyAI)componentInChildren).creatureVoice.clip = potentialCreatureVoice;
			}
			if ((Object)(object)((EnemyAI)componentInChildren).creatureSFX.clip != (Object)null && (Object)(object)potentialCreatureSFX != (Object)null)
			{
				((EnemyAI)componentInChildren).creatureSFX.clip = potentialCreatureSFX;
			}
			if ((Object)(object)screamSound != (Object)null)
			{
				componentInChildren.screamSound = screamSound;
			}
			if ((Object)(object)spawnSound != (Object)null)
			{
				((CodeRebirthEnemyAI)componentInChildren).spawnSound = spawnSound;
			}
			if ((Object)(object)dieSFX != (Object)null)
			{
				((EnemyAI)componentInChildren).dieSFX = dieSFX;
			}
		}
	}
	[CreateAssetMenu(fileName = "New Enemy Replacement Definition", menuName = "Entity Replacements/Enemy Replacements/CodeRebirth.src.Content.Enemies.Duck")]
	public class DuskEntityReplacementDefinition_CodeRebirth_src_Content_Enemies_Duck : DuskEnemyReplacementDefinition<Duck>
	{
		[Space(10f)]
		public AudioClipsWithTime _idleAudioClips = new AudioClipsWithTime();

		public AudioClip? questGiveClip;

		public AudioClip? questSucceedClip;

		public AudioClip? questFailClip;

		public AudioClip? questGiveAgainClip;

		public AudioClip? questAfterFailClip;

		public AudioClip? spawnSound;

		public AudioClip? dieSFX;

		public AudioClip? potentialCreatureUltraVoice;

		public AudioClip? potentialCreatureVoice;

		public AudioClip? potentialCreatureSFX;

		protected override void ApplyTyped(Duck Duck)
		{
			Duck componentInChildren = ((Component)Duck).gameObject.GetComponentInChildren<Duck>();
			if (_idleAudioClips.audioClips.Length != 0)
			{
				((CodeRebirthEnemyAI)componentInChildren)._idleAudioClips = _idleAudioClips;
			}
			if ((Object)(object)((QuestMasterAI)componentInChildren).creatureUltraVoice.clip != (Object)null && (Object)(object)potentialCreatureUltraVoice != (Object)null)
			{
				((QuestMasterAI)componentInChildren).creatureUltraVoice.clip = potentialCreatureUltraVoice;
			}
			if ((Object)(object)((EnemyAI)componentInChildren).creatureVoice.clip != (Object)null && (Object)(object)potentialCreatureVoice != (Object)null)
			{
				((EnemyAI)componentInChildren).creatureVoice.clip = potentialCreatureVoice;
			}
			if ((Object)(object)((EnemyAI)componentInChildren).creatureSFX.clip != (Object)null && (Object)(object)potentialCreatureSFX != (Object)null)
			{
				((EnemyAI)componentInChildren).creatureSFX.clip = potentialCreatureSFX;
			}
			if ((Object)(object)questGiveClip != (Object)null)
			{
				((QuestMasterAI)componentInChildren).questGiveClip = questGiveClip;
			}
			if ((Object)(object)questSucceedClip != (Object)null)
			{
				((QuestMasterAI)componentInChildren).questSucceedClip = questSucceedClip;
			}
			if ((Object)(object)questFailClip != (Object)null)
			{
				((QuestMasterAI)componentInChildren).questFailClip = questFailClip;
			}
			if ((Object)(object)questGiveAgainClip != (Object)null)
			{
				((QuestMasterAI)componentInChildren).questGiveAgainClip = questGiveAgainClip;
			}
			if ((Object)(object)questAfterFailClip != (Object)null)
			{
				((QuestMasterAI)componentInChildren).questAfterFailClip = questAfterFailClip;
			}
			if ((Object)(object)spawnSound != (Object)null)
			{
				((CodeRebirthEnemyAI)componentInChildren).spawnSound = spawnSound;
			}
			if ((Object)(object)dieSFX != (Object)null)
			{
				((EnemyAI)componentInChildren).dieSFX = dieSFX;
			}
		}
	}
	[CreateAssetMenu(fileName = "New Enemy Replacement Definition", menuName = "Entity Replacements/Enemy Replacements/CodeRebirth.src.Content.Enemies.Guardsman")]
	public class DuskEntityReplacementDefinition_CodeRebirth_src_Content_Enemies_Guardsman : DuskEnemyReplacementDefinition<Guardsman>
	{
		[Space(10f)]
		public AudioClipsWithTime _idleAudioClips = new AudioClipsWithTime();

		public AudioClip? _slamAudioClip;

		public AudioClip? _ripApartAudioClip;

		public AudioClip? spawnSound;

		public AudioClip? dieSFX;

		public AudioClip[] _enemySpottedAudioClips = Array.Empty<AudioClip>();

		public AudioClip? potentialCreatureVoice;

		public AudioClip? potentialCreatureSFX;

		public ParticleSystem? _dustParticleSystem;

		protected override void ApplyTyped(Guardsman Guardsman)
		{
			Guardsman componentInChildren = ((Component)Guardsman).gameObject.GetComponentInChildren<Guardsman>();
			if (_idleAudioClips.audioClips.Length != 0)
			{
				((CodeRebirthEnemyAI)componentInChildren)._idleAudioClips = _idleAudioClips;
			}
			if (_enemySpottedAudioClips.Length != 0)
			{
				componentInChildren._enemySpottedAudioClips = _enemySpottedAudioClips;
			}
			if ((Object)(object)((EnemyAI)componentInChildren).creatureVoice.clip != (Object)null && (Object)(object)potentialCreatureVoice != (Object)null)
			{
				((EnemyAI)componentInChildren).creatureVoice.clip = potentialCreatureVoice;
			}
			if ((Object)(object)((EnemyAI)componentInChildren).creatureSFX.clip != (Object)null && (Object)(object)potentialCreatureSFX != (Object)null)
			{
				((EnemyAI)componentInChildren).creatureSFX.clip = potentialCreatureSFX;
			}
			if ((Object)(object)_slamAudioClip != (Object)null)
			{
				componentInChildren._slamAudioClip = _slamAudioClip;
			}
			if ((Object)(object)_ripApartAudioClip != (Object)null)
			{
				componentInChildren._ripApartAudioClip = _ripApartAudioClip;
			}
			if ((Object)(object)spawnSound != (Object)null)
			{
				((CodeRebirthEnemyAI)componentInChildren).spawnSound = spawnSound;
			}
			if ((Object)(object)dieSFX != (Object)null)
			{
				((EnemyAI)componentInChildren).dieSFX = dieSFX;
			}
			if ((Object)(object)_dustParticleSystem != (Object)null)
			{
				ParticleSystem dustParticleSystem = _dustParticleSystem;
				ParticleSystem dustParticleSystem2 = componentInChildren._dustParticleSystem;
				if ((Object)(object)dustParticleSystem != (Object)null && (Object)(object)dustParticleSystem2 != (Object)null)
				{
					GameObject val = Object.Instantiate<GameObject>(((Component)dustParticleSystem).gameObject, ((Component)dustParticleSystem2).transform.parent);
					((Object)val).name = ((Object)((Component)dustParticleSystem2).gameObject).name;
					Object.Destroy((Object)(object)((Component)dustParticleSystem2).gameObject);
					componentInChildren._dustParticleSystem = _dustParticleSystem;
				}
			}
		}
	}
	[CreateAssetMenu(fileName = "New Enemy Replacement Definition", menuName = "Entity Replacements/Enemy Replacements/CodeRebirth.src.Content.Enemies.Janitor")]
	public class DuskEntityReplacementDefinition_CodeRebirth_src_Content_Enemies_Janitor : DuskEnemyReplacementDefinition<Janitor>
	{
		[Space(10f)]
		public AudioClipsWithTime _idleAudioClips = new AudioClipsWithTime();

		public AudioClip? spawnSound;

		public AudioClip? dieSFX;

		public AudioClip[] deathSounds = Array.Empty<AudioClip>();

		public AudioClip[] postDeathSounds = Array.Empty<AudioClip>();

		public AudioClip[] detectItemDroppedSounds = Array.Empty<AudioClip>();

		public AudioClip[] grabPlayerSounds = Array.Empty<AudioClip>();

		public AudioClip[] throwPlayerSounds = Array.Empty<AudioClip>();

		public AudioClip? potentialCreatureVoice;

		public AudioClip? potentialCreatureSFX;

		protected override void ApplyTyped(Janitor Janitor)
		{
			Janitor componentInChildren = ((Component)Janitor).gameObject.GetComponentInChildren<Janitor>();
			if (_idleAudioClips.audioClips.Length != 0)
			{
				((CodeRebirthEnemyAI)componentInChildren)._idleAudioClips = _idleAudioClips;
			}
			if (deathSounds.Length != 0)
			{
				componentInChildren.deathSounds = deathSounds;
			}
			if (postDeathSounds.Length != 0)
			{
				componentInChildren.postDeathSounds = postDeathSounds;
			}
			if (detectItemDroppedSounds.Length != 0)
			{
				componentInChildren.detectItemDroppedSounds = detectItemDroppedSounds;
			}
			if (grabPlayerSounds.Length != 0)
			{
				componentInChildren.grabPlayerSounds = grabPlayerSounds;
			}
			if (throwPlayerSounds.Length != 0)
			{
				componentInChildren.throwPlayerSounds = throwPlayerSounds;
			}
			if ((Object)(object)((EnemyAI)componentInChildren).creatureVoice.clip != (Object)null && (Object)(object)potentialCreatureVoice != (Object)null)
			{
				((EnemyAI)componentInChildren).creatureVoice.clip = potentialCreatureVoice;
			}
			if ((Object)(object)((EnemyAI)componentInChildren).creatureSFX.clip != (Object)null && (Object)(object)potentialCreatureSFX != (Object)null)
			{
				((EnemyAI)componentInChildren).creatureSFX.clip = potentialCreatureSFX;
			}
			if ((Object)(object)spawnSound != (Object)null)
			{
				((CodeRebirthEnemyAI)componentInChildren).spawnSound = spawnSound;
			}
			if ((Object)(object)dieSFX != (Object)null)
			{
				((EnemyAI)componentInChildren).dieSFX = dieSFX;
			}
		}
	}
	[CreateAssetMenu(fileName = "New Enemy Replacement Definition", menuName = "Entity Replacements/Enemy Replacements/CodeRebirth.src.Content.Enemies.Mistress")]
	public class DuskEntityReplacementDefinition_CodeRebirth_src_Content_Enemies_Mistress : DuskEnemyReplacementDefinition<Mistress>
	{
		[Space(10f)]
		public AudioClipsWithTime _idleAudioClips = new AudioClipsWithTime();

		public AudioClip? LoseSightSound;

		public AudioClip? spawnSound;

		public AudioClip? dieSFX;

		public AudioClip[] AttackSounds = Array.Empty<AudioClip>();

		public AudioClip? potentialCreatureVoice;

		public AudioClip? potentialCreatureSFX;

		protected override void ApplyTyped(Mistress Mistress)
		{
			Mistress componentInChildren = ((Component)Mistress).gameObject.GetComponentInChildren<Mistress>();
			if (_idleAudioClips.audioClips.Length != 0)
			{
				((CodeRebirthEnemyAI)componentInChildren)._idleAudioClips = _idleAudioClips;
			}
			if (AttackSounds.Length != 0)
			{
				componentInChildren.AttackSounds = AttackSounds;
			}
			if ((Object)(object)((EnemyAI)componentInChildren).creatureVoice.clip != (Object)null && (Object)(object)potentialCreatureVoice != (Object)null)
			{
				((EnemyAI)componentInChildren).creatureVoice.clip = potentialCreatureVoice;
			}
			if ((Object)(object)((EnemyAI)componentInChildren).creatureSFX.clip != (Object)null && (Object)(object)potentialCreatureSFX != (Object)null)
			{
				((EnemyAI)componentInChildren).creatureSFX.clip = potentialCreatureSFX;
			}
			if ((Object)(object)LoseSightSound != (Object)null)
			{
				componentInChildren.LoseSightSound = LoseSightSound;
			}
			if ((Object)(object)spawnSound != (Object)null)
			{
				((CodeRebirthEnemyAI)componentInChildren).spawnSound = spawnSound;
			}
			if ((Object)(object)dieSFX != (Object)null)
			{
				((EnemyAI)componentInChildren).dieSFX = dieSFX;
			}
		}
	}
	[CreateAssetMenu(fileName = "New Enemy Replacement Definition", menuName = "Entity Replacements/Enemy Replacements/CodeRebirth.src.Content.Enemies.Monarch")]
	public class DuskEntityReplacementDefinition_CodeRebirth_src_Content_Enemies_Monarch : DuskEnemyReplacementDefinition<Monarch>
	{
		[Space(10f)]
		public AudioClipsWithTime _idleAudioClips = new AudioClipsWithTime();

		public AudioClip? spawnSound;

		public AudioClip? dieSFX;

		public AudioClip[] _biteSounds = Array.Empty<AudioClip>();

		public AudioClip? potentialUltraCreatureVoice;

		public AudioClip? potentialCreatureVoice;

		public AudioClip? potentialCreatureSFX;

		protected override void ApplyTyped(Monarch Monarch)
		{
			Monarch componentInChildren = ((Component)Monarch).gameObject.GetComponentInChildren<Monarch>();
			if (_idleAudioClips.audioClips.Length != 0)
			{
				((CodeRebirthEnemyAI)componentInChildren)._idleAudioClips = _idleAudioClips;
			}
			if (_biteSounds.Length != 0)
			{
				componentInChildren._biteSounds = _biteSounds;
			}
			if ((Object)(object)componentInChildren.UltraCreatureVoice.clip != (Object)null && (Object)(object)potentialUltraCreatureVoice != (Object)null)
			{
				componentInChildren.UltraCreatureVoice.clip = potentialUltraCreatureVoice;
			}
			if ((Object)(object)((EnemyAI)componentInChildren).creatureVoice.clip != (Object)null && (Object)(object)potentialCreatureVoice != (Object)null)
			{
				((EnemyAI)componentInChildren).creatureVoice.clip = potentialCreatureVoice;
			}
			if ((Object)(object)((EnemyAI)componentInChildren).creatureSFX.clip != (Object)null && (Object)(object)potentialCreatureSFX != (Object)null)
			{
				((EnemyAI)componentInChildren).creatureSFX.clip = potentialCreatureSFX;
			}
			if ((Object)(object)spawnSound != (Object)null)
			{
				((CodeRebirthEnemyAI)componentInChildren).spawnSound = spawnSound;
			}
			if ((Object)(object)dieSFX != (Object)null)
			{
				((EnemyAI)componentInChildren).dieSFX = dieSFX;
			}
		}
	}
	[CreateAssetMenu(fileName = "New Enemy Replacement Definition", menuName = "Entity Replacements/Enemy Replacements/CodeRebirth.src.Content.Enemies.Nancy")]
	public class DuskEntityReplacementDefinition_CodeRebirth_src_Content_Enemies_Nancy : DuskEnemyReplacementDefinition<Nancy>
	{
		[Space(10f)]
		public AudioClipsWithTime _idleAudioClips = new AudioClipsWithTime();

		public AudioClip? spawnSound;

		public AudioClip? dieSFX;

		public AudioClip[] _detectInjuredPlayerVoicelines = Array.Empty<AudioClip>();

		public AudioClip[] _specialDetectInjuredPlayerVoicelines = Array.Empty<AudioClip>();

		public AudioClip[] _healFailVoicelines = Array.Empty<AudioClip>();

		public AudioClip[] _healSuccessVoiceline = Array.Empty<AudioClip>();

		public AudioClip? potential_rollingSource;

		public AudioClip? potential_healDuringSource;

		public AudioClip? potentialCreatureVoice;

		public AudioClip? potentialCreatureSFX;

		protected override void ApplyTyped(Nancy Nancy)
		{
			Nancy componentInChildren = ((Component)Nancy).gameObject.GetComponentInChildren<Nancy>();
			if (_idleAudioClips.audioClips.Length != 0)
			{
				((CodeRebirthEnemyAI)componentInChildren)._idleAudioClips = _idleAudioClips;
			}
			if (_detectInjuredPlayerVoicelines.Length != 0)
			{
				componentInChildren._detectInjuredPlayerVoicelines = _detectInjuredPlayerVoicelines;
			}
			if (_specialDetectInjuredPlayerVoicelines.Length != 0)
			{
				componentInChildren._specialDetectInjuredPlayerVoicelines = _specialDetectInjuredPlayerVoicelines;
			}
			if (_healFailVoicelines.Length != 0)
			{
				componentInChildren._healFailVoicelines = _healFailVoicelines;
			}
			if (_healSuccessVoiceline.Length != 0)
			{
				componentInChildren._healSuccessVoiceline = _healSuccessVoiceline;
			}
			if ((Object)(object)componentInChildren._rollingSource.clip != (Object)null && (Object)(object)potential_rollingSource != (Object)null)
			{
				componentInChildren._rollingSource.clip = potential_rollingSource;
			}
			if ((Object)(object)componentInChildren._healDuringSource.clip != (Object)null && (Object)(object)potential_healDuringSource != (Object)null)
			{
				componentInChildren._healDuringSource.clip = potential_healDuringSource;
			}
			if ((Object)(object)((EnemyAI)componentInChildren).creatureVoice.clip != (Object)null && (Object)(object)potentialCreatureVoice != (Object)null)
			{
				((EnemyAI)componentInChildren).creatureVoice.clip = potentialCreatureVoice;
			}
			if ((Object)(object)((EnemyAI)componentInChildren).creatureSFX.clip != (Object)null && (Object)(object)potentialCreatureSFX != (Object)null)
			{
				((EnemyAI)componentInChildren).creatureSFX.clip = potentialCreatureSFX;
			}
			if ((Object)(object)spawnSound != (Object)null)
			{
				((CodeRebirthEnemyAI)componentInChildren).spawnSound = spawnSound;
			}
			if ((Object)(object)dieSFX != (Object)null)
			{
				((EnemyAI)componentInChildren).dieSFX = dieSFX;
			}
		}
	}
	[CreateAssetMenu(fileName = "New Enemy Replacement Definition", menuName = "Entity Replacements/Enemy Replacements/CodeRebirth.src.Content.Enemies.PeaceKeeper")]
	public class DuskEntityReplacementDefinition_CodeRebirth_src_Content_Enemies_PeaceKeeper : DuskEnemyReplacementDefinition<PeaceKeeper>
	{
		[Space(10f)]
		public AudioClipsWithTime _idleAudioClips = new AudioClipsWithTime();

		public AudioClip? _revUpSound;

		public AudioClip? _revDownSound;

		public AudioClip? _bitchSlapSound;

		public AudioClip? _bitchSlapStartSound;

		public AudioClip? spawnSound;

		public AudioClip? dieSFX;

		public AudioClip? potential_treadsSource;

		public AudioClip? potential_aggroSFX;

		public AudioClip? potentialCreatureVoice;

		public AudioClip? potentialCreatureSFX;

		protected override void ApplyTyped(PeaceKeeper PeaceKeeper)
		{
			PeaceKeeper componentInChildren = ((Component)PeaceKeeper).gameObject.GetComponentInChildren<PeaceKeeper>();
			if (_idleAudioClips.audioClips.Length != 0)
			{
				((CodeRebirthEnemyAI)componentInChildren)._idleAudioClips = _idleAudioClips;
			}
			if ((Object)(object)componentInChildren._treadsSource.clip != (Object)null && (Object)(object)potential_treadsSource != (Object)null)
			{
				componentInChildren._treadsSource.clip = potential_treadsSource;
			}
			if ((Object)(object)componentInChildren._aggroSFX.clip != (Object)null && (Object)(object)potential_aggroSFX != (Object)null)
			{
				componentInChildren._aggroSFX.clip = potential_aggroSFX;
			}
			if ((Object)(object)((EnemyAI)componentInChildren).creatureVoice.clip != (Object)null && (Object)(object)potentialCreatureVoice != (Object)null)
			{
				((EnemyAI)componentInChildren).creatureVoice.clip = potentialCreatureVoice;
			}
			if ((Object)(object)((EnemyAI)componentInChildren).creatureSFX.clip != (Object)null && (Object)(object)potentialCreatureSFX != (Object)null)
			{
				((EnemyAI)componentInChildren).creatureSFX.clip = potentialCreatureSFX;
			}
			if ((Object)(object)_revUpSound != (Object)null)
			{
				componentInChildren._revUpSound = _revUpSound;
			}
			if ((Object)(object)_revDownSound != (Object)null)
			{
				componentInChildren._revDownSound = _revDownSound;
			}
			if ((Object)(object)_bitchSlapSound != (Object)null)
			{
				componentInChildren._bitchSlapSound = _bitchSlapSound;
			}
			if ((Object)(object)_bitchSlapStartSound != (Object)null)
			{
				componentInChildren._bitchSlapStartSound = _bitchSlapStartSound;
			}
			if ((Object)(object)spawnSound != (Object)null)
			{
				((CodeRebirthEnemyAI)componentInChildren).spawnSound = spawnSound;
			}
			if ((Object)(object)dieSFX != (Object)null)
			{
				((EnemyAI)componentInChildren).dieSFX = dieSFX;
			}
		}
	}
	[CreateAssetMenu(fileName = "New Enemy Replacement Definition", menuName = "Entity Replacements/Enemy Replacements/CodeRebirth.src.Content.Enemies.Puppeteer")]
	public class DuskEntityReplacementDefinition_CodeRebirth_src_Content_Enemies_Puppeteer : DuskEnemyReplacementDefinition<Puppeteer>
	{
		[Space(10f)]
		public AudioClipsWithTime _idleAudioClips = new AudioClipsWithTime();

		public AudioClip? grabPlayerSound;

		public AudioClip? makePuppetSound;

		public AudioClip? stabSound;

		public AudioClip? swipeSound;

		public AudioClip? maskDefensiveSound;

		public AudioClip? spawnSound;

		public AudioClip? dieSFX;

		public AudioClip[] normalFootstepSounds = Array.Empty<AudioClip>();

		public AudioClip[] combatFootstepSounds = Array.Empty<AudioClip>();

		public AudioClip[] reflectSounds = Array.Empty<AudioClip>();

		public AudioClip? potentialCreatureVoice;

		public AudioClip? potentialCreatureSFX;

		protected override void ApplyTyped(Puppeteer Puppeteer)
		{
			Puppeteer componentInChildren = ((Component)Puppeteer).gameObject.GetComponentInChildren<Puppeteer>();
			if (_idleAudioClips.audioClips.Length != 0)
			{
				((CodeRebirthEnemyAI)componentInChildren)._idleAudioClips = _idleAudioClips;
			}
			if (normalFootstepSounds.Length != 0)
			{
				componentInChildren.normalFootstepSounds = normalFootstepSounds;
			}
			if (combatFootstepSounds.Length != 0)
			{
				componentInChildren.combatFootstepSounds = combatFootstepSounds;
			}
			if (reflectSounds.Length != 0)
			{
				componentInChildren.reflectSounds = reflectSounds;
			}
			if ((Object)(object)((EnemyAI)componentInChildren).creatureVoice.clip != (Object)null && (Object)(object)potentialCreatureVoice != (Object)null)
			{
				((EnemyAI)componentInChildren).creatureVoice.clip = potentialCreatureVoice;
			}
			if ((Object)(object)((EnemyAI)componentInChildren).creatureSFX.clip != (Object)null && (Object)(object)potentialCreatureSFX != (Object)null)
			{
				((EnemyAI)componentInChildren).creatureSFX.clip = potentialCreatureSFX;
			}
			if ((Object)(object)grabPlayerSound != (Object)null)
			{
				componentInChildren.grabPlayerSound = grabPlayerSound;
			}
			if ((Object)(object)makePuppetSound != (Object)null)
			{
				componentInChildren.makePuppetSound = makePuppetSound;
			}
			if ((Object)(object)stabSound != (Object)null)
			{
				componentInChildren.stabSound = stabSound;
			}
			if ((Object)(object)swipeSound != (Object)null)
			{
				componentInChildren.swipeSound = swipeSound;
			}
			if ((Object)(object)maskDefensiveSound != (Object)null)
			{
				componentInChildren.maskDefensiveSound = maskDefensiveSound;
			}
			if ((Object)(object)spawnSound != (Object)null)
			{
				((CodeRebirthEnemyAI)componentInChildren).spawnSound = spawnSound;
			}
			if ((Object)(object)dieSFX != (Object)null)
			{
				((EnemyAI)componentInChildren).dieSFX = dieSFX;
			}
		}
	}
	[CreateAssetMenu(fileName = "New Enemy Replacement Definition", menuName = "Entity Replacements/Enemy Replacements/CodeRebirth.src.Content.Enemies.RabbitMagician")]
	public class DuskEntityReplacementDefinition_CodeRebirth_src_Content_Enemies_RabbitMagician : DuskEnemyReplacementDefinition<RabbitMagician>
	{
		[Space(10f)]
		public AudioClipsWithTime _idleAudioClips = new AudioClipsWithTime();

		public AudioClip? _spottedFromGroundAudioClip;

		public AudioClip? _spottedFromBackAudioClip;

		public AudioClip? spawnSound;

		public AudioClip? dieSFX;

		public AudioClip[] _fallingAudioClips = Array.Empty<AudioClip>();

		public AudioClip? potentialCreatureVoice;

		public AudioClip? potentialCreatureSFX;

		public ParticleSystem? _confettiParticles;

		protected override void ApplyTyped(RabbitMagician RabbitMagician)
		{
			RabbitMagician componentInChildren = ((Component)RabbitMagician).gameObject.GetComponentInChildren<RabbitMagician>();
			if (_idleAudioClips.audioClips.Length != 0)
			{
				((CodeRebirthEnemyAI)componentInChildren)._idleAudioClips = _idleAudioClips;
			}
			if (_fallingAudioClips.Length != 0)
			{
				componentInChildren._fallingAudioClips = _fallingAudioClips;
			}
			if ((Object)(object)((EnemyAI)componentInChildren).creatureVoice.clip != (Object)null && (Object)(object)potentialCreatureVoice != (Object)null)
			{
				((EnemyAI)componentInChildren).creatureVoice.clip = potentialCreatureVoice;
			}
			if ((Object)(object)((EnemyAI)componentInChildren).creatureSFX.clip != (Object)null && (Object)(object)potentialCreatureSFX != (Object)null)
			{
				((EnemyAI)componentInChildren).creatureSFX.clip = potentialCreatureSFX;
			}
			if ((Object)(object)_spottedFromGroundAudioClip != (Object)null)
			{
				componentInChildren._spottedFromGroundAudioClip = _spottedFromGroundAudioClip;
			}
			if ((Object)(object)_spottedFromBackAudioClip != (Object)null)
			{
				componentInChildren._spottedFromBackAudioClip = _spottedFromBackAudioClip;
			}
			if ((Object)(object)spawnSound != (Object)null)
			{
				((CodeRebirthEnemyAI)componentInChildren).spawnSound = spawnSound;
			}
			if ((Object)(object)dieSFX != (Object)null)
			{
				((EnemyAI)componentInChildren).dieSFX = dieSFX;
			}
			if ((Object)(object)_confettiParticles != (Object)null)
			{
				ParticleSystem confettiParticles = _confettiParticles;
				ParticleSystem confettiParticles2 = componentInChildren._confettiParticles;
				if ((Object)(object)confettiParticles != (Object)null && (Object)(object)confettiParticles2 != (Object)null)
				{
					GameObject val = Object.Instantiate<GameObject>(((Component)confettiParticles).gameObject, ((Component)confettiParticles2).transform.parent);
					((Object)val).name = ((Object)((Component)confettiParticles2).gameObject).name;
					Object.Destroy((Object)(object)((Component)confettiParticles2).gameObject);
					componentInChildren._confettiParticles = _confettiParticles;
				}
			}
		}
	}
	[CreateAssetMenu(fileName = "New Enemy Replacement Definition", menuName = "Entity Replacements/Enemy Replacements/CodeRebirth.src.Content.Enemies.RedwoodTitanAI")]
	public class DuskEntityReplacementDefinition_CodeRebirth_src_Content_Enemies_RedwoodTitanAI : DuskEnemyReplacementDefinition<RedwoodTitanAI>
	{
		[Space(10f)]
		public AudioClipsWithTime _idleAudioClips = new AudioClipsWithTime();

		public AudioClip? eatenSound;

		public AudioClip? roarSound;

		public AudioClip? jumpSound;

		public AudioClip? kickSound;

		public AudioClip? crunchySquishSound;

		public AudioClip? spawnSound;

		public AudioClip? dieSFX;

		public AudioClip? potentialCreatureSFXFar;

		public AudioClip? potentialCreatureVoice;

		public AudioClip? potentialCreatureSFX;

		public ParticleSystem? DustParticlesLeft;

		public ParticleSystem? DustParticlesRight;

		public ParticleSystem? ForestKeeperParticles;

		public ParticleSystem? DriftwoodGiantParticles;

		public ParticleSystem? OldBirdParticles;

		public ParticleSystem? DeathParticles;

		public ParticleSystem? BigSmokeEffect;

		protected override void ApplyTyped(RedwoodTitanAI RedwoodTitanAI)
		{
			RedwoodTitanAI componentInChildren = ((Component)RedwoodTitanAI).gameObject.GetComponentInChildren<RedwoodTitanAI>();
			if (_idleAudioClips.audioClips.Length != 0)
			{
				((CodeRebirthEnemyAI)componentInChildren)._idleAudioClips = _idleAudioClips;
			}
			if ((Object)(object)componentInChildren.creatureSFXFar.clip != (Object)null && (Object)(object)potentialCreatureSFXFar != (Object)null)
			{
				componentInChildren.creatureSFXFar.clip = potentialCreatureSFXFar;
			}
			if ((Object)(object)((EnemyAI)componentInChildren).creatureVoice.clip != (Object)null && (Object)(object)potentialCreatureVoice != (Object)null)
			{
				((EnemyAI)componentInChildren).creatureVoice.clip = potentialCreatureVoice;
			}
			if ((Object)(object)((EnemyAI)componentInChildren).creatureSFX.clip != (Object)null && (Object)(object)potentialCreatureSFX != (Object)null)
			{
				((EnemyAI)componentInChildren).creatureSFX.clip = potentialCreatureSFX;
			}
			if ((Object)(object)eatenSound != (Object)null)
			{
				componentInChildren.eatenSound = eatenSound;
			}
			if ((Object)(object)roarSound != (Object)null)
			{
				componentInChildren.roarSound = roarSound;
			}
			if ((Object)(object)jumpSound != (Object)null)
			{
				componentInChildren.jumpSound = jumpSound;
			}
			if ((Object)(object)kickSound != (Object)null)
			{
				componentInChildren.kickSound = kickSound;
			}
			if ((Object)(object)crunchySquishSound != (Object)null)
			{
				componentInChildren.crunchySquishSound = crunchySquishSound;
			}
			if ((Object)(object)spawnSound != (Object)null)
			{
				((CodeRebirthEnemyAI)componentInChildren).spawnSound = spawnSound;
			}
			if ((Object)(object)dieSFX != (Object)null)
			{
				((EnemyAI)componentInChildren).dieSFX = dieSFX;
			}
			if ((Object)(object)DustParticlesLeft != (Object)null)
			{
				ParticleSystem dustParticlesLeft = DustParticlesLeft;
				ParticleSystem dustParticlesLeft2 = componentInChildren.DustParticlesLeft;
				if ((Object)(object)dustParticlesLeft != (Object)null && (Object)(object)dustParticlesLeft2 != (Object)null)
				{
					GameObject val = Object.Instantiate<GameObject>(((Component)dustParticlesLeft).gameObject, ((Component)dustParticlesLeft2).transform.parent);
					((Object)val).name = ((Object)((Component)dustParticlesLeft2).gameObject).name;
					Object.Destroy((Object)(object)((Component)dustParticlesLeft2).gameObject);
					componentInChildren.DustParticlesLeft = DustParticlesLeft;
				}
			}
			if ((Object)(object)DustParticlesRight != (Object)null)
			{
				ParticleSystem dustParticlesRight = DustParticlesRight;
				ParticleSystem dustParticlesRight2 = componentInChildren.DustParticlesRight;
				if ((Object)(object)dustParticlesRight != (Object)null && (Object)(object)dustParticlesRight2 != (Object)null)
				{
					GameObject val2 = Object.Instantiate<GameObject>(((Component)dustParticlesRight).gameObject, ((Component)dustParticlesRight2).transform.parent);
					((Object)val2).name = ((Object)((Component)dustParticlesRight2).gameObject).name;
					Object.Destroy((Object)(object)((Component)dustParticlesRight2).gameObject);
					componentInChildren.DustParticlesRight = DustParticlesRight;
				}
			}
			if ((Object)(object)ForestKeeperParticles != (Object)null)
			{
				ParticleSystem forestKeeperParticles = ForestKeeperParticles;
				ParticleSystem forestKeeperParticles2 = componentInChildren.ForestKeeperParticles;
				if ((Object)(object)forestKeeperParticles != (Object)null && (Object)(object)forestKeeperParticles2 != (Object)null)
				{
					GameObject val3 = Object.Instantiate<GameObject>(((Component)forestKeeperParticles).gameObject, ((Component)forestKeeperParticles2).transform.parent);
					((Object)val3).name = ((Object)((Component)forestKeeperParticles2).gameObject).name;
					Object.Destroy((Object)(object)((Component)forestKeeperParticles2).gameObject);
					componentInChildren.ForestKeeperParticles = ForestKeeperParticles;
				}
			}
			if ((Object)(object)DriftwoodGiantParticles != (Object)null)
			{
				ParticleSystem driftwoodGiantParticles = DriftwoodGiantParticles;
				ParticleSystem driftwoodGiantParticles2 = componentInChildren.DriftwoodGiantParticles;
				if ((Object)(object)driftwoodGiantParticles != (Object)null && (Object)(object)driftwoodGiantParticles2 != (Object)null)
				{
					GameObject val4 = Object.Instantiate<GameObject>(((Component)driftwoodGiantParticles).gameObject, ((Component)driftwoodGiantParticles2).transform.parent);
					((Object)val4).name = ((Object)((Component)driftwoodGiantParticles2).gameObject).name;
					Object.Destroy((Object)(object)((Component)driftwoodGiantParticles2).gameObject);
					componentInChildren.DriftwoodGiantParticles = DriftwoodGiantParticles;
				}
			}
			if ((Object)(object)OldBirdParticles != (Object)null)
			{
				ParticleSystem oldBirdParticles = OldBirdParticles;
				ParticleSystem oldBirdParticles2 = componentInChildren.OldBirdParticles;
				if ((Object)(object)oldBirdParticles != (Object)null && (Object)(object)oldBirdParticles2 != (Object)null)
				{
					GameObject val5 = Object.Instantiate<GameObject>(((Component)oldBirdParticles).gameObject, ((Component)oldBirdParticles2).transform.parent);
					((Object)val5).name = ((Object)((Component)oldBirdParticles2).gameObject).name;
					Object.Destroy((Object)(object)((Component)oldBirdParticles2).gameObject);
					componentInChildren.OldBirdParticles = OldBirdParticles;
				}
			}
			if ((Object)(object)DeathParticles != (Object)null)
			{
				ParticleSystem deathParticles = DeathParticles;
				ParticleSystem deathParticles2 = componentInChildren.DeathParticles;
				if ((Object)(object)deathParticles != (Object)null && (Object)(object)deathParticles2 != (Object)null)
				{
					GameObject val6 = Object.Instantiate<GameObject>(((Component)deathParticles).gameObject, ((Component)deathParticles2).transform.parent);
					((Object)val6).name = ((Object)((Component)deathParticles2).gameObject).name;
					Object.Destroy((Object)(object)((Component)deathParticles2).gameObject);
					componentInChildren.DeathParticles = DeathParticles;
				}
			}
			if ((Object)(object)BigSmokeEffect != (Object)null)
			{
				ParticleSystem bigSmokeEffect = BigSmokeEffect;
				ParticleSystem bigSmokeEffect2 = componentInChildren.BigSmokeEffect;
				if ((Object)(object)bigSmokeEffect != (Object)null && (Object)(object)bigSmokeEffect2 != (Object)null)
				{
					GameObject val7 = Object.Instantiate<GameObject>(((Component)bigSmokeEffect).gameObject, ((Component)bigSmokeEffect2).transform.parent);
					((Object)val7).name = ((Object)((Component)bigSmokeEffect2).gameObject).name;
					Object.Destroy((Object)(object)((Component)bigSmokeEffect2).gameObject);
					componentInChildren.BigSmokeEffect = BigSmokeEffect;
				}
			}
		}
	}
	[CreateAssetMenu(fileName = "New Enemy Replacement Definition", menuName = "Entity Replacements/Enemy Replacements/CodeRebirth.src.Content.Enemies.SnailCatAI")]
	public class DuskEntityReplacementDefinition_CodeRebirth_src_Content_Enemies_SnailCatAI : DuskEnemyReplacementDefinition<SnailCatAI>
	{
		[Space(10f)]
		public AudioClipsWithTime _idleAudioClips = new AudioClipsWithTime();

		public AudioClip? enemyDetectSound;

		public AudioClip? spawnSound;

		public AudioClip? dieSFX;

		public AudioClip[] wiwiwiiiSound = Array.Empty<AudioClip>();

		public AudioClip? potentialCreatureVoice;

		public AudioClip? potentialCreatureSFX;

		protected override void ApplyTyped(SnailCatAI SnailCatAI)
		{
			SnailCatAI componentInChildren = ((Component)SnailCatAI).gameObject.GetComponentInChildren<SnailCatAI>();
			if (_idleAudioClips.audioClips.Length != 0)
			{
				((CodeRebirthEnemyAI)componentInChildren)._idleAudioClips = _idleAudioClips;
			}
			if (wiwiwiiiSound.Length != 0)
			{
				componentInChildren.wiwiwiiiSound = wiwiwiiiSound;
			}
			if ((Object)(object)((EnemyAI)componentInChildren).creatureVoice.clip != (Object)null && (Object)(object)potentialCreatureVoice != (Object)null)
			{
				((EnemyAI)componentInChildren).creatureVoice.clip = potentialCreatureVoice;
			}
			if ((Object)(object)((EnemyAI)componentInChildren).creatureSFX.clip != (Object)null && (Object)(object)potentialCreatureSFX != (Object)null)
			{
				((EnemyAI)componentInChildren).creatureSFX.clip = potentialCreatureSFX;
			}
			if ((Object)(object)enemyDetectSound != (Object)null)
			{
				componentInChildren.enemyDetectSound = enemyDetectSound;
			}
			if ((Object)(object)spawnSound != (Object)null)
			{
				((CodeRebirthEnemyAI)componentInChildren).spawnSound = spawnSound;
			}
			if ((Object)(object)dieSFX != (Object)null)
			{
				((EnemyAI)componentInChildren).dieSFX = dieSFX;
			}
		}
	}
	[CreateAssetMenu(fileName = "New Enemy Replacement Definition", menuName = "Entity Replacements/Enemy Replacements/CodeRebirth.src.Content.Enemies.Transporter")]
	public class DuskEntityReplacementDefinition_CodeRebirth_src_Content_Enemies_Transporter : DuskEnemyReplacementDefinition<Transporter>
	{
		[Space(10f)]
		public AudioClipsWithTime _idleAudioClips = new AudioClipsWithTime();

		public AudioClip? dumpHazardSound;

		public AudioClip? hitJimothySound;

		public AudioClip? pickUpHazardSound;

		public AudioClip? spawnSound;

		public AudioClip? dieSFX;

		public AudioClip[] engineAndIdleSounds = Array.Empty<AudioClip>();

		public AudioClip? potentialCreatureVoice;

		public AudioClip? potentialCreatureSFX;

		protected override void ApplyTyped(Transporter Transporter)
		{
			Transporter componentInChildren = ((Component)Transporter).gameObject.GetComponentInChildren<Transporter>();
			if (_idleAudioClips.audioClips.Length != 0)
			{
				((CodeRebirthEnemyAI)componentInChildren)._idleAudioClips = _idleAudioClips;
			}
			if (engineAndIdleSounds.Length != 0)
			{
				componentInChildren.engineAndIdleSounds = engineAndIdleSounds;
			}
			if ((Object)(object)((EnemyAI)componentInChildren).creatureVoice.clip != (Object)null && (Object)(object)potentialCreatureVoice != (Object)null)
			{
				((EnemyAI)componentInChildren).creatureVoice.clip = potentialCreatureVoice;
			}
			if ((Object)(object)((EnemyAI)componentInChildren).creatureSFX.clip != (Object)null && (Object)(object)potentialCreatureSFX != (Object)null)
			{
				((EnemyAI)componentInChildren).creatureSFX.clip = potentialCreatureSFX;
			}
			if ((Object)(object)dumpHazardSound != (Object)null)
			{
				componentInChildren.dumpHazardSound = dumpHazardSound;
			}
			if ((Object)(object)hitJimothySound != (Object)null)
			{
				componentInChildren.hitJimothySound = hitJimothySound;
			}
			if ((Object)(object)pickUpHazardSound != (Object)null)
			{
				componentInChildren.pickUpHazardSound = pickUpHazardSound;
			}
			if ((Object)(object)spawnSound != (Object)null)
			{
				((CodeRebirthEnemyAI)componentInChildren).spawnSound = spawnSound;
			}
			if ((Object)(object)dieSFX != (Object)null)
			{
				((EnemyAI)componentInChildren).dieSFX = dieSFX;
			}
		}
	}
	[CreateAssetMenu(fileName = "New Item Replacement Definition", menuName = "Entity Replacements/Item Replacements/CodeRebirth.src.Content.Items.Wallet")]
	public class DuskEntityReplacementDefinition_CodeRebirth_src_Content_Items_Wallet : DuskItemReplacementDefinition<Wallet>
	{
		[Space(10f)]
		public AudioClip? potentialAudioPlayer;

		protected override void ApplyTyped(Wallet Wallet)
		{
			Wallet componentInChildren = ((Component)Wallet).gameObject.GetComponentInChildren<Wallet>();
			if ((Object)(object)componentInChildren.audioPlayer.clip != (Object)null && (Object)(object)potentialAudioPlayer != (Object)null)
			{
				componentInChildren.audioPlayer.clip = potentialAudioPlayer;
			}
		}
	}
	[CreateAssetMenu(fileName = "New Map Object Replacement Definition", menuName = "Entity Replacements/Map Object Replacements/CodeRebirth.src.Content.Maps.Money")]
	public class DuskEntityReplacementDefinition_CodeRebirth_src_Content_Maps_Money : DuskMapObjectReplacementDefinition<DuskMapObject>
	{
		protected override void ApplyTyped(DuskMapObject Money)
		{
			Money componentInChildren = ((Component)Money).gameObject.GetComponentInChildren<Money>();
		}
	}
	[CreateAssetMenu(fileName = "New Unlockable Replacement Definition", menuName = "Entity Replacements/Unlockable Replacements/CodeRebirth.src.Content.Unlockables.CruiserGalAI")]
	public class DuskEntityReplacementDefinition_CodeRebirth_src_Content_Unlockables_CruiserGalAI : DuskUnlockableReplacementDefinition<DuskUnlockable>
	{
		[Space(10f)]
		public AudioClip? LaunchSound;

		public AudioClip? ChestCollisionToggleSound;

		public AudioClip? ActivateSound;

		public AudioClip? GreetOwnerSound;

		public AudioClip? DeactivateSound;

		public AudioClip[] RadioSounds = Array.Empty<AudioClip>();

		public AudioClip[] StartOrStopFlyingSounds = Array.Empty<AudioClip>();

		public AudioClip[] IdleSounds = Array.Empty<AudioClip>();

		public AudioClip[] HitSounds = Array.Empty<AudioClip>();

		public AudioClip[] FootstepSounds = Array.Empty<AudioClip>();

		public AudioClip? potentialRadioAudioSource;

		public AudioClip? potentialFootstepSource;

		public AudioClip? potentialGalVoice;

		public AudioClip? potentialGalSFX;

		protected override void ApplyTyped(DuskUnlockable CruiserGalAI)
		{
			CruiserGalAI componentInChildren = ((Component)CruiserGalAI).gameObject.GetComponentInChildren<CruiserGalAI>();
			if (RadioSounds.Length != 0)
			{
				componentInChildren.RadioSounds = RadioSounds;
			}
			if (StartOrStopFlyingSounds.Length != 0)
			{
				componentInChildren.StartOrStopFlyingSounds = StartOrStopFlyingSounds;
			}
			if (IdleSounds.Length != 0)
			{
				((GalAI)componentInChildren).IdleSounds = IdleSounds;
			}
			if (HitSounds.Length != 0)
			{
				((GalAI)componentInChildren).HitSounds = HitSounds;
			}
			if (FootstepSounds.Length != 0)
			{
				((GalAI)componentInChildren).FootstepSounds = FootstepSounds;
			}
			if ((Object)(object)componentInChildren.RadioAudioSource.clip != (Object)null && (Object)(object)potentialRadioAudioSource != (Object)null)
			{
				componentInChildren.RadioAudioSource.clip = potentialRadioAudioSource;
			}
			if ((Object)(object)componentInChildren.FootstepSource.clip != (Object)null && (Object)(object)potentialFootstepSource != (Object)null)
			{
				componentInChildren.FootstepSource.clip = potentialFootstepSource;
			}
			if ((Object)(object)((GalAI)componentInChildren).GalVoice.clip != (Object)null && (Object)(object)potentialGalVoice != (Object)null)
			{
				((GalAI)componentInChildren).GalVoice.clip = potentialGalVoice;
			}
			if ((Object)(object)((GalAI)componentInChildren).GalSFX.clip != (Object)null && (Object)(object)potentialGalSFX != (Object)null)
			{
				((GalAI)componentInChildren).GalSFX.clip = potentialGalSFX;
			}
			if ((Object)(object)LaunchSound != (Object)null)
			{
				componentInChildren.LaunchSound = LaunchSound;
			}
			if ((Object)(object)ChestCollisionToggleSound != (Object)null)
			{
				componentInChildren.ChestCollisionToggleSound = ChestCollisionToggleSound;
			}
			if ((Object)(object)ActivateSound != (Object)null)
			{
				((GalAI)componentInChildren).ActivateSound = ActivateSound;
			}
			if ((Object)(object)GreetOwnerSound != (Object)null)
			{
				((GalAI)componentInChildren).GreetOwnerSound = GreetOwnerSound;
			}
			if ((Object)(object)DeactivateSound != (Object)null)
			{
				((GalAI)componentInChildren).DeactivateSound = DeactivateSound;
			}
		}
	}
	[CreateAssetMenu(fileName = "New Unlockable Replacement Definition", menuName = "Entity Replacements/Unlockable Replacements/CodeRebirth.src.Content.Unlockables.SeamineGalAI")]
	public class DuskEntityReplacementDefinition_CodeRebirth_src_Content_Unlockables_SeamineGalAI : DuskUnlockableReplacementDefinition<DuskUnlockable>
	{
		[Space(10f)]
		public AudioClip? explosionSound;

		public AudioClip? hazardPingSound;

		public AudioClip? rechargeChargesSound;

		public AudioClip? spotEnemySound;

		public AudioClip? hugSound;

		public AudioClip? squeezeFishSound;

		public AudioClip? ActivateSound;

		public AudioClip? GreetOwnerSound;

		public AudioClip? DeactivateSound;

		public List<AudioClip> bruceSwimmingAudioClips = new List<AudioClip>();

		public List<AudioClip> startOrEndRidingBruceAudioClips = new List<AudioClip>();

		public AudioClip[] IdleSounds = Array.Empty<AudioClip>();

		public AudioClip[] HitSounds = Array.Empty<AudioClip>();

		public AudioClip[] FootstepSounds = Array.Empty<AudioClip>();

		public AudioClip? potentialRidingBruceSource;

		public AudioClip? potentialGalVoice;

		public AudioClip? potentialGalSFX;

		protected override void ApplyTyped(DuskUnlockable SeamineGalAI)
		{
			SeamineGalAI componentInChildren = ((Component)SeamineGalAI).gameObject.GetComponentInChildren<SeamineGalAI>();
			if (IdleSounds.Length != 0)
			{
				((GalAI)componentInChildren).IdleSounds = IdleSounds;
			}
			if (HitSounds.Length != 0)
			{
				((GalAI)componentInChildren).HitSounds = HitSounds;
			}
			if (FootstepSounds.Length != 0)
			{
				((GalAI)componentInChildren).FootstepSounds = FootstepSounds;
			}
			if ((Object)(object)componentInChildren.RidingBruceSource.clip != (Object)null && (Object)(object)potentialRidingBruceSource != (Object)null)
			{
				componentInChildren.RidingBruceSource.clip = potentialRidingBruceSource;
			}
			if ((Object)(object)((GalAI)componentInChildren).GalVoice.clip != (Object)null && (Object)(object)potentialGalVoice != (Object)null)
			{
				((GalAI)componentInChildren).GalVoice.clip = potentialGalVoice;
			}
			if ((Object)(object)((GalAI)componentInChildren).GalSFX.clip != (Object)null && (Object)(object)potentialGalSFX != (Object)null)
			{
				((GalAI)componentInChildren).GalSFX.clip = potentialGalSFX;
			}
			if (bruceSwimmingAudioClips.Count > 0)
			{
				componentInChildren.bruceSwimmingAudioClips = bruceSwimmingAudioClips;
			}
			if (startOrEndRidingBruceAudioClips.Count > 0)
			{
				componentInChildren.startOrEndRidingBruceAudioClips = startOrEndRidingBruceAudioClips;
			}
			if ((Object)(object)explosionSound != (Object)null)
			{
				componentInChildren.explosionSound = explosionSound;
			}
			if ((Object)(object)hazardPingSound != (Object)null)
			{
				componentInChildren.hazardPingSound = hazardPingSound;
			}
			if ((Object)(object)rechargeChargesSound != (Object)null)
			{
				componentInChildren.rechargeChargesSound = rechargeChargesSound;
			}
			if ((Object)(object)spotEnemySound != (Object)null)
			{
				componentInChildren.spotEnemySound = spotEnemySound;
			}
			if ((Object)(object)hugSound != (Object)null)
			{
				componentInChildren.hugSound = hugSound;
			}
			if ((Object)(object)squeezeFishSound != (Object)null)
			{
				componentInChildren.squeezeFishSound = squeezeFishSound;
			}
			if ((Object)(object)ActivateSound != (Object)null)
			{
				((GalAI)componentInChildren).ActivateSound = ActivateSound;
			}
			if ((Object)(object)GreetOwnerSound != (Object)null)
			{
				((GalAI)componentInChildren).GreetOwnerSound = GreetOwnerSound;
			}
			if ((Object)(object)DeactivateSound != (Object)null)
			{
				((GalAI)componentInChildren).DeactivateSound = DeactivateSound;
			}
		}
	}
	[CreateAssetMenu(fileName = "New Unlockable Replacement Definition", menuName = "Entity Replacements/Unlockable Replacements/CodeRebirth.src.Content.Unlockables.ShockwaveGalAI")]
	public class DuskEntityReplacementDefinition_CodeRebirth_src_Content_Unlockables_ShockwaveGalAI : DuskUnlockableReplacementDefinition<DuskUnlockable>
	{
		[Space(10f)]
		public AudioClip? PatSound;

		public AudioClip? ActivateSound;

		public AudioClip? GreetOwnerSound;

		public AudioClip? DeactivateSound;

		public AudioClip[] TakeDropItemSounds = Array.Empty<AudioClip>();

		public AudioClip[] IdleSounds = Array.Empty<AudioClip>();

		public AudioClip[] HitSounds = Array.Empty<AudioClip>();

		public AudioClip[] FootstepSounds = Array.Empty<AudioClip>();

		public AudioClip? potentialFlySource;

		public AudioClip? potentialGalVoice;

		public AudioClip? potentialGalSFX;

		protected override void ApplyTyped(DuskUnlockable ShockwaveGalAI)
		{
			ShockwaveGalAI componentInChildren = ((Component)ShockwaveGalAI).gameObject.GetComponentInChildren<ShockwaveGalAI>();
			if (TakeDropItemSounds.Length != 0)
			{
				componentInChildren.TakeDropItemSounds = TakeDropItemSounds;
			}
			if (IdleSounds.Length != 0)
			{
				((GalAI)componentInChildren).IdleSounds = IdleSounds;
			}
			if (HitSounds.Length != 0)
			{
				((GalAI)componentInChildren).HitSounds = HitSounds;
			}
			if (FootstepSounds.Length != 0)
			{
				((GalAI)componentInChildren).FootstepSounds = FootstepSounds;
			}
			if ((Object)(object)componentInChildren.FlySource.clip != (Object)null && (Object)(object)potentialFlySource != (Object)null)
			{
				componentInChildren.FlySource.clip = potentialFlySource;
			}
			if ((Object)(object)((GalAI)componentInChildren).GalVoice.clip != (Object)null && (Object)(object)potentialGalVoice != (Object)null)
			{
				((GalAI)componentInChildren).GalVoice.clip = potentialGalVoice;
			}
			if ((Object)(object)((GalAI)componentInChildren).GalSFX.clip != (Object)null && (Object)(object)potentialGalSFX != (Object)null)
			{
				((GalAI)componentInChildren).GalSFX.clip = potentialGalSFX;
			}
			if ((Object)(object)PatSound != (Object)null)
			{
				componentInChildren.PatSound = PatSound;
			}
			if ((Object)(object)ActivateSound != (Object)null)
			{
				((GalAI)componentInChildren).ActivateSound = ActivateSound;
			}
			if ((Object)(object)GreetOwnerSound != (Object)null)
			{
				((GalAI)componentInChildren).GreetOwnerSound = GreetOwnerSound;
			}
			if ((Object)(object)DeactivateSound != (Object)null)
			{
				((GalAI)componentInChildren).DeactivateSound = DeactivateSound;
			}
		}
	}
	[CreateAssetMenu(fileName = "New Unlockable Replacement Definition", menuName = "Entity Replacements/Unlockable Replacements/CodeRebirth.src.Content.Unlockables.TerminalGalAI")]
	public class DuskEntityReplacementDefinition_CodeRebirth_src_Content_Unlockables_TerminalGalAI : DuskUnlockableReplacementDefinition<DuskUnlockable>
	{
		[Space(10f)]
		public AudioClip? scrapPingSound;

		public AudioClip? keyboardPressSound;

		public AudioClip? zapperSound;

		public AudioClip? keySound;

		public AudioClip? teleporterSound;

		public AudioClip? ActivateSound;

		public AudioClip? GreetOwnerSound;

		public AudioClip? DeactivateSound;

		public List<AudioClip> startOrEndFlyingAudioClips = new List<AudioClip>();

		public AudioClip[] IdleSounds = Array.Empty<AudioClip>();

		public AudioClip[] HitSounds = Array.Empty<AudioClip>();

		public AudioClip[] FootstepSounds = Array.Empty<AudioClip>();

		public AudioClip? potentialFlyingSource;

		public AudioClip? potentialFootstepSource;

		public AudioClip? potentialSpecialSource;

		public AudioClip? potentialGalVoice;

		public AudioClip? potentialGalSFX;

		protected override void ApplyTyped(DuskUnlockable TerminalGalAI)
		{
			TerminalGalAI componentInChildren = ((Component)TerminalGalAI).gameObject.GetComponentInChildren<TerminalGalAI>();
			if (IdleSounds.Length != 0)
			{
				((GalAI)componentInChildren).IdleSounds = IdleSounds;
			}
			if (HitSounds.Length != 0)
			{
				((GalAI)componentInChildren).HitSounds = HitSounds;
			}
			if (FootstepSounds.Length != 0)
			{
				((GalAI)componentInChildren).FootstepSounds = FootstepSounds;
			}
			if ((Object)(object)componentInChildren.FlyingSource.clip != (Object)null && (Object)(object)potentialFlyingSource != (Object)null)
			{
				componentInChildren.FlyingSource.clip = potentialFlyingSource;
			}
			if ((Object)(object)componentInChildren.FootstepSource.clip != (Object)null && (Object)(object)potentialFootstepSource != (Object)null)
			{
				componentInChildren.FootstepSource.clip = potentialFootstepSource;
			}
			if ((Object)(object)componentInChildren.specialSource.clip != (Object)null && (Object)(object)potentialSpecialSource != (Object)null)
			{
				componentInChildren.specialSource.clip = potentialSpecialSource;
			}
			if ((Object)(object)((GalAI)componentInChildren).GalVoice.clip != (Object)null && (Object)(object)potentialGalVoice != (Object)null)
			{
				((GalAI)componentInChildren).GalVoice.clip = potentialGalVoice;
			}
			if ((Object)(object)((GalAI)componentInChildren).GalSFX.clip != (Object)null && (Object)(object)potentialGalSFX != (Object)null)
			{
				((GalAI)componentInChildren).GalSFX.clip = potentialGalSFX;
			}
			if (startOrEndFlyingAudioClips.Count > 0)
			{
				componentInChildren.startOrEndFlyingAudioClips = startOrEndFlyingAudioClips;
			}
			if ((Object)(object)scrapPingSound != (Object)null)
			{
				componentInChildren.scrapPingSound = scrapPingSound;
			}
			if ((Object)(object)keyboardPressSound != (Object)null)
			{
				componentInChildren.keyboardPressSound = keyboardPressSound;
			}
			if ((Object)(object)zapperSound != (Object)null)
			{
				componentInChildren.zapperSound = zapperSound;
			}
			if ((Object)(object)keySound != (Object)null)
			{
				componentInChildren.keySound = keySound;
			}
			if ((Object)(object)teleporterSound != (Object)null)
			{
				componentInChildren.teleporterSound = teleporterSound;
			}
			if ((Object)(object)ActivateSound != (Object)null)
			{
				((GalAI)componentInChildren).ActivateSound = ActivateSound;
			}
			if ((Object)(object)GreetOwnerSound != (Object)null)
			{
				((GalAI)componentInChildren).GreetOwnerSound = GreetOwnerSound;
			}
			if ((Object)(object)DeactivateSound != (Object)null)
			{
				((GalAI)componentInChildren).DeactivateSound = DeactivateSound;
			}
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}