Decompiled source of Adin Ross GTA 6 Server v1.1.0

CodeRebirth.dll

Decompiled a day ago
using System;
using System.CodeDom.Compiler;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
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 System.Text;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using CSync.Lib;
using CodeRebirth.src.Content.DevTools;
using CodeRebirth.src.Content.Enemies;
using CodeRebirth.src.Content.Items;
using CodeRebirth.src.Content.Maps;
using CodeRebirth.src.Content.Moons;
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 CodeRebirth.src.Util.Timer;
using CullFactory.Behaviours.API;
using Dawn;
using Dawn.Internal;
using Dawn.Utils;
using DigitalRuby.ThunderAndLightning;
using DunGen;
using Dusk;
using GameNetcodeStuff;
using HarmonyLib;
using IL;
using IL.GameNetcodeStuff;
using Imperium;
using InjectionLibrary.Attributes;
using LethalCompanyInputUtils.Api;
using LethalMoonUnlocks;
using Microsoft.CodeAnalysis;
using Mono.Cecil.Cil;
using MonoMod.Cil;
using MonoMod.RuntimeDetour;
using MoreCompany.Cosmetics;
using MoreCounterplay;
using MoreShipUpgrades.UpgradeComponents.OneTimeUpgrades.Store;
using MoreShipUpgrades.UpgradeComponents.TierUpgrades.AttributeUpgrades;
using On;
using On.GameNetcodeStuff;
using On.Unity.AI.Navigation;
using OpenBodyCams;
using TMPro;
using TooManyEmotes.Patches;
using Unity.AI.Navigation;
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.ProBuilder;
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.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: RequiresInjections]
[assembly: IgnoresAccessChecksTo("AmazingAssets.TerrainToMesh")]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp-firstpass")]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: IgnoresAccessChecksTo("BaronDrakula.MoreCounterplay")]
[assembly: IgnoresAccessChecksTo("ClientNetworkTransform")]
[assembly: IgnoresAccessChecksTo("com.github.teamxiaolan.dawnlib")]
[assembly: IgnoresAccessChecksTo("com.github.teamxiaolan.dawnlib.dusk")]
[assembly: IgnoresAccessChecksTo("com.olegknyazev.softmask")]
[assembly: IgnoresAccessChecksTo("DissonanceVoip")]
[assembly: IgnoresAccessChecksTo("DunGen")]
[assembly: IgnoresAccessChecksTo("DunGen.Integration.ASPP")]
[assembly: IgnoresAccessChecksTo("DunGen.Integration.UnityNav")]
[assembly: IgnoresAccessChecksTo("EasyTextEffects")]
[assembly: IgnoresAccessChecksTo("Facepunch Transport for Netcode for GameObjects")]
[assembly: IgnoresAccessChecksTo("Facepunch.Steamworks.Win64")]
[assembly: IgnoresAccessChecksTo("giosuel.Imperium")]
[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("Unity.XR.CoreUtils")]
[assembly: IgnoresAccessChecksTo("Unity.XR.Management")]
[assembly: IgnoresAccessChecksTo("Unity.XR.OpenXR")]
[assembly: IgnoresAccessChecksTo("Unity.XR.OpenXR.Features.ConformanceAutomation")]
[assembly: IgnoresAccessChecksTo("Unity.XR.OpenXR.Features.MetaQuestSupport")]
[assembly: IgnoresAccessChecksTo("Unity.XR.OpenXR.Features.MockRuntime")]
[assembly: IgnoresAccessChecksTo("Unity.XR.OpenXR.Features.OculusQuestSupport")]
[assembly: IgnoresAccessChecksTo("Unity.XR.OpenXR.Features.RuntimeDebugger")]
[assembly: IgnoresAccessChecksTo("UnityEngine.ARModule")]
[assembly: IgnoresAccessChecksTo("UnityEngine.NVIDIAModule")]
[assembly: IgnoresAccessChecksTo("UnityEngine.SpatialTracking")]
[assembly: IgnoresAccessChecksTo("UnityEngine.UI")]
[assembly: IgnoresAccessChecksTo("UnityEngine.XR.LegacyInputHelpers")]
[assembly: IgnoresAccessChecksTo("WeatherRegistry")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("CodeRebirth")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyDescription("Content mod that adds Custom Weathers, Items, Enemies and more.")]
[assembly: AssemblyFileVersion("1.6.9.0")]
[assembly: AssemblyInformationalVersion("1.6.9")]
[assembly: AssemblyProduct("CodeRebirth")]
[assembly: AssemblyTitle("CodeRebirth")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.6.9.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[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]
	[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]
	[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 = null;

	public Transform _startBeamTransform = null;

	public AudioClip _beamSound = null;

	public VisualEffect? _monarchParticle = null;

	[SerializeField]
	private SkinnedMeshRenderer _wingMesh = null;

	[SerializeField]
	private Transform _endBeamTransform = null;

	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_0007: 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 = null;

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

	public override bool executeInSceneView => true;

	public void ConfigureMaterial(Color edgeColor, Color fillColor, float thickness)
	{
		//IL_000c: Unknown result type (might be due to invalid IL or missing references)
		//IL_001e: 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_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_0031: Unknown result type (might be due to invalid IL or missing references)
		//IL_0036: Unknown result type (might be due to invalid IL or missing references)
		//IL_0042: Unknown result type (might be due to invalid IL or missing references)
		//IL_0047: Unknown result type (might be due to invalid IL or missing references)
		//IL_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)
		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_0057: 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_005d: 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_006c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0071: Unknown result type (might be due to invalid IL or missing references)
		//IL_009a: Unknown result type (might be due to invalid IL or missing references)
		//IL_009b: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
		//IL_00be: 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_00c9: 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_0009: Unknown result type (might be due to invalid IL or missing references)
		//IL_001a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0021: Unknown result type (might be due to invalid IL or missing references)
		//IL_0026: Unknown result type (might be due to invalid IL or missing references)
		//IL_002e: Unknown result type (might be due to invalid IL or missing references)
		//IL_004f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0078: Unknown result type (might be due to invalid IL or missing references)
		//IL_0083: Unknown result type (might be due to invalid IL or missing references)
		//IL_0084: Unknown result type (might be due to invalid IL or missing references)
		//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
		//IL_0098: Unknown result type (might be due to invalid IL or missing references)
		//IL_009d: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a2: 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_00b3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c0: 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 = null;

	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_0012: Unknown result type (might be due to invalid IL or missing references)
		//IL_0021: Unknown result type (might be due to invalid IL or missing references)
		//IL_0084: Unknown result type (might be due to invalid IL or missing references)
		//IL_008b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0092: 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_00de: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
		//IL_0101: Unknown result type (might be due to invalid IL or missing references)
		//IL_010c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0124: Unknown result type (might be due to invalid IL or missing references)
		//IL_003b: Unknown result type (might be due to invalid IL or missing references)
		//IL_004d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0075: Unknown result type (might be due to invalid IL or missing references)
		//IL_007a: 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_008a: Unknown result type (might be due to invalid IL or missing references)
		//IL_008f: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
		//IL_0150: Unknown result type (might be due to invalid IL or missing references)
		//IL_0166: Unknown result type (might be due to invalid IL or missing references)
		//IL_017a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0188: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
		//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ce: 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.6.9";
	}
	[GeneratedCode("DawnLib", "0.2.2")]
	public static class CodeRebirthEnemyKeys
	{
		public static NamespacedKey<DawnEnemyInfo> DebtCollector = NamespacedKey<DawnEnemyInfo>.From("code_rebirth", "debt_collector");

		public static NamespacedKey<DawnEnemyInfo> Guardsman = NamespacedKey<DawnEnemyInfo>.From("code_rebirth", "guardsman");

		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> RealEnemySnailCat = NamespacedKey<DawnEnemyInfo>.From("code_rebirth", "real_enemy_snailcat");

		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> ToastyToaster = NamespacedKey<DawnUnlockableItemInfo>.From("code_rebirth", "toasty_toaster");

		public static NamespacedKey<DawnUnlockableItemInfo> DenominationAnalyzer = NamespacedKey<DawnUnlockableItemInfo>.From("code_rebirth", "denomination_analyzer");

		public static NamespacedKey<DawnUnlockableItemInfo> TrashHoop = NamespacedKey<DawnUnlockableItemInfo>.From("code_rebirth", "trash_hoop");

		public static NamespacedKey<DawnUnlockableItemInfo> FancyCoatHanger = NamespacedKey<DawnUnlockableItemInfo>.From("code_rebirth", "fancy_coat_hanger");

		public static NamespacedKey<DawnUnlockableItemInfo> TeddyBear = NamespacedKey<DawnUnlockableItemInfo>.From("code_rebirth", "teddy_bear");

		public static NamespacedKey<DawnUnlockableItemInfo> CutieflyCase = NamespacedKey<DawnUnlockableItemInfo>.From("code_rebirth", "cutiefly_case");

		public static NamespacedKey<DawnUnlockableItemInfo> JimPlaque = NamespacedKey<DawnUnlockableItemInfo>.From("code_rebirth", "jim_plaque");

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

		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> TimmyBass = NamespacedKey<DawnUnlockableItemInfo>.From("code_rebirth", "timmy_bass");

		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> BurntFleshArm = NamespacedKey<DawnItemInfo>.From("code_rebirth", "burnt_flesh_arm");

		public static NamespacedKey<DawnItemInfo> BurntFleshEye = NamespacedKey<DawnItemInfo>.From("code_rebirth", "burnt_flesh_eye");

		public static NamespacedKey<DawnItemInfo> BurntRubble = NamespacedKey<DawnItemInfo>.From("code_rebirth", "burnt_rubble");

		public static NamespacedKey<DawnItemInfo> BurntFleshTeeth = NamespacedKey<DawnItemInfo>.From("code_rebirth", "burnt_flesh_teeth");

		public static NamespacedKey<DawnItemInfo> BurntFleshTongue = NamespacedKey<DawnItemInfo>.From("code_rebirth", "burnt_flesh_tongue");

		public static NamespacedKey<DawnItemInfo> Coin = NamespacedKey<DawnItemInfo>.From("code_rebirth", "coin");

		public static NamespacedKey<DawnItemInfo> CrispDollarBill = NamespacedKey<DawnItemInfo>.From("code_rebirth", "crisp_dollar_bill");

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

		public static NamespacedKey<DawnItemInfo> AlarmClock = NamespacedKey<DawnItemInfo>.From("code_rebirth", "alarm_clock");

		public static NamespacedKey<DawnItemInfo> Amber = NamespacedKey<DawnItemInfo>.From("code_rebirth", "amber");

		public static NamespacedKey<DawnItemInfo> MusicBox = NamespacedKey<DawnItemInfo>.From("code_rebirth", "music_box");

		public static NamespacedKey<DawnItemInfo> BirthdayCard = NamespacedKey<DawnItemInfo>.From("code_rebirth", "birthday_card");

		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> DisposableCamera = NamespacedKey<DawnItemInfo>.From("code_rebirth", "disposable_camera");

		public static NamespacedKey<DawnItemInfo> DuckyTube = NamespacedKey<DawnItemInfo>.From("code_rebirth", "ducky_tube");

		public static NamespacedKey<DawnItemInfo> EZBakeOven = NamespacedKey<DawnItemInfo>.From("code_rebirth", "ez_bake_oven");

		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> HandDrill = NamespacedKey<DawnItemInfo>.From("code_rebirth", "hand_drill");

		public static NamespacedKey<DawnItemInfo> HardHat = NamespacedKey<DawnItemInfo>.From("code_rebirth", "hard_hat");

		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> MagicEightBall = NamespacedKey<DawnItemInfo>.From("code_rebirth", "magic_eight_ball");

		public static NamespacedKey<DawnItemInfo> Mirror = NamespacedKey<DawnItemInfo>.From("code_rebirth", "mirror");

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

		public static NamespacedKey<DawnItemInfo> MouseTrap = NamespacedKey<DawnItemInfo>.From("code_rebirth", "mouse_trap");

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

		public static NamespacedKey<DawnItemInfo> OldBooze = NamespacedKey<DawnItemInfo>.From("code_rebirth", "old_booze");

		public static NamespacedKey<DawnItemInfo> OrbitalStrikeCaller = NamespacedKey<DawnItemInfo>.From("code_rebirth", "orbital_strike_caller");

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

		public static NamespacedKey<DawnItemInfo> PlasticCake = NamespacedKey<DawnItemInfo>.From("code_rebirth", "plastic_cake");

		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> RollingDuck = NamespacedKey<DawnItemInfo>.From("code_rebirth", "rolling_duck");

		public static NamespacedKey<DawnItemInfo> Rubberband = NamespacedKey<DawnItemInfo>.From("code_rebirth", "rubber_band");

		public static NamespacedKey<DawnItemInfo> RustedPickHead = NamespacedKey<DawnItemInfo>.From("code_rebirth", "rusted_pick_head");

		public static NamespacedKey<DawnItemInfo> SawBlade = NamespacedKey<DawnItemInfo>.From("code_rebirth", "saw_blade");

		public static NamespacedKey<DawnItemInfo> Scrapapult = NamespacedKey<DawnItemInfo>.From("code_rebirth", "scrapapult");

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

		public static NamespacedKey<DawnItemInfo> Skull = NamespacedKey<DawnItemInfo>.From("code_rebirth", "skull");

		public static NamespacedKey<DawnItemInfo> SpudTater = NamespacedKey<DawnItemInfo>.From("code_rebirth", "spud_tater");

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

		public static NamespacedKey<DawnItemInfo> TeddyBear = NamespacedKey<DawnItemInfo>.From("code_rebirth", "teddy_bear");

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

		public static NamespacedKey<DawnItemInfo> WalkingCane = NamespacedKey<DawnItemInfo>.From("code_rebirth", "walking_cane");

		public static NamespacedKey<DawnItemInfo> WiltedRose = NamespacedKey<DawnItemInfo>.From("code_rebirth", "wilted_rose");

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

		public static NamespacedKey<DawnItemInfo> XrayGlasses = NamespacedKey<DawnItemInfo>.From("code_rebirth", "xray_glasses");

		public static NamespacedKey<DawnItemInfo> Yoyo = NamespacedKey<DawnItemInfo>.From("code_rebirth", "yoyo");

		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> DebugStick = NamespacedKey<DawnItemInfo>.From("code_rebirth", "debug_stick");

		public static NamespacedKey<DawnItemInfo> StoatGun = NamespacedKey<DawnItemInfo>.From("code_rebirth", "stoat_gun");

		public static NamespacedKey<DawnItemInfo> CrispXuBuck = NamespacedKey<DawnItemInfo>.From("code_rebirth", "crisp_xubuck");

		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> GiantCallerHorn = NamespacedKey<DawnItemInfo>.From("code_rebirth", "giant_caller_horn");

		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> 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> 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> 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> SaltedBeef = NamespacedKey<DawnItemInfo>.From("code_rebirth", "salted_beef");

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

		public static NamespacedKey<DawnItemInfo> Yeehawlanie = 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> MilitaryPlane = NamespacedKey<DawnMapObjectInfo>.From("code_rebirth", "military_plane");

		public static NamespacedKey<DawnMapObjectInfo> Coin = NamespacedKey<DawnMapObjectInfo>.From("code_rebirth", "coin");

		public static NamespacedKey<DawnMapObjectInfo> CrispDollarBill = NamespacedKey<DawnMapObjectInfo>.From("code_rebirth", "crisp_dollar_bill");

		public static NamespacedKey<DawnMapObjectInfo> Wallet = NamespacedKey<DawnMapObjectInfo>.From("code_rebirth", "wallet");

		public static NamespacedKey<DawnMapObjectInfo> CommonVendingMachine = NamespacedKey<DawnMapObjectInfo>.From("code_rebirth", "common_vending_machine");

		public static NamespacedKey<DawnMapObjectInfo> LegendaryVendingMachine = NamespacedKey<DawnMapObjectInfo>.From("code_rebirth", "legendary_vending_machine");

		public static NamespacedKey<DawnMapObjectInfo> RareVendingMachine = NamespacedKey<DawnMapObjectInfo>.From("code_rebirth", "rare_vending_machine");

		public static NamespacedKey<DawnMapObjectInfo> UncommonVendingMachine = NamespacedKey<DawnMapObjectInfo>.From("code_rebirth", "uncommon_vending_machine");

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

		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> 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> 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> CodeRebirthPlatinum = NamespacedKey<DuskAchievementDefinition>.From("code_rebirth", "code_rebirth_platinum");

		public static NamespacedKey<DuskAchievementDefinition> LoreMaster = NamespacedKey<DuskAchievementDefinition>.From("code_rebirth", "lore_master");

		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>? GetByReflection(string name)
		{
			return (NamespacedKey<DuskAchievementDefinition>)(typeof(CodeRebirthAchievementKeys).GetField(name)?.GetValue(null));
		}
	}
	[GeneratedCode("DawnLib", "0.2.2")]
	public static class CodeRebirthEntityReplacementKeys
	{
		public static NamespacedKey<DuskEntityReplacementDefinition> BlackCat = NamespacedKey<DuskEntityReplacementDefinition>.From("code_rebirth", "black_cat");

		public static NamespacedKey<DuskEntityReplacementDefinition> BogWood = NamespacedKey<DuskEntityReplacementDefinition>.From("code_rebirth", "bog_wood");

		public static NamespacedKey<DuskEntityReplacementDefinition> Nuts = NamespacedKey<DuskEntityReplacementDefinition>.From("code_rebirth", "nuts");

		public static NamespacedKey<DuskEntityReplacementDefinition> SnailKat = NamespacedKey<DuskEntityReplacementDefinition>.From("code_rebirth", "snail_kat");

		public static NamespacedKey<DuskEntityReplacementDefinition> Lollipop = NamespacedKey<DuskEntityReplacementDefinition>.From("code_rebirth", "lollipop");

		public static NamespacedKey<DuskEntityReplacementDefinition> CaramelApple = NamespacedKey<DuskEntityReplacementDefinition>.From("code_rebirth", "caramel_apple");

		public static NamespacedKey<DuskEntityReplacementDefinition> Snarkies = NamespacedKey<DuskEntityReplacementDefinition>.From("code_rebirth", "snarkies");

		public static NamespacedKey<DuskEntityReplacementDefinition> JimsChips = NamespacedKey<DuskEntityReplacementDefinition>.From("code_rebirth", "jims_chips");

		public static NamespacedKey<DuskEntityReplacementDefinition> KingsTaffy = NamespacedKey<DuskEntityReplacementDefinition>.From("code_rebirth", "kings_taffy");

		public static NamespacedKey<DuskEntityReplacementDefinition> CandyCorn = NamespacedKey<DuskEntityReplacementDefinition>.From("code_rebirth", "candy_corn");

		public static NamespacedKey<DuskEntityReplacementDefinition> Baldys = NamespacedKey<DuskEntityReplacementDefinition>.From("code_rebirth", "baldys");

		public static NamespacedKey<DuskEntityReplacementDefinition> CountWood = NamespacedKey<DuskEntityReplacementDefinition>.From("code_rebirth", "count_wood");

		public static NamespacedKey<DuskEntityReplacementDefinition> FrankenCactoos = NamespacedKey<DuskEntityReplacementDefinition>.From("code_rebirth", "franken_cactoos");

		public static NamespacedKey<DuskEntityReplacementDefinition> Graper = NamespacedKey<DuskEntityReplacementDefinition>.From("code_rebirth", "graper");

		public static NamespacedKey<DuskEntityReplacementDefinition> LordoftheOpera = NamespacedKey<DuskEntityReplacementDefinition>.From("code_rebirth", "lord_of_the_opera");

		public static NamespacedKey<DuskEntityReplacementDefinition> Neko = NamespacedKey<DuskEntityReplacementDefinition>.From("code_rebirth", "neko");

		public static NamespacedKey<DuskEntityReplacementDefinition> OldWorldMonarch = NamespacedKey<DuskEntityReplacementDefinition>.From("code_rebirth", "old_world_monarch");

		public static NamespacedKey<DuskEntityReplacementDefinition> PeaceMassacrer = NamespacedKey<DuskEntityReplacementDefinition>.From("code_rebirth", "peace_massacrer");

		public static NamespacedKey<DuskEntityReplacementDefinition> Princess = NamespacedKey<DuskEntityReplacementDefinition>.From("code_rebirth", "princess");

		public static NamespacedKey<DuskEntityReplacementDefinition> RealisticBunny = NamespacedKey<DuskEntityReplacementDefinition>.From("code_rebirth", "realistic_bunny");

		public static NamespacedKey<DuskEntityReplacementDefinition> Roboman = NamespacedKey<DuskEntityReplacementDefinition>.From("code_rebirth", "roboman");

		public static NamespacedKey<DuskEntityReplacementDefinition> Spacey = NamespacedKey<DuskEntityReplacementDefinition>.From("code_rebirth", "spacey");

		public static NamespacedKey<DuskEntityReplacementDefinition> Spidey = NamespacedKey<DuskEntityReplacementDefinition>.From("code_rebirth", "spidey");

		public static NamespacedKey<DuskEntityReplacementDefinition> Spookstress = NamespacedKey<DuskEntityReplacementDefinition>.From("code_rebirth", "spookstress");

		public static NamespacedKey<DuskEntityReplacementDefinition> Spookyfly = NamespacedKey<DuskEntityReplacementDefinition>.From("code_rebirth", "spooky_fly");

		public static NamespacedKey<DuskEntityReplacementDefinition> TransportingDutchman = NamespacedKey<DuskEntityReplacementDefinition>.From("code_rebirth", "transporting_dutchman");

		public static NamespacedKey<DuskEntityReplacementDefinition> Widow = NamespacedKey<DuskEntityReplacementDefinition>.From("code_rebirth", "widow");

		public static NamespacedKey<DuskEntityReplacementDefinition> Witchy = NamespacedKey<DuskEntityReplacementDefinition>.From("code_rebirth", "witchy");

		public static NamespacedKey<DuskEntityReplacementDefinition>? GetByReflection(string name)
		{
			return (NamespacedKey<DuskEntityReplacementDefinition>)(typeof(CodeRebirthEntityReplacementKeys).GetField(name)?.GetValue(null));
		}
	}
	[GeneratedCode("DawnLib", "0.2.2")]
	public static class CodeRebirthMoonKeys
	{
		public static NamespacedKey<DawnMoonInfo> Haemoglobin = NamespacedKey<DawnMoonInfo>.From("code_rebirth", "haemoglobin");

		public static NamespacedKey<DawnMoonInfo> Oxyde = NamespacedKey<DawnMoonInfo>.From("code_rebirth", "oxyde");

		public static NamespacedKey<DawnMoonInfo>? GetByReflection(string name)
		{
			return (NamespacedKey<DawnMoonInfo>)(typeof(CodeRebirthMoonKeys).GetField(name)?.GetValue(null));
		}
	}
}
namespace CodeRebirth.src
{
	public class CodeRebirthConfig
	{
		public ConfigEntry<bool> ConfigOxydeEnabledFromStart { 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.");
			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_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cc: Expected O, but got Unknown
			//IL_0236: Unknown result type (might be due to invalid IL or missing references)
			//IL_0240: Expected O, but got Unknown
			//IL_04bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c6: Expected O, but got Unknown
			//IL_04f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0500: Expected O, but got Unknown
			//IL_0530: Unknown result type (might be due to invalid IL or missing references)
			//IL_053a: Expected O, but got Unknown
			//IL_056a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0574: Expected O, but got Unknown
			//IL_05a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ae: Expected O, but got Unknown
			//IL_05fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0605: Expected O, but got Unknown
			//IL_0635: Unknown result type (might be due to invalid IL or missing references)
			//IL_063f: Expected O, but got Unknown
			//IL_066f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0679: Expected O, but got Unknown
			//IL_06a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_06b3: Expected O, but got Unknown
			//IL_0700: Unknown result type (might be due to invalid IL or missing references)
			//IL_070a: Expected O, but got Unknown
			//IL_0732: Unknown result type (might be due to invalid IL or missing references)
			//IL_073c: Expected O, but got Unknown
			//IL_0764: Unknown result type (might be due to invalid IL or missing references)
			//IL_076e: Expected O, but got Unknown
			//IL_079e: Unknown result type (might be due to invalid IL or missing references)
			//IL_07a8: Expected O, but got Unknown
			//IL_07d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_07e2: Expected O, but got Unknown
			//IL_082f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0839: Expected O, but got Unknown
			//IL_0869: Unknown result type (might be due to invalid IL or missing references)
			//IL_0873: Expected O, but got Unknown
			//IL_08a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_08ad: 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 Bot Options", "Shockwave Gal | Charges", 10, "How many charges the Shockwave Gal has.");
			ConfigShockwaveHoldsFourItems = configFile.Bind<bool>("Shockwave Bot Options", "Shockwave Gal | Holds Four Items", false, "Whether the Shockwave Gal holds four items regardless of singleplayer or multiplayer.");
			ConfigShockwaveBotPropellerVolume = configFile.Bind<float>("Shockwave Bot 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 Bot 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 Tink Options", "Seamine Gal | Charges", 3, "How many charges the Seamine Gal has.");
			ConfigSeamineTinkRidingBruceVolume = configFile.Bind<float>("Seamine Tink 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 Tink 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 Tink 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 Tink Options", "Seamine Gal | Scan Range", 50f, "Range of the Seamine Gal's scan.");
			ConfigSeamineScanFrequency = configFile.Bind<float>("Seamine Tink Options", "Seamine Gal | Scan Frequency", 17.5f, "The average Frequency time of the Seamine Gal's scan in seconds.");
			ConfigTerminalBotAutomatic = configFile.Bind<bool>("Terminal Bot 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 Bot 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 Bot Options", "Terminal Gal | Scan Range", 50f, "Range of the Terminal Gal's scan.");
			ConfigTerminalScanFrequency = configFile.Bind<float>("Terminal Bot Options", "Terminal Gal | Scan Frequency", 17.5f, "The average Frequency time of the Terminal Gal's scan in seconds.");
			ConfigTerminalBotFlyingVolume = configFile.Bind<float>("Terminal Bot 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.");
			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; } = null;

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

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

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

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

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

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

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

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

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

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

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

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

		[InputAction(/*Could not decode attribute arguments.*/)]
		public InputAction MarrowHealPlayer { get; set; } = null;
	}
	[BepInPlugin("CodeRebirth", "CodeRebirth", "1.6.9")]
	[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; } = null;

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

			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;

		internal const int BURN_HIT_ID = 745737;

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

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

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

		public static PersistentDataContainer PersistentDataContainer { get; private set; } = null;

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

		private void Awake()
		{
			Logger = ((BaseUnityPlugin)this).Logger;
			PersistentDataContainer = BepInPluginExtensions.GetPersistentDataContainer((BaseUnityPlugin)(object)this);
			((DataContainer)PersistentDataContainer).Set<string>(NamespacedKey.From("code_rebirth", "last_version"), "1.6.9");
			configFile = ((BaseUnityPlugin)this).Config;
			ModConfig = new CodeRebirthConfig
			{
				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(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();
			SpikeTrapPatch.Init();
			EnemyAICollisionDetectPatch.Init();
			LandminePatch.Init();
			ShotgunItemPatch.Init();
			TurretPatch.Init();
			SoccerBallPropPatch.Init();
			VehicleControllerPatch.Init();
			MerchantTipPad.Init();
			StoatGun.Init();
			CommitKeyToSave.Init();
			HauntedTeddyBear.Init();
			BearTrapWheelProxy.Init();
			EntranceTeleportPatch.Init();
			((Registry<DawnEnemyInfo>)(object)LethalContent.Enemies).OnFreeze += PuppeteersVoodoo.CreateBlacklist;
			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_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			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_0003: Unknown result type (might be due to invalid IL or missing references)
			RevivePlayerClientRPC(playerRef, position);
		}

		[ClientRpc]
		private void RevivePlayerClientRPC(PlayerControllerReference playerRef, Vector3 position)
		{
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
			PlayerControllerB val = PlayerControllerReference.op_Implicit(playerRef);
			val.isInsideFactory = false;
			val.isInElevator = true;
			val.isInHangarShipRoom = true;
			val.ResetPlayerBloodObjects(val.isPlayerDead);
			val.health = 5;
			val.isClimbingLadder = false;
			val.clampLooking = false;
			val.inVehicleAnimation = false;
			val.disableMoveInput = false;
			val.disableLookInput = false;
			val.disableInteract = false;
			val.ResetZAndXRotation();
			((Collider)val.thisController).enabled = true;
			if (val.isPlayerDead)
			{
				((Collider)val.thisController).enabled = true;
				val.isPlayerDead = false;
				val.isPlayerControlled = true;
				val.health = 5;
				val.hasBeenCriticallyInjured = false;
				val.criticallyInjured = false;
				val.playerBodyAnimator.SetBool("Limp", false);
				val.TeleportPlayer(position, false, 0f, false, true);
				val.parentedToElevatorLastFrame = false;
				val.overrideGameOverSpectatePivot = null;
				StartOfRound.Instance.SetPlayerObjectExtrapolate(false);
				val.setPositionOfDeadPlayer = false;
				val.DisablePlayerModel(((Component)val).gameObject, true, true);
				((Behaviour)val.helmetLight).enabled = false;
				val.Crouch(false);
				Animator playerBodyAnimator = val.playerBodyAnimator;
				if (playerBodyAnimator != null)
				{
					playerBodyAnimator.SetBool("Limp", false);
				}
				val.bleedingHeavily = false;
				if ((Object)(object)val.deadBody != (Object)null)
				{
					((Behaviour)val.deadBody).enabled = false;
					((Component)val.deadBody).gameObject.SetActive(false);
				}
				val.bleedingHeavily = true;
				val.deadBody = null;
				val.activatingItem = false;
				val.twoHanded = false;
				val.inShockingMinigame = false;
				val.inSpecialInteractAnimation = false;
				val.freeRotationInInteractAnimation = false;
				val.disableSyncInAnimation = false;
				val.inAnimationWithEnemy = null;
				val.holdingWalkieTalkie = false;
				val.speakingToWalkieTalkie = false;
				val.isSinking = false;
				val.isUnderwater = false;
				val.sinkingValue = 0f;
				val.statusEffectAudio.Stop();
				val.DisableJetpackControlsLocally();
				val.mapRadarDotAnimator.SetBool("dead", false);
				val.hasBegunSpectating = false;
				val.externalForceAutoFade = Vector3.zero;
				val.hinderedMultiplier = 1f;
				val.isMovementHindered = 0;
				val.sourcesCausingSinking = 0;
				val.reverbPreset = StartOfRound.Instance.shipReverb;
				SoundManager.Instance.earsRingingTimer = 0f;
				val.voiceMuffledByEnemy = false;
				SoundManager.Instance.playerVoicePitchTargets[Array.IndexOf(StartOfRound.Instance.allPlayerScripts, val)] = 1f;
				SoundManager.Instance.SetPlayerPitch(1f, Array.IndexOf(StartOfRound.Instance.allPlayerScripts, val));
				if ((Object)(object)val.currentVoiceChatIngameSettings == (Object)null)
				{
					StartOfRound.Instance.RefreshPlayerVoicePlaybackObjects();
				}
				if ((Object)(object)val.currentVoiceChatIngameSettings != (Object)null)
				{
					if ((Object)(object)val.currentVoiceChatIngameSettings.voiceAudio == (Object)null)
					{
						val.currentVoiceChatIngameSettings.InitializeComponents();
					}
					if ((Object)(object)val.currentVoiceChatIngameSettings.voiceAudio == (Object)null)
					{
						return;
					}
					((Component)val.currentVoiceChatIngameSettings.voiceAudio).GetComponent<OccludeAudio>().overridingLowPass = false;
				}
				HUDManager.Instance.UpdateBoxesSpectateUI();
				HUDManager.Instance.UpdateSpectateBoxSpeakerIcons();
			}
			if ((Object)(object)GameNetworkManager.Instance.localPlayerController == (Object)(object)val)
			{
				val.bleedingHeavily = false;
				val.criticallyInjured = false;
				val.health = 5;
				HUDManager.Instance.UpdateHealthUI(5, true);
				Animator playerBodyAnimator2 = val.playerBodyAnimator;
				if (playerBodyAnimator2 != null)
				{
					playerBodyAnimator2.SetBool("Limp", false);
				}
				val.spectatedPlayerScript = null;
				StartOfRound.Instance.SetSpectateCameraToGameOverMode(false, val);
				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();
		}
	}
	public class CRPlayerData
	{
		public bool Water = false;

		public bool Fire = false;

		public bool Smoke = false;

		public bool ridingHoverboard = false;

		public bool flingingAway = false;

		public bool flung = false;

		public bool pseudoDead = false;

		public bool isJumping = false;

		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);