Dubdubaba-OuthardAdditionalContent Source

Communities

OutwardOuthardAdditionalContent

Install

Last Updated

First Uploaded

Downloads

309

Likes

Size

126MB

Dependency string

Dubdubaba-OuthardAdditionalContent-0.0.8

Dependants

0 other mods

Download

Details Required (1)Wiki Changelog Versions Analysis

using System;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using SideLoader;
using SideLoader.Model;
using SideLoader.Model.Status;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("SkilledAtMeditation")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("SkilledAtMeditation")]
[assembly: AssemblyCopyright("Copyright ©  2023")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("f58ba851-9161-4c37-a53a-8b7160761b1f")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
namespace SkilledAtMeditation;

public class SL_Meditation : SL_Effect, ICustomModel
{
	public Type SLTemplateModel => typeof(SL_Meditation);

	public Type GameModel => typeof(Meditation);

	public override void ApplyToComponent<T>(T component)
	{
	}

	public override void SerializeEffect<T>(T effect)
	{
	}
}
public class Meditation : Effect, ICustomModel
{
	public Type SLTemplateModel => typeof(SL_Meditation);

	public Type GameModel => typeof(Meditation);

	public override void ActivateLocally(Character _affectedCharacter, object[] _infos)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: Invalid comparison between Unknown and I4
		try
		{
			if ((int)_affectedCharacter.CurrentSpellCast != 41)
			{
				_affectedCharacter.StatusEffectMngr.CleanseStatusEffect("Meditation");
				return;
			}
			CharacterStats stats = _affectedCharacter.Stats;
			if (SkilledAtMeditation.EnableBurntRegen.Value)
			{
				Update(ref stats.m_burntStamina, 0f - SkilledAtMeditation.BurntStaminaRegen.Value, stats.MaxStamina);
				Update(ref stats.m_burntHealth, 0f - SkilledAtMeditation.BurntHealthRegen.Value, stats.MaxHealth);
				Update(ref stats.m_burntMana, 0f - SkilledAtMeditation.BurntManaRegen.Value, stats.MaxMana);
			}
			if (SkilledAtMeditation.EnableActiveRegen.Value)
			{
				Update(ref stats.m_stamina, SkilledAtMeditation.ActiveStaminaRegen.Value, stats.ActiveMaxStamina);
				Update(ref stats.m_health, SkilledAtMeditation.ActiveHealthRegen.Value, stats.ActiveMaxHealth);
				Update(ref stats.m_mana, SkilledAtMeditation.ActiveManaRegen.Value, stats.ActiveMaxMana);
			}
		}
		catch (Exception arg)
		{
			SkilledAtMeditation.Log.LogMessage((object)$"Exception during Meditation.ActivateLocally: {arg}");
		}
		static void Update(ref float cur, float delta, float max)
		{
			cur = Mathf.Clamp(cur + delta, 0f, max);
		}
	}
}
[BepInPlugin("com.exp111.SkilledAtMeditation", "SkilledAtMeditation", "1.0")]
public class SkilledAtMeditation : BaseUnityPlugin
{
	public const string ID = "com.exp111.SkilledAtMeditation";

	public const string NAME = "SkilledAtMeditation";

	public const string VERSION = "1.0";

	public static ManualLogSource Log;

	public const int MeditationSkillID = -46000;

	public const int MeditationStatusID = -46001;

	public const string MeditationStatusIdentifier = "Meditation";

	public Skill MeditationSkill;

	public static ConfigEntry<bool> EnableBurntRegen;

	public static ConfigEntry<bool> EnableActiveRegen;

	public static ConfigEntry<float> BurntStaminaRegen;

	public static ConfigEntry<float> BurntHealthRegen;

	public static ConfigEntry<float> BurntManaRegen;

	public static ConfigEntry<float> ActiveStaminaRegen;

	public static ConfigEntry<float> ActiveHealthRegen;

	public static ConfigEntry<float> ActiveManaRegen;

	public void Awake()
	{
		try
		{
			Log = ((BaseUnityPlugin)this).Logger;
			Log.LogMessage((object)"Awake");
			CreateConfig();
			CreateSkill();
			CreateStatusEffect();
			if (SL.PacksLoaded)
			{
				OnPackLoaded();
			}
			SL.OnPacksLoaded += OnPackLoaded;
			SL.OnSceneLoaded += OnSceneLoaded;
		}
		catch (Exception arg)
		{
			Log.LogMessage((object)$"Exception during SkilledAtMeditation.Awake: {arg}");
		}
	}

	private void CreateConfig()
	{
		EnableBurntRegen = ((BaseUnityPlugin)this).Config.Bind<bool>("Burnt Stat Regen", "Enable Burnt Stat Regeneration", true, "Enable or disable the regeneration of burnt stats while meditating");
		EnableActiveRegen = ((BaseUnityPlugin)this).Config.Bind<bool>("Active Stat Regen", "Enable Active Stat Regeneration", true, "Enable or disable the regeneration of active (non-burnt) stats while meditating");
		BurntStaminaRegen = ((BaseUnityPlugin)this).Config.Bind<float>("Burnt Stat Regen", "Burnt Stamina Regeneration Rate", 0.25f, "How quickly burnt stamina will regen while meditating.");
		BurntHealthRegen = ((BaseUnityPlugin)this).Config.Bind<float>("Burnt Stat Regen", "Burnt Health Regeneration Rate", 0.25f, "How quickly burnt health will regen while meditating.");
		BurntManaRegen = ((BaseUnityPlugin)this).Config.Bind<float>("Burnt Stat Regen", "Burnt Mana Regeneration Rate", 0.25f, "How quickly burnt Mana will regen while meditating.");
		ActiveStaminaRegen = ((BaseUnityPlugin)this).Config.Bind<float>("Active Stat Regen", "Active Stamina Regeneration", 0.5f, "How quickly stamina will regen while meditating.");
		ActiveHealthRegen = ((BaseUnityPlugin)this).Config.Bind<float>("Active Stat Regen", "Active Health Regeneration", 0.75f, "How quickly health will regen while meditating.");
		ActiveManaRegen = ((BaseUnityPlugin)this).Config.Bind<float>("Active Stat Regen", "Active Mana Regeneration", 0.5f, "How quickly mana will regen while meditating.");
	}

	public void OnDestroy()
	{
	}

	private void OnSceneLoaded()
	{
		try
		{
			foreach (Character value in CharacterManager.Instance.Characters.Values)
			{
				if (!value.IsAI && (Object)(object)value.Inventory != (Object)null && !value.Inventory.LearnedSkill((Item)(object)MeditationSkill))
				{
					value.Inventory.ReceiveSkillReward(((Item)MeditationSkill).ItemID);
				}
			}
		}
		catch (Exception arg)
		{
			Log.LogMessage((object)$"Exception during SkilledAtMeditation.OnSceneLoaded: {arg}");
		}
	}

	private void OnPackLoaded()
	{
		try
		{
			ref Skill meditationSkill = ref MeditationSkill;
			Item itemPrefab = ResourcesPrefabManager.Instance.GetItemPrefab(-46000);
			meditationSkill = (Skill)(object)((itemPrefab is Skill) ? itemPrefab : null);
			MeditationSkill.IgnoreLearnNotification = true;
		}
		catch (Exception arg)
		{
			Log.LogMessage((object)$"Exception during SkilledAtMeditation.OnPackLoaded: {arg}");
		}
	}

	private void CreateStatusEffect()
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0006: Expected O, but got Unknown
		//IL_0013: 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_00c5: Expected O, but got Unknown
		SL_StatusEffect val = new SL_StatusEffect();
		val.TargetStatusIdentifier = "Burning";
		val.EffectBehaviour = (EditBehaviours)2;
		val.StatusIdentifier = "Meditation";
		val.NewStatusID = -46001;
		val.Name = "Resting";
		val.Description = "Slowly restore stats while you rest.";
		((SL_StatusBase)val).SLPackName = "com.exp111.SkilledAtMeditation";
		((SL_StatusBase)val).SubfolderName = "Meditation";
		val.Lifespan = -1f;
		val.RefreshRate = 1f;
		val.DisplayedInHUD = true;
		val.IsMalusEffect = false;
		val.Purgeable = false;
		val.VFXInstantiationType = (FXInstantiationTypes)0;
		val.VFXPrefab = null;
		SL_EffectTransform[] array = new SL_EffectTransform[1];
		SL_EffectTransform val2 = new SL_EffectTransform();
		val2.TransformName = "Effects";
		val2.Effects = (SL_Effect[])(object)new SL_Effect[1]
		{
			new SL_Meditation()
		};
		array[0] = val2;
		val.Effects = (SL_EffectTransform[])(object)array;
		((ContentTemplate)val).ApplyTemplate();
	}

	private void CreateSkill()
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0006: Expected O, but got Unknown
		//IL_0013: Unknown result type (might be due to invalid IL or missing references)
		//IL_008d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0093: Expected O, but got Unknown
		//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b7: 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_00cb: Expected O, but got Unknown
		SL_Skill val = new SL_Skill();
		((SL_Item)val).Name = "Resting";
		((SL_Item)val).EffectBehaviour = (EditBehaviours)2;
		((SL_Item)val).Target_ItemID = 8100120;
		((SL_Item)val).New_ItemID = -46000;
		((SL_Item)val).SLPackName = "com.exp111.SkilledAtMeditation";
		((SL_Item)val).SubfolderName = "Meditate";
		((SL_Item)val).Description = "Enter a Resting state, slowly regenerating your vigor and injuries. When near a lit fire, your rest is enhanced and your body begins to recover.";
		((SL_Item)val).CastType = (SpellCastType)41;
		((SL_Item)val).CastModifier = (SpellCastModifier)0;
		((SL_Item)val).CastLocomotionEnabled = true;
		((SL_Item)val).MobileCastMovementMult = -1f;
		SL_EffectTransform[] array = new SL_EffectTransform[1];
		SL_EffectTransform val2 = new SL_EffectTransform();
		val2.TransformName = "Effects";
		val2.Effects = (SL_Effect[])(object)new SL_Effect[1] { (SL_Effect)new SL_AddStatusEffect
		{
			StatusEffect = "Meditation",
			ChanceToContract = 100,
			Delay = 1f
		} };
		array[0] = val2;
		((SL_Item)val).EffectTransforms = (SL_EffectTransform[])(object)array;
		val.Cooldown = 1f;
		val.StaminaCost = 0f;
		val.HealthCost = 0f;
		val.ManaCost = 0f;
		((ContentTemplate)val).ApplyTemplate();
	}

	[Conditional("DEBUG")]
	public static void DebugLog(string message)
	{
		Log.LogMessage((object)message);
	}

	[Conditional("TRACE")]
	public static void DebugTrace(string message)
	{
		Log.LogMessage((object)message);
	}
}

using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Logging;
using HarmonyLib;
using NodeCanvas.DialogueTrees;
using NodeCanvas.Framework;
using SideLoader;
using SideLoader.Model;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("OutwardModTemplate")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("OutwardModTemplate")]
[assembly: AssemblyCopyright("Copyright ©  2021")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("c5450fe0-edcf-483f-b9ea-4b1ef9d36da7")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
namespace APP;

[BepInPlugin("APP", "Advanced Picks & 'Poons", "0.9.6")]
public class Plugin : BaseUnityPlugin
{
	public const string GUID = "APP";

	public const string NAME = "Advanced Picks & 'Poons";

	public const string VERSION = "0.9.6";

	public static ManualLogSource Log;

	public const int DEFPICK_ID = 2120050;

	public const int DEFPOON_ID = 2130130;

	public const int DEFSICK_ID = 2000060;

	public const int APICK_ID = -31000;

	public const int APOON_ID = -31001;

	public const int EPICK_ID = -31002;

	public const int EPOON_ID = -31003;

	public const int MPICK_ID = -31004;

	public const int MPOON_ID = -31005;

	public const int ASICK_ID = -31006;

	public const int ESICK_ID = -31007;

	public const int MSICK_ID = -31008;

	public const int APICK_DURABILITY = 350;

	public const int APOON_DURABILITY = 250;

	public const int EPICK_DURABILITY = 400;

	public const int EPOON_DURABILITY = 300;

	public const int APICK_VALUE = 40;

	public const int APOON_VALUE = 40;

	public const int EPICK_VALUE = 75;

	public const int EPOON_VALUE = 75;

	public const int ASICK_VALUE = 40;

	public const int ESICK_VALUE = 75;

	internal void Awake()
	{
		Log = ((BaseUnityPlugin)this).Logger;
		Log.LogMessage((object)"Advanced Picks & 'Poons 0.9.6 successfully loaded!");
		SL.OnPacksLoaded += SL_OnPacksLoaded;
		Harmony.CreateAndPatchAll(typeof(Harmonize), (string)null);
	}

	private void SL_OnPacksLoaded()
	{
		SetUpPicks();
		SetUpPoons();
		SetUpSickles();
		AddToolsToDictionary();
		Recipes.CreateRecipes();
		Recipes.CreateRecipeScrolls();
		Recipes.AddRecipesToMerchants();
	}

	private void AddToolsToDictionary()
	{
		ItemUtilities.instance.m_gatherableToolEquivalences[2120050] = ItemUtilities.instance.m_gatherableToolEquivalences[2120050].Append(-31000).ToArray();
		ItemUtilities.instance.m_gatherableToolEquivalences[2120050] = ItemUtilities.instance.m_gatherableToolEquivalences[2120050].Append(-31002).ToArray();
		ItemUtilities.instance.m_gatherableToolEquivalences[2130130] = ItemUtilities.instance.m_gatherableToolEquivalences[2130130].Append(-31001).ToArray();
		ItemUtilities.instance.m_gatherableToolEquivalences[2130130] = ItemUtilities.instance.m_gatherableToolEquivalences[2130130].Append(-31003).ToArray();
	}

	private void SetUpSickles()
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0005: Unknown result type (might be due to invalid IL or missing references)
		//IL_0010: Unknown result type (might be due to invalid IL or missing references)
		//IL_001b: 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_0031: Unknown result type (might be due to invalid IL or missing references)
		//IL_0032: Unknown result type (might be due to invalid IL or missing references)
		//IL_0037: Unknown result type (might be due to invalid IL or missing references)
		//IL_003e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0043: Unknown result type (might be due to invalid IL or missing references)
		//IL_004e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0050: Unknown result type (might be due to invalid IL or missing references)
		//IL_005a: Expected O, but got Unknown
		//IL_005f: Unknown result type (might be due to invalid IL or missing references)
		//IL_006f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0081: Expected O, but got Unknown
		//IL_0081: Unknown result type (might be due to invalid IL or missing references)
		//IL_0082: Unknown result type (might be due to invalid IL or missing references)
		//IL_0087: 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)
		//IL_009d: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ad: Expected O, but got Unknown
		//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b3: 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_00c9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d9: Expected O, but got Unknown
		//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
		//IL_0104: Unknown result type (might be due to invalid IL or missing references)
		//IL_010f: Unknown result type (might be due to invalid IL or missing references)
		//IL_011a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0125: Unknown result type (might be due to invalid IL or missing references)
		//IL_0126: Unknown result type (might be due to invalid IL or missing references)
		//IL_012b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0132: Unknown result type (might be due to invalid IL or missing references)
		//IL_0137: Unknown result type (might be due to invalid IL or missing references)
		//IL_0142: Unknown result type (might be due to invalid IL or missing references)
		//IL_0144: Unknown result type (might be due to invalid IL or missing references)
		//IL_014e: Expected O, but got Unknown
		//IL_0153: Unknown result type (might be due to invalid IL or missing references)
		//IL_0163: Unknown result type (might be due to invalid IL or missing references)
		//IL_0175: Expected O, but got Unknown
		//IL_0175: Unknown result type (might be due to invalid IL or missing references)
		//IL_0176: Unknown result type (might be due to invalid IL or missing references)
		//IL_017b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0186: Unknown result type (might be due to invalid IL or missing references)
		//IL_0191: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a1: Expected O, but got Unknown
		//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
		//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
		//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
		//IL_01cd: Expected O, but got Unknown
		//IL_01cd: Unknown result type (might be due to invalid IL or missing references)
		//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
		((ContentTemplate)new SL_Weapon
		{
			Target_ItemID = 2000060,
			New_ItemID = -316,
			Name = "Advanced Sickle",
			Description = "A quality sickle used to gather items more efficiently.",
			StatsHolder = (SL_ItemStats)new SL_WeaponStats
			{
				BaseDamage = new List<SL_Damage>
				{
					new SL_Damage
					{
						Damage = 17f,
						Type = (Types)0
					}
				},
				MaxDurability = 350,
				BaseValue = 40
			},
			ItemVisuals = new SL_ItemVisual
			{
				Prefab_SLPack = "APP",
				Prefab_AssetBundle = "sickle-a",
				Prefab_Name = "sickle-a"
			},
			SpecialItemVisuals = new SL_ItemVisual
			{
				Prefab_SLPack = "APP",
				Prefab_AssetBundle = "ssickle-a",
				Prefab_Name = "ssickle-a"
			},
			SLPackName = "APP",
			SubfolderName = "AdvancedSickle"
		}).ApplyTemplate();
		((ContentTemplate)new SL_Weapon
		{
			Target_ItemID = 2000060,
			New_ItemID = -317,
			Name = "Expert Sickle",
			Description = "A quality sickle used to gather items more efficiently.",
			StatsHolder = (SL_ItemStats)new SL_WeaponStats
			{
				BaseDamage = new List<SL_Damage>
				{
					new SL_Damage
					{
						Damage = 20f,
						Type = (Types)0
					}
				},
				MaxDurability = 400,
				BaseValue = 75
			},
			ItemVisuals = new SL_ItemVisual
			{
				Prefab_SLPack = "APP",
				Prefab_AssetBundle = "sickle-a",
				Prefab_Name = "sickle-a"
			},
			SpecialItemVisuals = new SL_ItemVisual
			{
				Prefab_SLPack = "APP",
				Prefab_AssetBundle = "ssickle-a",
				Prefab_Name = "ssickle-a"
			},
			SLPackName = "APP",
			SubfolderName = "ExpertSickle"
		}).ApplyTemplate();
	}

	private void SetUpPicks()
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0005: Unknown result type (might be due to invalid IL or missing references)
		//IL_0010: Unknown result type (might be due to invalid IL or missing references)
		//IL_001b: 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_0031: Unknown result type (might be due to invalid IL or missing references)
		//IL_0032: Unknown result type (might be due to invalid IL or missing references)
		//IL_0037: Unknown result type (might be due to invalid IL or missing references)
		//IL_003e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0043: Unknown result type (might be due to invalid IL or missing references)
		//IL_004e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0050: Unknown result type (might be due to invalid IL or missing references)
		//IL_005a: Expected O, but got Unknown
		//IL_005f: Unknown result type (might be due to invalid IL or missing references)
		//IL_006f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0081: Expected O, but got Unknown
		//IL_0081: Unknown result type (might be due to invalid IL or missing references)
		//IL_008c: Unknown result type (might be due to invalid IL or missing references)
		//IL_009c: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c2: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00da: Unknown result type (might be due to invalid IL or missing references)
		//IL_00df: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f6: Expected O, but got Unknown
		//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
		//IL_010b: Unknown result type (might be due to invalid IL or missing references)
		//IL_011d: Expected O, but got Unknown
		//IL_011d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0128: Unknown result type (might be due to invalid IL or missing references)
		((ContentTemplate)new SL_MeleeWeapon
		{
			Target_ItemID = 2120050,
			New_ItemID = -310,
			Name = "Advanced Mining Pick",
			Description = "A mining pick of greater quality that is capable of mining more efficiently.",
			StatsHolder = (SL_ItemStats)new SL_WeaponStats
			{
				BaseDamage = new List<SL_Damage>
				{
					new SL_Damage
					{
						Damage = 20f,
						Type = (Types)0
					}
				},
				MaxDurability = 350,
				BaseValue = 40
			},
			SLPackName = "APP",
			SubfolderName = "AdvancedPick"
		}).ApplyTemplate();
		((ContentTemplate)new SL_MeleeWeapon
		{
			Target_ItemID = 2120050,
			New_ItemID = -312,
			Name = "Expert Mining Pick",
			Description = "A mining pick of exceptional quality that is capable of mining a great deal more efficiently.",
			StatsHolder = (SL_ItemStats)new SL_WeaponStats
			{
				BaseDamage = new List<SL_Damage>
				{
					new SL_Damage
					{
						Damage = 26f,
						Type = (Types)0
					}
				},
				MaxDurability = 400,
				BaseValue = 75
			},
			SLPackName = "APP",
			SubfolderName = "ExpertPick"
		}).ApplyTemplate();
	}

	private void SetUpPoons()
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0005: Unknown result type (might be due to invalid IL or missing references)
		//IL_0010: Unknown result type (might be due to invalid IL or missing references)
		//IL_001b: 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_0031: Unknown result type (might be due to invalid IL or missing references)
		//IL_0032: Unknown result type (might be due to invalid IL or missing references)
		//IL_0037: Unknown result type (might be due to invalid IL or missing references)
		//IL_003e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0043: Unknown result type (might be due to invalid IL or missing references)
		//IL_004e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0050: Unknown result type (might be due to invalid IL or missing references)
		//IL_005a: Expected O, but got Unknown
		//IL_005f: Unknown result type (might be due to invalid IL or missing references)
		//IL_006f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0081: Expected O, but got Unknown
		//IL_0081: Unknown result type (might be due to invalid IL or missing references)
		//IL_008c: Unknown result type (might be due to invalid IL or missing references)
		//IL_009c: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c2: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00da: Unknown result type (might be due to invalid IL or missing references)
		//IL_00df: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f6: Expected O, but got Unknown
		//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
		//IL_010b: Unknown result type (might be due to invalid IL or missing references)
		//IL_011d: Expected O, but got Unknown
		//IL_011d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0128: Unknown result type (might be due to invalid IL or missing references)
		((ContentTemplate)new SL_MeleeWeapon
		{
			Target_ItemID = 2130130,
			New_ItemID = -311,
			Name = "Advanced Fishing Harpoon",
			Description = "A harpoon of greater quality that is capable of fishing more effectively.",
			StatsHolder = (SL_ItemStats)new SL_WeaponStats
			{
				BaseDamage = new List<SL_Damage>
				{
					new SL_Damage
					{
						Damage = 20f,
						Type = (Types)0
					}
				},
				MaxDurability = 250,
				BaseValue = 40
			},
			SLPackName = "APP",
			SubfolderName = "AdvancedPoon"
		}).ApplyTemplate();
		((ContentTemplate)new SL_MeleeWeapon
		{
			Target_ItemID = 2130130,
			New_ItemID = -313,
			Name = "Expert Fishing Harpoon",
			Description = "A harpoon of exceptional quality that is capable of fishing a great deal more effectively.",
			StatsHolder = (SL_ItemStats)new SL_WeaponStats
			{
				BaseDamage = new List<SL_Damage>
				{
					new SL_Damage
					{
						Damage = 26f,
						Type = (Types)0
					}
				},
				MaxDurability = 300,
				BaseValue = 75
			},
			SLPackName = "APP",
			SubfolderName = "ExpertPoon"
		}).ApplyTemplate();
	}
}
public class Harmonize
{
	private static bool isMining;

	private static bool isFishing;

	private static bool isDialoguePatched;

	private static bool firstTime;

	public static Harmonize Instance { get; private set; }

	internal void Awake()
	{
		Instance = this;
	}

	[HarmonyPrefix]
	[HarmonyPatch(typeof(Gatherable), "OnGatherInteraction")]
	private static void GatherPatch(Character _gatherer, Gatherable __instance)
	{
		if (!firstTime)
		{
			if (isMining)
			{
				if (_gatherer.Inventory.OwnsItem(-31000) && !_gatherer.Inventory.OwnsItem(-31002))
				{
					if (Random.Range(1, 100) < 16)
					{
						MethodInfo method = typeof(Gatherable).GetMethod("StartInit", BindingFlags.Instance | BindingFlags.NonPublic);
						if (method != null)
						{
							method.Invoke(__instance, null);
						}
					}
				}
				else if (_gatherer.Inventory.OwnsItem(-31002) && Random.Range(1, 100) < 26)
				{
					MethodInfo method2 = typeof(Gatherable).GetMethod("StartInit", BindingFlags.Instance | BindingFlags.NonPublic);
					if (method2 != null)
					{
						method2.Invoke(__instance, null);
					}
				}
				isMining = false;
				return;
			}
			if (isFishing)
			{
				if (_gatherer.Inventory.OwnsItem(-31001) && !_gatherer.Inventory.OwnsItem(-31003))
				{
					if (Random.Range(1, 100) < 16)
					{
						MethodInfo method3 = typeof(Gatherable).GetMethod("StartInit", BindingFlags.Instance | BindingFlags.NonPublic);
						if (method3 != null)
						{
							method3.Invoke(__instance, null);
						}
					}
				}
				else if (_gatherer.Inventory.OwnsItem(-31003) && Random.Range(1, 100) < 26)
				{
					MethodInfo method4 = typeof(Gatherable).GetMethod("StartInit", BindingFlags.Instance | BindingFlags.NonPublic);
					if (method4 != null)
					{
						method4.Invoke(__instance, null);
					}
				}
				isFishing = false;
				return;
			}
			new List<Item>();
			if (_gatherer.Inventory.OwnsItem(-31006) && !_gatherer.Inventory.OwnsItem(-31007))
			{
				Item obj = _gatherer.Inventory.GetOwnedItems(-31006)[0];
				float num = obj.MaxDurability / 100;
				obj.ReduceDurability(num);
				if (Random.Range(1, 100) < 16)
				{
					MethodInfo method5 = typeof(Gatherable).GetMethod("StartInit", BindingFlags.Instance | BindingFlags.NonPublic);
					if (method5 != null)
					{
						method5.Invoke(__instance, null);
					}
				}
			}
			else
			{
				if (!_gatherer.Inventory.OwnsItem(-31007))
				{
					return;
				}
				Item obj2 = _gatherer.Inventory.GetOwnedItems(-31007)[0];
				float num2 = obj2.MaxDurability / 100;
				obj2.ReduceDurability(num2);
				if (Random.Range(1, 100) < 26)
				{
					MethodInfo method6 = typeof(Gatherable).GetMethod("StartInit", BindingFlags.Instance | BindingFlags.NonPublic);
					if (method6 != null)
					{
						method6.Invoke(__instance, null);
					}
				}
			}
		}
		else
		{
			firstTime = false;
		}
	}

	[HarmonyPostfix]
	[HarmonyPatch(typeof(CharacterInventory), "GetCompatibleGatherableTool")]
	private static void GetToolPatch(int _sourceToolID)
	{
		switch (_sourceToolID)
		{
		case 2120050:
			isMining = true;
			isFishing = false;
			break;
		case 2130130:
			isMining = false;
			isFishing = true;
			break;
		default:
			isMining = false;
			isFishing = false;
			break;
		}
	}

	[HarmonyPrefix]
	[HarmonyPatch(typeof(NPCInteraction), "OnActivate")]
	private static void NPCInteractionPatch(NPCInteraction __instance)
	{
		//IL_0041: Unknown result type (might be due to invalid IL or missing references)
		//IL_0046: Unknown result type (might be due to invalid IL or missing references)
		//IL_004c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0056: Expected O, but got Unknown
		//IL_0057: Expected O, but got Unknown
		//IL_0070: Unknown result type (might be due to invalid IL or missing references)
		//IL_007a: Expected O, but got Unknown
		if (__instance.DialogueActor.name == "Loud-Hammer" && !isDialoguePatched)
		{
			Graph graph = ((GraphOwner)((Component)__instance.DialogueActor).GetComponentInChildren<DialogueTreeController>()).graph;
			MultipleChoiceNodeExt val = graph.GetAllNodesOfType<MultipleChoiceNodeExt>()[0];
			Choice item = new Choice
			{
				statement = new Statement("Is there anything else you can teach me?")
			};
			val.availableChoices.Add(item);
			StatementNodeExt val2 = graph.AddNode<StatementNodeExt>();
			val2.statement = new Statement("If you are interested in discovering the secrets of more efficient gathering tools, seek out other blacksmiths in far away cities!");
			val2.SetActorName("Loud-Hammer");
			graph.allNodes.Add((Node)(object)val2);
			graph.ConnectNodes((Node)(object)val, (Node)(object)val2, 6, -1);
			isDialoguePatched = true;
		}
	}

	static Harmonize()
	{
		isMining = false;
		isFishing = false;
		isDialoguePatched = false;
		firstTime = true;
	}
}
public class Recipes
{
	public const string APICK_REC = "app.advpick";

	public const string EPICK_REC = "app.exppick";

	public const string APOON_REC = "app.advpoon";

	public const string EPOON_REC = "app.expoon";

	public const string MPICK_REC = "app.maspick";

	public const string MPOON_REC = "app.maspoon";

	public const string ASICK_REC = "app.advsick";

	public const string ESICK_REC = "app.expsick";

	public const string MSICK_REC = "app.massick";

	public const int APICK_REC_ID = -31010;

	public const int APOON_REC_ID = -31011;

	public const int EPICK_REC_ID = -31012;

	public const int EPOON_REC_ID = -31013;

	public const int MPICK_REC_ID = -31014;

	public const int MPOON_REC_ID = -31015;

	public const int ASICK_REC_ID = -31016;

	public const int ESICK_REC_ID = -31017;

	public const int MSICK_REC_ID = -31018;

	public const int ADVTOOLCOST = 75;

	public const int EXPTOOLCOST = 125;

	public const int MASTOOLCOST = 200;

	public const string ING_MININGPICK = "2120050";

	public const string ING_PALLADIUM = "6400070";

	public const string ING_AMMOLITE = "6200050";

	public const string ING_BEASTGOLEMSCRAPS = "6600130";

	public const string ING_GOLDINGOT = "6300030";

	public const string ING_AMETHYSTGEODE = "6000370";

	public const string ING_CHROMIUMSHARDS = "6000340";

	public const string ING_FISHINGHARPOON = "2130130";

	public const string ING_BLUESAND = "6400110";

	public const string ING_SHARKCARTILAGE = "6600170";

	public const string ING_PETRIFIEDORGANS = "6000440";

	public const string ING_DIGESTEDMANASTONE = "6000450";

	public const string ING_MACHETE = "2000060";

	public const string ING_WOOLSHROOM = "4000240";

	public const string ING_PETRIFIEDWOOD = "6400080";

	public const string ING_VOLTAICVINES = "6000410";

	public const string ING_BLOODROOT = "6000400";

	public static void CreateRecipes()
	{
		CreatePickRecipes();
		CreatePoonRecipes();
		CreateSickleRecipes();
		CreateMasterRecipes();
	}

	private static void CreatePickRecipes()
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_0011: Unknown result type (might be due to invalid IL or missing references)
		//IL_0013: Unknown result type (might be due to invalid IL or missing references)
		//IL_0018: Unknown result type (might be due to invalid IL or missing references)
		//IL_001f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_0026: Unknown result type (might be due to invalid IL or missing references)
		//IL_002b: Unknown result type (might be due to invalid IL or missing references)
		//IL_003b: Expected O, but got Unknown
		//IL_003d: 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_0044: Unknown result type (might be due to invalid IL or missing references)
		//IL_0049: Unknown result type (might be due to invalid IL or missing references)
		//IL_0059: Expected O, but got Unknown
		//IL_005b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0060: Unknown result type (might be due to invalid IL or missing references)
		//IL_0062: Unknown result type (might be due to invalid IL or missing references)
		//IL_0067: Unknown result type (might be due to invalid IL or missing references)
		//IL_0077: Expected O, but got Unknown
		//IL_0079: Unknown result type (might be due to invalid IL or missing references)
		//IL_007e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0080: Unknown result type (might be due to invalid IL or missing references)
		//IL_0085: Unknown result type (might be due to invalid IL or missing references)
		//IL_0095: Expected O, but got Unknown
		//IL_009b: 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_00a7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00be: Expected O, but got Unknown
		//IL_00c5: Expected O, but got Unknown
		//IL_00cc: 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_00dc: Unknown result type (might be due to invalid IL or missing references)
		//IL_00de: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
		//IL_010e: Expected O, but got Unknown
		//IL_0110: Unknown result type (might be due to invalid IL or missing references)
		//IL_0115: Unknown result type (might be due to invalid IL or missing references)
		//IL_0117: Unknown result type (might be due to invalid IL or missing references)
		//IL_011c: Unknown result type (might be due to invalid IL or missing references)
		//IL_012c: Expected O, but got Unknown
		//IL_012e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0133: Unknown result type (might be due to invalid IL or missing references)
		//IL_0135: Unknown result type (might be due to invalid IL or missing references)
		//IL_013a: Unknown result type (might be due to invalid IL or missing references)
		//IL_014a: Expected O, but got Unknown
		//IL_014c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0151: Unknown result type (might be due to invalid IL or missing references)
		//IL_0153: Unknown result type (might be due to invalid IL or missing references)
		//IL_0158: Unknown result type (might be due to invalid IL or missing references)
		//IL_0168: Expected O, but got Unknown
		//IL_016e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0175: 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_0185: Unknown result type (might be due to invalid IL or missing references)
		//IL_0191: Expected O, but got Unknown
		//IL_0198: Expected O, but got Unknown
		SL_Recipe val = new SL_Recipe
		{
			UID = "app.advpick",
			StationType = (CraftingType)2,
			Ingredients = new List<Ingredient>
			{
				new Ingredient
				{
					Type = (ActionTypes)1,
					SelectorValue = "2120050"
				},
				new Ingredient
				{
					Type = (ActionTypes)1,
					SelectorValue = "6400070"
				},
				new Ingredient
				{
					Type = (ActionTypes)1,
					SelectorValue = "6200050"
				},
				new Ingredient
				{
					Type = (ActionTypes)1,
					SelectorValue = "6600130"
				}
			},
			Results = new List<ItemQty>
			{
				new ItemQty
				{
					ItemID = -31000,
					Quantity = 1
				}
			}
		};
		((ContentTemplate)val).ApplyTemplate();
		SL_Recipe val2 = new SL_Recipe
		{
			UID = "app.exppick",
			StationType = (CraftingType)2,
			Ingredients = new List<Ingredient>
			{
				new Ingredient
				{
					Type = (ActionTypes)1,
					SelectorValue = (-31000).ToString()
				},
				new Ingredient
				{
					Type = (ActionTypes)1,
					SelectorValue = "6300030"
				},
				new Ingredient
				{
					Type = (ActionTypes)1,
					SelectorValue = "6000370"
				},
				new Ingredient
				{
					Type = (ActionTypes)1,
					SelectorValue = "6000350"
				}
			},
			Results = new List<ItemQty>
			{
				new ItemQty
				{
					ItemID = -31002,
					Quantity = 1
				}
			}
		};
		((ContentTemplate)val2).ApplyTemplate();
	}

	private static void CreatePoonRecipes()
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_0011: Unknown result type (might be due to invalid IL or missing references)
		//IL_0013: Unknown result type (might be due to invalid IL or missing references)
		//IL_0018: Unknown result type (might be due to invalid IL or missing references)
		//IL_001f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_0026: Unknown result type (might be due to invalid IL or missing references)
		//IL_002b: Unknown result type (might be due to invalid IL or missing references)
		//IL_003b: Expected O, but got Unknown
		//IL_003d: 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_0044: Unknown result type (might be due to invalid IL or missing references)
		//IL_0049: Unknown result type (might be due to invalid IL or missing references)
		//IL_0059: Expected O, but got Unknown
		//IL_005b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0060: Unknown result type (might be due to invalid IL or missing references)
		//IL_0062: Unknown result type (might be due to invalid IL or missing references)
		//IL_0067: Unknown result type (might be due to invalid IL or missing references)
		//IL_0077: Expected O, but got Unknown
		//IL_0079: Unknown result type (might be due to invalid IL or missing references)
		//IL_007e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0080: Unknown result type (might be due to invalid IL or missing references)
		//IL_0085: Unknown result type (might be due to invalid IL or missing references)
		//IL_0095: Expected O, but got Unknown
		//IL_009b: 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_00a7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00be: Expected O, but got Unknown
		//IL_00c5: Expected O, but got Unknown
		//IL_00cc: 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_00dc: Unknown result type (might be due to invalid IL or missing references)
		//IL_00de: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
		//IL_010e: Expected O, but got Unknown
		//IL_0110: Unknown result type (might be due to invalid IL or missing references)
		//IL_0115: Unknown result type (might be due to invalid IL or missing references)
		//IL_0117: Unknown result type (might be due to invalid IL or missing references)
		//IL_011c: Unknown result type (might be due to invalid IL or missing references)
		//IL_012c: Expected O, but got Unknown
		//IL_012e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0133: Unknown result type (might be due to invalid IL or missing references)
		//IL_0135: Unknown result type (might be due to invalid IL or missing references)
		//IL_013a: Unknown result type (might be due to invalid IL or missing references)
		//IL_014a: Expected O, but got Unknown
		//IL_014c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0151: Unknown result type (might be due to invalid IL or missing references)
		//IL_0153: Unknown result type (might be due to invalid IL or missing references)
		//IL_0158: Unknown result type (might be due to invalid IL or missing references)
		//IL_0168: Expected O, but got Unknown
		//IL_016e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0175: 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_0185: Unknown result type (might be due to invalid IL or missing references)
		//IL_0191: Expected O, but got Unknown
		//IL_0198: Expected O, but got Unknown
		SL_Recipe val = new SL_Recipe
		{
			UID = "app.advpoon",
			StationType = (CraftingType)2,
			Ingredients = new List<Ingredient>
			{
				new Ingredient
				{
					Type = (ActionTypes)1,
					SelectorValue = "2130130"
				},
				new Ingredient
				{
					Type = (ActionTypes)1,
					SelectorValue = "6400070"
				},
				new Ingredient
				{
					Type = (ActionTypes)1,
					SelectorValue = "6400110"
				},
				new Ingredient
				{
					Type = (ActionTypes)1,
					SelectorValue = "6600170"
				}
			},
			Results = new List<ItemQty>
			{
				new ItemQty
				{
					ItemID = -31001,
					Quantity = 1
				}
			}
		};
		((ContentTemplate)val).ApplyTemplate();
		SL_Recipe val2 = new SL_Recipe
		{
			UID = "app.expoon",
			StationType = (CraftingType)2,
			Ingredients = new List<Ingredient>
			{
				new Ingredient
				{
					Type = (ActionTypes)1,
					SelectorValue = (-31001).ToString()
				},
				new Ingredient
				{
					Type = (ActionTypes)1,
					SelectorValue = "6300030"
				},
				new Ingredient
				{
					Type = (ActionTypes)1,
					SelectorValue = "6000440"
				},
				new Ingredient
				{
					Type = (ActionTypes)1,
					SelectorValue = "6000450"
				}
			},
			Results = new List<ItemQty>
			{
				new ItemQty
				{
					ItemID = -31003,
					Quantity = 1
				}
			}
		};
		((ContentTemplate)val2).ApplyTemplate();
	}

	private static void CreateSickleRecipes()
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_0011: Unknown result type (might be due to invalid IL or missing references)
		//IL_0013: Unknown result type (might be due to invalid IL or missing references)
		//IL_0018: Unknown result type (might be due to invalid IL or missing references)
		//IL_001f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_0026: Unknown result type (might be due to invalid IL or missing references)
		//IL_002b: Unknown result type (might be due to invalid IL or missing references)
		//IL_003b: Expected O, but got Unknown
		//IL_003d: 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_0044: Unknown result type (might be due to invalid IL or missing references)
		//IL_0049: Unknown result type (might be due to invalid IL or missing references)
		//IL_0059: Expected O, but got Unknown
		//IL_005b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0060: Unknown result type (might be due to invalid IL or missing references)
		//IL_0062: Unknown result type (might be due to invalid IL or missing references)
		//IL_0067: Unknown result type (might be due to invalid IL or missing references)
		//IL_0077: Expected O, but got Unknown
		//IL_0079: Unknown result type (might be due to invalid IL or missing references)
		//IL_007e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0080: Unknown result type (might be due to invalid IL or missing references)
		//IL_0085: Unknown result type (might be due to invalid IL or missing references)
		//IL_0095: Expected O, but got Unknown
		//IL_009b: 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_00a7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00be: Expected O, but got Unknown
		//IL_00c5: Expected O, but got Unknown
		//IL_00cc: 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_00dc: Unknown result type (might be due to invalid IL or missing references)
		//IL_00de: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
		//IL_010e: Expected O, but got Unknown
		//IL_0110: Unknown result type (might be due to invalid IL or missing references)
		//IL_0115: Unknown result type (might be due to invalid IL or missing references)
		//IL_0117: Unknown result type (might be due to invalid IL or missing references)
		//IL_011c: Unknown result type (might be due to invalid IL or missing references)
		//IL_012c: Expected O, but got Unknown
		//IL_012e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0133: Unknown result type (might be due to invalid IL or missing references)
		//IL_0135: Unknown result type (might be due to invalid IL or missing references)
		//IL_013a: Unknown result type (might be due to invalid IL or missing references)
		//IL_014a: Expected O, but got Unknown
		//IL_014c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0151: Unknown result type (might be due to invalid IL or missing references)
		//IL_0153: Unknown result type (might be due to invalid IL or missing references)
		//IL_0158: Unknown result type (might be due to invalid IL or missing references)
		//IL_0168: Expected O, but got Unknown
		//IL_016e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0175: 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_0185: Unknown result type (might be due to invalid IL or missing references)
		//IL_0191: Expected O, but got Unknown
		//IL_0198: Expected O, but got Unknown
		SL_Recipe val = new SL_Recipe
		{
			UID = "app.advsick",
			StationType = (CraftingType)2,
			Ingredients = new List<Ingredient>
			{
				new Ingredient
				{
					Type = (ActionTypes)1,
					SelectorValue = "2000060"
				},
				new Ingredient
				{
					Type = (ActionTypes)1,
					SelectorValue = "6400070"
				},
				new Ingredient
				{
					Type = (ActionTypes)1,
					SelectorValue = "4000240"
				},
				new Ingredient
				{
					Type = (ActionTypes)1,
					SelectorValue = "6400080"
				}
			},
			Results = new List<ItemQty>
			{
				new ItemQty
				{
					ItemID = -31006,
					Quantity = 1
				}
			}
		};
		((ContentTemplate)val).ApplyTemplate();
		SL_Recipe val2 = new SL_Recipe
		{
			UID = "app.expsick",
			StationType = (CraftingType)2,
			Ingredients = new List<Ingredient>
			{
				new Ingredient
				{
					Type = (ActionTypes)1,
					SelectorValue = (-31006).ToString()
				},
				new Ingredient
				{
					Type = (ActionTypes)1,
					SelectorValue = "6300030"
				},
				new Ingredient
				{
					Type = (ActionTypes)1,
					SelectorValue = "6000410"
				},
				new Ingredient
				{
					Type = (ActionTypes)1,
					SelectorValue = "6000400"
				}
			},
			Results = new List<ItemQty>
			{
				new ItemQty
				{
					ItemID = -31007,
					Quantity = 1
				}
			}
		};
		((ContentTemplate)val2).ApplyTemplate();
	}

	public static void CreateMasterRecipes()
	{
	}

	public static void CreateRecipeScrolls()
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_0011: Unknown result type (might be due to invalid IL or missing references)
		//IL_001c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0027: Unknown result type (might be due to invalid IL or missing references)
		//IL_0032: Unknown result type (might be due to invalid IL or missing references)
		//IL_003d: Unknown result type (might be due to invalid IL or missing references)
		//IL_003e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0043: Unknown result type (might be due to invalid IL or missing references)
		//IL_0055: Expected O, but got Unknown
		//IL_0056: Expected O, but got Unknown
		//IL_005d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0062: Unknown result type (might be due to invalid IL or missing references)
		//IL_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_008e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0099: Unknown result type (might be due to invalid IL or missing references)
		//IL_009a: Unknown result type (might be due to invalid IL or missing references)
		//IL_009f: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b1: Expected O, but got Unknown
		//IL_00b2: Expected O, but got Unknown
		//IL_00b9: 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_00c9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00df: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ea: 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_00f6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
		//IL_010d: Expected O, but got Unknown
		//IL_010e: Expected O, but got Unknown
		//IL_0115: Unknown result type (might be due to invalid IL or missing references)
		//IL_011a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0125: Unknown result type (might be due to invalid IL or missing references)
		//IL_0130: Unknown result type (might be due to invalid IL or missing references)
		//IL_013b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0146: Unknown result type (might be due to invalid IL or missing references)
		//IL_0151: Unknown result type (might be due to invalid IL or missing references)
		//IL_0152: Unknown result type (might be due to invalid IL or missing references)
		//IL_0157: Unknown result type (might be due to invalid IL or missing references)
		//IL_0169: Expected O, but got Unknown
		//IL_016a: Expected O, but got Unknown
		//IL_0171: Unknown result type (might be due to invalid IL or missing references)
		//IL_0176: Unknown result type (might be due to invalid IL or missing references)
		//IL_0181: Unknown result type (might be due to invalid IL or missing references)
		//IL_018c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0197: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
		//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
		//IL_01c5: Expected O, but got Unknown
		//IL_01c7: Expected O, but got Unknown
		//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
		//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
		//IL_01df: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
		//IL_01f5: Unknown result type (might be due to invalid IL or missing references)
		//IL_0200: Unknown result type (might be due to invalid IL or missing references)
		//IL_020b: Unknown result type (might be due to invalid IL or missing references)
		//IL_020c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0211: Unknown result type (might be due to invalid IL or missing references)
		//IL_0223: Expected O, but got Unknown
		//IL_0225: Expected O, but got Unknown
		SL_RecipeItem val = new SL_RecipeItem
		{
			RecipeUID = "app.advpick",
			Target_ItemID = 5700187,
			New_ItemID = -31010,
			Name = "Crafting: Advanced Mining Pick",
			Description = "Schematic that teaches the user how to craft an Advanced Mining Pick",
			StatsHolder = new SL_ItemStats
			{
				BaseValue = 75
			}
		};
		((ContentTemplate)val).ApplyTemplate();
		SL_RecipeItem val2 = new SL_RecipeItem
		{
			RecipeUID = "app.exppick",
			Target_ItemID = 5700187,
			New_ItemID = -31012,
			Name = "Crafting: Expert Mining Pick",
			Description = "Schematic that teaches the user how to craft an Expert Mining Pick",
			StatsHolder = new SL_ItemStats
			{
				BaseValue = 125
			}
		};
		((ContentTemplate)val2).ApplyTemplate();
		SL_RecipeItem val3 = new SL_RecipeItem
		{
			RecipeUID = "app.advpoon",
			Target_ItemID = 5700187,
			New_ItemID = -31011,
			Name = "Crafting: Advanced Fishing Harpoon",
			Description = "Schematic that teaches the user how to craft an Advanced Fishing Harpoon",
			StatsHolder = new SL_ItemStats
			{
				BaseValue = 75
			}
		};
		((ContentTemplate)val3).ApplyTemplate();
		SL_RecipeItem val4 = new SL_RecipeItem
		{
			RecipeUID = "app.expoon",
			Target_ItemID = 5700187,
			New_ItemID = -31013,
			Name = "Crafting: Expert Fishing Harpoon",
			Description = "Schematic that teaches the user how to craft an Expert Fishing Harpoon",
			StatsHolder = new SL_ItemStats
			{
				BaseValue = 125
			}
		};
		((ContentTemplate)val4).ApplyTemplate();
		SL_RecipeItem val5 = new SL_RecipeItem
		{
			RecipeUID = "app.advsick",
			Target_ItemID = 5700187,
			New_ItemID = -31016,
			Name = "Crafting: Advanced Sickle",
			Description = "Schematic that teaches the user how to craft an Advanced Harvesting Sickle",
			StatsHolder = new SL_ItemStats
			{
				BaseValue = 75
			}
		};
		((ContentTemplate)val5).ApplyTemplate();
		SL_RecipeItem val6 = new SL_RecipeItem
		{
			RecipeUID = "app.expsick",
			Target_ItemID = 5700187,
			New_ItemID = -31017,
			Name = "Crafting: Expert Sickle",
			Description = "Schematic that teaches the user how to craft an Expert Harvesting Sickle",
			StatsHolder = new SL_ItemStats
			{
				BaseValue = 125
			}
		};
		((ContentTemplate)val6).ApplyTemplate();
	}

	public static void AddRecipesToMerchants()
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0005: Unknown result type (might be due to invalid IL or missing references)
		//IL_0010: Unknown result type (might be due to invalid IL or missing references)
		//IL_0017: Unknown result type (might be due to invalid IL or missing references)
		//IL_001c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0027: 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_003a: Expected O, but got Unknown
		//IL_003b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0040: Unknown result type (might be due to invalid IL or missing references)
		//IL_004b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0052: Unknown result type (might be due to invalid IL or missing references)
		//IL_005e: Expected O, but got Unknown
		//IL_005f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0064: Unknown result type (might be due to invalid IL or missing references)
		//IL_006f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0076: Unknown result type (might be due to invalid IL or missing references)
		//IL_0082: Expected O, but got Unknown
		//IL_0088: Expected O, but got Unknown
		//IL_008e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0093: Unknown result type (might be due to invalid IL or missing references)
		//IL_009e: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c8: Expected O, but got Unknown
		//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ec: Expected O, but got Unknown
		//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
		//IL_0104: Unknown result type (might be due to invalid IL or missing references)
		//IL_0110: Expected O, but got Unknown
		//IL_0116: Expected O, but got Unknown
		//IL_011c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0121: Unknown result type (might be due to invalid IL or missing references)
		//IL_0137: Unknown result type (might be due to invalid IL or missing references)
		//IL_013c: Unknown result type (might be due to invalid IL or missing references)
		SL_DropTable val = new SL_DropTable
		{
			UID = "gothiska.advtools",
			GuaranteedDrops = new List<SL_ItemDrop>
			{
				new SL_ItemDrop
				{
					DroppedItemID = -31010,
					MinQty = 1,
					MaxQty = 1
				},
				new SL_ItemDrop
				{
					DroppedItemID = -31011,
					MinQty = 1,
					MaxQty = 1
				},
				new SL_ItemDrop
				{
					DroppedItemID = -31016,
					MinQty = 1,
					MaxQty = 1
				}
			}
		};
		((ContentTemplate)val).ApplyTemplate();
		SL_DropTable val2 = new SL_DropTable
		{
			UID = "gothiska.exptools",
			GuaranteedDrops = new List<SL_ItemDrop>
			{
				new SL_ItemDrop
				{
					DroppedItemID = -31012,
					MinQty = 1,
					MaxQty = 1
				},
				new SL_ItemDrop
				{
					DroppedItemID = -31013,
					MinQty = 1,
					MaxQty = 1
				},
				new SL_ItemDrop
				{
					DroppedItemID = -31017,
					MinQty = 1,
					MaxQty = 1
				}
			}
		};
		((ContentTemplate)val2).ApplyTemplate();
		((ContentTemplate)new SL_DropTableAddition
		{
			DropTableUIDsToAdd = { val.UID }
		}).ApplyTemplate();
		((ContentTemplate)new SL_DropTableAddition
		{
			DropTableUIDsToAdd = { val2.UID }
		}).ApplyTemplate();
	}
}

The result has been truncated due to the large size, download it to view the full contents!

using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Threading;
using AlternateStart.Characters;
using AlternateStart.StartScenarios;
using BepInEx;
using HarmonyLib;
using NodeCanvas.DialogueTrees;
using NodeCanvas.Framework;
using NodeCanvas.Tasks.Actions;
using SideLoader;
using SideLoader.Managers;
using SideLoader.Model;
using UnityEngine;
using UnityEngine.SceneManagement;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("OutwardModTemplate")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("OutwardModTemplate")]
[assembly: AssemblyCopyright("Copyright ©  2021")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("c5450fe0-edcf-483f-b9ea-4b1ef9d36da7")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
namespace AlternateStart
{
	public enum ScenarioPassives
	{
		NONE = 0,
		Random = -2200,
		Vanilla = -2201,
		VanillaAlt = -2202,
		VanillaBerg = -2203,
		VanillaLevant = -2204,
		VanillaMonsoon = -2205,
		VanillaHarmattan = -2206,
		LevantSlums = -2207,
		EnmerkarHunter = -2208,
		PriestElatt = -2209,
		Claustrophobic = -2210,
		VendavelSlave = -2211,
		GiantRisen = -2212,
		ConfluxWatcher = -2213,
		Veteran = -2214,
		WolfgangMercenary = -2215,
		RobbedTrader = -2216,
		Survivor = -2217,
		CorruptedSoul = -2218,
		ChosenOne = -2219,
		Unbound = -2220,
		Cannibal = -2221,
		SandBandit = -2222,
		Nightmare = -2223
	}
	public enum ScenarioQuest
	{
		Quest_Test = -2300,
		Quest_Vanilla = -2301,
		Quest_VanillaAlt = -2302,
		Quest_VanillaBerg = -2303,
		Quest_VanillaLevant = -2304,
		Quest_VanillaMonsoon = -2305,
		Quest_VanillaHarmattan = -2306,
		Quest_LevantSlums = -2307,
		Quest_EmercarHunter = -2308,
		Quest_PriestElatt = -2309,
		Quest_Claustro = -2310,
		Quest_VendavelSlave = -2311,
		Quest_GiantRisen = -2312,
		Quest_ConfluxWatcher = -2313,
		Quest_Veteran = -2314,
		Quest_WolfgangMercenary = -2315,
		Quest_RobbedTrader = -2316,
		Quest_Survivor = -2317,
		Quest_CorruptedSoul = -2318,
		Quest_ChosenOne = -2319,
		Quest_Unbound = -2320,
		Quest_Cannibal = -2321,
		Quest_SandBandit = -2322
	}
	public enum ScenarioTheme
	{
		None,
		Magic,
		Stamina,
		Tanky,
		Freeform
	}
	public enum ScenarioType
	{
		WIPtest = 0,
		VanillaLike = -2207,
		Normal = -2208,
		Outlaw = -2209
	}
	internal static class QuestExtensions
	{
		internal static void UpdateLogEntry(this QuestProgress progress, QuestLogEntrySignature signature, bool displayTime)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			progress.UpdateLogEntry(signature.UID, displayTime, signature);
		}
	}
	public class ExtrasManager : MonoBehaviour
	{
		public static ExtrasManager Instance;

		private Vector3 spawn = new Vector3(1284.4f, -3.7f, 1622.2f);

		private Vector3 spawnRot = new Vector3(0f, 203f, 0f);

		public List<Character> allPlayers;

		internal void Awake()
		{
			Instance = this;
			allPlayers = new List<Character>();
		}
	}
	public static class GearManager
	{
		internal static void Init()
		{
		}

		public static void StartingGear()
		{
			foreach (PlayerSystem item in Global.Lobby.PlayersInLobby)
			{
				Character controlledCharacter = item.ControlledCharacter;
				CharacterSkillKnowledge skillKnowledge = controlledCharacter.Inventory.SkillKnowledge;
				foreach (Scenario value in ScenarioManager.startScenarios.Values)
				{
					if (((CharacterKnowledge)skillKnowledge).IsItemLearned((int)value.Passive))
					{
						Debug.Log((object)"adding scenario gear");
						value.Gear(controlledCharacter);
						break;
					}
				}
			}
		}

		public static void RandomPassive()
		{
		}
	}
	[BepInPlugin("com.iggy.altstart", "Alternate Start", "1.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class Plugin : BaseUnityPlugin
	{
		private const string GUID = "com.iggy.altstart";

		private const string NAME = "Alternate Start";

		private const string VERSION = "1.0";

		public static Plugin Instance;

		public const string SL_PACK_NAME = "iggythemad AlternateStart";

		public const string QUEST_EVENT_FAMILY_NAME = "A_Iggy_AlternateStart";

		internal void Awake()
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			Instance = this;
			((BaseUnityPlugin)this).Logger.LogMessage((object)"Alternate Start Awake()");
			((Component)this).gameObject.AddComponent<ExtrasManager>();
			ScenarioManager.Init();
			GearManager.Init();
			SL.OnPacksLoaded += SL_OnPacksLoaded;
			new Harmony("com.iggy.altstart").PatchAll();
		}

		internal void OnGUI()
		{
		}

		private void SL_OnPacksLoaded()
		{
			TrainerManager.Init();
		}

		internal static void Log(object log)
		{
			((BaseUnityPlugin)Instance).Logger.LogMessage((object)(log?.ToString() ?? string.Empty));
		}

		internal static void LogWarning(object log)
		{
			((BaseUnityPlugin)Instance).Logger.LogWarning((object)(log?.ToString() ?? string.Empty));
		}

		internal static void LogError(object log)
		{
			((BaseUnityPlugin)Instance).Logger.LogError((object)(log?.ToString() ?? string.Empty));
		}
	}
	public static class ScenarioManager
	{
		[HarmonyPatch(typeof(NetworkLevelLoader), "LoadLevel", new Type[]
		{
			typeof(int),
			typeof(int),
			typeof(float),
			typeof(bool)
		})]
		public class NetworkLevelLoader_LoadLevel
		{
			internal static void Prefix(ref int _buildIndex)
			{
				try
				{
					CharacterSave chosenSave = SplitScreenManager.Instance.LocalPlayers[0].ChosenSave;
					if (!((CharacterSaveData)chosenSave.PSave).NewSave && !string.IsNullOrEmpty(chosenSave.PSave.AreaName))
					{
						return;
					}
					for (int i = 0; i < SceneManager.sceneCountInBuildSettings; i++)
					{
						string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(SceneUtility.GetScenePathByBuildIndex(i));
						if (fileNameWithoutExtension != null && fileNameWithoutExtension == "DreamWorld")
						{
							_buildIndex = i;
							break;
						}
					}
				}
				catch
				{
				}
			}
		}

		[HarmonyPatch(typeof(CharacterSkillKnowledge), "AddItem", new Type[] { typeof(Item) })]
		private static class CharacterSkillKnowledge_AddItem
		{
			internal static void Postfix(Item _item)
			{
				//IL_0067: Unknown result type (might be due to invalid IL or missing references)
				if (!((Object)(object)((EffectSynchronizer)_item).OwnerCharacter == (Object)null) && ((EffectSynchronizer)_item).OwnerCharacter.IsLocalPlayer && !QuestEventManager.Instance.HasQuestEvent("iggythemad.altstart.destinyChosen") && _item.ItemID <= 0 && !(SceneManagerHelper.ActiveSceneName != "DreamWorld"))
				{
					((EffectSynchronizer)_item).OwnerCharacter.StatusEffectMngr.AddStatusEffect("StartTag");
					((EffectSynchronizer)_item).OwnerCharacter.AutoKnock(true, Vector3.back, ((EffectSynchronizer)_item).OwnerCharacter);
					if ((Object)(object)CharacterManager.Instance.GetWorldHostCharacter() == (Object)(object)((EffectSynchronizer)_item).OwnerCharacter)
					{
						((MonoBehaviour)Plugin.Instance).StartCoroutine(CheckStartPassives(((EffectSynchronizer)_item).OwnerCharacter, _item));
					}
				}
			}
		}

		[HarmonyPatch(typeof(InteractionTriggerBase), "TryActivateBasicAction", new Type[]
		{
			typeof(Character),
			typeof(int)
		})]
		public class InteractionTriggerBase_TryActivateBasicAction
		{
			[HarmonyPrefix]
			public static bool Prefix(InteractionTriggerBase __instance, Character _character, int _toggleState)
			{
				if (!_character.IsLocalPlayer || SceneManagerHelper.ActiveSceneName != "DreamWorld")
				{
					return true;
				}
				if (_character.StatusEffectMngr.HasStatusEffect("StartTag"))
				{
					return false;
				}
				return true;
			}
		}

		public static readonly Dictionary<ScenarioPassives, Scenario> startScenarios = new Dictionary<ScenarioPassives, Scenario>();

		internal static QuestEventSignature QE_DestinyChosen;

		private const string QE_DESTINY_CHOSEN_UID = "iggythemad.altstart.destinyChosen";

		private const string FULL_STOP_STATUS_IDENTIFIER = "fullstop";

		private const string startTag = "StartTag";

		internal static void Init()
		{
			QE_DestinyChosen = CustomQuests.CreateQuestEvent("iggythemad.altstart.destinyChosen", false, false, true, "A_Iggy_AlternateStart", "CustomEvent", "A custom event created with SideLoader");
			SL.OnGameplayResumedAfterLoading += SL_OnGameplayResumedAfterLoading;
			Type[] types = typeof(Scenario).Assembly.GetTypes();
			foreach (Type type in types)
			{
				if (type.IsSubclassOf(typeof(Scenario)))
				{
					Scenario scenario = Activator.CreateInstance(type) as Scenario;
					scenario.Init();
					startScenarios.Add(scenario.Passive, scenario);
				}
			}
		}

		private static void SL_OnGameplayResumedAfterLoading()
		{
			if (!(SceneManagerHelper.ActiveSceneName == "DreamWorld") || QuestEventManager.Instance.HasQuestEvent(QE_DestinyChosen))
			{
				return;
			}
			foreach (Item learnedItem in ((CharacterKnowledge)CharacterManager.Instance.GetWorldHostCharacter().Inventory.SkillKnowledge).m_learnedItems)
			{
				if (Enum.IsDefined(typeof(ScenarioPassives), learnedItem.ItemID))
				{
					Debug.Log((object)"HAS START SCENARIO");
					return;
				}
			}
			foreach (PlayerSystem item in Global.Lobby.PlayersInLobby)
			{
				item.ControlledCharacter.Inventory.RemoveMoney(27, true);
			}
			((MonoBehaviour)Plugin.Instance).StartCoroutine(DreamworldStopper());
		}

		private static IEnumerator DreamworldStopper()
		{
			yield return (object)new WaitForSeconds(0.2f);
			Vector3 spawn = new Vector3(-12.2f, 0.2f, -0.6f);
			Vector3 spawnRot = new Vector3(0f, 75.2f, 0f);
			while (SceneManagerHelper.ActiveSceneName == "DreamWorld")
			{
				foreach (PlayerSystem item in Global.Lobby.PlayersInLobby)
				{
					if (item.IsLocalPlayer && Vector3.Distance(((Component)item.ControlledCharacter).transform.position, spawn) > 3f)
					{
						item.ControlledCharacter.Teleport(spawn, spawnRot);
					}
				}
				yield return (object)new WaitForSeconds(0.5f);
			}
		}

		internal static void SetFullStop(bool add)
		{
			if (PhotonNetwork.isNonMasterClientInRoom)
			{
				return;
			}
			foreach (PlayerSystem item in Global.Lobby.PlayersInLobby)
			{
				if (add)
				{
					item.ControlledCharacter.StatusEffectMngr.AddStatusEffect("fullstop");
				}
				else
				{
					item.ControlledCharacter.StatusEffectMngr.RemoveStatusWithIdentifierName("fullstop");
				}
			}
		}

		private static IEnumerator CheckStartPassives(Character character, Item _item)
		{
			yield return (object)new WaitForSeconds(0.2f);
			List<Character> characterList = new List<Character>();
			while (true)
			{
				LobbySystem lobby = Global.Lobby;
				if (((lobby != null) ? lobby.PlayersInLobby : null) == null)
				{
					yield return null;
					continue;
				}
				break;
			}
			while (characterList.Count < Global.Lobby.PlayersInLobby.Count)
			{
				yield return (object)new WaitForSeconds(1f);
				foreach (PlayerSystem item in Global.Lobby.PlayersInLobby)
				{
					if (item.ControlledCharacter.StatusEffectMngr.HasStatusEffect("StartTag") && !characterList.Contains(item.ControlledCharacter))
					{
						characterList.Add(item.ControlledCharacter);
					}
				}
			}
			if (((CharacterKnowledge)character.Inventory.SkillKnowledge).IsItemLearned(-2200))
			{
				((MonoBehaviour)Plugin.Instance).StartCoroutine(PickAndStartScenario());
			}
			else if (IsAnyChosen<ScenarioPassives>(character))
			{
				ScenarioPassives itemID = (ScenarioPassives)_item.ItemID;
				((MonoBehaviour)Plugin.Instance).StartCoroutine(startScenarios[itemID].StartScenario());
			}
			foreach (PlayerSystem item2 in Global.Lobby.PlayersInLobby)
			{
				if (item2.ControlledCharacter.StatusEffectMngr.HasStatusEffect("StartTag"))
				{
					item2.ControlledCharacter.StatusEffectMngr.RemoveStatusWithIdentifierName("StartTag");
				}
			}
		}

		private static bool IsAnyChosen<T>(Character character) where T : Enum
		{
			T choice;
			return TryGetChoice<T>(character, out choice);
		}

		private static bool TryGetChoice<T>(Character character, out T choice) where T : Enum
		{
			foreach (object value in Enum.GetValues(typeof(T)))
			{
				if (((CharacterKnowledge)character.Inventory.SkillKnowledge).IsItemLearned((int)value))
				{
					choice = (T)value;
					return true;
				}
			}
			choice = default(T);
			return false;
		}

		private static IEnumerator PickAndStartScenario()
		{
			Character worldHostCharacter = CharacterManager.Instance.GetWorldHostCharacter();
			_ = worldHostCharacter.Inventory.SkillKnowledge;
			TryGetChoice<ScenarioPassives>(worldHostCharacter, out var choice);
			List<Scenario> list = new List<Scenario>();
			foreach (Scenario value in startScenarios.Values)
			{
				if (value.Difficulty != 0 && value.Difficulty != ScenarioType.Outlaw)
				{
					list.Add(value);
				}
			}
			if (!list.Any())
			{
				CharacterManager.Instance.GetWorldHostCharacter().CharacterUI.NotificationPanel.ShowNotification($"Sorry, there are no {choice} scenarios!");
				yield break;
			}
			Plugin.Log("Eligable scenarios: " + string.Join(",", list.Select((Scenario it) => it.GetType().Name)));
			Scenario scenario = list[Random.Range(0, list.Count)];
			Plugin.Log("Chosen scenario: " + scenario.GetType().Name);
			((MonoBehaviour)Plugin.Instance).StartCoroutine(scenario.StartScenario());
			foreach (PlayerSystem item in Global.Lobby.PlayersInLobby)
			{
				if (((CharacterKnowledge)item.ControlledCharacter.Inventory.SkillKnowledge).IsItemLearned(-2200))
				{
					if ((Object)(object)worldHostCharacter == (Object)(object)item.ControlledCharacter)
					{
						item.ControlledCharacter.Inventory.ReceiveSkillReward((int)scenario.Passive);
						continue;
					}
					Scenario scenario2 = list[Random.Range(0, list.Count)];
					item.ControlledCharacter.Inventory.ReceiveSkillReward((int)scenario2.Passive);
				}
			}
		}
	}
	public static class TrainerManager
	{
		internal static SL_Character bergSpellblade;

		private static SLPack pack;

		public static void Init()
		{
			pack = SL.GetSLPack("iggythemad AlternateStart");
			bergSpellblade = pack.CharacterTemplates["com.iggy.berg.spellblade.trainer"];
			bergSpellblade.OnSpawn += SpellbladeSetup;
			SL.OnGameplayResumedAfterLoading += spawnSpellblade;
		}

		private static void spawnSpellblade()
		{
			//IL_006a: 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)
			if (SceneManagerHelper.ActiveSceneName == "Berg" && CharacterManager.Instance.GetWorldHostCharacter().IsLocalPlayer && QuestEventManager.Instance.HasQuestEvent(QuestEventDictionary.GetQuestEvent("lDHL_XMS7kKEs0uOqrLQjw")))
			{
				Vector3 trainerPos = default(Vector3);
				((Vector3)(ref trainerPos))..ctor(1284.4f, -3.7f, 1622.2f);
				Vector3 trainerRot = default(Vector3);
				((Vector3)(ref trainerRot))..ctor(0f, 203f, 0f);
				SpawnCharacter("com.iggy.berg.spellblade.trainer", trainerPos, trainerRot);
			}
		}

		public static Character SpawnCharacter(string trainerID, Vector3 trainerPos, Vector3 trainerRot)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			return pack.CharacterTemplates[trainerID].Spawn(trainerPos, trainerRot, UID.op_Implicit(UID.Generate()), (string)null);
		}

		public static void SpellbladeSetup(Character trainer, string _)
		{
			GenericTrainerSetup(trainer, bergSpellblade, "com.iggy.bergspellblade", "You are alive! It's good to see a familiar face.", "What can you teach me?", "What happened to Cierzo?", "What should I do now?", "The Vendavel Scum. We were not prepared for an attack. I tried to fight back, but it was too late.", "Move on. Join a faction. Rissa is here, but you are free to do as you like.");
		}

		public static void GenericTrainerSetup(Character trainer, SL_Character currentCharacter, string treeUID, string introDialogue, string ask1, string ask2, string ask3, string reply2, string reply3)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Expected O, but got Unknown
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: 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_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Expected O, but got Unknown
			//IL_00b9: Expected O, but got Unknown
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Expected O, but got Unknown
			//IL_00dc: Expected O, but got Unknown
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Expected O, but got Unknown
			//IL_00ff: Expected O, but got Unknown
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Expected O, but got Unknown
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Expected O, but got Unknown
			Object.DestroyImmediate((Object)(object)((Component)trainer).GetComponent<CharacterStats>());
			Object.DestroyImmediate((Object)(object)((Component)trainer).GetComponent<StartingEquipment>());
			DialogueActor componentInChildren = ((Component)trainer).GetComponentInChildren<DialogueActor>();
			componentInChildren.SetName(currentCharacter.Name);
			Trainer componentInChildren2 = ((Component)trainer).GetComponentInChildren<Trainer>();
			componentInChildren2.m_skillTreeUID = new UID(treeUID);
			Graph graph = ((GraphOwner)((Component)trainer).GetComponentInChildren<DialogueTreeController>()).graph;
			List<ActorParameter> actorParameters = ((DialogueTree)((graph is DialogueTree) ? graph : null))._actorParameters;
			actorParameters[0].actor = (IDialogueActor)(object)componentInChildren;
			actorParameters[0].name = componentInChildren.name;
			StatementNodeExt val = graph.AddNode<StatementNodeExt>();
			val.statement = new Statement(introDialogue);
			val.SetActorName(componentInChildren.name);
			MultipleChoiceNodeExt val2 = graph.AddNode<MultipleChoiceNodeExt>();
			val2.availableChoices.Add(new Choice
			{
				statement = new Statement
				{
					text = ask1
				}
			});
			val2.availableChoices.Add(new Choice
			{
				statement = new Statement
				{
					text = ask2
				}
			});
			val2.availableChoices.Add(new Choice
			{
				statement = new Statement
				{
					text = ask3
				}
			});
			Node obj = graph.allNodes[1];
			ActionNode val3 = (ActionNode)(object)((obj is ActionNode) ? obj : null);
			ActionTask action = val3.action;
			((TrainDialogueAction)((action is TrainDialogueAction) ? action : null)).Trainer = new BBParameter<Trainer>(componentInChildren2);
			StatementNodeExt val4 = graph.AddNode<StatementNodeExt>();
			val4.statement = new Statement(reply2);
			val4.SetActorName(componentInChildren.name);
			StatementNodeExt val5 = graph.AddNode<StatementNodeExt>();
			val5.statement = new Statement(reply3);
			val5.SetActorName(componentInChildren.name);
			graph.allNodes.Clear();
			graph.allNodes.Add((Node)(object)val);
			graph.allNodes.Add((Node)(object)val2);
			graph.allNodes.Add((Node)(object)val3);
			graph.allNodes.Add((Node)(object)val4);
			graph.allNodes.Add((Node)(object)val5);
			graph.primeNode = (Node)(object)val;
			graph.ConnectNodes((Node)(object)val, (Node)(object)val2, -1, -1);
			graph.ConnectNodes((Node)(object)val2, (Node)(object)val3, 0, -1);
			graph.ConnectNodes((Node)(object)val2, (Node)(object)val4, 1, -1);
			graph.ConnectNodes((Node)(object)val4, (Node)(object)val, -1, -1);
			graph.ConnectNodes((Node)(object)val2, (Node)(object)val5, 2, -1);
			graph.ConnectNodes((Node)(object)val5, (Node)(object)val, -1, -1);
			((Component)trainer).gameObject.SetActive(true);
		}
	}
	public static class VanillaQuestsHelper
	{
		public const int lookingToTheFutureQ = 7011002;

		public const int callToAdventureQ = 7011001;

		public const int enrollmentQ = 7011400;

		public const string playerInCierzo = "sm812Cio9ki5ssbsiPr3Fw";

		public const string tutorialIntroFinished = "HteYicnCK0atCgd4j5TV1Q";

		public const string introPlayerHouse = "z23QoIdtkU6cUPoUOfDn6w";

		public const string grandmother = "YQD53MKgwke6juWiSWI7jQ";

		public const string rissaBegExtension = "nt9KhXoJtkOalZ-wtfueDA";

		public const string rissaTalk = "n_3w-BcFfEW52Ht4Q3ZCjw";

		public const string debtPAID = "8GvHUbDz90OOJWurd-RZlg";

		public const string callToAdventureENDa = "g3EX5w1mwUaYW1o0cpj0SQ";

		public const string notLighthouseOwner = "-Ku9dHjTl0KeUPxWk0ZWWQ";

		public const string lostLightHouse = "qPEx275DTUSPbnv-PnFn7w";

		public const string debtNOTpaid = "sAc2Dj-T_kysKXFV48Hp0A";

		public const string callToAdventureENDb = "8iAJYhhqj02ODuwZ9VvXMw";

		public const string bergHouse = "g403vlCU6EG0s1mI6t_rFA";

		public const string harmattanHouse = "0r087PIxTUqoj6N7z2HFNw";

		public const string levantHouse = "LpVUuoxfhkaWOgh6XLbarA";

		public const string monsoonHouse = "shhCMFa-lUqbIYS9hRcsdg";

		public const int vendavelQ = 7011004;

		public const string cierzoDestroy = "lDHL_XMS7kKEs0uOqrLQjw";

		public const string cierzoWarning = "-vFSY-MNoUuLH1XXBkcqvQ";

		public const string cierzoTimer = "bm3rB3abI0KFok2x5P0lrg";

		public const string cierzoFail = "WvGjemEntk6quLjy4rLrJQ";

		public const string factionCommit = "bjVloYMQxk6KXx0gph2A1Q";

		public const string directionRISA = "seEIFfM9SkeZxc4CpR40oQ";

		public const string directionOLIELE = "Bo4-Xvq4_kudPDnOgkI3VA";

		public const string directionYSAN = "gAJAjuzl7ESFpMooq1oOCg";

		public const string olieleMonsoon = "3_soGcNagk-KcYSeqpEgMg";

		public const string yzanLevant = "BgpOoGQF10O7IQyiB9HODw";

		public const string rissaBerg = "1a6Zs9A_gEmScBetAraQaw";

		public const string readyToChoose = "jNfNsLGBpk2iMRts9kkerw";

		public const string BCproposition = "fo2uI7yiw0WSRE7MsbYFyw";

		public const string HKproposition = "JlFMC_51RUalSa8yLkhTmg";

		public const string HMproposition = "JqL0_JD55US2gL0-GbOBow";

		public const string argensonMet = "QMe_j2TIWEKpssXkLHMMZA";

		public const string argensonStash = "h8jI-dDsfkStb3XkCjqMPw";

		public const string YzanFriendship = "nr9KDCbQzUae1Gwf-6yOIQ";

		public const string callAdventureExpired = "zoKR1_bqiUiAetJ3uxw-Ug";

		public const string callAdventureCompleted = "ZYzrMi1skUiJ4BgXXQ3sfw";

		public const string ashAllyFail = "nDy01eTHlUa_BPDlbIhZPQ";

		public const string ashCompleteFail = "f1JVZyhg2UiBA8xmC-w6Hw";

		public const string ashFight = "XqlcpbTJC0aTDZfjD4xCTg";

		public const string ashWarp = "oGkuUgWvfkej_El-rhz2gw";

		internal static void SkipHostToFactionChoice(bool keepHouse, bool complete)
		{
			Character worldHostCharacter = CharacterManager.Instance.GetWorldHostCharacter();
			worldHostCharacter.Inventory.QuestKnowledge.ReceiveQuest(7011001);
			worldHostCharacter.Inventory.QuestKnowledge.ReceiveQuest(7011002);
			((MonoBehaviour)Plugin.Instance).StartCoroutine(AddPrefactionEvents(keepHouse, complete));
		}

		internal static void DestroyCierzo(bool instant, bool receiveQ)
		{
			Character worldHostCharacter = CharacterManager.Instance.GetWorldHostCharacter();
			AddQuestEvent("-vFSY-MNoUuLH1XXBkcqvQ");
			AddQuestEvent("bm3rB3abI0KFok2x5P0lrg");
			if (receiveQ)
			{
				worldHostCharacter.Inventory.QuestKnowledge.ReceiveQuest(7011004);
			}
			if (instant)
			{
				AddQuestEvent("lDHL_XMS7kKEs0uOqrLQjw");
				AddQuestEvent("WvGjemEntk6quLjy4rLrJQ");
			}
		}

		internal static void AddQuestEvent(string questUID)
		{
			QuestEventManager.Instance.AddEvent(QuestEventDictionary.GetQuestEvent(questUID), 1);
		}

		internal static void RemoveEvent(string questUID)
		{
			QuestEventManager.Instance.RemoveEvent(questUID, true);
		}

		internal static IEnumerator AddPrefactionEvents(bool keepHouse, bool complete)
		{
			Character host = CharacterManager.Instance.GetWorldHostCharacter();
			yield return (object)new WaitForSeconds(0.1f);
			AddQuestEvent("sm812Cio9ki5ssbsiPr3Fw");
			AddQuestEvent("HteYicnCK0atCgd4j5TV1Q");
			AddQuestEvent("z23QoIdtkU6cUPoUOfDn6w");
			AddQuestEvent("nt9KhXoJtkOalZ-wtfueDA");
			AddQuestEvent("YQD53MKgwke6juWiSWI7jQ");
			AddQuestEvent("n_3w-BcFfEW52Ht4Q3ZCjw");
			if (keepHouse)
			{
				AddQuestEvent("8GvHUbDz90OOJWurd-RZlg");
				AddQuestEvent("g3EX5w1mwUaYW1o0cpj0SQ");
			}
			else
			{
				AddQuestEvent("-Ku9dHjTl0KeUPxWk0ZWWQ");
				AddQuestEvent("qPEx275DTUSPbnv-PnFn7w");
				AddQuestEvent("sAc2Dj-T_kysKXFV48Hp0A");
				AddQuestEvent("8iAJYhhqj02ODuwZ9VvXMw");
			}
			AddQuestEvent("seEIFfM9SkeZxc4CpR40oQ");
			AddQuestEvent("jNfNsLGBpk2iMRts9kkerw");
			AddQuestEvent("3_soGcNagk-KcYSeqpEgMg");
			AddQuestEvent("Bo4-Xvq4_kudPDnOgkI3VA");
			AddQuestEvent("JqL0_JD55US2gL0-GbOBow");
			AddQuestEvent("JlFMC_51RUalSa8yLkhTmg");
			AddQuestEvent("BgpOoGQF10O7IQyiB9HODw");
			AddQuestEvent("gAJAjuzl7ESFpMooq1oOCg");
			AddQuestEvent("QMe_j2TIWEKpssXkLHMMZA");
			AddQuestEvent("h8jI-dDsfkStb3XkCjqMPw");
			AddQuestEvent("nr9KDCbQzUae1Gwf-6yOIQ");
			AddQuestEvent("zoKR1_bqiUiAetJ3uxw-Ug");
			AddQuestEvent("ZYzrMi1skUiJ4BgXXQ3sfw");
			if (complete)
			{
				AddQuestEvent("fo2uI7yiw0WSRE7MsbYFyw");
				AddQuestEvent("1a6Zs9A_gEmScBetAraQaw");
				host.Inventory.QuestKnowledge.ReceiveQuest(7011400);
			}
		}

		internal static void StartHouseTimer()
		{
			CharacterManager.Instance.GetWorldHostCharacter().Inventory.QuestKnowledge.ReceiveQuest(7011001);
			((MonoBehaviour)Plugin.Instance).StartCoroutine(AddHouseTimerEvents());
		}

		private static IEnumerator AddHouseTimerEvents()
		{
			yield return (object)new WaitForSeconds(0.5f);
			AddQuestEvent("sm812Cio9ki5ssbsiPr3Fw");
			AddQuestEvent("HteYicnCK0atCgd4j5TV1Q");
			AddQuestEvent("z23QoIdtkU6cUPoUOfDn6w");
			AddQuestEvent("n_3w-BcFfEW52Ht4Q3ZCjw");
			AddQuestEvent("zoKR1_bqiUiAetJ3uxw-Ug");
		}
	}
}
namespace AlternateStart.StartScenarios
{
	public class ChosenOneScenario : Scenario
	{
		[HarmonyPatch(typeof(PlayerCharacterStats), "get_RemainingBreakthrough")]
		private class PlayerCharacterStats_RemainingBreakthrough
		{
			public static bool Prefix(ref int __result, PlayerCharacterStats __instance)
			{
				if (((CharacterStats)__instance).m_character.IsLocalPlayer && ((CharacterKnowledge)((CharacterStats)__instance).m_character.Inventory.SkillKnowledge).IsItemLearned(-2219))
				{
					__result = Mathf.Clamp(maxBreakthroughs - __instance.m_usedBreakthroughCount, 0, 20);
					return false;
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(SkillUnlockRequirementDisplay), "RefreshDisplay", new Type[] { typeof(SkillTreeSlotDisplay) })]
		public class SkillUnlockRequirementDisplay_RefreshDisplay
		{
			[HarmonyPostfix]
			public static void Postfix(SkillUnlockRequirementDisplay __instance, SkillTreeSlotDisplay _display)
			{
				if (!((Object)(object)_display == (Object)null) && ((UIElement)_display).LocalCharacter.IsLocalPlayer && ((CharacterKnowledge)((UIElement)_display).LocalCharacter.Inventory.SkillKnowledge).IsItemLearned(-2219))
				{
					if (!StoredCosts.Keys.Contains(((Item)_display.FocusedSkillSlot.Skill).ItemID))
					{
						StoredCosts.Add(((Item)_display.FocusedSkillSlot.Skill).ItemID, _display.FocusedSkillSlot.RequiredMoney);
					}
					StoredCosts.TryGetValue(((Item)_display.FocusedSkillSlot.Skill).ItemID, out var value);
					value = (int)Math.Round((float)value * 1.25f);
					_display.FocusedSkillSlot.m_requiredMoney = value;
				}
			}
		}

		private const string LogSignature_A = "chosen.objective.a";

		private const string LogSignature_B = "chosen.objective.b";

		private const string LogSignature_C = "chosen.objective.c";

		private QuestEventSignature QE_FixedLimitlessStart;

		private static int maxBreakthroughs = 4;

		public static Dictionary<int, int> StoredCosts = new Dictionary<int, int>();

		public override ScenarioQuest Type => ScenarioQuest.Quest_ChosenOne;

		public override ScenarioType Difficulty => ScenarioType.Normal;

		public override ScenarioPassives Passive => ScenarioPassives.ChosenOne;

		public override AreaEnum SpawnScene => (AreaEnum)101;

		public override Vector3 SpawnPosition => new Vector3(865.8f, 212.7f, 880.1f);

		public override Vector3 SpawnRotation => new Vector3(0f, 225.7f, 0f);

		public override bool HasQuest => true;

		public override string QuestName => "Angelic Descend";

		public override Dictionary<string, string> QuestLogSignatures => new Dictionary<string, string>
		{
			{ "chosen.objective.a", "Visit any city. Learn about the factions and their conflicts. Save Aurai." },
			{ "chosen.objective.b", "You've learned about the factions." },
			{ "chosen.objective.c", "You are ready to join a faction." }
		};

		public override void Gear(Character character)
		{
			character.Inventory.ReceiveItemReward(4100550, 5, false);
			character.Inventory.ReceiveItemReward(3000009, 1, true);
			character.Inventory.ReceiveItemReward(3000002, 1, true);
			character.Inventory.ReceiveItemReward(2010050, 1, false);
			character.Inventory.ReceiveItemReward(5100500, 1, true);
			character.Inventory.ReceiveItemReward(5300040, 1, true);
		}

		public override void Init()
		{
			base.Init();
			QE_FixedLimitlessStart = CustomQuests.CreateQuestEvent("iggythemad.chosenone.fixedstart", false, true, true, "A_Iggy_AlternateStart", "CustomEvent", "A custom event created with SideLoader");
			SL.OnGameplayResumedAfterLoading += SL_OnGameplayResumedAfterLoading;
		}

		private void SL_OnGameplayResumedAfterLoading()
		{
			if (!PhotonNetwork.isNonMasterClientInRoom && base.IsActiveScenario)
			{
				Character worldHostCharacter = CharacterManager.Instance.GetWorldHostCharacter();
				if (((CharacterKnowledge)worldHostCharacter.Inventory.QuestKnowledge).IsItemLearned((int)Type))
				{
					Item itemFromItemID = ((CharacterKnowledge)worldHostCharacter.Inventory.QuestKnowledge).GetItemFromItemID((int)Type);
					Quest quest = (Quest)(object)((itemFromItemID is Quest) ? itemFromItemID : null);
					UpdateQuestProgress(quest);
				}
			}
		}

		public override void UpdateQuestProgress(Quest quest)
		{
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			if (!PhotonNetwork.isNonMasterClientInRoom && base.IsActiveScenario)
			{
				CharacterManager.Instance.GetWorldHostCharacter();
				int eventCurrentStack = QuestEventManager.Instance.GetEventCurrentStack(QE_FixedLimitlessStart.EventUID);
				QuestProgress questProgress = quest.m_questProgress;
				if (eventCurrentStack < 1)
				{
					QuestEventManager.Instance.AddEvent(QE_FixedLimitlessStart, 1);
					eventCurrentStack = QuestEventManager.Instance.GetEventCurrentStack(QE_FixedLimitlessStart.EventUID);
					questProgress.UpdateLogEntry(questProgress.GetLogSignature(UID.op_Implicit("chosen.objective.a")), displayTime: true);
					ShowUIMessage("The world needs me. I should find about the troubles of Aurai...");
				}
				else if (eventCurrentStack < 2 && AreaManager.Instance.GetIsCurrentAreaTownOrCity())
				{
					QuestEventManager.Instance.AddEvent(QE_FixedLimitlessStart, 2);
					questProgress.UpdateLogEntry(questProgress.GetLogSignature(UID.op_Implicit("chosen.objective.b")), displayTime: true);
					questProgress.UpdateLogEntry(questProgress.GetLogSignature(UID.op_Implicit("chosen.objective.c")), displayTime: true);
					questProgress.DisableQuest((ProgressState)3);
					VanillaQuestsHelper.SkipHostToFactionChoice(keepHouse: false, complete: true);
					ShowUIMessage("Time to learn about the people of Aurai. I will join them!");
				}
			}
		}

		public override void OnScenarioChosen()
		{
		}

		public override void OnScenarioChosen(Character character)
		{
		}

		public override void OnStartSpawn()
		{
			GetOrGiveQuestToHost();
		}

		public override void OnStartSpawn(Character character)
		{
			character.SpellCastAnim((SpellCastType)41, (SpellCastModifier)0, 0);
		}
	}
	public class ClaustroScenario : Scenario
	{
		[HarmonyPatch(typeof(CharacterInventory), "EquipItem", new Type[]
		{
			typeof(Equipment),
			typeof(bool)
		})]
		public class CharacterInventory_EquipItem
		{
			[HarmonyPrefix]
			public static void Postfix(CharacterInventory __instance, Equipment _itemToEquip, bool _playAnim, ref Character ___m_character)
			{
				Character val = ___m_character;
				if (!((Object)(object)___m_character == (Object)null) && ___m_character.IsLocalPlayer && ((CharacterKnowledge)val.Inventory.SkillKnowledge).IsItemLearned(-2210))
				{
					((MonoBehaviour)Plugin.Instance).StartCoroutine(Instance.checkHelmet(val));
				}
			}
		}

		[HarmonyPatch(typeof(CharacterInventory), "TakeItem", new Type[]
		{
			typeof(Item),
			typeof(bool)
		})]
		public class CharacterInventory_TakeItem
		{
			[HarmonyPrefix]
			public static void Prefix(CharacterInventory __instance, Item takenItem, ref bool _tryToEquip, ref Character ___m_character)
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				Character val = ___m_character;
				if (!((Object)(object)val == (Object)null) && val.IsLocalPlayer)
				{
					Equipment val2 = (Equipment)(object)((!(takenItem is Equipment)) ? null : ((takenItem is Equipment) ? takenItem : null));
					if (((CharacterKnowledge)val.Inventory.SkillKnowledge).IsItemLearned(-2210) && val2 != null && (int)val2.EquipSlot == 0)
					{
						_tryToEquip = false;
					}
				}
			}
		}

		[HarmonyPatch(typeof(CharacterInventory), "UnequipItem", new Type[]
		{
			typeof(Equipment),
			typeof(bool)
		})]
		public class CharacterInventory_UnequipItem
		{
			[HarmonyPrefix]
			public static void Postfix(CharacterInventory __instance, Equipment _itemToUnequip, bool _playAnim, ref Character ___m_character)
			{
				Character val = ___m_character;
				if (!((Object)(object)___m_character == (Object)null) && ___m_character.IsLocalPlayer && ((CharacterKnowledge)val.Inventory.SkillKnowledge).IsItemLearned(-2210))
				{
					((MonoBehaviour)Plugin.Instance).StartCoroutine(Instance.checkHelmet(val));
				}
			}
		}

		[HarmonyPatch(typeof(CharacterKnowledge), "AddItem")]
		public class CharacterKnowledge_AddItem
		{
			[HarmonyPrefix]
			public static void Prefix(CharacterKnowledge __instance, Item _item, ref Character ___m_character)
			{
				Character val = ___m_character;
				if (!((Object)(object)val == (Object)null) && val.IsLocalPlayer && ((CharacterKnowledge)val.Inventory.SkillKnowledge).IsItemLearned(-2210))
				{
					((MonoBehaviour)Plugin.Instance).StartCoroutine(Instance.checkHelmet(val));
				}
			}
		}

		private const string LogSignature_A = "claustro.objective.a";

		private const string LogSignature_B = "claustro.objective.b";

		private const string LogSignature_C = "claustro.objective.c";

		private QuestEventSignature QE_FixedClaustroStart;

		private string claustroEffectID = "claustroEffect";

		public override ScenarioQuest Type => ScenarioQuest.Quest_Claustro;

		public override ScenarioType Difficulty => ScenarioType.Normal;

		public override ScenarioPassives Passive => ScenarioPassives.Claustrophobic;

		public override AreaEnum SpawnScene => (AreaEnum)550;

		public override Vector3 SpawnPosition => new Vector3(1499.7f, -8.9f, 54.7f);

		public override Vector3 SpawnRotation => new Vector3(0f, 99.8f, 0f);

		public override bool HasQuest => true;

		public override string QuestName => "Kidnap Miracle";

		public override Dictionary<string, string> QuestLogSignatures => new Dictionary<string, string>
		{
			{ "claustro.objective.a", "Escape before your kidnappers return." },
			{ "claustro.objective.b", "Reach somewhere safe. A city perhaps." },
			{ "claustro.objective.c", "You are ready to join a faction." }
		};

		internal static ClaustroScenario Instance { get; private set; }

		public override void Gear(Character character)
		{
			character.Stats.FullStamina();
			character.Inventory.ReceiveItemReward(3000081, 1, true);
			character.Inventory.ReceiveItemReward(3000083, 1, true);
			character.Inventory.ReceiveItemReward(3000086, 1, true);
		}

		public override void Init()
		{
			base.Init();
			QE_FixedClaustroStart = CustomQuests.CreateQuestEvent("iggythemad.claustro.fixedstart", false, true, true, "A_Iggy_AlternateStart", "CustomEvent", "A custom event created with SideLoader");
			SL.OnGameplayResumedAfterLoading += SL_OnGameplayResumedAfterLoading;
		}

		private void SL_OnGameplayResumedAfterLoading()
		{
			if (!PhotonNetwork.isNonMasterClientInRoom && base.IsActiveScenario)
			{
				Character worldHostCharacter = CharacterManager.Instance.GetWorldHostCharacter();
				if (((CharacterKnowledge)worldHostCharacter.Inventory.QuestKnowledge).IsItemLearned((int)Type))
				{
					Item itemFromItemID = ((CharacterKnowledge)worldHostCharacter.Inventory.QuestKnowledge).GetItemFromItemID((int)Type);
					Quest quest = (Quest)(object)((itemFromItemID is Quest) ? itemFromItemID : null);
					UpdateQuestProgress(quest);
				}
			}
		}

		public override void UpdateQuestProgress(Quest quest)
		{
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			if (PhotonNetwork.isNonMasterClientInRoom || !base.IsActiveScenario)
			{
				return;
			}
			int num = 3;
			int eventCurrentStack = QuestEventManager.Instance.GetEventCurrentStack(QE_FixedClaustroStart.EventUID);
			QuestProgress questProgress = quest.m_questProgress;
			if (eventCurrentStack >= num)
			{
				questProgress.DisableQuest((ProgressState)3);
				return;
			}
			if (eventCurrentStack < 1)
			{
				QuestEventManager.Instance.AddEvent(QE_FixedClaustroStart, 1);
				eventCurrentStack = QuestEventManager.Instance.GetEventCurrentStack(QE_FixedClaustroStart.EventUID);
				questProgress.UpdateLogEntry(questProgress.GetLogSignature(UID.op_Implicit("claustro.objective.a")), displayTime: true);
				ShowUIMessage("Something happened... this is my chance to escape.");
			}
			else if (eventCurrentStack < 2)
			{
				QuestEventManager.Instance.AddEvent(QE_FixedClaustroStart, 1);
				questProgress.UpdateLogEntry(questProgress.GetLogSignature(UID.op_Implicit("claustro.objective.b")), displayTime: false);
				ShowUIMessage("I should go somewhere safe...");
			}
			if (eventCurrentStack < 3 && AreaManager.Instance.GetIsCurrentAreaTownOrCity())
			{
				QuestEventManager.Instance.AddEvent(QE_FixedClaustroStart, 2);
				questProgress.UpdateLogEntry(questProgress.GetLogSignature(UID.op_Implicit("claustro.objective.b")), displayTime: true);
				questProgress.UpdateLogEntry(questProgress.GetLogSignature(UID.op_Implicit("claustro.objective.c")), displayTime: true);
				questProgress.DisableQuest((ProgressState)3);
				VanillaQuestsHelper.SkipHostToFactionChoice(keepHouse: false, complete: true);
				ShowUIMessage("It would be safer to join a faction...");
			}
			ReloadLogs(eventCurrentStack, questProgress);
		}

		public void ReloadLogs(int stack, QuestProgress progress)
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			foreach (KeyValuePair<string, string> questLogSignature in QuestLogSignatures)
			{
				if (num < stack && questLogSignature.Key != null)
				{
					Debug.Log((object)("log: " + questLogSignature.Key));
					progress.UpdateLogEntry(progress.GetLogSignature(UID.op_Implicit(questLogSignature.Key)), displayTime: false);
					num++;
				}
			}
		}

		public override void OnScenarioChosen(Character character)
		{
		}

		public override void OnStartSpawn()
		{
			GetOrGiveQuestToHost();
		}

		public override void OnStartSpawn(Character character)
		{
		}

		public ClaustroScenario()
		{
			Instance = this;
		}

		private IEnumerator checkHelmet(Character player)
		{
			player.StatusEffectMngr.RemoveStatusWithIdentifierName(claustroEffectID);
			yield return (object)new WaitForSeconds(0.5f);
			player.StatusEffectMngr.AddStatusEffect(claustroEffectID);
		}
	}
	public class ConfluxWatcherScenario : Scenario
	{
		private const string LogSignature_A = "watcher.objective.a";

		private const string LogSignature_B = "watcher.objective.b";

		private const string LogSignature_C = "watcher.objective.c";

		private QuestEventSignature QE_FixedWatcherStart;

		public override ScenarioQuest Type => ScenarioQuest.Quest_ConfluxWatcher;

		public override ScenarioType Difficulty => ScenarioType.Normal;

		public override ScenarioPassives Passive => ScenarioPassives.ConfluxWatcher;

		public override AreaEnum SpawnScene => (AreaEnum)106;

		public override Vector3 SpawnPosition => new Vector3(-435.2f, -19.1f, -96.5f);

		public override Vector3 SpawnRotation => new Vector3(0f, 172.4f, 0f);

		public override bool HasQuest => true;

		public override string QuestName => "Thy watch has ended";

		public override Dictionary<string, string> QuestLogSignatures => new Dictionary<string, string>
		{
			{ "watcher.objective.a", "Get out into the world." },
			{ "watcher.objective.b", "Visit the nearby village of Cierzo." },
			{ "watcher.objective.c", "You are again part of the world." }
		};

		public override void Gear(Character character)
		{
			character.Inventory.ReceiveSkillReward(8200040);
			character.Inventory.ReceiveSkillReward(8100220);
			character.Inventory.ReceiveSkillReward(8100230);
			character.Stats.SetManaPoint(3);
			character.Inventory.ReceiveItemReward(3000134, 1, true);
			character.Inventory.ReceiveItemReward(3000131, 1, true);
			character.Inventory.ReceiveItemReward(3000136, 1, true);
			character.Inventory.ReceiveItemReward(5100500, 1, true);
		}

		public override void Init()
		{
			base.Init();
			QE_FixedWatcherStart = CustomQuests.CreateQuestEvent("iggythemad.watcher.fixedstart", false, true, true, "A_Iggy_AlternateStart", "CustomEvent", "A custom event created with SideLoader");
			SL.OnGameplayResumedAfterLoading += SL_OnGameplayResumedAfterLoading;
		}

		private void SL_OnGameplayResumedAfterLoading()
		{
			if (!PhotonNetwork.isNonMasterClientInRoom && base.IsActiveScenario)
			{
				Character worldHostCharacter = CharacterManager.Instance.GetWorldHostCharacter();
				if (((CharacterKnowledge)worldHostCharacter.Inventory.QuestKnowledge).IsItemLearned((int)Type))
				{
					Item itemFromItemID = ((CharacterKnowledge)worldHostCharacter.Inventory.QuestKnowledge).GetItemFromItemID((int)Type);
					Quest quest = (Quest)(object)((itemFromItemID is Quest) ? itemFromItemID : null);
					UpdateQuestProgress(quest);
				}
			}
		}

		public override void UpdateQuestProgress(Quest quest)
		{
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			if (PhotonNetwork.isNonMasterClientInRoom || !base.IsActiveScenario)
			{
				return;
			}
			int num = 3;
			int eventCurrentStack = QuestEventManager.Instance.GetEventCurrentStack(QE_FixedWatcherStart.EventUID);
			QuestProgress questProgress = quest.m_questProgress;
			if (eventCurrentStack >= num)
			{
				questProgress.DisableQuest((ProgressState)3);
				return;
			}
			if (eventCurrentStack < 1)
			{
				QuestEventManager.Instance.AddEvent(QE_FixedWatcherStart, 1);
				eventCurrentStack = QuestEventManager.Instance.GetEventCurrentStack(QE_FixedWatcherStart.EventUID);
				questProgress.UpdateLogEntry(questProgress.GetLogSignature(UID.op_Implicit("watcher.objective.a")), displayTime: true);
				ShowUIMessage("My watch is over. The world might need me.");
			}
			else if (eventCurrentStack < 2 && SceneManagerHelper.ActiveSceneName == "ChersoneseNewTerrain")
			{
				QuestEventManager.Instance.AddEvent(QE_FixedWatcherStart, 1);
				questProgress.UpdateLogEntry(questProgress.GetLogSignature(UID.op_Implicit("watcher.objective.b")), displayTime: false);
				ShowUIMessage("There used to be a village nearby...Cierzo, is it?");
			}
			if (eventCurrentStack < 3 && SceneManagerHelper.ActiveSceneName == "CierzoNewTerrain")
			{
				QuestEventManager.Instance.AddEvent(QE_FixedWatcherStart, 2);
				questProgress.UpdateLogEntry(questProgress.GetLogSignature(UID.op_Implicit("watcher.objective.b")), displayTime: true);
				questProgress.UpdateLogEntry(questProgress.GetLogSignature(UID.op_Implicit("watcher.objective.c")), displayTime: true);
				questProgress.DisableQuest((ProgressState)3);
				VanillaQuestsHelper.SkipHostToFactionChoice(keepHouse: false, complete: false);
				ShowUIMessage("I should ask around...");
			}
			ReloadLogs(eventCurrentStack, questProgress);
		}

		public void ReloadLogs(int stack, QuestProgress progress)
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			foreach (KeyValuePair<string, string> questLogSignature in QuestLogSignatures)
			{
				if (num < stack && questLogSignature.Key != null)
				{
					Debug.Log((object)("log: " + questLogSignature.Key));
					progress.UpdateLogEntry(progress.GetLogSignature(UID.op_Implicit(questLogSignature.Key)), displayTime: false);
					num++;
				}
			}
		}

		public override void OnScenarioChosen()
		{
		}

		public override void OnStartSpawn()
		{
			GetOrGiveQuestToHost();
		}

		public override void OnStartSpawn(Character character)
		{
		}

		public override void OnScenarioChosen(Character character)
		{
		}
	}
	public class CorruptedScenario : Scenario
	{
		private const string LogSignature_A = "corrupted.objective.a";

		private const string LogSignature_B = "corrupted.objective.b";

		private const string LogSignature_C = "corrupted.objective.c";

		private QuestEventSignature QE_FixedCorruptedStart;

		public override ScenarioQuest Type => ScenarioQuest.Quest_CorruptedSoul;

		public override ScenarioType Difficulty => ScenarioType.Normal;

		public override ScenarioPassives Passive => ScenarioPassives.CorruptedSoul;

		public override AreaEnum SpawnScene => (AreaEnum)108;

		public override Vector3 SpawnPosition => new Vector3(-37.3f, -7f, -126.4f);

		public override Vector3 SpawnRotation => new Vector3(0f, 222.9f, 0f);

		public override bool HasQuest => true;

		public override string QuestName => "Corruption Reborn";

		public override Dictionary<string, string> QuestLogSignatures => new Dictionary<string, string>
		{
			{ "corrupted.objective.a", "Whatever happend to you. Find a way out. " },
			{ "corrupted.objective.b", "Head to a nearby settlement" },
			{ "corrupted.objective.c", "You are ready to join a faction." }
		};

		internal static CorruptedScenario Instance { get; private set; }

		public override void Gear(Character character)
		{
			character.Inventory.ReceiveItemReward(3000044, 1, true);
			character.Inventory.ReceiveItemReward(3000046, 1, true);
			character.Inventory.ReceiveItemReward(2150001, 1, false);
			character.Inventory.ReceiveItemReward(5100060, 1, true);
			character.Inventory.ReceiveSkillReward(8201029);
			character.Stats.SetManaPoint(2);
			character.Inventory.ReceiveSkillReward(8200040);
			character.Inventory.ReceiveItemReward(6400130, 5, true);
			character.Inventory.ReceiveItemReward(4400010, 5, true);
		}

		public override void Init()
		{
			base.Init();
			QE_FixedCorruptedStart = CustomQuests.CreateQuestEvent("iggythemad.corrupted.fixedstart", false, true, true, "A_Iggy_AlternateStart", "CustomEvent", "A custom event created with SideLoader");
			SL.OnGameplayResumedAfterLoading += SL_OnGameplayResumedAfterLoading;
		}

		private void SL_OnGameplayResumedAfterLoading()
		{
			foreach (Character value in CharacterManager.Instance.Characters.Values)
			{
				if (value.IsLocalPlayer && ((CharacterKnowledge)value.Inventory.SkillKnowledge).IsItemLearned(-2218) && value.PlayerStats.Corruption < 0f)
				{
					value.PlayerStats.AffectCorruptionLevel(0f, false);
				}
			}
			Character worldHostCharacter = CharacterManager.Instance.GetWorldHostCharacter();
			if (((CharacterKnowledge)worldHostCharacter.Inventory.QuestKnowledge).IsItemLearned((int)Type))
			{
				Item itemFromItemID = ((CharacterKnowledge)worldHostCharacter.Inventory.QuestKnowledge).GetItemFromItemID((int)Type);
				Quest quest = (Quest)(object)((itemFromItemID is Quest) ? itemFromItemID : null);
				UpdateQuestProgress(quest);
			}
		}

		public override void UpdateQuestProgress(Quest quest)
		{
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			if (PhotonNetwork.isNonMasterClientInRoom || !base.IsActiveScenario)
			{
				return;
			}
			int num = 3;
			int eventCurrentStack = QuestEventManager.Instance.GetEventCurrentStack(QE_FixedCorruptedStart.EventUID);
			QuestProgress questProgress = quest.m_questProgress;
			if (eventCurrentStack >= num)
			{
				questProgress.DisableQuest((ProgressState)3);
				return;
			}
			if (eventCurrentStack < 1)
			{
				QuestEventManager.Instance.AddEvent(QE_FixedCorruptedStart, 1);
				eventCurrentStack = QuestEventManager.Instance.GetEventCurrentStack(QE_FixedCorruptedStart.EventUID);
				questProgress.UpdateLogEntry(questProgress.GetLogSignature(UID.op_Implicit("corrupted.objective.a")), displayTime: true);
				ShowUIMessage("What... Where am I?");
			}
			else if (eventCurrentStack < 2)
			{
				QuestEventManager.Instance.AddEvent(QE_FixedCorruptedStart, 1);
				questProgress.UpdateLogEntry(questProgress.GetLogSignature(UID.op_Implicit("corrupted.objective.b")), displayTime: false);
				ShowUIMessage("I should find others... Living, preferably.");
			}
			if (eventCurrentStack < 3 && AreaManager.Instance.GetIsCurrentAreaTownOrCity())
			{
				QuestEventManager.Instance.AddEvent(QE_FixedCorruptedStart, 2);
				questProgress.UpdateLogEntry(questProgress.GetLogSignature(UID.op_Implicit("corrupted.objective.b")), displayTime: true);
				questProgress.UpdateLogEntry(questProgress.GetLogSignature(UID.op_Implicit("corrupted.objective.c")), displayTime: true);
				questProgress.DisableQuest((ProgressState)3);
				VanillaQuestsHelper.SkipHostToFactionChoice(keepHouse: false, complete: true);
				ShowUIMessage("I'm somehow back to life. I should do something with it.");
			}
			ReloadLogs(eventCurrentStack, questProgress);
		}

		public void ReloadLogs(int stack, QuestProgress progress)
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			foreach (KeyValuePair<string, string> questLogSignature in QuestLogSignatures)
			{
				if (num < stack && questLogSignature.Key != null)
				{
					Debug.Log((object)("log: " + questLogSignature.Key));
					progress.UpdateLogEntry(progress.GetLogSignature(UID.op_Implicit(questLogSignature.Key)), displayTime: false);
					num++;
				}
			}
		}

		public override void OnScenarioChosen()
		{
		}

		public override void OnStartSpawn()
		{
			GetOrGiveQuestToHost();
		}

		public override void OnScenarioChosen(Character character)
		{
		}

		public override void OnStartSpawn(Character character)
		{
		}

		public CorruptedScenario()
		{
			Instance = this;
		}
	}
	public class EnmerkarHunterScenario : Scenario
	{
		[HarmonyPatch(typeof(LocalCharacterControl), "DetectMovementInputs")]
		public class LocalCharacterControl_DetectMovementInputs
		{
			[HarmonyPostfix]
			public static void Postfix(LocalCharacterControl __instance, ref Character ___m_character)
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0052: Unknown result type (might be due to invalid IL or missing references)
				//IL_0057: Unknown result type (might be due to invalid IL or missing references)
				//IL_005c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0063: Unknown result type (might be due to invalid IL or missing references)
				//IL_0068: Unknown result type (might be due to invalid IL or missing references)
				//IL_0077: Unknown result type (might be due to invalid IL or missing references)
				//IL_007c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0081: Unknown result type (might be due to invalid IL or missing references)
				//IL_0086: Unknown result type (might be due to invalid IL or missing references)
				if (!((Object)(object)__instance == (Object)null) && ((CharacterControl)__instance).Character.IsLocalPlayer && ((CharacterKnowledge)((CharacterControl)__instance).Character.Inventory.SkillKnowledge).IsItemLearned(-2208) && ((CharacterControl)__instance).Character.CurrentlyChargingAttack)
				{
					((CharacterControl)__instance).m_moveInput = ((CharacterControl)__instance).m_moveInput * new Vector2(0.3f, 0.3f);
					__instance.m_modifMoveInput = Vector2.op_Implicit(Vector2.op_Implicit(__instance.m_modifMoveInput) * new Vector2(0.6f, 0.6f));
					((MonoBehaviour)Plugin.Instance).StartCoroutine(Instance.checkBowDraw(((CharacterControl)__instance).Character));
				}
			}
		}

		[HarmonyPatch(typeof(CharacterInventory), "EquipItem", new Type[]
		{
			typeof(Equipment),
			typeof(bool)
		})]
		public class CharacterInventory_EquipItem
		{
			[HarmonyPrefix]
			public static void Postfix(CharacterInventory __instance, Equipment _itemToEquip, bool _playAnim, ref Character ___m_character)
			{
				Character val = ___m_character;
				if (!((Object)(object)val == (Object)null) && val.IsLocalPlayer && ((CharacterKnowledge)val.Inventory.SkillKnowledge).IsItemLearned(-2208))
				{
					((MonoBehaviour)Plugin.Instance).StartCoroutine(Instance.checkBow(val));
				}
			}
		}

		[HarmonyPatch(typeof(CharacterInventory), "UnequipItem", new Type[]
		{
			typeof(Equipment),
			typeof(bool)
		})]
		public class CharacterInventory_UnequipItem
		{
			[HarmonyPrefix]
			public static void Postfix(CharacterInventory __instance, Equipment _itemToUnequip, bool _playAnim, ref Character ___m_character)
			{
				Character val = ___m_character;
				if (!((Object)(object)val == (Object)null) && val.IsLocalPlayer && ((CharacterKnowledge)val.Inventory.SkillKnowledge).IsItemLearned(-2208))
				{
					((MonoBehaviour)Plugin.Instance).StartCoroutine(Instance.checkBow(val));
				}
			}
		}

		[HarmonyPatch(typeof(CharacterKnowledge), "AddItem")]
		public class CharacterKnowledge_AddItem
		{
			[HarmonyPrefix]
			public static void Prefix(CharacterKnowledge __instance, Item _item, ref Character ___m_character)
			{
				Character val = ___m_character;
				if (!((Object)(object)val == (Object)null) && val.IsLocalPlayer && ((CharacterKnowledge)val.Inventory.SkillKnowledge).IsItemLearned(-2208))
				{
					((MonoBehaviour)Plugin.Instance).StartCoroutine(Instance.checkBow(val));
				}
			}
		}

		private const string LogSignature_A = "hunter.objective.a";

		private const string LogSignature_B = "hunter.objective.b";

		private const string LogSignature_C = "hunter.objective.c";

		private QuestEventSignature QE_FixedHunterStart;

		private string bowmanEffect = "bowmanEffect";

		public override ScenarioQuest Type => ScenarioQuest.Quest_EmercarHunter;

		public override ScenarioType Difficulty => ScenarioType.Normal;

		public override ScenarioPassives Passive => ScenarioPassives.EnmerkarHunter;

		public override AreaEnum SpawnScene => (AreaEnum)550;

		public override Vector3 SpawnPosition => new Vector3(600.6f, 0.8f, 8.1f);

		public override Vector3 SpawnRotation => new Vector3(0f, 29.3f, 0f);

		public override bool HasQuest => true;

		public override string QuestName => "A Good Hunt";

		public override Dictionary<string, string> QuestLogSignatures => new Dictionary<string, string>
		{
			{ "hunter.objective.a", "Leave your hut." },
			{ "hunter.objective.b", "Go to any city to sell your goods." },
			{ "hunter.objective.c", "You are ready to join a faction." }
		};

		internal static EnmerkarHunterScenario Instance { get; private set; }

		public override void Gear(Character character)
		{
			character.Inventory.ReceiveItemReward(9000010, 13, false);
			character.Inventory.ReceiveItemReward(3000020, 1, true);
			character.Inventory.ReceiveItemReward(3000022, 1, true);
			character.Inventory.ReceiveItemReward(2200000, 1, false);
			character.Inventory.ReceiveItemReward(5200001, 30, true);
			character.Inventory.ReceiveItemReward(4000060, 4, false);
		}

		public override void Init()
		{
			base.Init();
			QE_FixedHunterStart = CustomQuests.CreateQuestEvent("iggythemad.hunter.fixedstart", false, true, true, "A_Iggy_AlternateStart", "CustomEvent", "A custom event created with SideLoader");
			SL.OnGameplayResumedAfterLoading += SL_OnGameplayResumedAfterLoading;
		}

		private void SL_OnGameplayResumedAfterLoading()
		{
			if (!PhotonNetwork.isNonMasterClientInRoom && base.IsActiveScenario)
			{
				Character worldHostCharacter = CharacterManager.Instance.GetWorldHostCharacter();
				if (((CharacterKnowledge)worldHostCharacter.Inventory.QuestKnowledge).IsItemLearned((int)Type))
				{
					Item itemFromItemID = ((CharacterKnowledge)worldHostCharacter.Inventory.QuestKnowledge).GetItemFromItemID((int)Type);
					Quest quest = (Quest)(object)((itemFromItemID is Quest) ? itemFromItemID : null);
					UpdateQuestProgress(quest);
				}
			}
		}

		public override void UpdateQuestProgress(Quest quest)
		{
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			if (PhotonNetwork.isNonMasterClientInRoom || !base.IsActiveScenario)
			{
				return;
			}
			int num = 3;
			int eventCurrentStack = QuestEventManager.Instance.GetEventCurrentStack(QE_FixedHunterStart.EventUID);
			QuestProgress questProgress = quest.m_questProgress;
			if (eventCurrentStack >= num)
			{
				questProgress.DisableQuest((ProgressState)3);
				return;
			}
			if (eventCurrentStack < 1)
			{
				QuestEventManager.Instance.AddEvent(QE_FixedHunterStart, 1);
				eventCurrentStack = QuestEventManager.Instance.GetEventCurrentStack(QE_FixedHunterStart.EventUID);
				questProgress.UpdateLogEntry(questProgress.GetLogSignature(UID.op_Implicit("hunter.objective.a")), displayTime: true);
				ShowUIMessage("Today's was a good hunt...");
			}
			else if (eventCurrentStack < 2)
			{
				QuestEventManager.Instance.AddEvent(QE_FixedHunterStart, 1);
				questProgress.UpdateLogEntry(questProgress.GetLogSignature(UID.op_Implicit("hunter.objective.b")), displayTime: false);
				ShowUIMessage("I should sell my goods in the city...");
			}
			if (eventCurrentStack < 3 && AreaManager.Instance.GetIsCurrentAreaTownOrCity())
			{
				QuestEventManager.Instance.AddEvent(QE_FixedHunterStart, 2);
				questProgress.UpdateLogEntry(questProgress.GetLogSignature(UID.op_Implicit("hunter.objective.b")), displayTime: true);
				questProgress.UpdateLogEntry(questProgress.GetLogSignature(UID.op_Implicit("hunter.objective.c")), displayTime: true);
				questProgress.DisableQuest((ProgressState)3);
				VanillaQuestsHelper.SkipHostToFactionChoice(keepHouse: false, complete: true);
				ShowUIMessage("Huh... Should I join a faction?");
			}
			ReloadLogs(eventCurrentStack, questProgress);
		}

		public void ReloadLogs(int stack, QuestProgress progress)
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			foreach (KeyValuePair<string, string> questLogSignature in QuestLogSignatures)
			{
				if (num < stack && questLogSignature.Key != null)
				{
					Debug.Log((object)("log: " + questLogSignature.Key));
					progress.UpdateLogEntry(progress.GetLogSignature(UID.op_Implicit(questLogSignature.Key)), displayTime: false);
					num++;
				}
			}
		}

		public override void OnScenarioChosen()
		{
		}

		public override void OnScenarioChosen(Character character)
		{
		}

		public override void OnStartSpawn()
		{
			GetOrGiveQuestToHost();
		}

		public override void OnStartSpawn(Character character)
		{
			character.Inventory.ReceiveSkillReward(8205160);
		}

		public EnmerkarHunterScenario()
		{
			Instance = this;
		}

		private IEnumerator checkBowDraw(Character player)
		{
			player.Animator.speed = 2.2f;
			while (player.CurrentlyChargingAttack)
			{
				yield return (object)new WaitForSeconds(0.1f);
			}
			player.Animator.speed = 1f;
		}

		private IEnumerator checkBow(Character player)
		{
			player.StatusEffectMngr.RemoveStatusWithIdentifierName(bowmanEffect);
			yield return (object)new WaitForSeconds(0.5f);
			if ((int)player.CurrentWeapon.Type != 200)
			{
				player.StatusEffectMngr.AddStatusEffect(bowmanEffect);
			}
		}
	}
	public class GiantRisenScenario : Scenario
	{
		[HarmonyPatch(typeof(Character), "DodgeInput", new Type[] { typeof(Vector3) })]
		public class Character_DodgeInput
		{
			[HarmonyPostfix]
			public static void Postfix(Character __instance, Vector3 _direction)
			{
				if (__instance.IsLocalPlayer && ((CharacterKnowledge)__instance.Inventory.SkillKnowledge).IsItemLearned(-2212) && !__instance.DodgeRestricted)
				{
					((MonoBehaviour)Plugin.Instance).StartCoroutine(Instance.DodgeSlower(__instance));
				}
			}
		}

		private const string LogSignature_A = "giant.objective.a";

		private const string LogSignature_B = "giant.objective.b";

		private const string LogSignature_C = "giant.objective.c";

		private QuestEventSignature QE_FixedGiantRisenStart;

		public override ScenarioQuest Type => ScenarioQuest.Quest_GiantRisen;

		public override ScenarioType Difficulty => ScenarioType.Normal;

		public override ScenarioPassives Passive => ScenarioPassives.GiantRisen;

		public override AreaEnum SpawnScene => (AreaEnum)203;

		public override Vector3 SpawnPosition => default(Vector3);

		public override bool HasQuest => true;

		public override string QuestName => "Giant Mistake";

		public override Dictionary<string, string> QuestLogSignatures => new Dictionary<string, string>
		{
			{ "giant.objective.a", "The giants have disowned you! Run for your life!" },
			{ "giant.objective.b", "Find a new home..." },
			{ "giant.objective.c", "You are ready to join a faction." }
		};

		internal static GiantRisenScenario Instance { get; private set; }

		public override void Gear(Character character)
		{
			character.Inventory.ReceiveItemReward(3000221, 1, true);
			character.Inventory.ReceiveItemReward(3000220, 1, true);
			character.Inventory.ReceiveItemReward(3000222, 1, true);
			character.Inventory.ReceiveItemReward(2110000, 1, true);
		}

		public override void Init()
		{
			base.Init();
			QE_FixedGiantRisenStart = CustomQuests.CreateQuestEvent("iggythemad.giantrisen.fixedstart", false, true, true, "A_Iggy_AlternateStart", "CustomEvent", "A custom event created with SideLoader");
			SL.OnGameplayResumedAfterLoading += SL_OnGameplayResumedAfterLoading;
		}

		public override void OnScenarioChosen()
		{
		}

		public override void OnScenarioChosen(Character character)
		{
		}

		public override void OnStartSpawn()
		{
			GetOrGiveQuestToHost();
			VanillaQuestsHelper.AddQuestEvent("XqlcpbTJC0aTDZfjD4xCTg");
		}

		public override void OnStartSpawn(Character character)
		{
		}

		private void SL_OnGameplayResumedAfterLoading()
		{
			if (!PhotonNetwork.isNonMasterClientInRoom && base.IsActiveScenario)
			{
				Character worldHostCharacter = CharacterManager.Instance.GetWorldHostCharacter();
				if (((CharacterKnowledge)worldHostCharacter.Inventory.QuestKnowledge).IsItemLearned((int)Type))
				{
					Item itemFromItemID = ((CharacterKnowledge)worldHostCharacter.Inventory.QuestKnowledge).GetItemFromItemID((int)Type);
					Quest quest = (Quest)(object)((itemFromItemID is Quest) ? itemFromItemID : null);
					UpdateQuestProgress(quest);
				}
			}
		}

		public override void UpdateQuestProgress(Quest quest)
		{
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			if (PhotonNetwork.isNonMasterClientInRoom || !base.IsActiveScenario)
			{
				return;
			}
			int num = 3;
			int eventCurrentStack = QuestEventManager.Instance.GetEventCurrentStack(QE_FixedGiantRisenStart.EventUID);
			QuestProgress questProgress = quest.m_questProgress;
			if (eventCurrentStack >= num)
			{
				questProgress.DisableQuest((ProgressState)3);
				return;
			}
			if (eventCurrentStack < 1)
			{
				QuestEventManager.Instance.AddEvent(QE_FixedGiantRisenStart, 1);
				questProgress.UpdateLogEntry(questProgress.GetLogSignature(UID.op_Implicit("giant.objective.a")), displayTime: true);
				ShowUIMessage("I've been exiled! I should flee!");
			}
			else if (eventCurrentStack < 2)
			{
				QuestEventManager.Instance.AddEvent(QE_FixedGiantRisenStart, 1);
				questProgress.UpdateLogEntry(questProgress.GetLogSignature(UID.op_Implicit("giant.objective.b")), displayTime: false);
				ShowUIMessage("I need to find a new home...");
			}
			else if (eventCurrentStack < 3 && AreaManager.Instance.GetIsCurrentAreaTownOrCity())
			{
				QuestEventManager.Instance.AddEvent(QE_FixedGiantRisenStart, 1);
				questProgress.UpdateLogEntry(questProgress.GetLogSignature(UID.op_Implicit("giant.objective.b")), displayTime: true);
				questProgress.UpdateLogEntry(questProgress.GetLogSignature(UID.op_Implicit("giant.objective.c")), displayTime: true);
				questProgress.DisableQuest((ProgressState)3);
				VanillaQuestsHelper.RemoveEvent("oGkuUgWvfkej_El-rhz2gw");
				VanillaQuestsHelper.RemoveEvent("XqlcpbTJC0aTDZfjD4xCTg");
				VanillaQuestsHelper.RemoveEvent("nDy01eTHlUa_BPDlbIhZPQ");
				VanillaQuestsHelper.RemoveEvent("f1JVZyhg2UiBA8xmC-w6Hw");
				VanillaQuestsHelper.SkipHostToFactionChoice(keepHouse: false, complete: true);
				ShowUIMessage("Maybe I should join a new faction...");
			}
			ReloadLogs(eventCurrentStack, questProgress);
		}

		public void ReloadLogs(int stack, QuestProgress progress)
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			foreach (KeyValuePair<string, string> questLogSignature in QuestLogSignatures)
			{
				if (num < stack && questLogSignature.Key != null)
				{
					Debug.Log((object)("log: " + questLogSignature.Key));
					progress.UpdateLogEntry(progress.GetLogSignature(UID.op_Implicit(questLogSignature.Key)), displayTime: false);
					num++;
				}
			}
		}

		public GiantRisenScenario()
		{
			Instance = this;
		}

		public IEnumerator DodgeSlower(Character _character)
		{
			if (_character.Dodging)
			{
				_character.Animator.speed = 0.6f;
				while (_character.Dodging)
				{
					yield return (object)new WaitForSeconds(0.2f);
				}
				yield return (object)new WaitForSeconds(0.2f);
				_character.Animator.speed = 1f;
			}
		}
	}
	public class LimitlessScenario : Scenario
	{
		private const string LogSignature_A = "unbound.objective.a";

		private const string LogSignature_B = "unbound.objective.b";

		private const string LogSignature_C = "unbound.objective.c";

		private QuestEventSignature QE_FixedUnboundStart;

		public int questTrigger;

		public override ScenarioQuest Type => ScenarioQuest.Quest_Unbound;

		public override ScenarioType Difficulty => ScenarioType.WIPtest;

		public override ScenarioPassives Passive => ScenarioPassives.Unbound;

		public override AreaEnum SpawnScene => (AreaEnum)501;

		public override Vector3 SpawnPosition => new Vector3(1053.8f, -32f, 1155.6f);

		public override Vector3 SpawnRotation => new Vector3(0f, 230.2f, 0f);

		public override bool HasQuest => true;

		public override string QuestName => "Unbound. Unlimited.";

		public override Dictionary<string, string> QuestLogSignatures => new Dictionary<string, string>
		{
			{ "unbound.objective.a", "You've unlocked your true potential. You are unbound. Find any trainer to learn from." },
			{ "unbound.objective.b", "Purchase your first skill. No restrictions. Choose wisely." },
			{ "unbound.objective.c", "You are ready to face the world. You are ready to join a faction." }
		};

		public override void Gear(Character character)
		{
			character.Inventory.AddMoney(37);
			character.Inventory.ReceiveItemReward(4100550, 3, false);
			character.Inventory.ReceiveItemReward(3000091, 1, true);
			character.Inventory.ReceiveItemReward(3000282, 1, true);
			character.Inventory.ReceiveItemReward(2160020, 1, false);
			character.Inventory.ReceiveItemReward(5110030, 1, false);
		}

		public override void Init()
		{
			base.Init();
			QE_FixedUnboundStart = CustomQuests.CreateQuestEvent("iggythemad.unbound.fixedstart", false, true, true, "A_Iggy_AlternateStart", "CustomEvent", "A custom event created with SideLoader");
			SL.OnGameplayResumedAfterLoading += SL_OnGameplayResumedAfterLoading;
		}

		private void SL_OnGameplayResumedAfterLoading()
		{
			if (!PhotonNetwork.isNonMasterClientInRoom && base.IsActiveScenario)
			{
				Character worldHostCharacter = CharacterManager.Instance.GetWorldHostCharacter();
				if (((CharacterKnowledge)worldHostCharacter.Inventory.QuestKnowledge).IsItemLearned((int)Type))
				{
					Item itemFromItemID = ((CharacterKnowledge)worldHostCharacter.Inventory.QuestKnowledge).GetItemFromItemID((int)Type);
					Quest quest = (Quest)(object)((itemFromItemID is Quest) ? itemFromItemID : null);
					UpdateQuestProgress(quest);
				}
			}
		}

		public override void UpdateQuestProgress(Quest quest)
		{
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			if (!PhotonNetwork.isNonMasterClientInRoom && base.IsActiveScenario)
			{
				CharacterManager.Instance.GetWorldHostCharacter();
				int eventCurrentStack = QuestEventManager.Instance.GetEventCurrentStack(QE_FixedUnboundStart.EventUID);
				QuestProgress questProgress = quest.m_questProgress;
				if (eventCurrentStack < 1)
				{
					QuestEventManager.Instance.AddEvent(QE_FixedUnboundStart, 1);
					eventCurrentStack = QuestEventManager.Instance.GetEventCurrentStack(QE_FixedUnboundStart.EventUID);
					questProgress.UpdateLogEntry(questProgress.GetLogSignature(UID.op_Implicit("unbound.objective.a")), displayTime: true);
					ShowUIMessage("I feel... free. Unbound. I need power!");
				}
				else if (eventCurrentStack < 2 && AreaManager.Instance.GetIsCurrentAreaTownOrCity())
				{
					QuestEventManager.Instance.AddEvent(QE_FixedUnboundStart, 1);
					questProgress.UpdateLogEntry(questProgress.GetLogSignature(UID.op_Implicit("unbound.objective.b")), displayTime: true);
					ShowUIMessage("So many choices... I gotta choose wisely.");
				}
				else if (eventCurrentStack < 3 && questTrigger == 1)
				{
					QuestEventManager.Instance.AddEvent(QE_FixedUnboundStart, 2);
					questProgress.UpdateLogEntry(questProgress.GetLogSignature(UID.op_Implicit("unbound.objective.c")), displayTime: true);
					questProgress.DisableQuest((ProgressState)3);
					VanillaQuestsHelper.SkipHostToFactionChoice(keepHouse: false, complete: true);
				}
				ReloadLogs(eventCurrentStack, questProgress);
			}
		}

		public void ReloadLogs(int stack, QuestProgress progress)
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			foreach (KeyValuePair<string, string> questLogSignature in QuestLogSignatures)
			{
				if (num < stack && questLogSignature.Key != null)
				{
					Debug.Log((object)("log: " + questLogSignature.Key));
					progress.UpdateLogEntry(progress.GetLogSignature(UID.op_Implicit(questLogSignature.Key)), displayTime: false);
					num++;
				}
			}
		}

		public override void OnScenarioChosen()
		{
		}

		public override void OnScenarioChosen(Character character)
		{
		}

		public override void OnStartSpawn()
		{
			GetOrGiveQuestToHost();
		}

		public override void OnStartSpawn(Character character)
		{
		}
	}
	public class PriestElattScenario : Scenario
	{
		public override ScenarioQuest Type => ScenarioQuest.Quest_PriestElatt;

		public override ScenarioType Difficulty => ScenarioType.Normal;

		public override ScenarioPassives Passive => ScenarioPassives.PriestElatt;

		public override AreaEnum SpawnScene => (AreaEnum)200;

		public override Vector3 SpawnPosition => new Vector3(-175.2f, -1514.6f, 751.9f);

		public override Vector3 SpawnRotation => new Vector3(0f, 359f, 0f);

		public override bool HasQuest => false;

		public override string QuestName => "";

		public override Dictionary<string, string> QuestLogSignatures => new Dictionary<string, string>();

		internal static PriestElattScenario Instance { get; private set; }

		public override void Gear(Character character)
		{
			character.Inventory.ReceiveItemReward(9000010, 32, true);
			character.Inventory.ReceiveItemReward(3000071, 1, true);
			character.Inventory.ReceiveItemReward(3000070, 1, true);
			character.Stats.SetManaPoint(2);
			character.Inventory.ReceiveItemReward(3000174, 1, true);
			character.Inventory.ReceiveItemReward(2020010, 1, true);
			character.Inventory.ReceiveSkillReward(8200040);
		}

		public override void OnScenarioChosen()
		{
		}

		public override void OnScenarioChosen(Character character)
		{
		}

		public override void OnStartSpawn()
		{
			VanillaQuestsHelper.SkipHostToFactionChoice(keepHouse: false, complete: true);
		}

		public override void OnStartSpawn(Character character)
		{
		}

		public override void UpdateQuestProgress(Quest quest)
		{
		}

		public PriestElattScenario()
		{
			Instance = this;
		}
	}
	public class RobbedTraderScenario : Scenario
	{
		[HarmonyPatch(typeof(DefeatScenariosManager), "StartDefeat")]
		public class DefeatScenariosManager_StartDefeat
		{
			[HarmonyPrefix]
			public static bool Prefix(DefeatScenariosManager __instance)
			{
				if (!Instance.IsActiveScenario || PhotonNetwork.isNonMasterClientInRoom)
				{
					return true;
				}
				if (QuestEventManager.Instance.HasQuestEvent(QuestEventDictionary.GetQuestEvent("jNfNsLGBpk2iMRts9kkerw")))
				{
					return true;
				}
				foreach (PlayerSystem item in Global.Lobby.PlayersInLobby)
				{
					item.ControlledCharacter.Resurrect();
				}
				NetworkLevelLoader.Instance.RequestSwitchArea(AreaManager.Instance.GetArea((AreaEnum)101).SceneName, 0, 1.5f, false);
				return false;
			}
		}

		[HarmonyPatch(typeof(InteractionTriggerBase), "TryActivateBasicAction", new Type[]
		{
			typeof(Character),
			typeof(int)
		})]
		public class InteractionTriggerBase_TryActivateBasicAction
		{
			[HarmonyPrefix]
			public static bool Prefix(InteractionTriggerBase __instance, Character _character, int _toggleState)
			{
				//IL_0179: Unknown result type (might be due to invalid IL or missing references)
				//IL_0183: Unknown result type (might be due to invalid IL or missing references)
				//IL_0094: Unknown result type (might be due to invalid IL or missing references)
				//IL_009e: Unknown result type (might be due to invalid IL or missing references)
				//IL_010f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0119: Unknown result type (might be due to invalid IL or missing references)
				if (!Instance.IsActiveScenario || PhotonNetwork.isNonMasterClientInRoom || !Object.op_Implicit((Object)(object)_character))
				{
					return true;
				}
				if (!_character.IsLocalPlayer)
				{
					return true;
				}
				if (QuestEventManager.Instance.HasQuestEvent(QuestEventDictionary.GetQuestEvent("jNfNsLGBpk2iMRts9kkerw")))
				{
					return true;
				}
				EventActivator currentTriggerManager = __instance.CurrentTriggerManager;
				if (Object.op_Implicit((Object)(object)((currentTriggerManager is InteractionActivator) ? currentTriggerManager : null)))
				{
					EventActivator currentTriggerManager2 = __instance.CurrentTriggerManager;
					InteractionActivator val = (InteractionActivator)(object)((currentTriggerManager2 is InteractionActivator) ? currentTriggerManager2 : null);
					if (val.BasicInteraction != null)
					{
						IInteraction basicInteraction = val.BasicInteraction;
						if (SceneManagerHelper.ActiveSceneName == "CierzoNewTerrain")
						{
							if (basicInteraction is InteractionMerchantDialogue && Vector3.Distance(((Component)_character).transform.position, Instance.traderPosition) < 5f)
							{
								if (_character.Inventory.OwnsOrHasEquipped(-2353))
								{
									Instance.ShowUIMessage("I need to sell the goods before leaving.", instant: true);
								}
								else
								{
									VanillaQuestsHelper.SkipHostToFactionChoice(keepHouse: false, complete: true);
									NetworkLevelLoader.Instance.RequestSwitchArea(AreaManager.Instance.GetArea((AreaEnum)400).SceneName, 0, 1.5f, false);
								}
								return false;
							}
							if (basicInteraction is InteractionMerchantDialogue && Vector3.Distance(((Component)_character).transform.position, Instance.alchemistPosition) < 5f)
							{
								return true;
							}
							if (_character.Inventory.OwnsOrHasEquipped(-2353))
							{
								Instance.ShowUIMessage("I have no time for this...", instant: true);
							}
							else
							{
								Instance.ShowUIMessage("I should go back to harmattan...", instant: true);
							}
							return false;
						}
						if (SceneManagerHelper.ActiveSceneName == "ChersoneseNewTerrain")
						{
							if (Vector3.Distance(((Component)_character).transform.position, Instance.cierzoEntrance) < 5f)
							{
								return true;
							}
							Instance.ShowUIMessage("There is no time for this.", instant: true);
							return false;
						}
					}
				}
				return true;
			}
		}

		public string enemyID = "com.iggy.banditgeneric";

		public Vector3 traderPosition = new Vector3(1408.7f, 5.9f, 1663.8f);

		public Vector3 alchemistPosition = new Vector3(1384.9f, 7.8f, 1649.1f);

		public Vector3 chersoneseFailSpawn = new Vector3(181.5f, 32.6f, 1444.4f);

		public Vector3 cierzoEntrance = new Vector3(131.9f, 34.9f, 1461.7f);

		internal static RobbedTraderScenario Instance { get; private set; }

		public override ScenarioQuest Type => ScenarioQuest.Quest_RobbedTrader;

		public override ScenarioType Difficulty => ScenarioType.Normal;

		public override ScenarioPassives Passive => ScenarioPassives.RobbedTrader;

		public override AreaEnum SpawnScene => (AreaEnum)101;

		public override Vector3 SpawnPosition => new Vector3(300.3f, 37.3f, 1423.9f);

		public override Vector3 SpawnRotation => new Vector3(0f, 285.7f, 0f);

		public override bool HasQuest => false;

		public override string QuestName => "";

		public override Dictionary<string, string> QuestLogSignatures => new Dictionary<string, string>();

		public override void Gear(Character character)
		{
			character.Inventory.ReceiveItemReward(9000010, 56, false);
			character.Inventory.ReceiveItemReward(3000190, 1, true);
			character.Inventory.ReceiveItemReward(3000004, 1, true);
			character.Inventory.ReceiveItemReward(-2353, 1, true);
		}

		public override void Init()
		{
			base.Init();
			SL.OnGameplayResumedAfterLoading += SL_OnGameplayResumedAfterLoading;
		}

		public RobbedTraderScenario()
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			Instance = this;
		}

		public override void OnScenarioChosen()
		{
		}

		public override void OnScenarioChosen(Character character)
		{
		}

		public override void OnStartSpawn()
		{
		}

		public override void OnStartSpawn(Character character)
		{
			ShowUIMessage("I can see the lighthouse! Got to sell the goods in Cierzo!");
		}

		private void SL_OnGameplayResumedAfterLoading()
		{
			if (Instance.IsActiveScenario)
			{
				_ = PhotonNetwork.isNonMasterClientInRoom;
			}
		}

		public override void UpdateQuestProgress(Quest quest)
		{
		}
	}
	public class SandBanditScenario : Scenario
	{
		[HarmonyPatch(typeof(CharacterStats), "ReceiveDamage")]
		public class Character_ReceiveDamage
		{
			[HarmonyPostfix]
			public static void Postfix(CharacterStats __instance, ref float _damage, ref Character ___m_character)
			{
				if (Instance.IsActiveScenario && ___m_character.IsAI && !(SceneManagerHelper.ActiveSceneName != "Abrassar_Dungeon6") && _damage > __instance.CurrentHealth)
				{
					((MonoBehaviour)Plugin.Instance).StartCoroutine(Instance.LeftAlive());
				}
			}
		}

		[HarmonyPatch(typeof(CharacterManager), "RequestAreaSwitch")]
		public class CharacterManager_RequestAreaSwitch
		{
			[HarmonyPrefix]
			public static bool Prefix(CharacterManager __instance, Character _character, Area _areaToSwitchTo, int _longTravelTime, int _spawnPoint, float _offset, string _overrideLocKey)
			{
				if (!Instance.IsActiveScenario)
				{
					return true;
				}
				if (PhotonNetwork.isNonMasterClientInRoom)
				{
					return true;
				}
				if (_areaToSwitchTo.SceneName == "Levant")
				{
					_character.CharacterUI.ShowInfoNotification("You are not welcome here");
					return false;
				}
				return true;
			}
		}

		private const float GRACE_PERIOD_INGAMETIME = 0.3f;

		private const string LogSignature_A = "sandbandits.objective.a";

		private const string LogSignature_B = "sandbandits.objective.b";

		private static QuestEventSignature QE_StartTimer;

		private Coroutine delayedQuestUpdate;

		internal static DialogueCharacter levantGuard;

		public override ScenarioQuest Type => ScenarioQuest.Quest_SandBandit;

		public override ScenarioType Difficulty => ScenarioType.WIPtest;

		public override ScenarioPassives Passive => ScenarioPassives.SandBandit;

		public override AreaEnum SpawnScene => (AreaEnum)307;

		public override Vector3 SpawnPosition => new Vector3(-53.3f, 0.5f, 55.1f);

		public override Vector3 SpawnRotation => new Vector3(0f, 227.3f, 0f);

		public override bool HasQuest => true;

		public override string QuestName => "Sand Corsair Exile";

		public override Dictionary<string, string> QuestLogSignatures => new Dictionary<string, string>
		{
			{ "sandbandits.objective.a", "You have been exiled from the Sand Corsairs, leave before they turn on you!" },
			{ "sandbandits.objective.b", "Your grace period is over, Old Levant is no longer your ally." }
		};

		internal static SandBanditScenario Instance { get; private set; }

		public override void Gear(Character character)
		{
			character.Inventory.ReceiveItemReward(9000010, 26, false);
			character.Inventory.ReceiveItemReward(5100010, 1, true);
			character.Inventory.ReceiveItemReward(3000087, 1, true);
			character.Inventory.ReceiveItemReward(3000201, 1, true);
			character.Inventory.ReceiveItemReward(3000205, 1, true);
			character.Inventory.ReceiveItemReward(2000110, 1, true);
		}

		public SandBanditScenario()
		{
			Instance = this;
		}

		public override void Init()
		{
			base.Init();
			QE_StartTimer = CustomQuests.CreateQuestEvent("iggythemad.sandbandits.starttimer", true, false, true, "A_Iggy_AlternateStart", "CustomEvent", "A custom event created with SideLoader");
			SL.OnGameplayResumedAfterLoading += SL_OnGameplayResumedAfterLoading;
			SetupTestCharacter();
		}

		public override void OnScenarioChosen()
		{
			VanillaQuestsHelper.SkipHostToFactionChoice(keepHouse: false, complete: true);
		}

		public override void OnScenarioChosen(Character character)
		{
		}

		public override void OnStartSpawn()
		{
			ChangeCharactersFactions((Factions)2, QuestLogSignatures["sandbandits.objective.a"]);
			QuestEventManager.Instance.AddEvent(QE_StartTimer, 1);
			GetOrGiveQuestToHost();
			StartDelayedQuestUpdate();
		}

		public override void OnStartSpawn(Character character)
		{
		}

		private void ChangeCharactersFactions(Factions faction, string notifText)
		{
			//IL_002c: 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_0035: Unknown result type (might be due to invalid IL or missing references)
			foreach (string value in CharacterManager.Instance.PlayerCharacters.Values)
			{
				Character character = CharacterManager.Instance.GetCharacter(value);
				if (character.Faction != faction)
				{
					character.ChangeFaction(faction, true);
					if (!string.IsNullOrEmpty(notifText))
					{
						ShowUIMessage(notifText);
					}
				}
			}
		}

		private void SL_OnGameplayResumedAfterLoading()
		{
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Invalid comparison between Unknown and I4
			if (PhotonNetwork.isNonMasterClientInRoom || !base.IsActiveScenario)
			{
				return;
			}
			Character worldHostCharacter = CharacterManager.Instance.GetWorldHostCharacter();
			if (((CharacterKnowledge)worldHostCharacter.Inventory.QuestKnowledge).IsItemLearned((int)Type))
			{
				Item itemFromItemID = ((CharacterKnowledge)worldHostCharacter.Inventory.QuestKnowledge).GetItemFromItemID((int)Type);
				Quest quest = (Quest)(object)((itemFromItemID is Quest) ? itemFromItemID : null);
				UpdateQuestProgress(quest);
			}
			if (SceneManagerHelper.ActiveSceneName == "Abrassar_Dungeon6")
			{
				Character[] array = Object.FindObjectsOfType<Character>();
				int num = 0;
				Character[] array2 = array;
				foreach (Character val in array2)
				{
					if (val.Alive && val.IsAI && (int)val.Faction == 2)
					{
						num++;
					}
				}
				Instance.ShowUIMessage(num + " former friends left alive.");
			}
			else if (SceneManagerHelper.ActiveSceneName == "Levant")
			{
				NetworkLevelLoader.Instance.RequestSwitchArea(AreaManager.Instance.GetArea((AreaEnum)301).SceneName, 0, 1.5f, false);
			}
		}

		private void StartDelayedQuestUpdate()
		{
			if (delayedQuestUpdate != null)
			{
				((MonoBehaviour)Plugin.Instance).StopCoroutine(delayedQuestUpdate);
			}
			delayedQuestUpdate = ((MonoBehaviour)Plugin.Instance).StartCoroutine(UpdateQuestAfterDelay());
		}

		private IEnumerator UpdateQuestAfterDelay()
		{
			float eventActiveTimeDelta = QuestEventManager.Instance.GetEventActiveTimeDelta(QE_StartTimer.EventUID);
			while (eventActiveTimeDelta < 0.3f)
			{
				yield return (object)new WaitForSeconds(1f);
				if (!((Object)(object)QuestEventManager.Instance == (Object)null))
				{
					CharacterManager instance = CharacterManager.Instance;
					if (!Object.op_Implicit((Object)(object)((instance != null) ? instance.GetWorldHostCharacter() : null)))
					{
						yield break;
					}
					eventActiveTimeDelta = QuestEventManager.Instance.GetEventActiveTimeDelta(QE_StartTimer.EventUID);
					continue;
				}
				yield break;
			}
			CharacterManager instance2 = CharacterManager.Instance;
			Character val = ((instance2 != null) ? instance2.GetWorldHostCharacter() : null);
			if (Object.op_Implicit((Object)(object)val))
			{
				if (((CharacterKnowledge)val.Inventory.QuestKnowledge).IsItemLearned((int)Type))
				{
					Item itemFromItemID = ((CharacterKnowledge)val.Inventory.QuestKnowledge).GetItemFromItemID((int)Type);
					Quest quest = (Quest)(object)((itemFromItemID is Quest) ? itemFromItemID : null);
					UpdateQuestProgress(quest);
				}
				delayedQuestUpdate = null;
			}
		}

		public override void UpdateQuestProgress(Quest quest)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			if (!PhotonNetwork.isNonMasterClientInRoom && base.IsActiveScenario)
			{
				float eventActiveTimeDelta = QuestEventManager.Instance.GetEventActiveTimeDelta(QE_StartTimer.EventUID);
				QuestProgress questProgress = quest.m_questProgress;
				questProgress.UpdateLogEntry(questProgress.GetLogSignature(UID.op_Implicit("sandbandits.objective.a")), eventActiveTimeDelta >= 0.3f);
				if (eventActiveTimeDelta >= 0.3f)
				{
					questProgress.UpdateLogEntry(questProgress.GetLogSignature(UID.op_Implicit("sandbandits.objective.b")), displayTime: true);
					ChangeCharactersFactions((Factions)1, QuestLogSignatures["sandbandits.objective.b"]);
					questProgress.DisableQuest((ProgressState)3);
				}
				else
				{
					ChangeCharactersFactions((Factions)2, string.Empty);
					StartDelayedQuestUpdate();
				}
			}
		}

		private IEnumerator LeftAlive()
		{
			yield return (object)new WaitForSeconds(0.5f);
			Character[] array = Object.FindObjectsOfType<Character>();
			int num = 0;
			Character[] array2 = array;
			foreach (Character val in array2)
			{
				if (val.Alive && val.IsAI && (int)val.Faction == 2)
				{
					num++;
				}
			}
			Instance.ShowUIMessage(num + " former friends left alive.");
			if (num > 0)
			{
				Instance.ShowUIMessage(num + " former friends left alive.");
			}
		}

		private void SetupTestCharacter()
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			levantGuard = new DialogueCharacter
			{
				UID = "levantguard.character",
				Name = "Levant Guard",
				SpawnSceneBuildName = "Abrassar",
				SpawnPosition = new Vector3(-159.4f, 131.8f, -532.7f),
				SpawnRotation = new Vector3(0f, 43.7f, 0f),
				HelmetID = 3000115,
				ChestID = 3000112,
				BootsID = 3000118,
				WeaponID = 2130305,
				StartingPose = (SpellCastType)42
			};
			SL_Character obj = levantGuard.CreateAndApplyTemplate();
			levantGuard.OnSetupDialogueGraph += TestCharacter_OnSetupDialogueGraph;
			obj.ShouldSpawn = () => base.IsActiveScenario;
		}

		private void TestCharacter_OnSetupDialogueGraph(DialogueTree graph, Character character)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Expected O, but got Unknown
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Expected O, but got Unknown
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Expected O, but got Unknown
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Expected O, but got Unknown
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Expected O, but got Unknown
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Expected O, but got Unknown
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Expected O, but got Unknown
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Expected O, but got Unknown
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Expected O, but got Unknown
			ActorParameter val = graph.actorParameters[0];
			StatementNodeExt val2 = ((Graph)graph).AddNode<StatementNodeExt>();
			val2.statement = new Statement("Halt! You are not welcome here, bandit. Go away or I'll make you.");
			val2.SetActorName(val.name);
			MultipleChoiceNodeExt val3 = ((Graph)graph).AddNode<MultipleChoiceNodeExt>();
			val3.availableChoices.Add(new Choice(new Statement("Why dont you trust me?")));
			val3.availableChoices.Add(new Choice(new Statement("I've left the corsairs behind. Let me in.")));
			val3.availableChoices.Add(new Choice(new Statement("How can I prove my loyalty to the king?")));
			StatementNodeExt val4 = ((Graph)graph).AddNode<StatementNodeExt>();
			val4.statement = new Statement("We have seen your bunch. Nothing more than soon-to-be-dead outlaws.");
			val4.SetActorName(val.name);
			StatementNodeExt val5 = ((Graph)graph).AddNode<StatementNodeExt>();
			val5.statement = new Statement("Should we just believe you? Just like that? Piss off, kid. I'm watching you.");
			val5.SetActorName(val.name);
			StatementNodeExt val6 = ((Graph)graph).AddNode<StatementNodeExt>();
			val6.statement = new Statement("Pfff-You can't be serious... Well I suppose getting rid of your people in the Sand Rose cave could ear you a way in.");
			val6.SetActorName(val.name);
			((Graph)graph).allNodes.Clear();
			((Graph)graph).allNodes.Add((Node)(object)val2);
			((Graph)graph).primeNode = (Node)(object)val2;
			((Graph)graph).allNodes.Add((Node)(object)val3);
			((Graph)graph).allNodes.Add((Node)(object)val4);
			((Graph)graph).allNodes.Add((Node)(object)val5);
			((Graph)graph).allNodes.Add((Node)(object)val6);
			((Graph)graph).ConnectNodes((Node)(object)val2, (Node)(object)val3, -1, -1);
			((Graph)graph).ConnectNodes((Node)(object)val3, (Node)(object)val4, 0, -1);
			((Graph)graph).ConnectNodes((Node)(object)val4, (Node)(object)val2, -1, -1);
			((Graph)graph).ConnectNodes((Node)(object)val3, (Node)(object)val5, 1, -1);
			((Graph)graph).ConnectNodes((Node)(object)val5, (Node)(object)val2, -1, -1);
			((Graph)graph).ConnectNodes((Node)(object)val3, (Node)(object)val6, 2, -1);
			((Graph)graph).ConnectNodes((Node)(object)val6, (Node)(object)val2, -1, -1);
		}
	}
	public abstract class Scenario
	{
		public abstract ScenarioQuest Type { get; }

		public abstract ScenarioType Difficulty { get; }

		[Obsolete("Not yet implemented.")]
		public virtual ScenarioTheme Theme { get; }

		public abstract ScenarioPassives Passive { get; }

		public abstract AreaEnum SpawnScene { get; }

		public abstract Vector3 SpawnPosition { get; }

		public virtual Vector3 SpawnRotation
		{
			get
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0005: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				Quaternion identity = Quaternion.identity;
				return ((Quaternion)(ref identity)).eulerAngles;
			}
		}

		public abstract bool HasQuest { get; }

		public SL_Quest QuestTemplate { get; private set; }

		public virtual string QuestName { get; }

		public virtual Dictionary<string, string> QuestLogSignatures { get; }

		public QuestEventSignature QE_ScenarioQuestEvent { get; private set; }

		public string QE_Scenario_UID => "iggythemad.scenarios." + GetType().Name;

		public bool IsActiveScenario => QuestEventManager.Instance.HasQuestEvent(QE_ScenarioQuestEvent);

		public virtual void Gear(Character character)
		{
		}

		public virtual void OnStartDestiny()
		{
			Debug.Log((object)"OnStartDestiny");
			GearManager.StartingGear();
		}

		public abstract void OnStartSpawn();

		public abstract void UpdateQuestProgress(Quest quest);

		public virtual void Init()
		{
			SL.OnPacksLoaded += OnPacksLoaded;
			QE_ScenarioQuestEvent = CustomQuests.CreateQuestEvent(QE_Scenario_UID, false, false, true, "A_Iggy_AlternateStart", "CustomEvent", "A custom event created with SideLoader");
		}

		public virtual void OnPacksLoaded()
		{
			if (HasQuest)
			{
				PrepareSLQuest();
			}
		}

		public virtual void OnScenarioChosen()
		{
			foreach (string value in CharacterManager.Instance.PlayerCharacters.Values)
			{
				Character character = CharacterManager.Instance.GetCharacter(value);
				OnScenarioChosen(character);
			}
		}

		public virtual void OnScenarioChosen(Character character)
		{
		}

		public virtual void OnStartSpawn(Character character)
		{
		}

		public IEnumerator StartScenario()
		{
			QuestEventManager.Instance.AddEvent(ScenarioManager.QE_DestinyChosen, 1);
			QuestEventManager.Instance.AddEvent(QE_ScenarioQuestEvent, 1);
			OnScenarioChosen();
			foreach (string value in CharacterManager.Instance.PlayerCharacters.Values)
			{
				Character character = CharacterManager.Instance.GetCharacter(value);
				character.AutoKnock(true, Vector3.back, character);
				OnScenarioChosen(character);
			}
			yield return (object)new WaitForSeconds(1f);
			CharacterManager.Instance.GetWorldHostCharacter();
			if (Object.op_Implicit((Object)(object)CharacterManager.Instance.GetFirstLocalCharacter()))
			{
				NetworkLevelLoader.Instance.RequestSwitchArea(AreaManager.Instance.GetArea(SpawnScene).SceneName, 0, 1.5f, false);
			}
			SL.OnGameplayResumedAfterLoading += OnGameplayResumedAfterScenarioStart;
		}

		private void OnGameplayResumedAfterScenarioStart()
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			foreach (string value in CharacterManager.Instance.PlayerCharacters.Values)
			{
				Character character = CharacterManager.Instance.GetCharacter(value);
				if (SpawnPosition != default(Vector3))
				{
					character.Teleport(SpawnPosition, SpawnRotation);
				}
				character.SpellCastProcess(29, 0, 0, 0f);
				OnStartSpawn(character);
			}
			OnStartSpawn();
			OnStartDestiny();
			SL.OnGameplayResumedAfterLoading -= OnGameplayResumedAfterScenarioStart;
		}

		private void PrepareSLQuest()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Expected O, but got Unknown
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Expected O, but got Unknown
			SL_Quest val = new SL_Quest();
			((SL_Item)val).Target_ItemID = 7011620;
			((SL_Item)val).New_ItemID = (int)Type;
			((SL_Item)val).Name = QuestName;
			val.IsSideQuest = false;
			((SL_Item)val).ItemExtensions = (SL_ItemExtension[])(object)new SL_ItemExtension[1] { (SL_ItemExtension)new SL_QuestProgress() };
			QuestTemplate = val;
			List<SL_QuestLogEntrySignature> list = new List<SL_QuestLogEntrySignature>();
			foreach (KeyValuePair<string, string> questLogSignature in QuestLogSignatures)
			{
				list.Add(new SL_QuestLogEntrySignature
				{
					UID = questLogSignature.Key,
					Text = questLogSignature.Value,
					Type = (QuestLogEntrySignatureType)0
				});
			}
			SL_ItemExtension obj = ((SL_Item)QuestTemplate).ItemExtensions[0];
			((SL_QuestProgress)((obj is SL_QuestProgress) ? obj : null)).LogSignatures = list.ToArray();
			((ContentTemplate)QuestTemplate).ApplyTemplate();
			QuestTemplate.OnQuestLoaded += UpdateQuestProgress;
		}

		public Quest GetOrGiveQuestToHost()
		{
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			Character worldHostCharacter = CharacterManager.Instance.GetWorldHostCharacter();
			if (((CharacterKnowledge)worldHostCharacter.Inventory.QuestKnowledge).IsItemLearned((int)Type))
			{
				Item itemFromItemID = ((CharacterKnowledge)worldHostCharacter.Inventory.QuestKnowledge).GetItemFromItemID((int)Type);
				return (Quest)(object)((itemFromItemID is Quest) ? itemFromItemID : null);
			}
			Item obj = ItemManager.Instance.GenerateItemNetwork((int)Type);
			Quest val = (Quest)(object)((obj is Quest) ? obj : null);
			((Component)val).transform.SetParent(((Component)worldHostCharacter.Inventory.QuestKnow

using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using HarmonyLib;
using SideLoader;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("HardcoreRebalance")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("HardcoreRebalance")]
[assembly: AssemblyCopyright("Copyright ©  2021")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("42fa9a70-4056-4212-8387-b19532e9b8ae")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
namespace HardcoreRebalance;

internal class ContentTweks
{
	[HarmonyPatch(typeof(InteractionTriggerBase), "TryActivateBasicAction", new Type[]
	{
		typeof(Character),
		typeof(int)
	})]
	public class InteractionTriggerBase_TryActivateBasicAction
	{
		[HarmonyPrefix]
		public static bool Prefix(InteractionTriggerBase __instance, Character _character, int _toggleState)
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)_character) || !_character.IsLocalPlayer)
			{
				return true;
			}
			EventActivator currentTriggerManager = __instance.CurrentTriggerManager;
			if (Object.op_Implicit((Object)(object)((currentTriggerManager is InteractionActivator) ? currentTriggerManager : null)))
			{
				EventActivator currentTriggerManager2 = __instance.CurrentTriggerManager;
				InteractionActivator val = (InteractionActivator)(object)((currentTriggerManager2 is InteractionActivator) ? currentTriggerManager2 : null);
				if (val.BasicInteraction != null && val.BasicInteraction is InteractionToggleContraption && Vector3.Distance(_character.CenterPosition, CabalLeverPos) < leverDist)
				{
					_character.CharacterUI.ShowInfoNotification("The lever is stuck...");
					return false;
				}
			}
			return true;
		}
	}

	private static Vector3 CabalLeverPos = new Vector3(-1.6f, 12.5f, 44f);

	private static float leverDist = 2f;
}
public static class CraftingLimits
{
	[HarmonyPatch(typeof(CraftingMenu), "TryCraft")]
	public class CraftingMenu_TryCraft
	{
		[HarmonyPrefix]
		public static bool Prefix(CraftingMenu __instance)
		{
			if ((Object)(object)((__instance != null) ? ((UIElement)__instance).LocalCharacter : null) != (Object)null && ((UIElement)__instance).LocalCharacter.IsLocalPlayer)
			{
				bool flag = false;
				if (Object.op_Implicit((Object)(object)((ItemDisplay)__instance.m_recipeResultDisplay).RefItem) || !HardcoreRebalanceBase.CraftLimitsStored)
				{
					return true;
				}
				if (__instance.m_ingredientSelectors.Length <= 1)
				{
					flag = true;
				}
				else
				{
					int num = 0;
					for (int i = 0; i < __instance.m_ingredientSelectors.Length; i++)
					{
						IngredientSelector obj = __instance.m_ingredientSelectors[i];
						if (obj == null)
						{
							continue;
						}
						CompatibleIngredient assignedIngredient = obj.AssignedIngredient;
						if (assignedIngredient == null)
						{
							continue;
						}
						_ = assignedIngredient.ItemID;
						if (true)
						{
							num++;
							if (ExceptionIDs.CraftExceptions.Values.Contains(__instance.m_ingredientSelectors[i].AssignedIngredient.ItemID) || __instance.m_ingredientSelectors[i].AssignedIngredient.ItemPrefab.Name.Contains("Lantern") || __instance.m_ingredientSelectors[i].AssignedIngredient.ItemPrefab.Name.Contains("Tsar"))
							{
								flag = true;
								break;
							}
						}
					}
					if (num == 1)
					{
						flag = true;
					}
				}
				if (flag)
				{
					return true;
				}
				int num2 = ((__instance.m_lastRecipeIndex != -1) ? __instance.m_complexeRecipes[__instance.m_lastRecipeIndex].Key : __instance.m_lastFreeRecipeIndex);
				if (num2 != -1)
				{
					int num3 = 0;
					while (true)
					{
						int num4 = num3;
						Recipe obj2 = __instance.m_allRecipes[num2];
						if (!(num4 < ((obj2 == null) ? null : obj2.Results?.Length)))
						{
							break;
						}
						ItemReferenceQuantity obj3 = __instance.m_allRecipes[num2].Results[num3];
						if (obj3 != null && obj3.ItemID < -1)
						{
							Debug.Log((object)("itemID: " + __instance.m_allRecipes[num2].Results[num3].ItemID));
							((UIElement)__instance).LocalCharacter.CharacterUI.ShowInfoNotification("Mod craft allowed.");
							return true;
						}
						num3++;
					}
				}
				((UIElement)__instance).LocalCharacter.CharacterUI.ShowInfoNotification("No recipe known...");
				return false;
			}
			return true;
		}
	}

	internal static void Awake()
	{
		SL.OnGameplayResumedAfterLoading += StartingRecipe;
	}

	private static void StartingRecipe()
	{
		foreach (PlayerSystem item in Global.Lobby.PlayersInLobby)
		{
			if (!item.IsLocalPlayer)
			{
				continue;
			}
			foreach (string value2 in ExceptionIDs.StartingRecipees.Values)
			{
				if (!item.ControlledCharacter.Inventory.RecipeKnowledge.IsRecipeLearned(value2))
				{
					RecipeManager.Instance.m_recipes.TryGetValue(value2, out var value);
					item.ControlledCharacter.Inventory.RecipeKnowledge.LearnRecipe(value);
				}
			}
		}
		SL.OnGameplayResumedAfterLoading -= StartingRecipe;
	}
}
internal static class DeathMortality
{
	[HarmonyPatch(typeof(DefeatScenariosManager), "OnAllPlayersDefeated")]
	public class DefeatScenariosManager_OnAllPlayersDefeated
	{
		[HarmonyPrefix]
		public static void Prefix(DefeatScenariosManager __instance)
		{
			if (!CharacterManager.Instance.GetFirstLocalCharacter().IsWorldHost)
			{
				return;
			}
			foreach (Character value in CharacterManager.Instance.Characters.Values)
			{
				if (value.IsAI && value.Stats.CurrentHealth > 0f)
				{
					value.Stats.AffectHealth(value.Stats.MaxHealth * HardcoreBalance.deathEnemyHealMult);
				}
			}
			Item itemPrefab = ResourcesPrefabManager.Instance.GetItemPrefab(-2057);
			foreach (PlayerSystem item in Global.Lobby.PlayersInLobby)
			{
				Character controlledCharacter = item.ControlledCharacter;
				int num = 0;
				int num2 = Random.Range(1, 11);
				num = (controlledCharacter.HardcoreMode ? ((num2 <= 4) ? 1 : ((num2 <= 9) ? 2 : 3)) : ((num2 <= 7) ? 1 : ((num2 <= 9) ? 2 : 3)));
				controlledCharacter.Inventory.GenerateItem(itemPrefab, num, false);
				foreach (Item ownedItem in controlledCharacter.Inventory.GetOwnedItems(-2057))
				{
					controlledCharacter.Inventory.TakeItemToPouch(ownedItem);
				}
				((MonoBehaviour)HardcoreRebalanceBase.Instance).StartCoroutine(MoveToPouch(controlledCharacter));
				int num3 = Random.Range(500, 2500);
				controlledCharacter.Inventory.OnCharacterReceivedHit((float)num3, false);
			}
		}
	}

	[HarmonyPatch(typeof(CharacterUI), "ShowMenu", new Type[] { typeof(MenuScreens) })]
	public class CharacterUI_ShowMenu
	{
		[HarmonyPrefix]
		public static void Prefix(CharacterUI __instance, MenuScreens _menu)
		{
			Character targetCharacter = __instance.TargetCharacter;
			if (!((Object)(object)targetCharacter == (Object)null) && targetCharacter.IsLocalPlayer)
			{
				CheckMortality();
			}
		}
	}

	private static bool reviver;

	public static List<Character> allPlayers;

	private static int onlinePlayersNo;

	internal static void Awake()
	{
		SL.OnGameplayResumedAfterLoading += Fixer;
	}

	private static void Fixer()
	{
		Debug.Log((object)"CHECKING MORTALITY----");
		CheckMortality();
	}

	private static void CheckMortality()
	{
		foreach (PlayerSystem item in Global.Lobby.PlayersInLobby)
		{
			Character controlledCharacter = item.ControlledCharacter;
			if (!controlledCharacter.IsLocalPlayer || !controlledCharacter.Inventory.OwnsItem(-2057))
			{
				continue;
			}
			int num = controlledCharacter.Inventory.ItemCount(-2057);
			for (int i = 0; i < num; i++)
			{
				controlledCharacter.StatusEffectMngr.AddStatusEffect(HardcoreEffects.Mortality.ToString());
			}
			controlledCharacter.Inventory.RemoveItem(-2057, num);
			bool flag = false;
			foreach (Blessings value in Enum.GetValues(typeof(Blessings)))
			{
				if (((CharacterKnowledge)controlledCharacter.Inventory.SkillKnowledge).IsItemLearned((int)value))
				{
					Item itemFromItemID = ((CharacterKnowledge)controlledCharacter.Inventory.SkillKnowledge).GetItemFromItemID((int)value);
					ItemManager.Instance.DestroyItem(itemFromItemID);
					((CharacterKnowledge)controlledCharacter.Inventory.SkillKnowledge).RemoveItem(itemFromItemID);
					flag = true;
				}
			}
			if (flag)
			{
				controlledCharacter.CharacterUI.ShowInfoNotification("Blessings lost");
			}
		}
	}

	private static IEnumerator MoveToPouch(Character xplayer)
	{
		yield return (object)new WaitForSeconds(0.1f);
		foreach (Item ownedItem in xplayer.Inventory.GetOwnedItems(-2057))
		{
			xplayer.Inventory.TakeItemToPouch(ownedItem);
		}
	}

	public static void GetNewScenario(DefeatScenariosManager defeatManager)
	{
		DefeatScenario val = defeatManager.m_scerariosContainer.ChooseScenario();
		defeatManager.ForceDefeat(val);
	}
}
public static class ExceptionIDs
{
	private const string CRYSTAL_POWDER_RECIPE_UID = "-SEtMHRqWUmvrmyvryV8Ng";

	public static readonly Dictionary<string, string> StartingRecipees;

	public static readonly Dictionary<string, int> CraftExceptions;

	static ExceptionIDs()
	{
		StartingRecipees = new Dictionary<string, string>
		{
			["Crystal Powder"] = "-SEtMHRqWUmvrmyvryV8Ng",
			["Trinket of Elatt"] = "com.iggy.trinketrecipe",
			["Flint and Steel"] = "com.dub.flintandsteelrecipe",
			["Makeshift Hatchet"] = "com.dub.makeshifthatchetrecipe",
			["Makeshift Mining Pick"] = "com.dub.makeshiftminingpickrecipe",
			["Makeshift Fishing Harpoon"] = "com.dub.fishingharpoonrecipe",
			["Elixir of Memory Echoes"] = "4300192",
			["Sugar"] = "OE10NFgta0ulLYZCrcChnw",
			["Salt Water"] = "saltwater-recipe",
			["Racid Water clear"] = "c9nZOQ_BmUaFBmB7xEadnQ",
			["River Water clear"] = "SK6LKVhmx0CFs1-uwKJvaA",
			["charcoal"] = "com.dub.charcoal",
			["Healing Poultice"] = "com.dub.healingpoultice",
			["First Aid Tools"] = "com.dub.Firstaidtools",
			["Soaked Bandages"] = "com.dub.SoakedBandages",
			["Camping Gear"] = "com.dub.campinggear",
			["Crafting Influence"] = "com.dub.influencerecipe",
			["Crafting Fletching Feathers"] = "com.dub.fletchingfeathers"
		};
		CraftExceptions = new Dictionary<string, int>
		{
			["Explorer Lantern"] = 5100000,
			["Old Lantern"] = 5100010,
			["Glowstone Lantern"] = 5100020,
			["Firefly Lantern"] = 5100030,
			["Lantern of Souls"] = 5100080,
			["Coil Lantern"] = 5100090,
			["Virgin Lantern"] = 5100100,
			["Djinn’s Lamp"] = 5100110,
			["Calixa’s Relic"] = 6600225,
			["Elatt’s Relic"] = 6600222,
			["Gep’s Generosity"] = 6600220,
			["Haunted Memory"] = 6600224,
			["Leyline Figment"] = 6600226,
			["Pearlbird’s Courage"] = 6600221,
			["Scourge’s Tears"] = 6600223,
			["Vendavel's Hospitality"] = 6600227,
			["Flowering Corruption"] = 6600228,
			["Metalized Bones"] = 6600230,
			["Enchanted Mask"] = 6600229,
			["Noble’s Greed"] = 6600232,
			["Scarlet Whisper"] = 6600231,
			["Calygrey’s Wisdom"] = 6600233,
			["Hailfrost Claymore"] = 2100270,
			["Hailfrost Mace"] = 2020290,
			["Hailfrost Hammer"] = 2120240,
			["Hailfrost Axe"] = 2010250,
			["Hailfrost Greataxe"] = 2110230,
			["Hailfrost Spear"] = 2130280,
			["Hailfrost Halberd"] = 2150110,
			["Hailfrost Pistol"] = 5110270,
			["Hailfrost Knuckles"] = 2160200,
			["Hailfrost Sword"] = 2000280,
			["Hailfrost Dagger"] = 5110015,
			["Mysterious Blade"] = 2000320,
			["Mysterious Long Blade"] = 2100300,
			["Ceremonial Bow"] = 2200190,
			["Cracked Red Moon"] = 2150180,
			["Compasswood Staff"] = 2150030,
			["Scarred Dagger"] = 5110340,
			["De-powered Bludgeon"] = 2120270,
			["Unusual Knuckles"] = 2160230,
			["Strange Rusted Sword"] = 2000151
		};
	}
}
public static class NightGates
{
	[HarmonyPatch(typeof(CharacterManager), "RequestAreaSwitch")]
	public class CharacterManager_RequestAreaSwitch
	{
		[HarmonyPrefix]
		public static bool Prefix(CharacterManager __instance, Character _character, Area _areaToSwitchTo, int _longTravelTime, int _spawnPoint, float _offset, string _overrideLocKey)
		{
			if (!HardcoreRebalanceBase.NightGatesStored)
			{
				return true;
			}
			Debug.Log((object)("Time is: " + EnvironmentConditions.Instance.TimeOfDay));
			if (EnvironmentConditions.Instance.TimeOfDay > 20f || EnvironmentConditions.Instance.TimeOfDay < 4f)
			{
				if ((_areaToSwitchTo.SceneName == "CierzoNewTerrain" && SceneManagerHelper.ActiveSceneName == "ChersoneseNewTerrain") || (_areaToSwitchTo.SceneName == "Berg" && SceneManagerHelper.ActiveSceneName == "Emercar"))
				{
					return GetBribeStage(_character, 25);
				}
				if (_areaToSwitchTo.SceneName == "Levant" && SceneManagerHelper.ActiveSceneName == "Abrassar")
				{
					return GetBribeStage(_character, 35);
				}
				if (_areaToSwitchTo.SceneName == "Harmattan" && SceneManagerHelper.ActiveSceneName == "AntiqueField")
				{
					return GetBribeStage(_character, 30);
				}
				if (!(_areaToSwitchTo.SceneName == "Monsoon") || !(SceneManagerHelper.ActiveSceneName == "HallowedMarshNewTerrain"))
				{
					return true;
				}
				return GetBribeStage(_character, 20, isBoat: true);
			}
			return true;
		}
	}

	private static int BribeAttempt;

	private static Coroutine bribeCO;

	private static bool GetBribeStage(Character _character, int bribeCost, bool isBoat = false)
	{
		if (BribeAttempt == 0)
		{
			if (isBoat)
			{
				_character.CharacterUI.ShowInfoNotification("No sailing at night...unless...");
			}
			else
			{
				_character.CharacterUI.ShowInfoNotification("Gates are closed at night...unless...");
			}
		}
		else if (BribeAttempt == 1)
		{
			if (isBoat)
			{
				_character.CharacterUI.ShowInfoNotification("Convince boatman for " + bribeCost + " silver?");
			}
			else
			{
				_character.CharacterUI.ShowInfoNotification("Bribe guard for " + bribeCost + " silver?");
			}
		}
		else if (BribeAttempt == 2)
		{
			if (isBoat)
			{
				_character.CharacterUI.ShowInfoNotification("Wanna pay? Convince boatman for " + bribeCost + " silver?");
			}
			else
			{
				_character.CharacterUI.ShowInfoNotification("Wanna pay? Bribe guard for " + bribeCost + " silver?");
			}
		}
		if (bribeCO != null)
		{
			((MonoBehaviour)HardcoreRebalanceBase.Instance).StopCoroutine(bribeCO);
			bribeCO = null;
		}
		bribeCO = ((MonoBehaviour)HardcoreRebalanceBase.Instance).StartCoroutine(resetBribe());
		if (BribeAttempt == 3)
		{
			BribeAttempt = 0;
			if (_character.Inventory.AvailableMoney > bribeCost)
			{
				_character.Inventory.RemoveMoney(bribeCost, false);
				return true;
			}
			_character.CharacterUI.ShowInfoNotification("Not enough silver...");
			_character.Knock(true);
			return false;
		}
		if (BribeAttempt < 3)
		{
			BribeAttempt++;
		}
		return false;
	}

	private static IEnumerator resetBribe()
	{
		yield return (object)new WaitForSeconds(5f);
		BribeAttempt = 0;
	}
}
internal class Tester
{
}
public enum HardcoreItems
{
	ElattCleanse = -2051,
	ElattTrinket = -2052,
	ElattPiece = -2053,
	MortalAdd = -2057
}
public enum Blessings
{
	BlessingWisdom = -2054,
	BlessingPower = -2055,
	BlessingCourage = -2056,
	BlessingDetermination = -59000,
	BlessingInfluence = -59001,
	BlessingTolerance = -59002
}
public enum HardcoreEffects
{
	EnemyHealing,
	Mortality,
	CombatEquiping,
	TrapAware
}
public static class HardcoreBalance
{
	public static int trinketDropChance = 1;

	public static float deathEnemyHealMult = 0.6f;

	public static int flintBreakChance = 30;

	public static float reviveTimer = 4f;

	public static float timeToEquip = 2f;
}
public static class EventsManager
{
	[HarmonyPatch(typeof(NetworkLevelLoader), "UnPauseGameplay")]
	public class NetworkLevelLoader_UnPauseGameplay
	{
		[HarmonyPostfix]
		public static void Postfix(NetworkLevelLoader __instance, string _identifier)
		{
			if (HardcoreRebalanceBase.PerCityStashStored)
			{
				_cachedStash = null;
			}
		}
	}

	[HarmonyReversePatch(/*Could not decode attribute arguments.*/)]
	[HarmonyPatch(typeof(ItemContainer), "ShowContent")]
	public class ItemContainer_ShowContent
	{
		[HarmonyReversePatch(/*Could not decode attribute arguments.*/)]
		public static void Reversefix(ItemContainer __instance, Character _character)
		{
		}
	}

	[HarmonyPatch(typeof(TreasureChest), "ShowContent")]
	public class TreasureChest_ShowContent
	{
		[HarmonyPrefix]
		public static bool Prefix(TreasureChest __instance, Character _character)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Invalid comparison between Unknown and I4
			if (!HardcoreRebalanceBase.PerCityStashStored)
			{
				return true;
			}
			if ((int)((ItemContainer)__instance).SpecialType == 4 && TryGetStash(_character, out var stash))
			{
				_character.CharacterUI.StashPanel.SetStash(stash);
			}
			ItemContainer_ShowContent.Reversefix((ItemContainer)(object)__instance, _character);
			return false;
		}
	}

	[HarmonyPatch(typeof(TreasureChest), "InitDrops")]
	public class TreasureChest_InitDrops
	{
		[HarmonyPostfix]
		public static void Postfix(TreasureChest __instance)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			if (HardcoreRebalanceBase.PerCityStashStored)
			{
				_ = ((ItemContainer)__instance).SpecialType;
				_ = 4;
			}
		}
	}

	[HarmonyPatch(typeof(CharacterKnowledge), "AddItem")]
	public class CharacterKnowledge_AddItem
	{
		[HarmonyPostfix]
		public static void Postfix(CharacterKnowledge __instance, Item _item, ref Character ___m_character)
		{
			Character val = ___m_character;
			if ((Object)(object)val != (Object)null && val.IsLocalPlayer && _item.ItemID == -2051)
			{
				int num = 4;
				if (val.HardcoreMode)
				{
					num = 2;
				}
				val.StatusEffectMngr.ReduceStatusLevel(HardcoreEffects.Mortality.ToString(), num);
				ItemManager.Instance.DestroyItem(_item.UID);
				((CharacterKnowledge)val.Inventory.SkillKnowledge).RemoveItem(_item);
			}
		}
	}

	[HarmonyPatch(typeof(Item), "Use", new Type[] { typeof(Character) })]
	public class Item_Usage
	{
		[HarmonyPrefix]
		public static bool Prefix(Item __instance, Character _character)
		{
			if (!_character.IsLocalPlayer)
			{
				return true;
			}
			if (__instance.ItemID == -2052)
			{
				int num = 10;
				_character.StatusEffectMngr.ReduceStatusLevel(HardcoreEffects.Mortality.ToString(), num);
				_character.Inventory.RemoveItem(-2052, 1);
				_character.SpellCastAnim((SpellCastType)25, (SpellCastModifier)0, 0);
			}
			return true;
		}
	}

	[HarmonyPatch(typeof(BasicDeployable), "TryDeploying", new Type[] { typeof(Character) })]
	public class BasicDeployable_TryDeploying
	{
		[HarmonyPrefix]
		public static bool Prefix(BasicDeployable __instance, Character _usingCharacter)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_usingCharacter == (Object)null || !_usingCharacter.IsLocalPlayer)
			{
				return true;
			}
			if (AreaManager.Instance.GetIsCurrentAreaTownOrCity() && ((ItemExtension)__instance).Item.IsSleepKit)
			{
				float num = Vector3.Distance(levantSlums, ((Component)_usingCharacter).transform.position);
				if (SceneManagerHelper.ActiveSceneName == "Levant" && num < 30f)
				{
					return true;
				}
				_usingCharacter.CharacterUI.ShowInfoNotification("Vagrancy is not allowed");
				return false;
			}
			return true;
		}
	}

	private enum CampingActivities
	{
		None = 0,
		Sleep = 2,
		Guard = 4,
		Repair = 8
	}

	[HarmonyPatch(typeof(RestingMenu), "Show")]
	public class RestingMenu_Show
	{
		[HarmonyPrefix]
		public static void Prefix(RestingMenu __instance)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			if (!HardcoreRebalanceBase.CampingGuardStored)
			{
				return;
			}
			Debug.Log((object)"Showing Menu----");
			foreach (Transform item in ((Component)__instance.m_restingActivitiesHolder).transform)
			{
				Transform val = item;
				CampingActivities[] array = new CampingActivities[3]
				{
					CampingActivities.Sleep,
					CampingActivities.Guard,
					CampingActivities.Repair
				};
				for (int i = 0; i < array.Length; i++)
				{
					_ = array[i];
					if (((Object)((Component)val).gameObject).name.Contains(CampingActivities.Guard.ToString()))
					{
						((Component)val).gameObject.SetActive(false);
					}
				}
			}
			Debug.Log((object)"Disabling Guard----");
		}
	}

	[HarmonyPatch(typeof(Item), "OnUse")]
	public class Item_OnUse
	{
		[HarmonyPostfix]
		public static void Postfix(Item __instance, Character _targetChar)
		{
			if (__instance.ItemID == 5600010 && ((EffectSynchronizer)__instance).OwnerCharacter.IsLocalPlayer && Random.Range(1, 101) <= HardcoreBalance.flintBreakChance)
			{
				__instance.RemoveQuantity(1);
				__instance.m_ownerCharacter.CharacterUI.ShowInfoNotification("Flint and Steel broke on use.");
			}
		}
	}

	[HarmonyPatch(typeof(Character), "UpdateReviveInteraction")]
	public class Character_UpdateReviveInteraction
	{
		[HarmonyPostfix]
		public static void Prefix(Character __instance)
		{
			if (!((Object)(object)__instance == (Object)null))
			{
				Transform val = ((Component)__instance).transform.Find("ReviveInteraction");
				if ((Object)(object)val != (Object)null)
				{
					((InteractionBase)((Component)val).GetComponent<InteractionRevive>()).HoldActivationTime = HardcoreBalance.reviveTimer;
				}
			}
		}
	}

	[HarmonyPatch(typeof(DefeatCoinLost), "Activate")]
	public class DefeatCoinLost_Activate
	{
		[HarmonyPrefix]
		public static void Prefix(DefeatCoinLost __instance, Character _affectedCharacter, ref int ___m_minLostCoins, ref int ___m_maxLostCoins, ref int ___m_minPercentLost, ref int ___m_maxPerentLost)
		{
			if ((Object)(object)_affectedCharacter != (Object)null && _affectedCharacter.IsLocalPlayer)
			{
				Debug.Log((object)"lossing COINS");
				___m_minLostCoins = 50;
				___m_maxLostCoins = 500;
				___m_minPercentLost = 30;
				___m_maxPerentLost = 90;
			}
		}
	}

	[HarmonyPatch(typeof(DefeatDamageEquipment), "Activate")]
	public class DefeatDamageEquipment_Activate
	{
		[HarmonyPrefix]
		public static void Prefix(DefeatDamageEquipment __instance, Character _affectedCharacter, ref int ___m_minDamage, ref int ___m_maxDamage)
		{
			if ((Object)(object)_affectedCharacter != (Object)null && _affectedCharacter.IsLocalPlayer)
			{
				Debug.Log((object)"breaking ARMOR");
				___m_minDamage = 100;
				___m_maxDamage = 800;
			}
		}
	}

	[HarmonyPatch(typeof(CharacterEquipment), "RepairEquipment")]
	public class CharacterEquipmen_RepairEquipment
	{
		[HarmonyPrefix]
		public static void Prefix(CharacterEquipment __instance, bool _forceRepair, ref EquipmentSlot[] ___m_equipmentSlots)
		{
			if (__instance.m_character.IsLocalPlayer && ___m_equipmentSlots != null)
			{
				EquipmentSlot[] array = ___m_equipmentSlots;
				foreach (EquipmentSlot val in array)
				{
					if ((Object)(object)val != (Object)null && (Object)(object)val.EquippedItem != (Object)null && val.HasItemEquipped)
					{
						Debug.Log((object)("SHOULD REPAIR: " + val.SlotName));
						((Item)val.EquippedItem).RepairedInRest = true;
					}
				}
			}
			else
			{
				Debug.Log((object)"HARD ERROR ---------------");
			}
		}
	}

	[HarmonyPatch(typeof(CharacterEquipment), "RepairEquipmentAfterRest")]
	public class CharacterEquipmen_RepairEquipmentAfterRest
	{
		[HarmonyPrefix]
		public static void Prefix(CharacterEquipment __instance, ref EquipmentSlot[] ___m_equipmentSlots)
		{
			if (__instance.m_character.IsLocalPlayer && ___m_equipmentSlots != null)
			{
				EquipmentSlot[] array = ___m_equipmentSlots;
				foreach (EquipmentSlot val in array)
				{
					if ((Object)(object)val != (Object)null && (Object)(object)val.EquippedItem != (Object)null && val.HasItemEquipped && ((Item)val.EquippedItem).CurrentDurability <= 0f)
					{
						((Item)val.EquippedItem).RepairedInRest = false;
						Debug.Log((object)("BROKEN ITEM: " + val.SlotName));
					}
				}
			}
			else
			{
				Debug.Log((object)"HARD ERROR ---------------");
			}
		}
	}

	[HarmonyPatch(typeof(ItemDropper), "GenerateItem")]
	public class ItemDropper_GenerateItem
	{
		[HarmonyPrefix]
		public static void Prefix(ItemDropper __instance, ItemContainer _container, BasicItemDrop _itemDrop, int _spawnAmount)
		{
			if ((Object)(object)player != (Object)null && player.IsWorldHost && Random.Range(1, 200) <= HardcoreBalance.trinketDropChance)
			{
				ItemManager.Instance.GenerateItemNetwork(-2053).ChangeParent(((Component)_container).transform);
			}
		}
	}

	public static AreaManager areaManager;

	public static Character player;

	private static bool reviver = false;

	public static List<Character> allPlayers;

	private static int onlinePlayersNo;

	private static List<Character> oversleptPlayers;

	private static List<Character> wellPlayers;

	private static Vector3 levantSlums = new Vector3(-160f, 4.4f, 66f);

	private static int minAmbush = 20;

	private static bool startStash;

	private static readonly Dictionary<AreaEnum, (string UID, Vector3[] Positions)> CityStashData = new Dictionary<AreaEnum, (string, Vector3[])>
	{
		[(AreaEnum)100] = ("ImqRiGAT80aE2WtUHfdcMw", (Vector3[])(object)new Vector3[2]
		{
			new Vector3(-367.85f, -1488.25f, 596.277f),
			new Vector3(-373.539f, -1488.25f, 583.187f)
		}),
		[(AreaEnum)500] = ("ImqRiGAT80aE2WtUHfdcMw", (Vector3[])(object)new Vector3[2]
		{
			new Vector3(-386.62f, -1493.132f, 773.86f),
			new Vector3(-372.41f, -1493.132f, 773.86f)
		}),
		[(AreaEnum)200] = ("ImqRiGAT80aE2WtUHfdcMw", (Vector3[])(object)new Vector3[1]
		{
			new Vector3(-371.628f, -1493.41f, 569.91f)
		}),
		[(AreaEnum)300] = ("ZbPXNsPvlUeQVJRks3zBzg", (Vector3[])(object)new Vector3[2]
		{
			new Vector3(-369.28f, -1502.535f, 592.85f),
			new Vector3(-380.53f, -1502.535f, 593.08f)
		}),
		[(AreaEnum)400] = ("ImqRiGAT80aE2WtUHfdcMw", (Vector3[])(object)new Vector3[4]
		{
			new Vector3(-178.672f, -1515.915f, 597.934f),
			new Vector3(-182.373f, -1515.915f, 606.291f),
			new Vector3(-383.484f, -1504.82f, 583.343f),
			new Vector3(-392.681f, -1504.82f, 586.551f)
		}),
		[(AreaEnum)601] = ("IqUugGqBBkaOcQdRmhnMng", (Vector3[])(object)new Vector3[0])
	};

	private static ItemContainer _cachedStash;

	internal static void Awake()
	{
		SL.OnGameplayResumedAfterLoading += startItemsKill;
		allPlayers = new List<Character>();
		oversleptPlayers = new List<Character>();
		wellPlayers = new List<Character>();
	}

	private static void startItemsKill()
	{
		SL.OnGameplayResumedAfterLoading -= startItemsKill;
		if (!PhotonNetwork.isNonMasterClientInRoom && !startStash)
		{
			startStash = true;
			QuestEventManager.Instance.AddEvent(QuestEventDictionary.GetQuestEvent("dlMPJtXDWU6R1YEfsezlSA"), 1);
			QuestEventManager.Instance.AddEvent(QuestEventDictionary.GetQuestEvent("ypT9_eYB6UK2gnAaqJVA3g"), 1);
			QuestEventManager.Instance.AddEvent(QuestEventDictionary.GetQuestEvent("EEdVb-dL10qjF70lw0UZKw"), 1);
			QuestEventManager.Instance.AddEvent(QuestEventDictionary.GetQuestEvent("1iyLYN6eXUCQY9ZjD0kd1w"), 1);
			QuestEventManager.Instance.AddEvent(QuestEventDictionary.GetQuestEvent("Q-U-VKV68Uezx3jM4ZB8Jg"), 1);
			QuestEventManager.Instance.AddEvent(QuestEventDictionary.GetQuestEvent("_P9lL0G5RUOfVC4ydwa1kQ"), 1);
		}
	}

	public static bool TryGetStash(Character character, out ItemContainer stash)
	{
		//IL_0046: Unknown result type (might be due to invalid IL or missing references)
		//IL_0050: Expected O, but got Unknown
		if ((Object)(object)_cachedStash == (Object)null && AreaManager.Instance.CurrentArea != null && CityStashData.TryGetValue((AreaEnum)AreaManager.Instance.CurrentArea.ID, out (string, Vector3[]) value))
		{
			_cachedStash = (ItemContainer)(TreasureChest)ItemManager.Instance.GetItem(value.Item1);
		}
		stash = _cachedStash;
		return (Object)(object)stash != (Object)null;
	}
}
public static class AIManager
{
	[HarmonyPatch(typeof(Character), "UpdateStability")]
	public class Character_UpdateStability
	{
		[HarmonyPrefix]
		public static bool Prefix(Character __instance)
		{
			if (!__instance.IsLocalPlayer)
			{
				return true;
			}
			if (__instance.Blocking)
			{
				return false;
			}
			return true;
		}
	}

	[HarmonyPatch(typeof(Character), "OnReceiveHit")]
	public class Character_OnReceiveHit
	{
		[HarmonyPrefix]
		public static void Prefix(Character __instance, Weapon _weapon, float _damage, DamageList _damageList, Vector3 _hitDir, Vector3 _hitPoint, float _angle, float _angleDir, Character _dealerChar, float _knockBack)
		{
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			if (!HardcoreRebalanceBase.EnemyHealingStored || !player.IsWorldHost || (Object)(object)_dealerChar == (Object)null)
			{
				return;
			}
			if (!__instance.IsAI && _dealerChar.IsAI && _knockBack > 1f)
			{
				_dealerChar.StatusEffectMngr.AddStatusEffect(HardcoreEffects.EnemyHealing.ToString());
			}
			else if (__instance.IsAI && !_dealerChar.IsAI && _knockBack > 1f)
			{
				if (__instance.StatusEffectMngr.HasStatusEffect(HardcoreEffects.EnemyHealing.ToString()))
				{
					__instance.StatusEffectMngr.RemoveStatusWithIdentifierName(HardcoreEffects.EnemyHealing.ToString());
				}
			}
			else
			{
				if (!__instance.IsAI || !_dealerChar.IsAI)
				{
					return;
				}
				foreach (PlayerSystem item in Global.Lobby.PlayersInLobby)
				{
					Character controlledCharacter = item.ControlledCharacter;
					if (Vector3.Distance(((Component)__instance).transform.position, ((Component)controlledCharacter).transform.position) < botDmgRange)
					{
						_damage *= botDmgMult;
						return;
					}
				}
				_damage = 0f;
			}
		}
	}

	[HarmonyPatch(typeof(Character), "StabilityHit")]
	public class Character_StabilityHit
	{
		[HarmonyPrefix]
		public static void Prefix(Character __instance, ref float _knockValue, float _angle, bool _block, Character _dealerChar)
		{
			if (Object.op_Implicit((Object)(object)__instance) && Object.op_Implicit((Object)(object)_dealerChar) && __instance.Blocking)
			{
				if (__instance.IsLocalPlayer)
				{
					_knockValue *= 1.4f;
				}
				else if (__instance.IsAI)
				{
					_knockValue *= 1.2f;
				}
			}
		}
	}

	[HarmonyPatch(typeof(Character), "StabilityHit")]
	public class Character_StabilityHitPost
	{
		[HarmonyPostfix]
		public static void Postfix(Character __instance, ref float _knockValue, float _angle, bool _block, Character _dealerChar)
		{
			if (Object.op_Implicit((Object)(object)__instance) && Object.op_Implicit((Object)(object)_dealerChar) && __instance.Blocking)
			{
				if (__instance.IsAI)
				{
					_dealerChar.StabilityHit(_knockValue / 2f, _angle * -1f, false, (Character)null);
				}
				if (__instance.IsLocalPlayer)
				{
					_dealerChar.StabilityHit(_knockValue / 3f, _angle * -1f, false, (Character)null);
				}
			}
		}
	}

	[HarmonyPatch(typeof(CharacterStats), "UseMana")]
	public class Character_UseMana
	{
		[HarmonyPostfix]
		public static void Postfix(CharacterStats __instance, Tag[] _tags, ref float _amount, ref Character ___m_character)
		{
			if (___m_character.IsLocalPlayer)
			{
				drainStability(___m_character, _amount, isMana: true);
			}
		}
	}

	[HarmonyPatch(typeof(AIPreset), "ApplyToCharAI")]
	private class AIFix
	{
		[HarmonyPostfix]
		public static void Postfix(CharacterAI _charAI)
		{
			if ((Object)(object)player != (Object)null && HardcoreRebalanceBase.EnhancedAIStored)
			{
				Debug.Log((object)"APPLYING Enhanced AI--------------");
				AICEnemyDetection[] componentsInChildren = ((Component)_charAI).GetComponentsInChildren<AICEnemyDetection>(true);
				foreach (AICEnemyDetection obj in componentsInChildren)
				{
					obj.GoodViewAngle = goodViewAngle;
					obj.ViewAngle = viewAngle;
					obj.LowViewRange = lowViewRange;
					obj.ViewRange = viewRange;
					obj.ViewVisDetect = viewVisDetect;
					obj.HearingDetect = hearingDetect;
					obj.HearingDetectRange = hearingDetectRange;
					obj.HearingCanDetect = true;
					obj.SuspiciousMult = suspiciousMult;
					obj.SuspiciousDelay = suspiciousDelay;
				}
			}
		}
	}

	private static Character player;

	private static Character[] players;

	private static List<Character> allPlayers;

	private static float goodViewAngle = 40f;

	private static float viewAngle = 160f;

	private static float viewRange = 80f;

	private static float viewVisDetect = 80f;

	private static float lowViewRange = 35f;

	private static float suspiciousMult = 20f;

	private static float suspiciousDelay = 10f;

	private static float hearingDetect = 30f;

	private static float hearingDetectRange = 40f;

	private static float chanceToSwitchTargetOnHurt = 80f;

	private static int playersNo = 0;

	private static int counterNum = 0;

	private static List<UID> enemyHOTs;

	private static List<int> enemyTimers;

	private static int botRegenTimer = 20;

	private static float botDmgRange = 40f;

	private static float botDmgMult = 0.2f;

	private static int pullEnemiesTimer = 3;

	private static Coroutine pullCO;

	internal static void Awake()
	{
		enemyHOTs = new List<UID>();
		enemyTimers = new List<int>();
		players = (Character[])(object)new Character[2];
		allPlayers = new List<Character>();
		SL.OnGameplayResumedAfterLoading += Fixer;
		SL.OnGameplayResumedAfterLoading += NerfStability;
	}

	private static void NerfStability()
	{
		foreach (PlayerSystem item in Global.Lobby.PlayersInLobby)
		{
			item.ControlledCharacter.Stats.m_stabilityRegen.BaseValue = 5f;
		}
	}

	private static void Fixer()
	{
		counterNum = 0;
		player = CharacterManager.Instance.GetFirstLocalCharacter();
		if (player.IsWorldHost)
		{
			if (pullCO != null)
			{
				((MonoBehaviour)HardcoreRebalanceBase.Instance).StopCoroutine(pullCO);
			}
			pullCO = ((MonoBehaviour)HardcoreRebalanceBase.Instance).StartCoroutine(EnemyPull());
			((MonoBehaviour)HardcoreRebalanceBase.Instance).StartCoroutine(EnemyHealer());
		}
	}

	private static IEnumerator EnemyHealer()
	{
		yield return (object)new WaitForSeconds(2f);
		List<Character> list = new List<Character>();
		CharacterManager.Instance.FindCharactersInRange(player.CenterPosition, botDmgRange, ref list);
		foreach (Character item in list)
		{
			if (item.IsAI && item.Alive && !item.IsDead && item.Stats.CurrentHealth > 2f)
			{
				item.Stats.AffectHealth(1000f);
			}
		}
	}

	private static IEnumerator EnemyPull()
	{
		while ((Object)(object)player != (Object)null)
		{
			foreach (PlayerSystem item in Global.Lobby.PlayersInLobby)
			{
				Character nplayer = item.ControlledCharacter;
				if (!((Object)(object)nplayer != (Object)null))
				{
					continue;
				}
				List<Character> list = new List<Character>();
				CharacterManager.Instance.FindCharactersInRange(nplayer.CenterPosition, botDmgRange, ref list);
				foreach (Character enemy in list)
				{
					yield return (object)new WaitForSeconds(Random.Range(0.1f, (float)pullEnemiesTimer));
					TargetingSystem targetingSystem = enemy.TargetingSystem;
					if ((Object)(object)((targetingSystem != null) ? targetingSystem.LockingPoint : null) != (Object)null && !enemy.IsAlly(nplayer) && enemy.IsAI && enemy.Stats.CurrentHealth > 0f && !Physics.Linecast(enemy.CenterPosition, ((Component)((Component)nplayer).gameObject.GetComponent<Collider>()).transform.position, Global.SightHideMask) && Random.Range(1, 3) == 1)
					{
						enemy.TargetingSystem.SwitchTarget(nplayer.LockingPoint);
					}
				}
			}
		}
	}

	private static void drainStability(Character player, float _amount, bool isMana = false)
	{
		_amount = ((!isMana) ? (_amount * 1f) : (_amount * 2.5f));
		if (_amount >= 30f)
		{
			_amount = 30f;
		}
		player.m_stability = Mathf.Clamp(player.m_stability - _amount, 0f, 100f);
		_ = player.Stability;
		_ = 1f;
	}
}
[BepInPlugin("com.iggy.hardcorere", "True Hardcore", "3.1.0")]
[BepInDependency("com.sinai.SideLoader", "3.7.7")]
public class HardcoreRebalanceBase : BaseUnityPlugin
{
	private const string GUID = "com.iggy.hardcorere";

	private const string NAME = "True Hardcore";

	private const string VERSION = "3.1.0";

	public static ConfigEntry<bool> EnhancedAI;

	public static ConfigEntry<bool> PickupAnim;

	public static ConfigEntry<bool> PerCityStash;

	public static ConfigEntry<bool> CampingGuard;

	public static ConfigEntry<bool> CraftLimits;

	public static ConfigEntry<bool> NightGates;

	public static ConfigEntry<bool> EnemyHealing;

	public static bool EnhancedAIStored;

	public static bool PickupAnimStored;

	public static bool PerCityStashStored;

	public static bool CampingGuardStored;

	public static bool CraftLimitsStored;

	public static bool NightGatesStored;

	public static bool EnemyHealingStored;

	public static string OptionsName = "Weenie Hut Jrs Options (RESTART REQUIRED)";

	public static HardcoreRebalanceBase Instance;

	internal void Awake()
	{
		//IL_0110: Unknown result type (might be due to invalid IL or missing references)
		Instance = this;
		Debug.Log((object)"True Hardcoreawake");
		EnhancedAI = ((BaseUnityPlugin)this).Config.Bind<bool>(OptionsName, "Improve enemies AI", true, "Disable to: Remove Improved enemies sight, aggresiveness and hearing.");
		PickupAnim = ((BaseUnityPlugin)this).Config.Bind<bool>(OptionsName, "OoC Animations", true, "Disable to: Remove looting and equiping animations while out of combat");
		PerCityStash = ((BaseUnityPlugin)this).Config.Bind<bool>(OptionsName, "Per City Stash", true, "Disable to: Make stashes universal again, instead of per city.");
		CampingGuard = ((BaseUnityPlugin)this).Config.Bind<bool>(OptionsName, "Unsafe Camping", true, "Disable to: Allow players to guard while camping.");
		CraftLimits = ((BaseUnityPlugin)this).Config.Bind<bool>(OptionsName, "Crafting Limits", true, "Disable to: Allow VANILLA items to be crafted without recipee knowledge too. By default only MOD items can be crafted with no recipee.");
		NightGates = ((BaseUnityPlugin)this).Config.Bind<bool>(OptionsName, "Night Gates", true, "Disable to: Allow players to enter cities freely at night.");
		EnemyHealing = ((BaseUnityPlugin)this).Config.Bind<bool>(OptionsName, "Enemy Healing", true, "Disable to: Stop enemies from healing when damaging players.");
		_ = ((Component)this).gameObject;
		EventsManager.Awake();
		AIManager.Awake();
		CraftingLimits.Awake();
		DeathMortality.Awake();
		new Harmony("com.iggy.hardcorere").PatchAll();
	}

	internal void Start()
	{
		EnhancedAIStored = EnhancedAI.Value;
		PickupAnimStored = PickupAnim.Value;
		PerCityStashStored = PerCityStash.Value;
		CampingGuardStored = CampingGuard.Value;
		CraftLimitsStored = CraftLimits.Value;
		NightGatesStored = NightGates.Value;
		EnemyHealingStored = EnemyHealing.Value;
		Debug.Log((object)"True HardcoreLoaded");
	}
}
internal static class TrapAwareness
{
	[HarmonyPatch(typeof(TrapTrigger), "OnTriggerEnter")]
	public class TrapTrigger_OnTriggerEnter
	{
		[HarmonyPrefix]
		public static bool Prefix(TrapTrigger __instance, Collider _other)
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Invalid comparison between Unknown and I4
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Invalid comparison between Unknown and I4
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			if (AreaManager.Instance.GetIsCurrentAreaTownOrCity())
			{
				return true;
			}
			if ((Object)(object)_other == (Object)null)
			{
				return true;
			}
			if ((Object)(object)NetworkLevelLoader.Instance == (Object)null || !NetworkLevelLoader.Instance.IsOverallLoadingDone)
			{
				if (!__instance.m_pendingActivation.Contains(_other))
				{
					__instance.m_pendingActivation.Add(_other);
				}
				return true;
			}
			Character component = ((Component)_other).GetComponent<Character>();
			if ((Object)(object)component == (Object)null || __instance.m_charactersInTrigger.Contains(component))
			{
				return true;
			}
			if (__instance.IgnoreFaction || ((int)__instance.m_targetType == 1 && Object.op_Implicit((Object)(object)component.OwnerPlayerSys)) || ((int)__instance.m_targetType == 2 && UnityEngineExtensions.Contains<Factions>(__instance.m_targetableFactions, component.Faction)))
			{
				if (component.StatusEffectMngr.HasStatusEffect(HardcoreEffects.TrapAware.ToString()))
				{
					return false;
				}
				Debug.Log((object)(component.Name + " Added Awareness"));
				component.StatusEffectMngr.AddStatusEffect(HardcoreEffects.TrapAware.ToString());
				return true;
			}
			return true;
		}
	}
}

The result has been truncated due to the large size, download it to view the full contents!

using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using SideLoader;
using SideLoader.Model;
using SideLoader.Model.Status;
using SideLoader_ExtendedEffects.Events;
using SideLoader_ExtendedEffects.Item_Context_Menu;
using SideLoader_ExtendedEffects.Released;
using TravelSpeed.Extensions;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("SideLoader Custom Effects")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("SideLoader Custom Effects")]
[assembly: AssemblyCopyright("Copyright ©  2021")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("c5450fe0-edcf-483f-b9ea-4b1ef9d36da7")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
namespace TravelSpeed.Patches
{
	[HarmonyPatch(typeof(Effect))]
	public static class EffectPatches
	{
		[HarmonyPatch("TryActivateLocally")]
		[HarmonyPrefix]
		public static bool Effect_TryActivateLocally_Prefix(Effect __instance, Character _affectedCharacter, object[] _infos)
		{
			return (Object)(object)__instance.m_parentStatusEffect == (Object)null || !__instance.m_parentStatusEffect.IsEffectSuspended();
		}
	}
	[HarmonyPatch(typeof(StatusEffectDetailDisplay))]
	public static class StatusEffectDetailDisplayPatches
	{
		[HarmonyPatch("RefreshDisplay")]
		[HarmonyPostfix]
		public static void StatusEffectDetailDisplay_RefreshDisplay_Postfix(StatusEffectDetailDisplay __instance)
		{
			if ((Object)(object)__instance.m_statusEffect != (Object)null && __instance.m_statusEffect.IsTimerSuspended() && Object.op_Implicit((Object)(object)__instance.m_lblTimer))
			{
				__instance.m_lblTimer.text = "Suspended";
			}
		}
	}
	[HarmonyPatch(typeof(StatusEffect))]
	public static class StatusEffectPatches
	{
		[HarmonyPatch("UpdateTotalData")]
		[HarmonyPrefix]
		public static void StatusEffect_UpdateTotalData_Prefix(StatusEffect __instance, ref bool _updateDelta)
		{
			if (__instance.IsTimerSuspended())
			{
				_updateDelta = false;
			}
		}
	}
}
namespace TravelSpeed.Extensions
{
	public class StatusEffectExt
	{
		private bool timerSuspended = false;

		private bool effectSuspended = false;

		public bool TimerSuspended
		{
			get
			{
				return timerSuspended;
			}
			set
			{
				timerSuspended = value;
			}
		}

		public bool EffectSuspended
		{
			get
			{
				return effectSuspended;
			}
			set
			{
				effectSuspended = value;
			}
		}
	}
	public static class StatusEffectExtensions
	{
		private static ConditionalWeakTable<StatusEffect, StatusEffectExt> SuspendedEffects = new ConditionalWeakTable<StatusEffect, StatusEffectExt>();

		public static void SetTimerSuspended(this StatusEffect statusEffect, bool suspended)
		{
			StatusEffectExt value = SuspendedEffects.GetValue(statusEffect, (StatusEffect key) => new StatusEffectExt());
			value.TimerSuspended = suspended;
		}

		public static bool IsTimerSuspended(this StatusEffect statusEffect)
		{
			if (SuspendedEffects.TryGetValue(statusEffect, out var value))
			{
				return value.TimerSuspended;
			}
			return false;
		}

		public static void SetEffectSuspended(this StatusEffect statusEffect, bool suspended)
		{
			StatusEffectExt value = SuspendedEffects.GetValue(statusEffect, (StatusEffect key) => new StatusEffectExt());
			value.EffectSuspended = suspended;
		}

		public static bool IsEffectSuspended(this StatusEffect statusEffect)
		{
			if (SuspendedEffects.TryGetValue(statusEffect, out var value))
			{
				return value.EffectSuspended;
			}
			return false;
		}
	}
}
namespace SideLoader_ExtendedEffects
{
	public class CustomItemMenuManager
	{
		public Dictionary<int, CustomItemDisplayMenuOption> CustomItemOptions { get; private set; }

		public CustomItemMenuManager()
		{
			CustomItemOptions = new Dictionary<int, CustomItemDisplayMenuOption>();
		}

		public void RegisterCustomMenuOption(int NewActionID, string ActionString, Action<Character, Item, ItemDisplayOptionPanel, int> OnCustomActionPressed, Func<Character, Item, ItemDisplayOptionPanel, int, bool> ShouldAddAction)
		{
			ExtendedEffects.Instance?.DebugLogMessage($"Registering custom action with ID {NewActionID} String {ActionString}");
			if (!CustomItemOptions.ContainsKey(NewActionID))
			{
				CustomItemOptions.Add(NewActionID, new CustomItemDisplayMenuOption(NewActionID, ActionString, OnCustomActionPressed, ShouldAddAction));
			}
			else
			{
				ExtendedEffects.Instance?.DebugLogMessage($"Custom Action already exists with ID {NewActionID}");
			}
		}

		public void UnRegisterCustomMenuOption(int CustomActionID)
		{
			if (CustomItemOptions.ContainsKey(CustomActionID))
			{
				ExtendedEffects.Instance?.DebugLogMessage($"UnRegistering custom action ID {CustomActionID}");
				CustomItemOptions.Remove(CustomActionID);
			}
		}
	}
	[BepInPlugin("sideloaderextendedeffects.extendedeffects", "SideLoader Extended Effects", "1.2.4")]
	public class ExtendedEffects : BaseUnityPlugin
	{
		public const string GUID = "sideloaderextendedeffects.extendedeffects";

		public const string NAME = "SideLoader Extended Effects";

		public const string VERSION = "1.2.4";

		internal static ManualLogSource _Log;

		public const string SL_VISUAL_TRANSFORM = "SLVISUALCONTAINER";

		public static ConfigEntry<bool> AddTestItems;

		public static ConfigEntry<bool> AddItemDebug;

		public static ConfigEntry<bool> ShowDebugLog;

		private static Dictionary<string, string> _SkillTreeOverrides = new Dictionary<string, string>();

		public static ExtendedEffects Instance { get; private set; }

		public CustomItemMenuManager CustomItemMenuManager { get; private set; }

		public static Dictionary<string, string> SkillTreeOverrides => _SkillTreeOverrides;

		internal void Awake()
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			_Log = ((BaseUnityPlugin)this).Logger;
			Instance = this;
			CustomItemMenuManager = new CustomItemMenuManager();
			InitializeSL();
			InitializeConfig();
			new Harmony("sideloaderextendedeffects.extendedeffects").PatchAll();
		}

		private void InitializeSL()
		{
			SL.BeforePacksLoaded += SL_BeforePacksLoaded;
		}

		private void InitializeConfig()
		{
			AddItemDebug = ((BaseUnityPlugin)this).Config.Bind<bool>("SideLoader Extended Effects", "Add Debug Menu options to Items", false, "Add Debug Menu options to Items.");
			AddTestItems = ((BaseUnityPlugin)this).Config.Bind<bool>("SideLoader Extended Effects", "Add Test Items", false, "Adds test items, spawnable using the debug mode menu (requires restart)");
			ShowDebugLog = ((BaseUnityPlugin)this).Config.Bind<bool>("SideLoader Extended Effects", "Show Debug Log", true, "Enables the Debug Log for SideLoader Extended Effects.");
		}

		private void SL_BeforePacksLoaded()
		{
			if (AddTestItems.Value)
			{
				DefineTestItems();
			}
			if (AddItemDebug.Value)
			{
				CustomItemMenuManager.RegisterCustomMenuOption(101010, "Debug Log Item", delegate(Character Character, Item Item, ItemDisplayOptionPanel ItemDisplayOptionPanel, int someInt)
				{
					((BaseUnityPlugin)this).Logger.LogMessage((object)Item);
					((BaseUnityPlugin)this).Logger.LogMessage((object)$"Item Name {Item.DisplayName} Item ID {Item.ItemID} Item UID {Item.UID}");
					((BaseUnityPlugin)this).Logger.LogMessage((object)$"Item Current Slot {Item.CurrentEquipmentSlot}");
					((BaseUnityPlugin)this).Logger.LogMessage((object)$"Durability {Item.CurrentDurability} / {Item.MaxDurability}");
				}, null);
				CustomItemMenuManager.RegisterCustomMenuOption(101110, "Repair Item", delegate(Character Character, Item Item, ItemDisplayOptionPanel ItemDisplayOptionPanel, int someInt)
				{
					Item.RepairAmount(9000f);
				}, null);
			}
		}

		public static void AddSkillTreeOverride(string trainerUID, string customTreeUID)
		{
			if (!SkillTreeOverrides.ContainsKey(trainerUID))
			{
				SkillTreeOverrides.Add(trainerUID, customTreeUID);
			}
			else
			{
				_Log.LogMessage((object)"Override already found for this Trainer! Not sure how to handle this!");
			}
		}

		public static bool HasSkillTreeOverride(string trainerUID)
		{
			return SkillTreeOverrides.ContainsKey(trainerUID);
		}

		private void DefineTestItems()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Expected O, but got Unknown
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Expected O, but got Unknown
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Expected O, but got Unknown
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Expected O, but got Unknown
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Expected O, but got Unknown
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Expected O, but got Unknown
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Expected O, but got Unknown
			SL_MeleeWeapon val = new SL_MeleeWeapon();
			((SL_Item)val).Target_ItemID = 2000031;
			((SL_Item)val).New_ItemID = -26999;
			((SL_Item)val).Name = "Emo Test Blade of Testing";
			((SL_Item)val).Description = "WHACK";
			((SL_Item)val).StatsHolder = (SL_ItemStats)new SL_WeaponStats
			{
				BaseDamage = new List<SL_Damage>
				{
					new SL_Damage
					{
						Damage = 25f,
						Type = (Types)0
					}
				},
				AttackSpeed = 0.9f
			};
			SL_EffectTransform[] array = new SL_EffectTransform[1];
			SL_EffectTransform val2 = new SL_EffectTransform();
			val2.TransformName = "Activation";
			val2.Effects = (SL_Effect[])(object)new SL_Effect[0];
			array[0] = val2;
			((SL_Item)val).EffectTransforms = (SL_EffectTransform[])(object)array;
			SL_MeleeWeapon val3 = val;
			((ContentTemplate)val3).ApplyTemplate();
			SL_Item val4 = new SL_Item();
			val4.Target_ItemID = 4300130;
			val4.New_ItemID = -26987;
			val4.Name = "Emo Test Potion";
			val4.Description = "Test Potion";
			val4.EffectBehaviour = (EditBehaviours)2;
			val4.QtyRemovedOnUse = 0;
			SL_EffectTransform[] array2 = new SL_EffectTransform[1];
			val2 = new SL_EffectTransform();
			val2.TransformName = "Effects";
			val2.Effects = (SL_Effect[])(object)new SL_Effect[0];
			array2[0] = val2;
			val4.EffectTransforms = (SL_EffectTransform[])(object)array2;
			SL_Item val5 = val4;
			((ContentTemplate)val5).ApplyTemplate();
			SL_Skill val6 = new SL_Skill();
			((SL_Item)val6).Target_ItemID = 8100120;
			((SL_Item)val6).New_ItemID = -26986;
			((SL_Item)val6).Name = "Emo Test Skill";
			((SL_Item)val6).EffectBehaviour = (EditBehaviours)1;
			SL_EffectTransform[] array3 = new SL_EffectTransform[1];
			val2 = new SL_EffectTransform();
			val2.TransformName = "Activation";
			val2.Effects = (SL_Effect[])(object)new SL_Effect[2]
			{
				new SL_RemoveItemFromInventory
				{
					ItemID = 4000010,
					ItemQuantity = 5
				},
				new SL_RemoveItemFromInventory
				{
					ItemID = 2000010,
					ItemQuantity = 2
				}
			};
			array3[0] = val2;
			((SL_Item)val6).EffectTransforms = (SL_EffectTransform[])(object)array3;
			SL_Skill val7 = val6;
			((ContentTemplate)val7).ApplyTemplate();
		}

		public void DebugLogMessage(object logMessage)
		{
			if (ShowDebugLog.Value && _Log != null)
			{
				_Log.LogMessage(logMessage);
			}
		}
	}
	public class InstancedEvent<TInstance, TEvent> where TEvent : Delegate
	{
		private readonly Dictionary<TInstance, TEvent> dictionary = new Dictionary<TInstance, TEvent>();

		public void AddListener(TInstance instance, TEvent listener)
		{
			if (!dictionary.ContainsKey(instance))
			{
				dictionary.Add(instance, listener);
				return;
			}
			TEvent a = dictionary[instance];
			a = Delegate.Combine(a, listener) as TEvent;
			dictionary[instance] = a;
		}

		public void RemoveListener(TInstance instance, TEvent listener)
		{
			if (dictionary.TryGetValue(instance, out var value))
			{
				value = Delegate.Remove(value, listener) as TEvent;
				if (!value.GetInvocationList().Any())
				{
					dictionary.Remove(instance);
				}
				else
				{
					dictionary[instance] = value;
				}
			}
		}

		internal void InvokeForInstance(TInstance instance, params object[] args)
		{
			if (dictionary.TryGetValue(instance, out var value))
			{
				value.DynamicInvoke(args);
			}
		}
	}
	public static class OutwardEvents
	{
		public static InstancedEvent<Character, Action<Character, CharacterDamageEvent>> OnCharacterRecievedHit;
	}
	public static class OutwardHelpers
	{
		public static string Emission_Property_Value = "_EmissionColor";

		public static void UpdateWeaponDamage(Weapon WeaponInstance, DamageList newDamageList)
		{
			WeaponInstance.Damage.Clear();
			WeaponInstance.Stats.BaseDamage = newDamageList;
			WeaponInstance.m_baseDamage = WeaponInstance.Stats.BaseDamage.Clone();
			WeaponInstance.m_activeBaseDamage = WeaponInstance.Stats.BaseDamage.Clone();
			WeaponInstance.baseDamage = WeaponInstance.Stats.BaseDamage.Clone();
			WeaponInstance.Stats.Attacks = SL_WeaponStats.GetScaledAttackData(WeaponInstance);
		}

		public static MeshFilter TryGetWeaponMesh(Equipment weaponGameObject, bool IncludeInActive = true)
		{
			BoxCollider[] componentsInChildren = ((Component)((Item)weaponGameObject).GetItemVisual()).GetComponentsInChildren<BoxCollider>(true);
			foreach (BoxCollider val in componentsInChildren)
			{
				ExtendedEffects.Instance.DebugLogMessage("BoxCollider GO Name " + ((Object)((Component)val).transform).name);
				if (((Component)((Component)val).transform.parent).gameObject.activeInHierarchy)
				{
					return ((Component)val).GetComponent<MeshFilter>();
				}
			}
			return null;
		}

		public static Transform TryGetHumanBone(Character character, HumanBodyBones bone)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			return ((Object)(object)character.Animator != (Object)null) ? character.Animator.GetBoneTransform(bone) : null;
		}

		public static T GetFromAssetBundle<T>(string SLPackName, string AssetBundle, string key) where T : Object
		{
			if (!SL.PacksLoaded)
			{
				return default(T);
			}
			return SL.GetSLPack(SLPackName).AssetBundles[AssetBundle].LoadAsset<T>(key);
		}

		public static List<T> GetTypeFromColliders<T>(Collider[] colliders) where T : Component
		{
			List<T> list = new List<T>();
			foreach (Collider val in colliders)
			{
				T componentInChildren = ((Component)val).GetComponentInChildren<T>();
				if ((Object)(object)componentInChildren != (Object)null)
				{
					list.Add(componentInChildren);
				}
			}
			return list;
		}

		public static Tag GetTagFromName(string tagName)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			Tag[] tags = TagSourceManager.Instance.m_tags;
			foreach (Tag val in tags)
			{
				if (val.TagName == tagName)
				{
					return val;
				}
			}
			return default(Tag);
		}
	}
	public struct CharacterDamageEvent
	{
		public Character DamageTarget;

		public object DamageSource;

		public float TotalDamage;

		public DamageList DamageDone;

		public Vector3 DamageDirection;

		public Vector3 DamagePosition;

		public float HitAngle;

		public float HitAngleDirection;

		public Character DamageSourceCharacter;

		public float KnocksBack;

		public bool DamageInventory;
	}
	public struct BagEventData
	{
		public Bag Bag;

		public Character CharacterOwner;
	}
	public class SL_AffectCooldown : SL_Effect, ICustomModel
	{
		public float Amount;

		public bool IsModifier;

		public bool OnOwner;

		public int[] AllowedSkills;

		public Type SLTemplateModel => typeof(SL_AffectCooldown);

		public Type GameModel => typeof(AffectCooldown);

		public override void ApplyToComponent<T>(T component)
		{
			AffectCooldown affectCooldown = component as AffectCooldown;
			affectCooldown.Amount = Amount;
			affectCooldown.IsModifier = IsModifier;
			affectCooldown.OnOwner = OnOwner;
			affectCooldown.AllowedSkills = AllowedSkills;
		}

		public override void SerializeEffect<T>(T effect)
		{
			AffectCooldown affectCooldown = effect as AffectCooldown;
			Amount = affectCooldown.Amount;
			IsModifier = affectCooldown.IsModifier;
			OnOwner = affectCooldown.OnOwner;
			AllowedSkills = affectCooldown.AllowedSkills;
		}
	}
	public class AffectCooldown : Effect, ICustomModel
	{
		public float Amount;

		public bool IsModifier;

		public bool OnOwner;

		public int[] AllowedSkills;

		public Type SLTemplateModel => typeof(SL_AffectCooldown);

		public Type GameModel => typeof(AffectCooldown);

		public override void ActivateLocally(Character _affectedCharacter, object[] _infos)
		{
			Character val = (OnOwner ? ((Effect)this).OwnerCharacter : _affectedCharacter);
			IList<string> learnedActiveSkillUIDs = val.Inventory.SkillKnowledge.GetLearnedActiveSkillUIDs();
			foreach (string item2 in learnedActiveSkillUIDs)
			{
				Item item = ItemManager.Instance.GetItem(item2);
				Skill val2 = (Skill)(object)((item is Skill) ? item : null);
				SL.Log(((Item)val2).Name + " " + ((Item)val2).ItemID);
				if (AllowedSkills != null && AllowedSkills.Length != 0 && !Extensions.Contains(AllowedSkills, ((Item)val2).ItemID))
				{
					SL.Log("Not Whitelisted");
					continue;
				}
				float num = (IsModifier ? (val2.RealCooldown * Amount / 100f) : Amount);
				val2.m_remainingCooldownTime -= num;
				val2.UpdateCooldownRatio();
			}
		}
	}
	public class SL_ApplyEnchantment : SL_Effect, ICustomModel
	{
		public EquipmentSlotIDs EquipmentSlot;

		public int EnchantmentID;

		public bool ApplyPermanently;

		public Type SLTemplateModel => typeof(SL_ApplyEnchantment);

		public Type GameModel => typeof(ApplyEnchantment);

		public override void ApplyToComponent<T>(T component)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			ApplyEnchantment applyEnchantment = component as ApplyEnchantment;
			applyEnchantment.EquipmentSlot = EquipmentSlot;
			applyEnchantment.EnchantmentId = EnchantmentID;
			applyEnchantment.ApplyPermanently = ApplyPermanently;
		}

		public override void SerializeEffect<T>(T effect)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			ApplyEnchantment applyEnchantment = effect as ApplyEnchantment;
			EnchantmentID = applyEnchantment.EnchantmentId;
			EquipmentSlot = applyEnchantment.EquipmentSlot;
			ApplyPermanently = applyEnchantment.ApplyPermanently;
		}
	}
	public class ApplyEnchantment : Effect, ICustomModel
	{
		public EquipmentSlotIDs EquipmentSlot;

		public int EnchantmentId;

		public bool ApplyPermanently;

		[SerializeField]
		private UID affectedItem = UID.Empty;

		public Type SLTemplateModel => typeof(SL_ApplyEnchantment);

		public Type GameModel => typeof(ApplyEnchantment);

		public override void ActivateLocally(Character _affectedCharacter, object[] _infos)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_affectedCharacter == (Object)null)
			{
				ExtendedEffects.Instance.DebugLogMessage("Affected Character null");
			}
			else if (_affectedCharacter.Inventory.Equipment.EquipmentSlots[EquipmentSlot].HasItemEquipped)
			{
				Equipment equippedItem = _affectedCharacter.Inventory.Equipment.EquipmentSlots[EquipmentSlot].EquippedItem;
				if (UID.op_Implicit(((Item)equippedItem).UID) != affectedItem)
				{
					ExtendedEffects.Instance.DebugLogMessage("Item has Changed");
					if (!((UID)(ref affectedItem)).IsNull)
					{
						ExtendedEffects.Instance.DebugLogMessage("Cleaning Affected Item");
						CleanAffectedItem();
					}
					affectedItem = UID.op_Implicit(((Item)equippedItem).UID);
					if (!equippedItem.m_enchantmentIDs.Contains(EnchantmentId))
					{
						ExtendedEffects.Instance.DebugLogMessage($"Adding Enchant {EnchantmentId} to {((Item)equippedItem).Name}");
						equippedItem.AddEnchantment(EnchantmentId, false);
					}
				}
			}
			else if (!((UID)(ref affectedItem)).IsNull)
			{
				CleanAffectedItem();
			}
		}

		public override void StopAffectLocally(Character _affectedCharacter)
		{
			if (!((UID)(ref affectedItem)).IsNull)
			{
				CleanAffectedItem();
			}
			((Effect)this).StopAffectLocally(_affectedCharacter);
		}

		private void CleanAffectedItem()
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			if (ApplyPermanently)
			{
				return;
			}
			Item item = ItemManager.Instance.GetItem(UID.op_Implicit(affectedItem));
			Equipment val = (Equipment)(object)((item is Equipment) ? item : null);
			val.m_enchantmentIDs.Remove(EnchantmentId);
			foreach (Enchantment activeEnchantment in val.m_activeEnchantments)
			{
				if (((EffectPreset)activeEnchantment).PresetID == EnchantmentId)
				{
					val.m_activeEnchantments.Remove(activeEnchantment);
					activeEnchantment.UnapplyEnchantment();
					float durabilityRatio = ((Item)val).DurabilityRatio;
					val.RefreshEnchantmentModifiers();
					if (durabilityRatio != ((Item)val).DurabilityRatio)
					{
						((Item)val).SetDurabilityRatio(durabilityRatio);
					}
					break;
				}
			}
			affectedItem = UID.Empty;
		}
	}
	public class SL_ChangeMaterialTimed : SL_Effect, ICustomModel
	{
		public string SLPackName;

		public string AssetBundleName;

		public string PrefabName;

		public float ChangeTime;

		public Type SLTemplateModel => typeof(SL_ChangeMaterialTimed);

		public Type GameModel => typeof(ChangeMaterialTimed);

		public override void ApplyToComponent<T>(T component)
		{
			ChangeMaterialTimed changeMaterialTimed = component as ChangeMaterialTimed;
			changeMaterialTimed.ChangeTime = ChangeTime;
			changeMaterialTimed.SLPackName = SLPackName;
			changeMaterialTimed.AssetBundleName = AssetBundleName;
			changeMaterialTimed.PrefabName = PrefabName;
		}

		public override void SerializeEffect<T>(T effect)
		{
			ChangeMaterialTimed changeMaterialTimed = effect as ChangeMaterialTimed;
			ChangeTime = changeMaterialTimed.ChangeTime;
			SLPackName = changeMaterialTimed.SLPackName;
			AssetBundleName = changeMaterialTimed.AssetBundleName;
			PrefabName = changeMaterialTimed.PrefabName;
		}
	}
	public class ChangeMaterialTimed : Effect, ICustomModel
	{
		public string SLPackName;

		public string AssetBundleName;

		public string PrefabName;

		public float ChangeTime;

		private bool IsChanged;

		private Dictionary<Renderer, Material> CurrentRenderers = new Dictionary<Renderer, Material>();

		public Type SLTemplateModel => typeof(SL_ChangeMaterialTimed);

		public Type GameModel => typeof(ChangeMaterialTimed);

		public override void ActivateLocally(Character _affectedCharacter, object[] _infos)
		{
			if (IsChanged)
			{
				return;
			}
			Material fromAssetBundle = OutwardHelpers.GetFromAssetBundle<Material>(SLPackName, AssetBundleName, PrefabName);
			if ((Object)(object)fromAssetBundle != (Object)null)
			{
				CacheOriginalMaterials(_affectedCharacter);
				ChangeMaterialForRenderers(fromAssetBundle);
				if (ChangeTime > 0f)
				{
					((MonoBehaviour)this).StartCoroutine(DelayRevert(_affectedCharacter));
				}
				IsChanged = true;
			}
		}

		private IEnumerator DelayRevert(Character _affectedCharacter)
		{
			yield return (object)new WaitForSeconds(ChangeTime);
			ReturnToOriginalMaterials();
		}

		public override void StopAffectLocally(Character _affectedCharacter)
		{
			((Effect)this).StopAffectLocally(_affectedCharacter);
			if (ChangeTime <= 0f)
			{
				ReturnToOriginalMaterials();
			}
		}

		private void CacheOriginalMaterials(Character _affectedCharacter)
		{
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Expected O, but got Unknown
			if ((Object)(object)_affectedCharacter == (Object)null)
			{
				return;
			}
			if (CurrentRenderers.Count > 0)
			{
				ReturnToOriginalMaterials();
			}
			CurrentRenderers.Clear();
			ExtendedEffects.Instance.DebugLogMessage("Caching Original Materials");
			Renderer[] renderers = GetRenderers(_affectedCharacter.VisualHolderTrans, IncludeInActive: false);
			Renderer[] array = renderers;
			foreach (Renderer val in array)
			{
				if ((Object)(object)val != (Object)null)
				{
					ExtendedEffects.Instance.DebugLogMessage("Cached " + ((Object)((Component)val).transform).name + " " + ((Object)val.material).name);
					CurrentRenderers.Add(val, new Material(val.material));
				}
			}
		}

		private void ChangeMaterialForRenderers(Material NewMaterial)
		{
			foreach (KeyValuePair<Renderer, Material> currentRenderer in CurrentRenderers)
			{
				if (!((Object)(object)currentRenderer.Key == (Object)null) && !((Object)(object)currentRenderer.Value == (Object)null) && CurrentRenderers.TryGetValue(currentRenderer.Key, out var _))
				{
					ExtendedEffects.Instance.DebugLogMessage($"Changing {((Object)((Component)currentRenderer.Key).transform).name} to {NewMaterial}");
					currentRenderer.Key.material = NewMaterial;
				}
			}
		}

		private void ReturnToOriginalMaterials()
		{
			foreach (KeyValuePair<Renderer, Material> currentRenderer in CurrentRenderers)
			{
				if (!((Object)(object)currentRenderer.Key == (Object)null) && !((Object)(object)currentRenderer.Value == (Object)null) && CurrentRenderers.TryGetValue(currentRenderer.Key, out var value))
				{
					ExtendedEffects.Instance.DebugLogMessage($"Reverting {((Object)((Component)currentRenderer.Key).transform).name} to {currentRenderer.Value}");
					currentRenderer.Key.material = value;
				}
			}
			IsChanged = false;
		}

		private Renderer[] GetRenderers(Transform transform, bool IncludeInActive)
		{
			return ((Component)transform).GetComponentsInChildren<Renderer>(IncludeInActive);
		}
	}
	public class SL_CustomImbueVFX : SL_Effect, ICustomModel
	{
		public string SLPackName;

		public string AssetBundleName;

		public string PrefabName;

		public Vector3 PositionOffset;

		public Vector3 RotationOffset;

		public bool IsMainHand = true;

		public Type SLTemplateModel => typeof(SL_CustomImbueVFX);

		public Type GameModel => typeof(SLEx_CustomImbueVFX);

		public override void ApplyToComponent<T>(T component)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			SLEx_CustomImbueVFX sLEx_CustomImbueVFX = component as SLEx_CustomImbueVFX;
			sLEx_CustomImbueVFX.SLPackName = SLPackName;
			sLEx_CustomImbueVFX.AssetBundleName = AssetBundleName;
			sLEx_CustomImbueVFX.PrefabName = PrefabName;
			sLEx_CustomImbueVFX.PositionOffset = PositionOffset;
			sLEx_CustomImbueVFX.RotationOffset = RotationOffset;
			sLEx_CustomImbueVFX.IsMainHand = IsMainHand;
		}

		public override void SerializeEffect<T>(T effect)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			SLEx_CustomImbueVFX sLEx_CustomImbueVFX = effect as SLEx_CustomImbueVFX;
			SLPackName = sLEx_CustomImbueVFX.SLPackName;
			AssetBundleName = sLEx_CustomImbueVFX.AssetBundleName;
			PrefabName = sLEx_CustomImbueVFX.PrefabName;
			PositionOffset = sLEx_CustomImbueVFX.PositionOffset;
			RotationOffset = sLEx_CustomImbueVFX.RotationOffset;
			IsMainHand = sLEx_CustomImbueVFX.IsMainHand;
		}
	}
	public class SLEx_CustomImbueVFX : Effect, ICustomModel
	{
		public string SLPackName;

		public string AssetBundleName;

		public string PrefabName;

		public Vector3 PositionOffset;

		public Vector3 RotationOffset;

		public bool IsMainHand;

		private GameObject Instance;

		private Equipment LastEquipmentInstance = null;

		public Type SLTemplateModel => typeof(SL_CustomImbueVFX);

		public Type GameModel => typeof(SLEx_CustomImbueVFX);

		public override void ActivateLocally(Character _affectedCharacter, object[] _infos)
		{
			if ((Object)(object)_affectedCharacter == (Object)null)
			{
				return;
			}
			if ((Object)(object)LastEquipmentInstance != (Object)null && (Object)(object)_affectedCharacter.CurrentWeapon != (Object)(object)LastEquipmentInstance)
			{
				if ((Object)(object)Instance != (Object)null)
				{
					Object.Destroy((Object)(object)Instance);
				}
				LastEquipmentInstance = null;
			}
			Equipment val = FindCurrentWeapon(_affectedCharacter);
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			GameObject fromAssetBundle = OutwardHelpers.GetFromAssetBundle<GameObject>(SLPackName, AssetBundleName, PrefabName);
			if ((Object)(object)fromAssetBundle != (Object)null)
			{
				ParticleSystem[] componentsInChildren = fromAssetBundle.GetComponentsInChildren<ParticleSystem>();
				if (componentsInChildren.Length == 0)
				{
					ExtendedEffects.Instance?.DebugLogMessage("SLEx_CustomImbueVFX prefab " + PrefabName + " and its children do not contain a particle system.");
					return;
				}
				MeshFilter val2 = OutwardHelpers.TryGetWeaponMesh(val, IncludeInActive: false);
				if ((Object)(object)val2 == (Object)null)
				{
					ExtendedEffects.Instance?.DebugLogMessage("SLEx_CustomImbueVFX Mesh Filter For  " + ((Item)val).Name + " cant be found.");
					return;
				}
				if ((Object)(object)Instance == (Object)null)
				{
					Instance = Object.Instantiate<GameObject>(fromAssetBundle);
				}
				UpdateParticleSystemMesh(Instance, val, val2);
				LastEquipmentInstance = val;
			}
			else
			{
				ExtendedEffects.Instance?.DebugLogMessage("SLEx_CustomImbueVFX Prefab from AssetBundle " + AssetBundleName + " was null.");
			}
		}

		private void UpdateParticleSystemMesh(GameObject Instance, Equipment CurrentWeapon, MeshFilter meshFilter)
		{
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Invalid comparison between Unknown and I4
			//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_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Invalid comparison between Unknown and I4
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			ParticleSystem[] componentsInChildren = Instance.GetComponentsInChildren<ParticleSystem>();
			ParticleSystem[] array = componentsInChildren;
			foreach (ParticleSystem val in array)
			{
				ShapeModule shape;
				if ((Object)(object)val != (Object)null)
				{
					shape = val.shape;
					if ((int)((ShapeModule)(ref shape)).shapeType == 13)
					{
						goto IL_004e;
					}
				}
				shape = val.shape;
				if ((int)((ShapeModule)(ref shape)).shapeType != 6)
				{
					continue;
				}
				goto IL_004e;
				IL_004e:
				ShapeModule shape2 = val.shape;
				((ShapeModule)(ref shape2)).mesh = meshFilter.sharedMesh;
				((ShapeModule)(ref shape2)).meshRenderer = ((Component)meshFilter).GetComponent<MeshRenderer>();
				((ShapeModule)(ref shape2)).scale = ((Component)CurrentWeapon).transform.localScale;
				((ShapeModule)(ref shape2)).position = Vector3.zero;
				((ShapeModule)(ref shape2)).rotation = Vector3.zero;
			}
			Instance.transform.parent = ((Component)((Item)CurrentWeapon).LoadedVisual).transform;
			if (RotationOffset == Vector3.zero)
			{
				Instance.transform.localEulerAngles = new Vector3(90f, 270f, 0f);
			}
			else
			{
				Instance.transform.localEulerAngles = RotationOffset;
			}
			Instance.transform.localPosition = PositionOffset;
		}

		private Equipment FindCurrentWeapon(Character _affectedCharacter)
		{
			Equipment val = null;
			EquipmentSlot matchingSlot = _affectedCharacter.Inventory.Equipment.GetMatchingSlot((EquipmentSlotIDs)6);
			if (IsMainHand)
			{
				if ((Object)(object)_affectedCharacter.CurrentWeapon == (Object)null)
				{
					ExtendedEffects.Instance.DebugLogMessage("SLEx_CustomImbueVFX Current Weapon is null");
					return null;
				}
				val = (Equipment)(object)_affectedCharacter.CurrentWeapon;
			}
			else
			{
				if ((Object)(object)matchingSlot == (Object)null)
				{
					ExtendedEffects.Instance.DebugLogMessage("SLEx_CustomImbueVFX OffHand EquipmentSlot cannot be found");
					return null;
				}
				if (!matchingSlot.HasItemEquipped)
				{
					ExtendedEffects.Instance?.DebugLogMessage("SLEx_CustomImbueVFX OffHand EquipmentSlotitem is null");
					return null;
				}
				val = matchingSlot.EquippedItem;
			}
			return val;
		}

		public override void CleanUpOnDestroy()
		{
			((Effect)this).CleanUpOnDestroy();
			if (Object.op_Implicit((Object)(object)Instance))
			{
				ExtendedEffects.Instance.DebugLogMessage("SLEx_CustomImbueVFX Cleaning up Instance");
				Object.Destroy((Object)(object)Instance);
			}
		}

		public override void StopAffectLocally(Character _affectedCharacter)
		{
			if (Object.op_Implicit((Object)(object)Instance))
			{
				ExtendedEffects.Instance.DebugLogMessage("SLEx_CustomImbueVFX destroying Instance");
				Object.Destroy((Object)(object)Instance);
			}
		}
	}
	public class SL_ForceAIState : SL_Effect, ICustomModel
	{
		public int AIState;

		public Type SLTemplateModel => typeof(SL_ForceAIState);

		public Type GameModel => typeof(SLEx_ForceAIStateForTime);

		public override void ApplyToComponent<T>(T component)
		{
			SLEx_ForceAIStateForTime sLEx_ForceAIStateForTime = component as SLEx_ForceAIStateForTime;
			sLEx_ForceAIStateForTime.AIState = AIState;
		}

		public override void SerializeEffect<T>(T effect)
		{
			SLEx_ForceAIStateForTime sLEx_ForceAIStateForTime = effect as SLEx_ForceAIStateForTime;
			AIState = sLEx_ForceAIStateForTime.AIState;
		}
	}
	public class SLEx_ForceAIStateForTime : Effect, ICustomModel
	{
		public int AIState;

		public Type SLTemplateModel => typeof(SL_ForceAIState);

		public Type GameModel => typeof(SLEx_ForceAIStateForTime);

		public override void ActivateLocally(Character _affectedCharacter, object[] _infos)
		{
			if (AIState <= 3)
			{
				CharacterAI component = ((Component)_affectedCharacter).GetComponent<CharacterAI>();
				if (Object.op_Implicit((Object)(object)component))
				{
					ForceCharacterAIState(component, AIState);
				}
			}
		}

		private void ForceCharacterAIState(CharacterAI CharacterAI, int state)
		{
			CharacterAI.SwitchAiState(state);
		}
	}
	public class SL_HidePlayer : SL_Effect, ICustomModel
	{
		public float HideTime;

		public Type SLTemplateModel => typeof(SL_HidePlayer);

		public Type GameModel => typeof(SLEx_HidePlayer);

		public override void ApplyToComponent<T>(T component)
		{
			SLEx_HidePlayer sLEx_HidePlayer = component as SLEx_HidePlayer;
			sLEx_HidePlayer.HideTime = HideTime;
		}

		public override void SerializeEffect<T>(T effect)
		{
			SLEx_HidePlayer sLEx_HidePlayer = effect as SLEx_HidePlayer;
			HideTime = sLEx_HidePlayer.HideTime;
		}
	}
	public class SLEx_HidePlayer : Effect, ICustomModel
	{
		public float HideTime;

		private bool IsRunning = false;

		public Type SLTemplateModel => typeof(SL_HidePlayer);

		public Type GameModel => typeof(SLEx_HidePlayer);

		public override void ActivateLocally(Character _affectedCharacter, object[] _infos)
		{
			SL.Log("Activating Locally");
			if (!IsRunning)
			{
				((MonoBehaviour)this).StartCoroutine(ToggleCharacterVisual(((Effect)this).OwnerCharacter));
			}
		}

		private IEnumerator ToggleCharacterVisual(Character _affectedCharacter)
		{
			IsRunning = true;
			((Component)_affectedCharacter.VisualHolderTrans).gameObject.SetActive(false);
			yield return (object)new WaitForSeconds(HideTime);
			((Component)_affectedCharacter.VisualHolderTrans).gameObject.SetActive(true);
			IsRunning = false;
		}
	}
	public class SL_PlayAssetBundleVFX : SL_Effect, ICustomModel
	{
		public string SLPackName;

		public string AssetBundleName;

		public string PrefabName;

		public Vector3 PositionOffset;

		public Vector3 RotationOffset;

		public bool ParentToAffected;

		public bool PositionOffsetAsRelativeDirection;

		public bool RotateToPlayerDirection;

		public float LifeTime;

		public virtual Type SLTemplateModel => typeof(SL_PlayAssetBundleVFX);

		public virtual Type GameModel => typeof(SLEx_PlayAssetBundleVFX);

		public override void ApplyToComponent<T>(T component)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			SLEx_PlayAssetBundleVFX sLEx_PlayAssetBundleVFX = component as SLEx_PlayAssetBundleVFX;
			sLEx_PlayAssetBundleVFX.SLPackName = SLPackName;
			sLEx_PlayAssetBundleVFX.AssetBundleName = AssetBundleName;
			sLEx_PlayAssetBundleVFX.PrefabName = PrefabName;
			sLEx_PlayAssetBundleVFX.PositionOffset = PositionOffset;
			sLEx_PlayAssetBundleVFX.RotationOffset = RotationOffset;
			sLEx_PlayAssetBundleVFX.ParentToAffected = ParentToAffected;
			sLEx_PlayAssetBundleVFX.PositionOffsetAsRelativeDirection = PositionOffsetAsRelativeDirection;
			sLEx_PlayAssetBundleVFX.RotateToPlayerDirection = RotateToPlayerDirection;
			sLEx_PlayAssetBundleVFX.LifeTime = LifeTime;
		}

		public override void SerializeEffect<T>(T effect)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			SLEx_PlayAssetBundleVFX sLEx_PlayAssetBundleVFX = effect as SLEx_PlayAssetBundleVFX;
			SLPackName = sLEx_PlayAssetBundleVFX.SLPackName;
			AssetBundleName = sLEx_PlayAssetBundleVFX.AssetBundleName;
			PrefabName = sLEx_PlayAssetBundleVFX.PrefabName;
			PositionOffset = sLEx_PlayAssetBundleVFX.PositionOffset;
			RotationOffset = sLEx_PlayAssetBundleVFX.RotationOffset;
			ParentToAffected = sLEx_PlayAssetBundleVFX.ParentToAffected;
			RotateToPlayerDirection = sLEx_PlayAssetBundleVFX.RotateToPlayerDirection;
			LifeTime = sLEx_PlayAssetBundleVFX.LifeTime;
		}
	}
	public class SLEx_PlayAssetBundleVFX : Effect, ICustomModel
	{
		public string SLPackName;

		public string AssetBundleName;

		public string PrefabName;

		public Vector3 PositionOffset;

		public Vector3 RotationOffset;

		public bool ParentToAffected;

		public bool PositionOffsetAsRelativeDirection;

		public bool RotateToPlayerDirection;

		public float LifeTime;

		private GameObject Instance;

		public virtual Type SLTemplateModel => typeof(SL_PlayAssetBundleVFX);

		public virtual Type GameModel => typeof(SLEx_PlayAssetBundleVFX);

		public override void ActivateLocally(Character _affectedCharacter, object[] _infos)
		{
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			GameObject fromAssetBundle = OutwardHelpers.GetFromAssetBundle<GameObject>(SLPackName, AssetBundleName, PrefabName);
			if ((Object)(object)fromAssetBundle != (Object)null)
			{
				if ((Object)(object)Instance == (Object)null)
				{
					Instance = Object.Instantiate<GameObject>(fromAssetBundle);
				}
				if (ParentToAffected)
				{
					Instance.transform.parent = _affectedCharacter.VisualHolderTrans;
					Instance.transform.localPosition = PositionOffset;
					Instance.transform.localEulerAngles = (RotateToPlayerDirection ? Vector3.zero : RotationOffset);
				}
				else
				{
					Instance.transform.position = ((Component)_affectedCharacter).transform.position + (PositionOffsetAsRelativeDirection ? (((Component)_affectedCharacter).transform.forward + ((Component)_affectedCharacter).transform.TransformVector(PositionOffset)) : PositionOffset);
					Instance.transform.eulerAngles = (RotateToPlayerDirection ? ((Component)_affectedCharacter).transform.eulerAngles : RotationOffset);
				}
				if (LifeTime > 0f)
				{
					ExtendedEffects.Instance.DebugLogMessage($"SLEx_PlayAssetBundleVFX LIFETIME IS {LifeTime}");
					Object.Destroy((Object)(object)Instance, LifeTime);
				}
			}
			else
			{
				ExtendedEffects.Instance.DebugLogMessage("SLEx_PlayAssetBundleVFX Prefab from AssetBundle " + AssetBundleName + " was null.");
			}
		}

		public override void CleanUpOnDestroy()
		{
			((Effect)this).CleanUpOnDestroy();
			if (LifeTime == 0f && Object.op_Implicit((Object)(object)Instance))
			{
				Object.Destroy((Object)(object)Instance);
			}
		}

		public override void StopAffectLocally(Character _affectedCharacter)
		{
			if (LifeTime == 0f && Object.op_Implicit((Object)(object)Instance))
			{
				Object.Destroy((Object)(object)Instance);
			}
		}
	}
	public class SL_PlayAssetBundleVFX_Bones : SL_PlayAssetBundleVFX
	{
		public int BoneID;

		public override Type SLTemplateModel => typeof(SL_PlayAssetBundleVFX_Bones);

		public override Type GameModel => typeof(SLEx_PlayAssetBundleVFX_Bones);

		public override void ApplyToComponent<T>(T component)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			SLEx_PlayAssetBundleVFX_Bones sLEx_PlayAssetBundleVFX_Bones = component as SLEx_PlayAssetBundleVFX_Bones;
			sLEx_PlayAssetBundleVFX_Bones.SLPackName = SLPackName;
			sLEx_PlayAssetBundleVFX_Bones.AssetBundleName = AssetBundleName;
			sLEx_PlayAssetBundleVFX_Bones.PrefabName = PrefabName;
			sLEx_PlayAssetBundleVFX_Bones.PositionOffset = PositionOffset;
			sLEx_PlayAssetBundleVFX_Bones.RotationOffset = RotationOffset;
			sLEx_PlayAssetBundleVFX_Bones.ParentToAffected = ParentToAffected;
			sLEx_PlayAssetBundleVFX_Bones.PositionOffsetAsRelativeDirection = PositionOffsetAsRelativeDirection;
			sLEx_PlayAssetBundleVFX_Bones.LifeTime = LifeTime;
			sLEx_PlayAssetBundleVFX_Bones.RotateToPlayerDirection = RotateToPlayerDirection;
			sLEx_PlayAssetBundleVFX_Bones.BoneID = BoneID;
		}

		public override void SerializeEffect<T>(T effect)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			SLEx_PlayAssetBundleVFX_Bones sLEx_PlayAssetBundleVFX_Bones = effect as SLEx_PlayAssetBundleVFX_Bones;
			SLPackName = sLEx_PlayAssetBundleVFX_Bones.SLPackName;
			AssetBundleName = sLEx_PlayAssetBundleVFX_Bones.AssetBundleName;
			PrefabName = sLEx_PlayAssetBundleVFX_Bones.PrefabName;
			PositionOffset = sLEx_PlayAssetBundleVFX_Bones.PositionOffset;
			RotationOffset = sLEx_PlayAssetBundleVFX_Bones.RotationOffset;
			ParentToAffected = sLEx_PlayAssetBundleVFX_Bones.ParentToAffected;
			PositionOffsetAsRelativeDirection = sLEx_PlayAssetBundleVFX_Bones.PositionOffsetAsRelativeDirection;
			LifeTime = sLEx_PlayAssetBundleVFX_Bones.LifeTime;
			BoneID = sLEx_PlayAssetBundleVFX_Bones.BoneID;
		}
	}
	public class SLEx_PlayAssetBundleVFX_Bones : SLEx_PlayAssetBundleVFX
	{
		public int BoneID;

		private GameObject Instance;

		public override Type SLTemplateModel => typeof(SL_PlayAssetBundleVFX_Bones);

		public override Type GameModel => typeof(SLEx_PlayAssetBundleVFX_Bones);

		public override void ActivateLocally(Character _affectedCharacter, object[] _infos)
		{
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			GameObject fromAssetBundle = OutwardHelpers.GetFromAssetBundle<GameObject>(SLPackName, AssetBundleName, PrefabName);
			if ((Object)(object)fromAssetBundle != (Object)null)
			{
				Transform val = OutwardHelpers.TryGetHumanBone(_affectedCharacter, (HumanBodyBones)BoneID);
				if ((Object)(object)val == (Object)null)
				{
					ExtendedEffects.Instance.DebugLogMessage("SLEx_PlayAssetBundleVFX_Bone cannot find target bone");
					return;
				}
				if ((Object)(object)Instance == (Object)null)
				{
					Instance = Object.Instantiate<GameObject>(fromAssetBundle);
				}
				if (ParentToAffected)
				{
					Instance.transform.parent = val;
					Instance.transform.localPosition = PositionOffset;
					Instance.transform.localEulerAngles = RotationOffset;
				}
				else
				{
					Instance.transform.position = ((Component)val).transform.position + (PositionOffsetAsRelativeDirection ? ((Component)_affectedCharacter).transform.TransformPoint(PositionOffset) : PositionOffset);
					Instance.transform.eulerAngles = (RotateToPlayerDirection ? ((Component)_affectedCharacter).transform.eulerAngles : RotationOffset);
				}
				if (LifeTime > 0f)
				{
					ExtendedEffects.Instance.DebugLogMessage($"SLEx_PlayAssetBundleVFX_Bones LIFETIME IS {LifeTime}");
					Object.Destroy((Object)(object)Instance, LifeTime);
				}
			}
			else
			{
				ExtendedEffects.Instance.DebugLogMessage("SLEx_PlayAssetBundleVFX_Bones Prefab from AssetBundle " + AssetBundleName + " was null.");
			}
		}

		public override void CleanUpOnDestroy()
		{
			base.CleanUpOnDestroy();
			if (LifeTime == 0f && Object.op_Implicit((Object)(object)Instance))
			{
				Object.Destroy((Object)(object)Instance);
			}
		}

		public override void StopAffectLocally(Character _affectedCharacter)
		{
			if (LifeTime == 0f && Object.op_Implicit((Object)(object)Instance))
			{
				Object.Destroy((Object)(object)Instance);
			}
		}
	}
	public class SL_SetWeaponEmission : SL_Effect, ICustomModel
	{
		public Vector3 Color;

		public float ColorIntensity = 4f;

		public float ColorLerpTime = 0.5f;

		public Type SLTemplateModel => typeof(SL_SetWeaponEmission);

		public Type GameModel => typeof(SLEx_SetWeaponEmission);

		public override void ApplyToComponent<T>(T component)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			SLEx_SetWeaponEmission sLEx_SetWeaponEmission = component as SLEx_SetWeaponEmission;
			sLEx_SetWeaponEmission.ColorIntensity = ColorIntensity;
			sLEx_SetWeaponEmission.NewColor = Color;
			sLEx_SetWeaponEmission.ColorLerpTime = ColorLerpTime;
		}

		public override void SerializeEffect<T>(T component)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			SLEx_SetWeaponEmission sLEx_SetWeaponEmission = component as SLEx_SetWeaponEmission;
			Color = sLEx_SetWeaponEmission.NewColor;
			ColorIntensity = sLEx_SetWeaponEmission.ColorIntensity;
			ColorLerpTime = sLEx_SetWeaponEmission.ColorLerpTime;
		}
	}
	public class SLEx_SetWeaponEmission : Effect, ICustomModel
	{
		public Vector3 NewColor;

		public float ColorIntensity;

		public float ColorLerpTime;

		private bool IsRunning = false;

		public Type SLTemplateModel => typeof(SL_SetWeaponEmission);

		public Type GameModel => typeof(SLEx_SetWeaponEmission);

		public override void ActivateLocally(Character _affectedCharacter, object[] _infos)
		{
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			Weapon currentWeapon = ((Effect)this).OwnerCharacter.CurrentWeapon;
			if ((Object)(object)currentWeapon != (Object)null)
			{
				Renderer component = ((Component)((Component)((Item)currentWeapon).LoadedVisual).GetComponentInChildren<BoxCollider>()).GetComponent<Renderer>();
				if ((Object)(object)component != (Object)null && !IsRunning)
				{
					((MonoBehaviour)this).StartCoroutine(LerpMaterialEmissionColor(component, ColorLerpTime, new Color(NewColor.x, NewColor.y, NewColor.z, 1f), ColorIntensity));
				}
			}
		}

		private IEnumerator LerpMaterialEmissionColor(Renderer Renderer, float lerpTime, Color newColor, float Intensity)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			IsRunning = true;
			Color OriginalColor = Renderer.material.GetColor("_EmissionColor");
			float timer = 0f;
			while (timer < lerpTime)
			{
				float currentPercent = timer / lerpTime;
				Renderer.material.SetColor("_EmissionColor", Color.Lerp(OriginalColor, newColor * Intensity, currentPercent));
				timer += Time.deltaTime;
				yield return null;
			}
			IsRunning = false;
		}
	}
	public class SL_SummonExtension : SL_Effect, ICustomModel
	{
		public Vector3 NewBaseColor;

		public Vector3 NewParticlesColor;

		public SL_Damage NewWeaponDamage;

		public string StatusEffectOnSpawn;

		public Type SLTemplateModel => typeof(SL_SummonExtension);

		public Type GameModel => typeof(SummonExtension);

		public override void ApplyToComponent<T>(T component)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Expected O, but got Unknown
			SummonExtension summonExtension = component as SummonExtension;
			summonExtension.NewBaseColor = NewBaseColor;
			summonExtension.NewParticlesColor = NewParticlesColor;
			summonExtension.NewWeaponDamage = new DamageType(NewWeaponDamage.Type, NewWeaponDamage.Damage);
			summonExtension.StatusEffectOnSpawn = StatusEffectOnSpawn;
		}

		public override void SerializeEffect<T>(T effect)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: 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_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Expected O, but got Unknown
			SummonExtension summonExtension = effect as SummonExtension;
			NewBaseColor = summonExtension.NewBaseColor;
			NewParticlesColor = summonExtension.NewParticlesColor;
			StatusEffectOnSpawn = summonExtension.StatusEffectOnSpawn;
			NewWeaponDamage = new SL_Damage
			{
				Damage = summonExtension.NewWeaponDamage.Damage,
				Type = summonExtension.NewWeaponDamage.Type
			};
		}
	}
	public class SummonExtension : Effect
	{
		public Vector3 NewBaseColor;

		public Vector3 NewParticlesColor;

		public DamageType NewWeaponDamage;

		public string StatusEffectOnSpawn;

		public override void ActivateLocally(Character _affectedCharacter, object[] _infos)
		{
			if ((Object)(object)_affectedCharacter.CurrentSummon != (Object)null)
			{
				UpdateSummonBaseColor(_affectedCharacter);
				UpdateSummonParticles(_affectedCharacter);
				if (!string.IsNullOrEmpty(StatusEffectOnSpawn))
				{
					AddSummonStatusEffects(_affectedCharacter.CurrentSummon);
				}
				if (NewWeaponDamage != null)
				{
					OverrideSummonWeaponDamage(_affectedCharacter.CurrentSummon);
				}
			}
		}

		private void UpdateSummonBaseColor(Character _affectedCharacter)
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			Renderer[] componentsInChildren = ((Component)((Effect)this).OwnerCharacter.CurrentSummon).GetComponentsInChildren<Renderer>();
			foreach (Renderer val in componentsInChildren)
			{
				val.material.SetColor("_Color", new Color(NewBaseColor.x, NewBaseColor.y, NewBaseColor.z));
			}
		}

		private void UpdateSummonParticles(Character _affectedCharacter)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			ParticleSystem[] componentsInChildren = ((Component)((Effect)this).OwnerCharacter.CurrentSummon).GetComponentsInChildren<ParticleSystem>();
			foreach (ParticleSystem val in componentsInChildren)
			{
				if (Object.op_Implicit((Object)(object)val))
				{
					MainModule main = val.main;
					((MainModule)(ref main)).startColor = MinMaxGradient.op_Implicit(new Color(NewParticlesColor.x, NewParticlesColor.y, NewParticlesColor.z));
				}
			}
		}

		private void AddSummonStatusEffects(Character _summonCharacter)
		{
			StatusEffect statusEffectPrefab = ResourcesPrefabManager.Instance.GetStatusEffectPrefab(StatusEffectOnSpawn);
			if ((Object)(object)statusEffectPrefab != (Object)null)
			{
				_summonCharacter.StatusEffectMngr.AddStatusEffect(statusEffectPrefab.StatusName);
			}
			else
			{
				ExtendedEffects._Log.LogMessage((object)("SL_SummonExtension : Could not find Status by name " + StatusEffectOnSpawn));
			}
		}

		private void OverrideSummonWeaponDamage(Character _summonCharacter)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			if ((Object)(object)_summonCharacter.CurrentWeapon != (Object)null && NewWeaponDamage != null)
			{
				OutwardHelpers.UpdateWeaponDamage(_summonCharacter.CurrentWeapon, new DamageList(NewWeaponDamage));
			}
		}
	}
	public class SL_SuspendStatusEffect : SL_Effect, ICustomModel
	{
		public string[] StatusEffectIdentifiers;

		public Type SLTemplateModel => typeof(SL_SuspendStatusEffect);

		public Type GameModel => typeof(SLEx_SuspendStatusEffect);

		public override void ApplyToComponent<T>(T component)
		{
			SLEx_SuspendStatusEffect sLEx_SuspendStatusEffect = component as SLEx_SuspendStatusEffect;
			sLEx_SuspendStatusEffect.StatusEffectIdentifiers = StatusEffectIdentifiers;
		}

		public override void SerializeEffect<T>(T effect)
		{
			SLEx_SuspendStatusEffect sLEx_SuspendStatusEffect = effect as SLEx_SuspendStatusEffect;
			StatusEffectIdentifiers = sLEx_SuspendStatusEffect.StatusEffectIdentifiers;
		}
	}
	public class SLEx_SuspendStatusEffect : Effect, ICustomModel
	{
		public string[] StatusEffectIdentifiers;

		public Type SLTemplateModel => typeof(SL_SuspendStatusEffect);

		public Type GameModel => typeof(SLEx_SuspendStatusEffect);

		private void SetSuspendedEffects(Character _affectedCharacter, bool suspended)
		{
			if (StatusEffectIdentifiers == null || StatusEffectIdentifiers.Length == 0)
			{
				ExtendedEffects._Log.LogDebug((object)"SLEx_SuspendStatusEffect defined without effects. Please specify the StatusEffectIdentifiers to suspend.");
				return;
			}
			foreach (StatusEffect status in _affectedCharacter.StatusEffectMngr.Statuses)
			{
				if (UnityEngineExtensions.Contains<string>(StatusEffectIdentifiers, status.IdentifierName) && status.IsEffectSuspended() != suspended)
				{
					ExtendedEffects._Log.LogDebug((object)$"Suspending effect of {status.IdentifierName} = {suspended}");
					status.SetEffectSuspended(suspended);
				}
			}
		}

		public override void ActivateLocally(Character _affectedCharacter, object[] _infos)
		{
			SetSuspendedEffects(_affectedCharacter, suspended: true);
		}

		public override void StopAffectLocally(Character _affectedCharacter)
		{
			SetSuspendedEffects(_affectedCharacter, suspended: false);
		}
	}
	public class SL_SuspendStatusTimer : SL_Effect, ICustomModel
	{
		public string[] StatusEffectIdentifiers;

		public Type SLTemplateModel => typeof(SL_SuspendStatusTimer);

		public Type GameModel => typeof(SLEx_SuspendStatusTimer);

		public override void ApplyToComponent<T>(T component)
		{
			SLEx_SuspendStatusTimer sLEx_SuspendStatusTimer = component as SLEx_SuspendStatusTimer;
			sLEx_SuspendStatusTimer.StatusEffectIdentifiers = StatusEffectIdentifiers;
		}

		public override void SerializeEffect<T>(T effect)
		{
			SLEx_SuspendStatusTimer sLEx_SuspendStatusTimer = effect as SLEx_SuspendStatusTimer;
			StatusEffectIdentifiers = sLEx_SuspendStatusTimer.StatusEffectIdentifiers;
		}
	}
	public class SLEx_SuspendStatusTimer : Effect, ICustomModel
	{
		public string[] StatusEffectIdentifiers;

		public Type SLTemplateModel => typeof(SL_SuspendStatusTimer);

		public Type GameModel => typeof(SLEx_SuspendStatusTimer);

		private void SetSuspendedTimers(Character _affectedCharacter, bool suspended)
		{
			if (StatusEffectIdentifiers == null || StatusEffectIdentifiers.Length == 0)
			{
				ExtendedEffects._Log.LogDebug((object)"SLEx_SuspendStatusTimer defined without effects. Please specify the StatusEffectIdentifiers to suspend.");
				return;
			}
			foreach (StatusEffect status in _affectedCharacter.StatusEffectMngr.Statuses)
			{
				if (UnityEngineExtensions.Contains<string>(StatusEffectIdentifiers, status.IdentifierName) && status.IsTimerSuspended() != suspended)
				{
					ExtendedEffects._Log.LogDebug((object)$"Suspending timer of {status.IdentifierName} = {suspended}");
					status.SetTimerSuspended(suspended);
				}
			}
		}

		public override void ActivateLocally(Character _affectedCharacter, object[] _infos)
		{
			SetSuspendedTimers(_affectedCharacter, suspended: true);
		}

		public override void StopAffectLocally(Character _affectedCharacter)
		{
			SetSuspendedTimers(_affectedCharacter, suspended: false);
		}
	}
	[Serializable]
	public class SkillTreeOverride
	{
		public string OriginalSkillTreeUID;

		public string NewSkillTreeUID;

		public SkillTreeOverride(string originalSkillTreeUID, string newSkillTreeUID)
		{
			OriginalSkillTreeUID = originalSkillTreeUID;
			NewSkillTreeUID = newSkillTreeUID;
		}
	}
}
namespace SideLoader_ExtendedEffects.Containers
{
	public class SL_EffectLifecycleEffect : SL_ParentEffect
	{
	}
	public class EffectLifecycleEffect : ParentEffect, ICustomModel
	{
		private bool activated = false;

		public Type SLTemplateModel => typeof(SL_EffectLifecycleEffect);

		public Type GameModel => typeof(EffectLifecycleEffect);

		public override void ActivateLocally(Character _affectedCharacter, object[] _infos)
		{
			if (!activated)
			{
				((EffectSynchronizer)((Effect)this).m_subEffects[0]).SynchronizeEffects((EffectCategories)2, ((Effect)this).OwnerCharacter);
				activated = true;
			}
			((EffectSynchronizer)((Effect)this).m_subEffects[0]).SynchronizeEffects((EffectCategories)1, ((Effect)this).OwnerCharacter);
		}

		public override void StopAffectLocally(Character _affectedCharacter)
		{
			((EffectSynchronizer)((Effect)this).m_subEffects[0]).SynchronizeEffects((EffectCategories)5, ((Effect)this).OwnerCharacter);
			activated = false;
			((EffectSynchronizer)((Effect)this).m_subEffects[0]).StopAllEffects((EffectCategories)5, ((Effect)this).OwnerCharacter);
			((EffectSynchronizer)((Effect)this).m_subEffects[0]).StopAllEffects((EffectCategories)2, ((Effect)this).OwnerCharacter);
			((EffectSynchronizer)((Effect)this).m_subEffects[0]).StopAllEffects((EffectCategories)1, ((Effect)this).OwnerCharacter);
			base.StopAffectLocally(_affectedCharacter);
		}
	}
	public abstract class SL_ParentEffect : SL_Effect
	{
		public EditBehaviours EffectBehavior = (EditBehaviours)2;

		public SL_EffectTransform[] ChildEffects;

		public int ActivationLimit;

		public override void ApplyToComponent<T>(T component)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Expected O, but got Unknown
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				ParentEffect parentEffect = component as ParentEffect;
				GameObject val = new GameObject();
				Object.DontDestroyOnLoad((Object)(object)val);
				val.SetActive(false);
				parentEffect.ActivationLimit = ActivationLimit;
				parentEffect.ChildEffects = val.gameObject.AddComponent<SubEffect>();
				SL_EffectTransform.ApplyTransformList(((Component)parentEffect.ChildEffects).transform, ChildEffects, EffectBehavior);
			}
			catch (Exception ex)
			{
				SL.Log((object)ex);
			}
		}

		public override void SerializeEffect<T>(T effect)
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Expected O, but got Unknown
			try
			{
				ParentEffect parentEffect = effect as ParentEffect;
				if (((Component)parentEffect.ChildEffects).transform.childCount > 0)
				{
					List<SL_EffectTransform> list = new List<SL_EffectTransform>();
					foreach (Transform item in ((Component)parentEffect.ChildEffects).transform)
					{
						Transform val = item;
						SL_EffectTransform val2 = SL_EffectTransform.ParseTransform(val);
						if (val2.HasContent)
						{
							list.Add(val2);
						}
					}
					ChildEffects = list.ToArray();
				}
				ActivationLimit = parentEffect.ActivationLimit;
			}
			catch (Exception ex)
			{
				SL.Log((object)ex);
			}
		}
	}
	public abstract class ParentEffect : Shooter
	{
		public SubEffect ChildEffects;

		public int ActivationLimit;

		private float lastApplyTime = 0f;

		private Dictionary<Character, int> affectedThisInterval;

		public override void Setup(Factions[] _targetFactions, Transform _parent)
		{
			try
			{
				SL.Log("Set Up");
				SL.Log("own parent: " + ((Object)((Effect)this).m_parentSynchronizer).name);
				((Shooter)this).Setup(_targetFactions, _parent);
				if (((Effect)this).m_subEffects == null)
				{
					((Effect)this).m_subEffects = (SubEffect[])(object)new SubEffect[1] { Object.Instantiate<SubEffect>(ChildEffects) };
				}
				((Component)((Effect)this).m_subEffects[0]).gameObject.SetActive(true);
				((Effect)this).m_subEffects[0].Setup((Effect)(object)this, 0, _targetFactions, _parent);
				SL.Log((object)((Effect)this).m_subEffects[0].m_parentEffect);
				((Effect)this).m_subEffects[0].m_parentEffect = (Effect)(object)this;
				Effect[] componentsInChildren = ((Component)((Component)((Effect)this).m_subEffects[0]).transform).GetComponentsInChildren<Effect>();
				foreach (Effect val in componentsInChildren)
				{
				}
			}
			catch (Exception ex)
			{
				SL.Log("=========Setup Error!===========");
				SL.Log((object)ex);
			}
		}

		public override void StopAffectLocally(Character _affectedCharacter)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			foreach (EffectCategories value in Enum.GetValues(typeof(EffectCategories)))
			{
				((EffectSynchronizer)((Effect)this).m_subEffects[0]).StopAllEffects(value, _affectedCharacter);
			}
			((Effect)this).StopAffectLocally(_affectedCharacter);
		}

		public virtual void StartApply(EffectCategories[] categories, Character affectedCharacter, Vector3 pos, Vector3 dir)
		{
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			if (Time.time - lastApplyTime > 0f)
			{
				lastApplyTime = Time.time;
				if (affectedThisInterval == null)
				{
					affectedThisInterval = new Dictionary<Character, int>();
				}
				else
				{
					affectedThisInterval.Clear();
				}
			}
			int value = 0;
			if (!affectedThisInterval.TryGetValue(affectedCharacter, out value))
			{
				affectedThisInterval.Add(affectedCharacter, 0);
			}
			if (ActivationLimit == 0 || value < ActivationLimit)
			{
				affectedThisInterval[affectedCharacter]++;
				foreach (EffectCategories val in categories)
				{
					((EffectSynchronizer)((Effect)this).m_subEffects[0]).SynchronizeEffects(val, affectedCharacter, pos, dir);
				}
			}
		}

		public virtual void StopApply(EffectCategories[] categories, Character affectedCharacter)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			foreach (EffectCategories val in categories)
			{
				((EffectSynchronizer)((Effect)this).m_subEffects[0]).StopAllEffects(val, affectedCharacter);
			}
		}

		public virtual void Apply(EffectCategories[] categories, Character affectedCharacter, Vector3 pos, Vector3 dir)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			StartApply(categories, affectedCharacter, pos, dir);
			StopApply(categories, affectedCharacter);
		}
	}
}
namespace SideLoader_ExtendedEffects.Containers.Triggers
{
	public class SL_OnEquipEffect : SL_ParentEffect
	{
		public EquipmentSlotIDs[] AllowedSlots;

		public override void ApplyToComponent<T>(T component)
		{
			base.ApplyToComponent(component);
			OnEquipEffect onEquipEffect = component as OnEquipEffect;
			onEquipEffect.AllowedSlots = AllowedSlots;
		}

		public override void SerializeEffect<T>(T effect)
		{
			base.SerializeEffect(effect);
			OnEquipEffect onEquipEffect = effect as OnEquipEffect;
			AllowedSlots = onEquipEffect.AllowedSlots;
		}
	}
	public class OnEquipEffect : TriggeredEffect<EquipEvent>, ICustomModel
	{
		public EquipmentSlotIDs[] AllowedSlots;

		public Type SLTemplateModel => typeof(SL_OnEquipEffect);

		public Type GameModel => typeof(OnEquipEffect);

		public override void OnEvent(object sender, EquipEvent args)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: 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)
			if (!((Object)(object)args.character != (Object)(object)((Effect)this).OwnerCharacter) && (AllowedSlots == null || AllowedSlots.Length == 0 || UnityEngineExtensions.Contains<EquipmentSlotIDs>(AllowedSlots, args.slot)))
			{
				if (args.equipped)
				{
					ExtendedEffects.Instance.DebugLogMessage("Equipped item");
					StartApply((EffectCategories[])(object)new EffectCategories[2]
					{
						(EffectCategories)2,
						(EffectCategories)1
					}, args.character, args.character.m_lastPosition, args.character.m_lastForward);
				}
				else
				{
					ExtendedEffects.Instance.DebugLogMessage("Unequipped item");
					StartApply((EffectCategories[])(object)new EffectCategories[2]
					{
						(EffectCategories)5,
						(EffectCategories)1
					}, args.character, args.character.m_lastPosition, args.character.m_lastForward);
				}
			}
		}
	}
	public class SL_OnHitEffect : SL_ParentEffect
	{
		public OnHitEffect.DamageSourceType RequiredSourceType;

		public Types[] DamageTypes;

		public bool RequireAllTypes;

		public int MinDamage;

		public bool OnlyCountRequiredTypes;

		public bool UseHighestType;

		public bool IgnoreDamageReduction;

		public override void ApplyToComponent<T>(T component)
		{
			base.ApplyToComponent(component);
			OnHitEffect onHitEffect = component as OnHitEffect;
			onHitEffect.RequiredSourceType = RequiredSourceType;
			onHitEffect.DamageTypes = DamageTypes;
			onHitEffect.RequireAllTypes = RequireAllTypes;
			onHitEffect.MinDamage = MinDamage;
			onHitEffect.OnlyCountRequiredTypes = OnlyCountRequiredTypes;
			onHitEffect.UseHighestType = UseHighestType;
			onHitEffect.IgnoreDamageReduction = IgnoreDamageReduction;
		}

		public override void SerializeEffect<T>(T effect)
		{
			base.SerializeEffect(effect);
			OnHitEffect onHitEffect = effect as OnHitEffect;
			RequiredSourceType = onHitEffect.RequiredSourceType;
			DamageTypes = onHitEffect.DamageTypes;
			RequireAllTypes = onHitEffect.RequireAllTypes;
			MinDamage = onHitEffect.MinDamage;
			OnlyCountRequiredTypes = onHitEffect.OnlyCountRequiredTypes;
			UseHighestType = onHitEffect.UseHighestType;
			IgnoreDamageReduction = onHitEffect.IgnoreDamageReduction;
		}
	}
	public class OnHitEffect : TriggeredEffect<HitEvent>, ICustomModel
	{
		public enum DamageSourceType
		{
			ANY,
			WEAPON,
			NON_WEAPON
		}

		public DamageSourceType RequiredSourceType;

		public Types[] DamageTypes;

		public bool RequireAllTypes;

		public int MinDamage;

		public bool OnlyCountRequiredTypes;

		public bool UseHighestType;

		public bool IgnoreDamageReduction;

		public Type SLTemplateModel => typeof(SL_OnHitEffect);

		public Type GameModel => typeof(OnHitEffect);

		public override void OnEvent(object sender, HitEvent args)
		{
			//IL_036e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0374: Unknown result type (might be due to invalid IL or missing references)
			//IL_038d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0393: Unknown result type (might be due to invalid IL or missing references)
			//IL_034b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0351: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0257: Unknown result type (might be due to invalid IL or missing references)
			//IL_0263: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if ((RequiredSourceType == DamageSourceType.NON_WEAPON && args.source is Weapon) || (RequiredSourceType == DamageSourceType.WEAPON && !(args.source is Weapon)))
				{
					ExtendedEffects.Instance.DebugLogMessage("Wrong Hit Type");
					return;
				}
				if (!IgnoreDamageReduction)
				{
					if (args.source is Weapon)
					{
						? val = args.target;
						EffectSynchronizer source = args.source;
						((Character)val).ProcessDamageReduction((Weapon)(object)((source is Weapon) ? source : null), args.damage, false);
					}
					else if (args.source is StatusEffect)
					{
						? val2 = args.target;
						DamageList damage = args.damage;
						EffectSynchronizer source2 = args.source;
						((Character)val2).ProcessDamageReduction((Weapon)null, damage, ((StatusEffect)((source2 is StatusEffect) ? source2 : null)).IgnoreBarrier);
					}
					else
					{
						args.target.ProcessDamageReduction((Weapon)null, args.damage, false);
					}
				}
				if (UseHighestType)
				{
					int dTypeOfHighestDamage = args.damage.GetDTypeOfHighestDamage((IList<int>)(List<int>)DamageType.TypeList);
					if (DamageTypes != null && DamageTypes.Length != 0 && ((DamageTypes != null && DamageTypes.Length > 1 && RequireAllTypes) || !UnityEngineExtensions.Contains<Types>(DamageTypes, args.damage[dTypeOfHighestDamage].Type)))
					{
						ExtendedEffects.Instance.DebugLogMessage("Highest Damage Type Wrong");
						return;
					}
					if (args.damage[dTypeOfHighestDamage].Damage < (float)MinDamage)
					{
						ExtendedEffects.Instance.DebugLogMessage("Highest Damage Too Low");
						return;
					}
				}
				else if (RequireAllTypes)
				{
					Types[] damageTypes = DamageTypes;
					foreach (Types val3 in damageTypes)
					{
						if (!args.damage.Contains(val3))
						{
							ExtendedEffects.Instance.DebugLogMessage("Not All Types Present");
							return;
						}
					}
				}
				else if (DamageTypes != null && DamageTypes.Length != 0)
				{
					Types[] damageTypes2 = DamageTypes;
					foreach (Types val4 in damageTypes2)
					{
						bool flag = false;
						if (args.damage.Contains(val4))
						{
							flag = true;
							break;
						}
						if (!flag)
						{
							ExtendedEffects.Instance.DebugLogMessage("None Of Types Present");
							return;
						}
					}
				}
				List<EffectCategories> list = new List<EffectCategories>();
				List<EffectCategories> list2 = new List<EffectCategories>();
				if ((Object)(object)args.target == (Object)(object)((Effect)this).OwnerCharacter)
				{
					try
					{
						list.Add((EffectCategories)6);
						list2.Add((EffectCategories)5);
					}
					catch (Exception logMessage)
					{
						ExtendedEffects.Instance.DebugLogMessage(logMessage);
					}
				}
				if ((Object)(object)args.dealer == (Object)(object)((Effect)this).OwnerCharacter)
				{
					list2.Add((EffectCategories)4);
					list.Add((EffectCategories)1);
				}
				if ((Object)(object)args.dealer == (Object)(object)args.target)
				{
					list.AddRange(list2);
					Apply(list.ToArray(), args.dealer, args.hitLocation, args.hitDirection);
				}
				else
				{
					Apply(list.ToArray(), args.dealer, args.hitLocation, args.hitDirection);
					Apply(list2.ToArray(), args.target, args.hitLocation, args.hitDirection);
				}
			}
			catch (Exception logMessage2)
			{
				ExtendedEffects.Instance.DebugLogMessage("=============Hit Event Error============");
				ExtendedEffects.Instance.DebugLogMessage(logMessage2);
			}
		}
	}
	public abstract class TriggeredEffect<Event> : ParentEffect where Event : struct
	{
		private bool registered = false;

		public override void ActivateLocally(Character _affectedCharacter, object[] _infos)
		{
			if (!registered)
			{
				ExtendedEffects.Instance.DebugLogMessage("Registering Event");
				ExtendedEffects.Instance.DebugLogMessage(new EventHandler<Event>(OnEvent).Method.DeclaringType);
				Publisher<Event>.Handler += OnEvent;
				registered = true;
			}
			else
			{
				ExtendedEffects.Instance.DebugLogMessage("Event already registered");
			}
		}

		public override void StopAffectLocally(Character _affectedCharacter)
		{
			if (registered)
			{
				ExtendedEffects.Instance.DebugLogMessage("Deregistering Event");
				Publisher<Event>.Handler -= OnEvent;
				registered = false;
			}
			else
			{
				ExtendedEffects.Instance.DebugLogMessage("Event not registered");
			}
			base.StopAffectLocally(_affectedCharacter);
		}

		public abstract void OnEvent(object sender, Event args);
	}
}
namespace SideLoader_ExtendedEffects.Patches
{
	[HarmonyPatch(typeof(ItemDisplayOptionPanel))]
	public static class ItemDisplayOptionPanelPatches
	{
		[HarmonyPatch("GetActiveActions")]
		[HarmonyPostfix]
		private static void EquipmentMenu_GetActiveActions_Postfix(ItemDisplayOptionPanel __instance, GameObject pointerPress, ref List<int> __result)
		{
			if ((Object)(object)__instance.m_pendingItem == (Object)null || ((UIElement)__instance).LocalCharacter.IsAI)
			{
				return;
			}
			foreach (KeyValuePair<int, CustomItemDisplayMenuOption> customItemOption in ExtendedEffects.Instance.CustomItemMenuManager.CustomItemOptions)
			{
				if (__result.Contains(customItemOption.Key))
				{
					continue;
				}
				if (customItemOption.Value.ShouldAddActionDelegate != null)
				{
					if (customItemOption.Value.ShouldAddActionDelegate(((UIElement)__instance).LocalCharacter, __instance.m_pendingItem, __instance, customItemOption.Key))
					{
						__result.Add(customItemOption.Key);
					}
				}
				else
				{
					__result.Add(customItemOption.Key);
				}
			}
		}

		[HarmonyPatch("ActionHasBeenPressed")]
		[HarmonyPrefix]
		private static void EquipmentMenu_ActionHasBeenPressed_Prefix(ItemDisplayOptionPanel __instance, int _actionID)
		{
			Character targetCharacter = ((UIElement)__instance).m_characterUI.TargetCharacter;
			Item pendingItem = __instance.m_pendingItem;
			if (!Object.op_Implicit((Object)(object)targetCharacter) || !Object.op_Implicit((Object)(object)pendingItem) || !targetCharacter.Inventory.OwnsOrHasEquipped(pendingItem.ItemID))
			{
				return;
			}
			foreach (KeyValuePair<int, CustomItemDisplayMenuOption> customItemOption in ExtendedEffects.Instance.CustomItemMenuManager.CustomItemOptions)
			{
				if (_actionID == customItemOption.Key)
				{
					customItemOption.Value?.OnCustomActionPressed(targetCharacter, pendingItem, __instance, _actionID);
				}
			}
		}

		[HarmonyPatch("GetActionText")]
		[HarmonyPrefix]
		private static bool EquipmentMenu_GetActionText_Prefix(ItemDisplayOptionPanel __instance, int _actionID, ref string __result)
		{
			foreach (KeyValuePair<int, CustomItemDisplayMenuOption> customItemOption in ExtendedEffects.Instance.CustomItemMenuManager.CustomItemOptions)
			{
				if (_actionID == customItemOption.Key)
				{
					__result = customItemOption.Value.ActionString;
					return false;
				}
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(Trainer))]
	public static class TrainerPatches
	{
		[HarmonyPatch("GetSkillTree")]
		[HarmonyPrefix]
		public static bool GetSkillTreeOverridePrefix(Trainer __instance, ref SkillSchool __result)
		{
			//IL_0041: 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_007a: Unknown result type (might be due to invalid IL or missing references)
			SNPC val = ((Component)__instance).GetComponentInParent<SNPC>();
			string empty = string.Empty;
			if ((Object)(object)val == (Object)null)
			{
				val = ((Component)((Component)__instance).transform.parent.parent).GetComponentInChildren<SNPC>();
				empty = __instance.HolderUID.m_value;
			}
			else
			{
				empty = val.HolderUID.m_value;
			}
			if ((Object)(object)val != (Object)null)
			{
				if (ExtendedEffects.HasSkillTreeOverride(empty))
				{
					string text = ExtendedEffects.SkillTreeOverrides[empty];
					SkillSchool skillTreeFromUID = SkillTreeHolder.Instance.GetSkillTreeFromUID(UID.op_Implicit(text));
					if ((Object)(object)skillTreeFromUID != (Object)null)
					{
						__result = skillTreeFromUID;
						return false;
					}
					ExtendedEffects._Log.LogMessage((object)("Could not find a valid SkillSchool with UID " + text));
				}
				else
				{
					ExtendedEffects._Log.LogMessage((object)("No Override For Trainer with UID " + empty));
				}
			}
			else
			{
				ExtendedEffects._Log.LogMessage((object)"Character isn't a trainer.");
			}
			return true;
		}
	}
}
namespace SideLoader_ExtendedEffects.Item_Context_Menu
{
	public class CustomItemDisplayMenuOption
	{
		public int CustomEquipActionID = 10000;

		public string ActionString = "Activate ";

		public Action<Character, Item, ItemDisplayOptionPanel, int> OnCustomActionPressed;

		public Func<Character, Item, ItemDisplayOptionPanel, int, bool> ShouldAddActionDelegate;

		public CustomItemDisplayMenuOption(int customEquipActionID, string equip_String, Action<Character, Item, ItemDisplayOptionPanel, int> onCustomActionPressed, Func<Character, Item, ItemDisplayOptionPanel, int, bool> shouldAddActionDelegate)
		{
			CustomEquipActionID = customEquipActionID;
			ActionString = equip_String;
			OnCustomActionPressed = onCustomActionPressed;
			ShouldAddActionDelegate = shouldAddActionDelegate;
		}
	}
}
namespace SideLoader_ExtendedEffects.Extensions
{
	public static class SLEffectExtensions
	{
		public static void ApplyIcon(this SL_StatusEffect effect)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Expected O, but got Unknown
			SLPack sLPack = SL.GetSLPack(((SL_StatusBase)effect).SLPackName);
			string path = sLPack.FolderPath + "\\StatusEffects\\" + effect.StatusIdentifier + "\\icon.png";
			byte[] array = File.ReadAllBytes(path);
			Texture2D val = new Texture2D(2, 2);
			ImageConversion.LoadImage(val, array);
			Sprite val2 = CustomTextures.CreateSprite(val, (SpriteBorderTypes)0);
			StatusEffect statusEffectPrefab = ResourcesPrefabManager.Instance.GetStatusEffectPrefab(effect.StatusIdentifier);
			statusEffectPrefab.OverrideIcon = val2;
			statusEffectPrefab.m_defaultStatusIcon = new StatusTypeIcon(Tag.None)
			{
				Icon = val2
			};
		}
	}
}
namespace SideLoader_ExtendedEffects.Released
{
	public class SL_AffectCurrentHP : SL_Effect, ICustomModel
	{
		public float Modifier;

		public Type SLTemplateModel => typeof(SL_AffectCurrentHP);

		public Type GameModel => typeof(AffectCurrentHP);

		public override void ApplyToComponent<T>(T component)
		{
			AffectCurrentHP affectCurrentHP = component as AffectCurrentHP;
			affectCurrentHP.Modifier = Modifier;
		}

		public override void SerializeEffect<T>(T effect)
		{
			AffectCurrentHP affectCurrentHP = effect as AffectCurrentHP;
			Modifier = affectCurrentHP.Modifier;
		}
	}
	public class AffectCurrentHP : Effect
	{
		public float Modifier;

		public override void ActivateLocally(Character _affectedCharacter, object[] _infos)
		{
			if (!(Modifier <= 0f))
			{
				float num = _affectedCharacter.Health * Modifier;
				_affectedCharacter.Stats.AffectHealth(num);
			}
		}
	}
	public class SL_ApplyCharacterAuraVFX : SL_Effect, ICustomModel
	{
		public string SLPackName;

		public string AssetBundleName;

		public string PrefabName;

		public float LifeTime;

		public Type SLTemplateModel => typeof(SL_ApplyCharacterAuraVFX);

		public Type GameModel => typeof(ApplyCharacterAuraVFX);

		public override void ApplyToComponent<T>(T component)
		{
			ApplyCharacterAuraVFX applyCharacterAuraVFX = component as ApplyCharacterAuraVFX;
			applyCharacterAuraVFX.SLPackName = SLPackName;
			applyCharacterAuraVFX.AssetBundleName = AssetBundleName;
			applyCharacterAuraVFX.PrefabName = PrefabName;
			applyCharacterAuraVFX.LifeTime = LifeTime;
		}

		public override void SerializeEffect<T>(T effect)
		{
			ApplyCharacterAuraVFX applyCharacterAuraVFX = effect as ApplyCharacterAuraVFX;
			SLPackName = applyCharacterAuraVFX.SLPackName;
			AssetBundleName = applyCharacterAuraVFX.AssetBundleName;
			PrefabName = applyCharacterAuraVFX.PrefabName;
			LifeTime = applyCharacterAuraVFX.LifeTime;
		}
	}
	public class ApplyCharacterAuraVFX : Effect
	{
		public string SLPackName;

		public string AssetBundleName;

		public string PrefabName;

		public float LifeTime;

		private GameObject Instance;

		private GameObject Prefab = null;

		private SkinnedMeshRenderer BodyMesh = null;

		private ParticleSystem[] CachedPS = null;

		public override void ActivateLocally(Character _affectedCharacter, object[] _infos)
		{
			if ((Object)(object)Prefab == (Object)null)
			{
				Prefab = OutwardHelpers.GetFromAssetBundle<GameObject>(SLPackName, AssetBundleName, PrefabName);
			}
			if ((Object)(object)Prefab != (Object)null)
			{
				if ((Object)(object)BodyMesh == (Object)null)
				{
					BodyMesh = FindBaseBody(_affectedCharacter);
				}
				if ((Object)(object)BodyMesh == (Object)null)
				{
					ExtendedEffects.Instance.DebugLogMessage("ApplyCharacterAuraVFX cant find body mesh");
					return;
				}
				if ((Object)(object)Instance == (Object)null)
				{
					Instance = Object.Instantiate<GameObject>(Prefab);
				}
				Instance.transform.parent = _affectedCharacter.VisualHolderTrans;
				if ((Object)(object)BodyMesh != (Object)null)
				{
					UpdateVFXParticleSystem(Instance, BodyMesh);
				}
			}
			else
			{
				ExtendedEffects.Instance.DebugLogMessage("ApplyCharacterAuraVFX Prefab is null.");
			}
		}

		public override void CleanUpOnDestroy()
		{
			((Effect)this).CleanUpOnDestroy();
			if (Object.op_Implicit((Object)(object)Instance))
			{
				ExtendedEffects.Instance.DebugLogMessage("ApplyCharacterAuraVFX Cleaning up Instance");
				Object.Destroy((Object)(object)Instance);
			}
		}

		public override void StopAffectLocally(Character _affectedCharacter)
		{
			if (Object.op_Implicit((Object)(object)Instance))
			{
				ExtendedEffects.Instance.DebugLogMessage("ApplyCharacterAuraVFX destroying Instance");
				Object.Destroy((Object)(object)Instance);
			}
		}

		private SkinnedMeshRenderer FindBaseBody(Character _affectedCharacter)
		{
			SkinnedMeshRenderer[] componentsInChildren = ((Component)_affectedCharacter.VisualHolderTrans).GetComponentsInChildren<SkinnedMeshRenderer>(true);
			SkinnedMeshRenderer[] array = componentsInChildren;
			foreach (SkinnedMeshRenderer val in array)
			{
				if (((Object)((Component)val).transform).name.Contains("Body"))
				{
					return val;
				}
			}
			return null;
		}

		private void UpdateVFXParticleSystem(GameObject VFXInstance, SkinnedMeshRenderer SkinnedMeshRenderer)
		{
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Invalid comparison between Unknown and I4
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			if (CachedPS == null)
			{
				CachedPS = VFXInstance.GetComponentsInChildren<ParticleSystem>();
			}
			if (CachedPS == null || CachedPS.Length == 0)
			{
				return;
			}
			ParticleSystem[] cachedPS = CachedPS;
			foreach (ParticleSystem val in cachedPS)
			{
				if ((Object)(object)val != (Object)null)
				{
					ShapeModule shape = val.shape;
					if ((int)((ShapeModule)(ref shape)).shapeType == 14)
					{
						ShapeModule shape2 = val.shape;
						((ShapeModule)(ref shape2)).skinnedMeshRenderer = SkinnedMeshRenderer;
						((ShapeModule)(ref shape2)).scale = Vector3.one;
						((ShapeModule)(ref shape2)).position = Vector3.zero;
						((ShapeModule)(ref shape2)).rotation = Vector3.zero;
					}
				}
			}
			VFXInstance.transform.localPosition = Vector3.zero;
		}
	}
	public class SL_RemoveItemFromInventory : SL_Effect, ICustomModel
	{
		public int ItemID;

		public int ItemQuantity;

		public Type SLTemplateModel => typeof(SL_RemoveItemFromInventory);

		public Type GameModel => typeof(RemoveItemFromInventory);

		public override void ApplyToComponent<T>(T component)
		{
			RemoveItemFromInventory removeItemFromInventory = component as RemoveItemFromInventory;
			removeItemFromInventory.ItemID = ItemID;
			removeItemFromInventory.ItemQuantity = ItemQuantity;
		}

		public override void SerializeEffect<T>(T effect)
		{
			RemoveItemFromInventory removeItemFromInventory = effect as RemoveItemFromInventory;
			ItemID = removeItemFromInventory.ItemID;
			ItemQuantity = removeItemFromInventory.ItemQuantity;
		}
	}
	public class RemoveItemFromInventory : Effect
	{
		public int ItemID;

		public int ItemQuantity;

		public override void ActivateLocally(Character _affectedCharacter, object[] _infos)
		{
			if (_affectedCharacter.IsAI || (Object)(object)_affectedCharacter.Inventory == (Object)null)
			{
				return;
			}
			List<Item> ownedItems = _affectedCharacter.Inventory.GetOwnedItems(ItemID);
			if (ownedItems.Count > 0)
			{
				Item val = ownedItems[0];
				if (val.IsStackable)
				{
					if (val.RemainingAmount >= ItemQuantity)
					{
						val.RemoveQuantity(ItemQuantity);
					}
					else
					{
						ExtendedEffects.Instance.DebugLogMessage("RemoveItemFromInventory :: Not enough items in stack");
					}
				}
				else if (ownedItems.Count >= ItemQuantity)
				{
					_affectedCharacter.Inventory.RemoveItem(ItemID, ItemQuantity);
				}
			}
			else
			{
				ExtendedEffects.Instance.DebugLogMessage($"RemoveItemFromInventory :: No Items found with ID {ItemID}");
			}
		}
	}
	public class SL_ScalingWeaponDamage : SL_Effect, ICustomModel
	{
		public SL_Damage[] DamageModifiers;

		public float KnockbackAmount;

		public bool HitInventory;

		public Type SLTemplateModel => typeof(SL_ScalingWeaponDamage);

		public Type GameModel => typeof(SLEx_ScalingWeaponDamage);

		public override void ApplyToComponent<T>(T component)
		{
			SLEx_ScalingWeaponDamage sLEx_ScalingWeaponDamage = component as SLEx_ScalingWeaponDamage;
			sLEx_ScalingWeaponDamage.KnockbackAmount = KnockbackAmount;
			sLEx_ScalingWeaponDamage.HitInventory = HitInventory;
			sLEx_ScalingWeaponDamage.DamageModifiers = DamageModifiers.ToList();
		}

		public override void SerializeEffect<T>(T effect)
		{
			SLEx_ScalingWeaponDamage sLEx_ScalingWeaponDamage = effect as SLEx_ScalingWeaponDamage;
			KnockbackAmount = sLEx_ScalingWeaponDamage.KnockbackAmount;
			HitInventory = sLEx_ScalingWeaponDamage.HitInventory;
			DamageModifiers = sLEx_ScalingWeaponDamage.DamageModifiers.ToArray();
		}
	}
	public class SLEx_ScalingWeaponDamage : Effect, ICustomModel
	{
		public List<SL_Damage> DamageModifiers;

		public float KnockbackAmount;

		public bool HitInventory;

		public Type SLTemplateModel => typeof(SL_ScalingWeaponDamage);

		public Type GameModel => typeof(SLEx_ScalingWeaponDamage);

		public override void ActivateLocally(Character _affectedCharacter, object[] _infos)
		{
			//IL_0026: 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_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			Character ownerCharacter = base.m_parentSynchronizer.OwnerCharacter;
			Weapon currentWeapon = ownerCharacter.CurrentWeapon;
			if ((Object)(object)currentWeapon != (Object)null)
			{
				Vector3 val = ((Component)ownerCharacter).transform.position - ((Component)_affectedCharacter).transform.position;
				_affectedCharacter.ReceiveHit((Object)(object)((Effect)this).OwnerCharacter, CalculateWeaponDamage(currentWeapon), val, ((Component)_affectedCharacter).transform.position, 0f, 0f, ownerCharacter, KnockbackAmount, HitInventory);
			}
			else
			{
				ExtendedEffects.Instance.DebugLogMessage("SLEx_ScalingWeapon Owner has no weapon equipped!");
			}
		}

		private DamageList CalculateWeaponDamage(Weapon weapon)
		{
			DamageList NewList = weapon.Damage.Clone();
			if (DamageModifiers != null && DamageModifiers.Count > 0)
			{
				int i;
				for (i = 0; i < NewList.Count; i++)
				{
					SL_Damage val = DamageModifiers.Find((SL_Damage x) => x.Type == NewList[i].Type);
					if (val != null)
					{
						DamageType obj = NewList[i];
						obj.Damage *= val.Damage;
					}
				}
			}
			return NewList;
		}
	}
}
namespace SideLoader_ExtendedEffects.Released.Conditions
{
	public class SL_EquipmentSlotHasTag : SL_EffectCondition, ICustomModel
	{
		public string EquipmentSlotID;

		public string TagName;

		public Type SLTemplateModel => typeof(SL_EquipmentSlotHasTag);

		public Type GameModel => typeof(EquipmentSlotHasTag);

		public override void ApplyToComponent<T>(T component)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			EquipmentSlotHasTag equipmentSlotHasTag = component as EquipmentSlotHasTag;
			equipmentSlotHasTag.EquipmentSlot = (EquipmentSlotIDs)Enum.Parse(typeof(EquipmentSlotIDs), EquipmentSlotID);
			equipmentSlotHasTag.TagName = TagName;
		}

		public override void SerializeEffect<T>(T component)
		{
			EquipmentSlotHasTag equipmentSlotHasTag = component as EquipmentSlotHasTag;
			EquipmentSlotID = ((object)(EquipmentSlotIDs)(ref equipmentSlotHasTag.EquipmentSlot)).ToString();
			TagName = equipmentSlotHasTag.TagName;
		}
	}
	public class EquipmentSlotHasTag : EffectCondition
	{
		public EquipmentSlotIDs EquipmentSlot;

		public string TagName;

		public override bool CheckIsValid(Character _affectedCharacter)
		{
			//IL_000d: 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_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: 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_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			if (_affectedCharacter.Inventory.Equipment.HasItemEquipped(EquipmentSlot))
			{
				Tag tagFromName = OutwardHelpers.GetTagFromName(TagName);
				if (tagFromName != default(Tag))
				{
					Equipment equippedItem = _affectedCharacter.Inventory.Equipment.GetMatchingSlot(EquipmentSlot).EquippedItem;
					return (Object)(object)equippedItem != (Object)null && ((Item)equippedItem).HasTag(tagFromName);
				}
				ExtendedEffects.Instance.DebugLogMessage("Couldn't find tag with name " + TagName);
			}
			ExtendedEffects.Instance.DebugLogMessage($"Has no equipped Item in the specified slot {EquipmentSlot}");
			return false;
		}
	}
	public class SL_HasStat : SL_EffectCondition, ICustomModel
	{
		public string TagName;

		public float StatValue;

		public bool IsAbsolute = true;

		public Type SLTemplateModel => typeof(SL_HasStat);

		public Type GameModel => typeof(HasStat);

		public override void ApplyToComponent<T>(T component)
		{
			HasStat hasStat = component as HasStat;
			hasStat.TagName = TagName;
			hasStat.StatValue = StatValue;
			hasStat.IsAbsolute = IsAbsolute;
		}

		public override void SerializeEffect<T>(T component)
		{
			HasStat hasStat = component as HasStat;
			TagName = hasStat.TagName;
			StatValue = hasStat.StatValue;
			IsAbsolute = hasStat.IsAbsolute;
		}
	}
	public class HasStat : EffectCondition
	{
		public string TagName;

		public float StatValue;

		public bool IsAbsolute = true;

		public override bool CheckIsValid(Character _affectedCharacter)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			Tag tagFromName = OutwardHelpers.GetTagFromName(TagName);
			if (tagFromName != default(Tag))
			{
				Stat stat = _affectedCharacter.Stats.GetStat(tagFromName);
				if (stat == null)
				{
					ExtendedEffects._Log.LogMessage((object)"FoundStat was null");
					return false;
				}
				if (IsAbsolute)
				{
					return stat.CurrentValue <= StatValue;
				}
				float num = stat.CurrentValue / stat.MaxRange * 100f;
				return num <= StatValue;
			}
			ExtendedEffects._Log.LogMessage((object)("Stat Tag (" + TagName + ") could not be found"));
			return false;
		}
	}
	public class SL_IsAllowedScene : SL_EffectCondition, ICustomModel
	{
		public List<string> AllowedScenes;

		public Type SLTemplateModel => typeof(SL_IsAllowedScene);

		public Type GameModel => typeof(IsAllowedSceneCondition);

		public override void ApplyToComponent<T>(T component)
		{
			IsAllowedSceneCondition isAllowedSceneCondition = component as IsAllowedSceneCondition;

using System; using System.Diagnostics; using System.Reflection; using System.Runtime.CompilerServices; using System.Runtime.InteropServices; using System.Runtime.Versioning; using System.Security; using System.Security.Permissions; using BepInEx; using BepInEx.Configuration; using BepInEx.Logging; using SideLoader; using SideLoader.Model; using SideLoader.Model.Status; using UnityEngine; [assembly: CompilationRelaxations(8)] [assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)] [assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)] [assembly: AssemblyTitle("SkilledAtMeditation")] [assembly: AssemblyDescription("")] [assembly: AssemblyConfiguration("")] [assembly: AssemblyCompany("")] [assembly: AssemblyProduct("SkilledAtMeditation")] [assembly: AssemblyCopyright("Copyright © 2023")] [assembly: AssemblyTrademark("")] [assembly: ComVisible(false)] [assembly: Guid("f58ba851-9161-4c37-a53a-8b7160761b1f")] [assembly: AssemblyFileVersion("1.0.0.0")] [assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")] [assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)] [assembly: AssemblyVersion("1.0.0.0")] [module: UnverifiableCode] namespace SkilledAtMeditation; public class SL_Meditation : SL_Effect, ICustomModel { public Type SLTemplateModel => typeof(SL_Meditation); public Type GameModel => typeof(Meditation); public override void ApplyToComponent<T>(T component) { } public override void SerializeEffect<T>(T effect) { } } public class Meditation : Effect, ICustomModel { public Type SLTemplateModel => typeof(SL_Meditation); public Type GameModel => typeof(Meditation); public override void ActivateLocally(Character _affectedCharacter, object[] _infos) { //IL_0001: Unknown result type (might be due to invalid IL or missing references) //IL_0008: Invalid comparison between Unknown and I4 try { if ((int)_affectedCharacter.CurrentSpellCast != 41) { _affectedCharacter.StatusEffectMngr.CleanseStatusEffect("Meditation"); return; } CharacterStats stats = _affectedCharacter.Stats; if (SkilledAtMeditation.EnableBurntRegen.Value) { Update(ref stats.m_burntStamina, 0f - SkilledAtMeditation.BurntStaminaRegen.Value, stats.MaxStamina); Update(ref stats.m_burntHealth, 0f - SkilledAtMeditation.BurntHealthRegen.Value, stats.MaxHealth); Update(ref stats.m_burntMana, 0f - SkilledAtMeditation.BurntManaRegen.Value, stats.MaxMana); } if (SkilledAtMeditation.EnableActiveRegen.Value) { Update(ref stats.m_stamina, SkilledAtMeditation.ActiveStaminaRegen.Value, stats.ActiveMaxStamina); Update(ref stats.m_health, SkilledAtMeditation.ActiveHealthRegen.Value, stats.ActiveMaxHealth); Update(ref stats.m_mana, SkilledAtMeditation.ActiveManaRegen.Value, stats.ActiveMaxMana); } } catch (Exception arg) { SkilledAtMeditation.Log.LogMessage((object)$"Exception during Meditation.ActivateLocally: {arg}"); } static void Update(ref float cur, float delta, float max) { cur = Mathf.Clamp(cur + delta, 0f, max); } } } [BepInPlugin("com.exp111.SkilledAtMeditation", "SkilledAtMeditation", "1.0")] public class SkilledAtMeditation : BaseUnityPlugin { public const string ID = "com.exp111.SkilledAtMeditation"; public const string NAME = "SkilledAtMeditation"; public const string VERSION = "1.0"; public static ManualLogSource Log; public const int MeditationSkillID = -46000; public const int MeditationStatusID = -46001; public const string MeditationStatusIdentifier = "Meditation"; public Skill MeditationSkill; public static ConfigEntry<bool> EnableBurntRegen; public static ConfigEntry<bool> EnableActiveRegen; public static ConfigEntry<float> BurntStaminaRegen; public static ConfigEntry<float> BurntHealthRegen; public static ConfigEntry<float> BurntManaRegen; public static ConfigEntry<float> ActiveStaminaRegen; public static ConfigEntry<float> ActiveHealthRegen; public static ConfigEntry<float> ActiveManaRegen; public void Awake() { try { Log = ((BaseUnityPlugin)this).Logger; Log.LogMessage((object)"Awake"); CreateConfig(); CreateSkill(); CreateStatusEffect(); if (SL.PacksLoaded) { OnPackLoaded(); } SL.OnPacksLoaded += OnPackLoaded; SL.OnSceneLoaded += OnSceneLoaded; } catch (Exception arg) { Log.LogMessage((object)$"Exception during SkilledAtMeditation.Awake: {arg}"); } } private void CreateConfig() { EnableBurntRegen = ((BaseUnityPlugin)this).Config.Bind<bool>("Burnt Stat Regen", "Enable Burnt Stat Regeneration", true, "Enable or disable the regeneration of burnt stats while meditating"); EnableActiveRegen = ((BaseUnityPlugin)this).Config.Bind<bool>("Active Stat Regen", "Enable Active Stat Regeneration", true, "Enable or disable the regeneration of active (non-burnt) stats while meditating"); BurntStaminaRegen = ((BaseUnityPlugin)this).Config.Bind<float>("Burnt Stat Regen", "Burnt Stamina Regeneration Rate", 0.25f, "How quickly burnt stamina will regen while meditating."); BurntHealthRegen = ((BaseUnityPlugin)this).Config.Bind<float>("Burnt Stat Regen", "Burnt Health Regeneration Rate", 0.25f, "How quickly burnt health will regen while meditating."); BurntManaRegen = ((BaseUnityPlugin)this).Config.Bind<float>("Burnt Stat Regen", "Burnt Mana Regeneration Rate", 0.25f, "How quickly burnt Mana will regen while meditating."); ActiveStaminaRegen = ((BaseUnityPlugin)this).Config.Bind<float>("Active Stat Regen", "Active Stamina Regeneration", 0.5f, "How quickly stamina will regen while meditating."); ActiveHealthRegen = ((BaseUnityPlugin)this).Config.Bind<float>("Active Stat Regen", "Active Health Regeneration", 0.75f, "How quickly health will regen while meditating."); ActiveManaRegen = ((BaseUnityPlugin)this).Config.Bind<float>("Active Stat Regen", "Active Mana Regeneration", 0.5f, "How quickly mana will regen while meditating."); } public void OnDestroy() { } private void OnSceneLoaded() { try { foreach (Character value in CharacterManager.Instance.Characters.Values) { if (!value.IsAI && (Object)(object)value.Inventory != (Object)null && !value.Inventory.LearnedSkill((Item)(object)MeditationSkill)) { value.Inventory.ReceiveSkillReward(((Item)MeditationSkill).ItemID); } } } catch (Exception arg) { Log.LogMessage((object)$"Exception during SkilledAtMeditation.OnSceneLoaded: {arg}"); } } private void OnPackLoaded() { try { ref Skill meditationSkill = ref MeditationSkill; Item itemPrefab = ResourcesPrefabManager.Instance.GetItemPrefab(-46000); meditationSkill = (Skill)(object)((itemPrefab is Skill) ? itemPrefab : null); MeditationSkill.IgnoreLearnNotification = true; } catch (Exception arg) { Log.LogMessage((object)$"Exception during SkilledAtMeditation.OnPackLoaded: {arg}"); } } private void CreateStatusEffect() { //IL_0000: Unknown result type (might be due to invalid IL or missing references) //IL_0006: Expected O, but got Unknown //IL_0013: 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_00c5: Expected O, but got Unknown SL_StatusEffect val = new SL_StatusEffect(); val.TargetStatusIdentifier = "Burning"; val.EffectBehaviour = (EditBehaviours)2; val.StatusIdentifier = "Meditation"; val.NewStatusID = -46001; val.Name = "Resting"; val.Description = "Slowly restore stats while you rest."; ((SL_StatusBase)val).SLPackName = "com.exp111.SkilledAtMeditation"; ((SL_StatusBase)val).SubfolderName = "Meditation"; val.Lifespan = -1f; val.RefreshRate = 1f; val.DisplayedInHUD = true; val.IsMalusEffect = false; val.Purgeable = false; val.VFXInstantiationType = (FXInstantiationTypes)0; val.VFXPrefab = null; SL_EffectTransform[] array = new SL_EffectTransform[1]; SL_EffectTransform val2 = new SL_EffectTransform(); val2.TransformName = "Effects"; val2.Effects = (SL_Effect[])(object)new SL_Effect[1] { new SL_Meditation() }; array[0] = val2; val.Effects = (SL_EffectTransform[])(object)array; ((ContentTemplate)val).ApplyTemplate(); } private void CreateSkill() { //IL_0000: Unknown result type (might be due to invalid IL or missing references) //IL_0006: Expected O, but got Unknown //IL_0013: Unknown result type (might be due to invalid IL or missing references) //IL_008d: Unknown result type (might be due to invalid IL or missing references) //IL_0093: Expected O, but got Unknown //IL_00a7: Unknown result type (might be due to invalid IL or missing references) //IL_00ac: Unknown result type (might be due to invalid IL or missing references) //IL_00b7: 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_00cb: Expected O, but got Unknown SL_Skill val = new SL_Skill(); ((SL_Item)val).Name = "Resting"; ((SL_Item)val).EffectBehaviour = (EditBehaviours)2; ((SL_Item)val).Target_ItemID = 8100120; ((SL_Item)val).New_ItemID = -46000; ((SL_Item)val).SLPackName = "com.exp111.SkilledAtMeditation"; ((SL_Item)val).SubfolderName = "Meditate"; ((SL_Item)val).Description = "Enter a Resting state, slowly regenerating your vigor and injuries. When near a lit fire, your rest is enhanced and your body begins to recover."; ((SL_Item)val).CastType = (SpellCastType)41; ((SL_Item)val).CastModifier = (SpellCastModifier)0; ((SL_Item)val).CastLocomotionEnabled = true; ((SL_Item)val).MobileCastMovementMult = -1f; SL_EffectTransform[] array = new SL_EffectTransform[1]; SL_EffectTransform val2 = new SL_EffectTransform(); val2.TransformName = "Effects"; val2.Effects = (SL_Effect[])(object)new SL_Effect[1] { (SL_Effect)new SL_AddStatusEffect { StatusEffect = "Meditation", ChanceToContract = 100, Delay = 1f } }; array[0] = val2; ((SL_Item)val).EffectTransforms = (SL_EffectTransform[])(object)array; val.Cooldown = 1f; val.StaminaCost = 0f; val.HealthCost = 0f; val.ManaCost = 0f; ((ContentTemplate)val).ApplyTemplate(); } [Conditional("DEBUG")] public static void DebugLog(string message) { Log.LogMessage((object)message); } [Conditional("TRACE")] public static void DebugTrace(string message) { Log.LogMessage((object)message); } }

using System.Collections.Generic; using System.Diagnostics; using System.Linq; using System.Reflection; using System.Runtime.CompilerServices; using System.Runtime.InteropServices; using System.Runtime.Versioning; using System.Security; using System.Security.Permissions; using BepInEx; using BepInEx.Logging; using HarmonyLib; using NodeCanvas.DialogueTrees; using NodeCanvas.Framework; using SideLoader; using SideLoader.Model; using UnityEngine; [assembly: CompilationRelaxations(8)] [assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)] [assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)] [assembly: AssemblyTitle("OutwardModTemplate")] [assembly: AssemblyDescription("")] [assembly: AssemblyConfiguration("")] [assembly: AssemblyCompany("")] [assembly: AssemblyProduct("OutwardModTemplate")] [assembly: AssemblyCopyright("Copyright © 2021")] [assembly: AssemblyTrademark("")] [assembly: ComVisible(false)] [assembly: Guid("c5450fe0-edcf-483f-b9ea-4b1ef9d36da7")] [assembly: AssemblyFileVersion("1.0.0.0")] [assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")] [assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)] [assembly: AssemblyVersion("1.0.0.0")] [module: UnverifiableCode] namespace APP; [BepInPlugin("APP", "Advanced Picks & 'Poons", "0.9.6")] public class Plugin : BaseUnityPlugin { public const string GUID = "APP"; public const string NAME = "Advanced Picks & 'Poons"; public const string VERSION = "0.9.6"; public static ManualLogSource Log; public const int DEFPICK_ID = 2120050; public const int DEFPOON_ID = 2130130; public const int DEFSICK_ID = 2000060; public const int APICK_ID = -31000; public const int APOON_ID = -31001; public const int EPICK_ID = -31002; public const int EPOON_ID = -31003; public const int MPICK_ID = -31004; public const int MPOON_ID = -31005; public const int ASICK_ID = -31006; public const int ESICK_ID = -31007; public const int MSICK_ID = -31008; public const int APICK_DURABILITY = 350; public const int APOON_DURABILITY = 250; public const int EPICK_DURABILITY = 400; public const int EPOON_DURABILITY = 300; public const int APICK_VALUE = 40; public const int APOON_VALUE = 40; public const int EPICK_VALUE = 75; public const int EPOON_VALUE = 75; public const int ASICK_VALUE = 40; public const int ESICK_VALUE = 75; internal void Awake() { Log = ((BaseUnityPlugin)this).Logger; Log.LogMessage((object)"Advanced Picks & 'Poons 0.9.6 successfully loaded!"); SL.OnPacksLoaded += SL_OnPacksLoaded; Harmony.CreateAndPatchAll(typeof(Harmonize), (string)null); } private void SL_OnPacksLoaded() { SetUpPicks(); SetUpPoons(); SetUpSickles(); AddToolsToDictionary(); Recipes.CreateRecipes(); Recipes.CreateRecipeScrolls(); Recipes.AddRecipesToMerchants(); } private void AddToolsToDictionary() { ItemUtilities.instance.m_gatherableToolEquivalences[2120050] = ItemUtilities.instance.m_gatherableToolEquivalences[2120050].Append(-31000).ToArray(); ItemUtilities.instance.m_gatherableToolEquivalences[2120050] = ItemUtilities.instance.m_gatherableToolEquivalences[2120050].Append(-31002).ToArray(); ItemUtilities.instance.m_gatherableToolEquivalences[2130130] = ItemUtilities.instance.m_gatherableToolEquivalences[2130130].Append(-31001).ToArray(); ItemUtilities.instance.m_gatherableToolEquivalences[2130130] = ItemUtilities.instance.m_gatherableToolEquivalences[2130130].Append(-31003).ToArray(); } private void SetUpSickles() { //IL_0000: Unknown result type (might be due to invalid IL or missing references) //IL_0005: Unknown result type (might be due to invalid IL or missing references) //IL_0010: Unknown result type (might be due to invalid IL or missing references) //IL_001b: 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_0031: Unknown result type (might be due to invalid IL or missing references) //IL_0032: Unknown result type (might be due to invalid IL or missing references) //IL_0037: Unknown result type (might be due to invalid IL or missing references) //IL_003e: Unknown result type (might be due to invalid IL or missing references) //IL_0043: Unknown result type (might be due to invalid IL or missing references) //IL_004e: Unknown result type (might be due to invalid IL or missing references) //IL_0050: Unknown result type (might be due to invalid IL or missing references) //IL_005a: Expected O, but got Unknown //IL_005f: Unknown result type (might be due to invalid IL or missing references) //IL_006f: Unknown result type (might be due to invalid IL or missing references) //IL_0081: Expected O, but got Unknown //IL_0081: Unknown result type (might be due to invalid IL or missing references) //IL_0082: Unknown result type (might be due to invalid IL or missing references) //IL_0087: 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) //IL_009d: Unknown result type (might be due to invalid IL or missing references) //IL_00ad: Expected O, but got Unknown //IL_00ad: Unknown result type (might be due to invalid IL or missing references) //IL_00ae: Unknown result type (might be due to invalid IL or missing references) //IL_00b3: 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_00c9: Unknown result type (might be due to invalid IL or missing references) //IL_00d9: Expected O, but got Unknown //IL_00d9: Unknown result type (might be due to invalid IL or missing references) //IL_00e4: Unknown result type (might be due to invalid IL or missing references) //IL_00f4: Unknown result type (might be due to invalid IL or missing references) //IL_00f9: Unknown result type (might be due to invalid IL or missing references) //IL_0104: Unknown result type (might be due to invalid IL or missing references) //IL_010f: Unknown result type (might be due to invalid IL or missing references) //IL_011a: Unknown result type (might be due to invalid IL or missing references) //IL_0125: Unknown result type (might be due to invalid IL or missing references) //IL_0126: Unknown result type (might be due to invalid IL or missing references) //IL_012b: Unknown result type (might be due to invalid IL or missing references) //IL_0132: Unknown result type (might be due to invalid IL or missing references) //IL_0137: Unknown result type (might be due to invalid IL or missing references) //IL_0142: Unknown result type (might be due to invalid IL or missing references) //IL_0144: Unknown result type (might be due to invalid IL or missing references) //IL_014e: Expected O, but got Unknown //IL_0153: Unknown result type (might be due to invalid IL or missing references) //IL_0163: Unknown result type (might be due to invalid IL or missing references) //IL_0175: Expected O, but got Unknown //IL_0175: Unknown result type (might be due to invalid IL or missing references) //IL_0176: Unknown result type (might be due to invalid IL or missing references) //IL_017b: Unknown result type (might be due to invalid IL or missing references) //IL_0186: Unknown result type (might be due to invalid IL or missing references) //IL_0191: Unknown result type (might be due to invalid IL or missing references) //IL_01a1: Expected O, but got Unknown //IL_01a1: Unknown result type (might be due to invalid IL or missing references) //IL_01a2: Unknown result type (might be due to invalid IL or missing references) //IL_01a7: Unknown result type (might be due to invalid IL or missing references) //IL_01b2: Unknown result type (might be due to invalid IL or missing references) //IL_01bd: Unknown result type (might be due to invalid IL or missing references) //IL_01cd: Expected O, but got Unknown //IL_01cd: Unknown result type (might be due to invalid IL or missing references) //IL_01d8: Unknown result type (might be due to invalid IL or missing references) ((ContentTemplate)new SL_Weapon { Target_ItemID = 2000060, New_ItemID = -316, Name = "Advanced Sickle", Description = "A quality sickle used to gather items more efficiently.", StatsHolder = (SL_ItemStats)new SL_WeaponStats { BaseDamage = new List<SL_Damage> { new SL_Damage { Damage = 17f, Type = (Types)0 } }, MaxDurability = 350, BaseValue = 40 }, ItemVisuals = new SL_ItemVisual { Prefab_SLPack = "APP", Prefab_AssetBundle = "sickle-a", Prefab_Name = "sickle-a" }, SpecialItemVisuals = new SL_ItemVisual { Prefab_SLPack = "APP", Prefab_AssetBundle = "ssickle-a", Prefab_Name = "ssickle-a" }, SLPackName = "APP", SubfolderName = "AdvancedSickle" }).ApplyTemplate(); ((ContentTemplate)new SL_Weapon { Target_ItemID = 2000060, New_ItemID = -317, Name = "Expert Sickle", Description = "A quality sickle used to gather items more efficiently.", StatsHolder = (SL_ItemStats)new SL_WeaponStats { BaseDamage = new List<SL_Damage> { new SL_Damage { Damage = 20f, Type = (Types)0 } }, MaxDurability = 400, BaseValue = 75 }, ItemVisuals = new SL_ItemVisual { Prefab_SLPack = "APP", Prefab_AssetBundle = "sickle-a", Prefab_Name = "sickle-a" }, SpecialItemVisuals = new SL_ItemVisual { Prefab_SLPack = "APP", Prefab_AssetBundle = "ssickle-a", Prefab_Name = "ssickle-a" }, SLPackName = "APP", SubfolderName = "ExpertSickle" }).ApplyTemplate(); } private void SetUpPicks() { //IL_0000: Unknown result type (might be due to invalid IL or missing references) //IL_0005: Unknown result type (might be due to invalid IL or missing references) //IL_0010: Unknown result type (might be due to invalid IL or missing references) //IL_001b: 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_0031: Unknown result type (might be due to invalid IL or missing references) //IL_0032: Unknown result type (might be due to invalid IL or missing references) //IL_0037: Unknown result type (might be due to invalid IL or missing references) //IL_003e: Unknown result type (might be due to invalid IL or missing references) //IL_0043: Unknown result type (might be due to invalid IL or missing references) //IL_004e: Unknown result type (might be due to invalid IL or missing references) //IL_0050: Unknown result type (might be due to invalid IL or missing references) //IL_005a: Expected O, but got Unknown //IL_005f: Unknown result type (might be due to invalid IL or missing references) //IL_006f: Unknown result type (might be due to invalid IL or missing references) //IL_0081: Expected O, but got Unknown //IL_0081: Unknown result type (might be due to invalid IL or missing references) //IL_008c: Unknown result type (might be due to invalid IL or missing references) //IL_009c: Unknown result type (might be due to invalid IL or missing references) //IL_00a1: Unknown result type (might be due to invalid IL or missing references) //IL_00ac: Unknown result type (might be due to invalid IL or missing references) //IL_00b7: Unknown result type (might be due to invalid IL or missing references) //IL_00c2: 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_00ce: Unknown result type (might be due to invalid IL or missing references) //IL_00d3: Unknown result type (might be due to invalid IL or missing references) //IL_00da: Unknown result type (might be due to invalid IL or missing references) //IL_00df: Unknown result type (might be due to invalid IL or missing references) //IL_00ea: Unknown result type (might be due to invalid IL or missing references) //IL_00ec: Unknown result type (might be due to invalid IL or missing references) //IL_00f6: Expected O, but got Unknown //IL_00fb: Unknown result type (might be due to invalid IL or missing references) //IL_010b: Unknown result type (might be due to invalid IL or missing references) //IL_011d: Expected O, but got Unknown //IL_011d: Unknown result type (might be due to invalid IL or missing references) //IL_0128: Unknown result type (might be due to invalid IL or missing references) ((ContentTemplate)new SL_MeleeWeapon { Target_ItemID = 2120050, New_ItemID = -310, Name = "Advanced Mining Pick", Description = "A mining pick of greater quality that is capable of mining more efficiently.", StatsHolder = (SL_ItemStats)new SL_WeaponStats { BaseDamage = new List<SL_Damage> { new SL_Damage { Damage = 20f, Type = (Types)0 } }, MaxDurability = 350, BaseValue = 40 }, SLPackName = "APP", SubfolderName = "AdvancedPick" }).ApplyTemplate(); ((ContentTemplate)new SL_MeleeWeapon { Target_ItemID = 2120050, New_ItemID = -312, Name = "Expert Mining Pick", Description = "A mining pick of exceptional quality that is capable of mining a great deal more efficiently.", StatsHolder = (SL_ItemStats)new SL_WeaponStats { BaseDamage = new List<SL_Damage> { new SL_Damage { Damage = 26f, Type = (Types)0 } }, MaxDurability = 400, BaseValue = 75 }, SLPackName = "APP", SubfolderName = "ExpertPick" }).ApplyTemplate(); } private void SetUpPoons() { //IL_0000: Unknown result type (might be due to invalid IL or missing references) //IL_0005: Unknown result type (might be due to invalid IL or missing references) //IL_0010: Unknown result type (might be due to invalid IL or missing references) //IL_001b: 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_0031: Unknown result type (might be due to invalid IL or missing references) //IL_0032: Unknown result type (might be due to invalid IL or missing references) //IL_0037: Unknown result type (might be due to invalid IL or missing references) //IL_003e: Unknown result type (might be due to invalid IL or missing references) //IL_0043: Unknown result type (might be due to invalid IL or missing references) //IL_004e: Unknown result type (might be due to invalid IL or missing references) //IL_0050: Unknown result type (might be due to invalid IL or missing references) //IL_005a: Expected O, but got Unknown //IL_005f: Unknown result type (might be due to invalid IL or missing references) //IL_006f: Unknown result type (might be due to invalid IL or missing references) //IL_0081: Expected O, but got Unknown //IL_0081: Unknown result type (might be due to invalid IL or missing references) //IL_008c: Unknown result type (might be due to invalid IL or missing references) //IL_009c: Unknown result type (might be due to invalid IL or missing references) //IL_00a1: Unknown result type (might be due to invalid IL or missing references) //IL_00ac: Unknown result type (might be due to invalid IL or missing references) //IL_00b7: Unknown result type (might be due to invalid IL or missing references) //IL_00c2: 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_00ce: Unknown result type (might be due to invalid IL or missing references) //IL_00d3: Unknown result type (might be due to invalid IL or missing references) //IL_00da: Unknown result type (might be due to invalid IL or missing references) //IL_00df: Unknown result type (might be due to invalid IL or missing references) //IL_00ea: Unknown result type (might be due to invalid IL or missing references) //IL_00ec: Unknown result type (might be due to invalid IL or missing references) //IL_00f6: Expected O, but got Unknown //IL_00fb: Unknown result type (might be due to invalid IL or missing references) //IL_010b: Unknown result type (might be due to invalid IL or missing references) //IL_011d: Expected O, but got Unknown //IL_011d: Unknown result type (might be due to invalid IL or missing references) //IL_0128: Unknown result type (might be due to invalid IL or missing references) ((ContentTemplate)new SL_MeleeWeapon { Target_ItemID = 2130130, New_ItemID = -311, Name = "Advanced Fishing Harpoon", Description = "A harpoon of greater quality that is capable of fishing more effectively.", StatsHolder = (SL_ItemStats)new SL_WeaponStats { BaseDamage = new List<SL_Damage> { new SL_Damage { Damage = 20f, Type = (Types)0 } }, MaxDurability = 250, BaseValue = 40 }, SLPackName = "APP", SubfolderName = "AdvancedPoon" }).ApplyTemplate(); ((ContentTemplate)new SL_MeleeWeapon { Target_ItemID = 2130130, New_ItemID = -313, Name = "Expert Fishing Harpoon", Description = "A harpoon of exceptional quality that is capable of fishing a great deal more effectively.", StatsHolder = (SL_ItemStats)new SL_WeaponStats { BaseDamage = new List<SL_Damage> { new SL_Damage { Damage = 26f, Type = (Types)0 } }, MaxDurability = 300, BaseValue = 75 }, SLPackName = "APP", SubfolderName = "ExpertPoon" }).ApplyTemplate(); } } public class Harmonize { private static bool isMining; private static bool isFishing; private static bool isDialoguePatched; private static bool firstTime; public static Harmonize Instance { get; private set; } internal void Awake() { Instance = this; } [HarmonyPrefix] [HarmonyPatch(typeof(Gatherable), "OnGatherInteraction")] private static void GatherPatch(Character _gatherer, Gatherable __instance) { if (!firstTime) { if (isMining) { if (_gatherer.Inventory.OwnsItem(-31000) && !_gatherer.Inventory.OwnsItem(-31002)) { if (Random.Range(1, 100) < 16) { MethodInfo method = typeof(Gatherable).GetMethod("StartInit", BindingFlags.Instance | BindingFlags.NonPublic); if (method != null) { method.Invoke(__instance, null); } } } else if (_gatherer.Inventory.OwnsItem(-31002) && Random.Range(1, 100) < 26) { MethodInfo method2 = typeof(Gatherable).GetMethod("StartInit", BindingFlags.Instance | BindingFlags.NonPublic); if (method2 != null) { method2.Invoke(__instance, null); } } isMining = false; return; } if (isFishing) { if (_gatherer.Inventory.OwnsItem(-31001) && !_gatherer.Inventory.OwnsItem(-31003)) { if (Random.Range(1, 100) < 16) { MethodInfo method3 = typeof(Gatherable).GetMethod("StartInit", BindingFlags.Instance | BindingFlags.NonPublic); if (method3 != null) { method3.Invoke(__instance, null); } } } else if (_gatherer.Inventory.OwnsItem(-31003) && Random.Range(1, 100) < 26) { MethodInfo method4 = typeof(Gatherable).GetMethod("StartInit", BindingFlags.Instance | BindingFlags.NonPublic); if (method4 != null) { method4.Invoke(__instance, null); } } isFishing = false; return; } new List<Item>(); if (_gatherer.Inventory.OwnsItem(-31006) && !_gatherer.Inventory.OwnsItem(-31007)) { Item obj = _gatherer.Inventory.GetOwnedItems(-31006)[0]; float num = obj.MaxDurability / 100; obj.ReduceDurability(num); if (Random.Range(1, 100) < 16) { MethodInfo method5 = typeof(Gatherable).GetMethod("StartInit", BindingFlags.Instance | BindingFlags.NonPublic); if (method5 != null) { method5.Invoke(__instance, null); } } } else { if (!_gatherer.Inventory.OwnsItem(-31007)) { return; } Item obj2 = _gatherer.Inventory.GetOwnedItems(-31007)[0]; float num2 = obj2.MaxDurability / 100; obj2.ReduceDurability(num2); if (Random.Range(1, 100) < 26) { MethodInfo method6 = typeof(Gatherable).GetMethod("StartInit", BindingFlags.Instance | BindingFlags.NonPublic); if (method6 != null) { method6.Invoke(__instance, null); } } } } else { firstTime = false; } } [HarmonyPostfix] [HarmonyPatch(typeof(CharacterInventory), "GetCompatibleGatherableTool")] private static void GetToolPatch(int _sourceToolID) { switch (_sourceToolID) { case 2120050: isMining = true; isFishing = false; break; case 2130130: isMining = false; isFishing = true; break; default: isMining = false; isFishing = false; break; } } [HarmonyPrefix] [HarmonyPatch(typeof(NPCInteraction), "OnActivate")] private static void NPCInteractionPatch(NPCInteraction __instance) { //IL_0041: Unknown result type (might be due to invalid IL or missing references) //IL_0046: Unknown result type (might be due to invalid IL or missing references) //IL_004c: Unknown result type (might be due to invalid IL or missing references) //IL_0056: Expected O, but got Unknown //IL_0057: Expected O, but got Unknown //IL_0070: Unknown result type (might be due to invalid IL or missing references) //IL_007a: Expected O, but got Unknown if (__instance.DialogueActor.name == "Loud-Hammer" && !isDialoguePatched) { Graph graph = ((GraphOwner)((Component)__instance.DialogueActor).GetComponentInChildren<DialogueTreeController>()).graph; MultipleChoiceNodeExt val = graph.GetAllNodesOfType<MultipleChoiceNodeExt>()[0]; Choice item = new Choice { statement = new Statement("Is there anything else you can teach me?") }; val.availableChoices.Add(item); StatementNodeExt val2 = graph.AddNode<StatementNodeExt>(); val2.statement = new Statement("If you are interested in discovering the secrets of more efficient gathering tools, seek out other blacksmiths in far away cities!"); val2.SetActorName("Loud-Hammer"); graph.allNodes.Add((Node)(object)val2); graph.ConnectNodes((Node)(object)val, (Node)(object)val2, 6, -1); isDialoguePatched = true; } } static Harmonize() { isMining = false; isFishing = false; isDialoguePatched = false; firstTime = true; } } public class Recipes { public const string APICK_REC = "app.advpick"; public const string EPICK_REC = "app.exppick"; public const string APOON_REC = "app.advpoon"; public const string EPOON_REC = "app.expoon"; public const string MPICK_REC = "app.maspick"; public const string MPOON_REC = "app.maspoon"; public const string ASICK_REC = "app.advsick"; public const string ESICK_REC = "app.expsick"; public const string MSICK_REC = "app.massick"; public const int APICK_REC_ID = -31010; public const int APOON_REC_ID = -31011; public const int EPICK_REC_ID = -31012; public const int EPOON_REC_ID = -31013; public const int MPICK_REC_ID = -31014; public const int MPOON_REC_ID = -31015; public const int ASICK_REC_ID = -31016; public const int ESICK_REC_ID = -31017; public const int MSICK_REC_ID = -31018; public const int ADVTOOLCOST = 75; public const int EXPTOOLCOST = 125; public const int MASTOOLCOST = 200; public const string ING_MININGPICK = "2120050"; public const string ING_PALLADIUM = "6400070"; public const string ING_AMMOLITE = "6200050"; public const string ING_BEASTGOLEMSCRAPS = "6600130"; public const string ING_GOLDINGOT = "6300030"; public const string ING_AMETHYSTGEODE = "6000370"; public const string ING_CHROMIUMSHARDS = "6000340"; public const string ING_FISHINGHARPOON = "2130130"; public const string ING_BLUESAND = "6400110"; public const string ING_SHARKCARTILAGE = "6600170"; public const string ING_PETRIFIEDORGANS = "6000440"; public const string ING_DIGESTEDMANASTONE = "6000450"; public const string ING_MACHETE = "2000060"; public const string ING_WOOLSHROOM = "4000240"; public const string ING_PETRIFIEDWOOD = "6400080"; public const string ING_VOLTAICVINES = "6000410"; public const string ING_BLOODROOT = "6000400"; public static void CreateRecipes() { CreatePickRecipes(); CreatePoonRecipes(); CreateSickleRecipes(); CreateMasterRecipes(); } private static void CreatePickRecipes() { //IL_0001: Unknown result type (might be due to invalid IL or missing references) //IL_0006: Unknown result type (might be due to invalid IL or missing references) //IL_0011: Unknown result type (might be due to invalid IL or missing references) //IL_0013: Unknown result type (might be due to invalid IL or missing references) //IL_0018: Unknown result type (might be due to invalid IL or missing references) //IL_001f: Unknown result type (might be due to invalid IL or missing references) //IL_0024: Unknown result type (might be due to invalid IL or missing references) //IL_0026: Unknown result type (might be due to invalid IL or missing references) //IL_002b: Unknown result type (might be due to invalid IL or missing references) //IL_003b: Expected O, but got Unknown //IL_003d: 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_0044: Unknown result type (might be due to invalid IL or missing references) //IL_0049: Unknown result type (might be due to invalid IL or missing references) //IL_0059: Expected O, but got Unknown //IL_005b: Unknown result type (might be due to invalid IL or missing references) //IL_0060: Unknown result type (might be due to invalid IL or missing references) //IL_0062: Unknown result type (might be due to invalid IL or missing references) //IL_0067: Unknown result type (might be due to invalid IL or missing references) //IL_0077: Expected O, but got Unknown //IL_0079: Unknown result type (might be due to invalid IL or missing references) //IL_007e: Unknown result type (might be due to invalid IL or missing references) //IL_0080: Unknown result type (might be due to invalid IL or missing references) //IL_0085: Unknown result type (might be due to invalid IL or missing references) //IL_0095: Expected O, but got Unknown //IL_009b: 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_00a7: Unknown result type (might be due to invalid IL or missing references) //IL_00b2: Unknown result type (might be due to invalid IL or missing references) //IL_00be: Expected O, but got Unknown //IL_00c5: Expected O, but got Unknown //IL_00cc: 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_00dc: Unknown result type (might be due to invalid IL or missing references) //IL_00de: Unknown result type (might be due to invalid IL or missing references) //IL_00e3: Unknown result type (might be due to invalid IL or missing references) //IL_00ea: Unknown result type (might be due to invalid IL or missing references) //IL_00ef: Unknown result type (might be due to invalid IL or missing references) //IL_00f1: Unknown result type (might be due to invalid IL or missing references) //IL_00f6: Unknown result type (might be due to invalid IL or missing references) //IL_010e: Expected O, but got Unknown //IL_0110: Unknown result type (might be due to invalid IL or missing references) //IL_0115: Unknown result type (might be due to invalid IL or missing references) //IL_0117: Unknown result type (might be due to invalid IL or missing references) //IL_011c: Unknown result type (might be due to invalid IL or missing references) //IL_012c: Expected O, but got Unknown //IL_012e: Unknown result type (might be due to invalid IL or missing references) //IL_0133: Unknown result type (might be due to invalid IL or missing references) //IL_0135: Unknown result type (might be due to invalid IL or missing references) //IL_013a: Unknown result type (might be due to invalid IL or missing references) //IL_014a: Expected O, but got Unknown //IL_014c: Unknown result type (might be due to invalid IL or missing references) //IL_0151: Unknown result type (might be due to invalid IL or missing references) //IL_0153: Unknown result type (might be due to invalid IL or missing references) //IL_0158: Unknown result type (might be due to invalid IL or missing references) //IL_0168: Expected O, but got Unknown //IL_016e: Unknown result type (might be due to invalid IL or missing references) //IL_0175: 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_0185: Unknown result type (might be due to invalid IL or missing references) //IL_0191: Expected O, but got Unknown //IL_0198: Expected O, but got Unknown SL_Recipe val = new SL_Recipe { UID = "app.advpick", StationType = (CraftingType)2, Ingredients = new List<Ingredient> { new Ingredient { Type = (ActionTypes)1, SelectorValue = "2120050" }, new Ingredient { Type = (ActionTypes)1, SelectorValue = "6400070" }, new Ingredient { Type = (ActionTypes)1, SelectorValue = "6200050" }, new Ingredient { Type = (ActionTypes)1, SelectorValue = "6600130" } }, Results = new List<ItemQty> { new ItemQty { ItemID = -31000, Quantity = 1 } } }; ((ContentTemplate)val).ApplyTemplate(); SL_Recipe val2 = new SL_Recipe { UID = "app.exppick", StationType = (CraftingType)2, Ingredients = new List<Ingredient> { new Ingredient { Type = (ActionTypes)1, SelectorValue = (-31000).ToString() }, new Ingredient { Type = (ActionTypes)1, SelectorValue = "6300030" }, new Ingredient { Type = (ActionTypes)1, SelectorValue = "6000370" }, new Ingredient { Type = (ActionTypes)1, SelectorValue = "6000350" } }, Results = new List<ItemQty> { new ItemQty { ItemID = -31002, Quantity = 1 } } }; ((ContentTemplate)val2).ApplyTemplate(); } private static void CreatePoonRecipes() { //IL_0001: Unknown result type (might be due to invalid IL or missing references) //IL_0006: Unknown result type (might be due to invalid IL or missing references) //IL_0011: Unknown result type (might be due to invalid IL or missing references) //IL_0013: Unknown result type (might be due to invalid IL or missing references) //IL_0018: Unknown result type (might be due to invalid IL or missing references) //IL_001f: Unknown result type (might be due to invalid IL or missing references) //IL_0024: Unknown result type (might be due to invalid IL or missing references) //IL_0026: Unknown result type (might be due to invalid IL or missing references) //IL_002b: Unknown result type (might be due to invalid IL or missing references) //IL_003b: Expected O, but got Unknown //IL_003d: 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_0044: Unknown result type (might be due to invalid IL or missing references) //IL_0049: Unknown result type (might be due to invalid IL or missing references) //IL_0059: Expected O, but got Unknown //IL_005b: Unknown result type (might be due to invalid IL or missing references) //IL_0060: Unknown result type (might be due to invalid IL or missing references) //IL_0062: Unknown result type (might be due to invalid IL or missing references) //IL_0067: Unknown result type (might be due to invalid IL or missing references) //IL_0077: Expected O, but got Unknown //IL_0079: Unknown result type (might be due to invalid IL or missing references) //IL_007e: Unknown result type (might be due to invalid IL or missing references) //IL_0080: Unknown result type (might be due to invalid IL or missing references) //IL_0085: Unknown result type (might be due to invalid IL or missing references) //IL_0095: Expected O, but got Unknown //IL_009b: 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_00a7: Unknown result type (might be due to invalid IL or missing references) //IL_00b2: Unknown result type (might be due to invalid IL or missing references) //IL_00be: Expected O, but got Unknown //IL_00c5: Expected O, but got Unknown //IL_00cc: 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_00dc: Unknown result type (might be due to invalid IL or missing references) //IL_00de: Unknown result type (might be due to invalid IL or missing references) //IL_00e3: Unknown result type (might be due to invalid IL or missing references) //IL_00ea: Unknown result type (might be due to invalid IL or missing references) //IL_00ef: Unknown result type (might be due to invalid IL or missing references) //IL_00f1: Unknown result type (might be due to invalid IL or missing references) //IL_00f6: Unknown result type (might be due to invalid IL or missing references) //IL_010e: Expected O, but got Unknown //IL_0110: Unknown result type (might be due to invalid IL or missing references) //IL_0115: Unknown result type (might be due to invalid IL or missing references) //IL_0117: Unknown result type (might be due to invalid IL or missing references) //IL_011c: Unknown result type (might be due to invalid IL or missing references) //IL_012c: Expected O, but got Unknown //IL_012e: Unknown result type (might be due to invalid IL or missing references) //IL_0133: Unknown result type (might be due to invalid IL or missing references) //IL_0135: Unknown result type (might be due to invalid IL or missing references) //IL_013a: Unknown result type (might be due to invalid IL or missing references) //IL_014a: Expected O, but got Unknown //IL_014c: Unknown result type (might be due to invalid IL or missing references) //IL_0151: Unknown result type (might be due to invalid IL or missing references) //IL_0153: Unknown result type (might be due to invalid IL or missing references) //IL_0158: Unknown result type (might be due to invalid IL or missing references) //IL_0168: Expected O, but got Unknown //IL_016e: Unknown result type (might be due to invalid IL or missing references) //IL_0175: 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_0185: Unknown result type (might be due to invalid IL or missing references) //IL_0191: Expected O, but got Unknown //IL_0198: Expected O, but got Unknown SL_Recipe val = new SL_Recipe { UID = "app.advpoon", StationType = (CraftingType)2, Ingredients = new List<Ingredient> { new Ingredient { Type = (ActionTypes)1, SelectorValue = "2130130" }, new Ingredient { Type = (ActionTypes)1, SelectorValue = "6400070" }, new Ingredient { Type = (ActionTypes)1, SelectorValue = "6400110" }, new Ingredient { Type = (ActionTypes)1, SelectorValue = "6600170" } }, Results = new List<ItemQty> { new ItemQty { ItemID = -31001, Quantity = 1 } } }; ((ContentTemplate)val).ApplyTemplate(); SL_Recipe val2 = new SL_Recipe { UID = "app.expoon", StationType = (CraftingType)2, Ingredients = new List<Ingredient> { new Ingredient { Type = (ActionTypes)1, SelectorValue = (-31001).ToString() }, new Ingredient { Type = (ActionTypes)1, SelectorValue = "6300030" }, new Ingredient { Type = (ActionTypes)1, SelectorValue = "6000440" }, new Ingredient { Type = (ActionTypes)1, SelectorValue = "6000450" } }, Results = new List<ItemQty> { new ItemQty { ItemID = -31003, Quantity = 1 } } }; ((ContentTemplate)val2).ApplyTemplate(); } private static void CreateSickleRecipes() { //IL_0001: Unknown result type (might be due to invalid IL or missing references) //IL_0006: Unknown result type (might be due to invalid IL or missing references) //IL_0011: Unknown result type (might be due to invalid IL or missing references) //IL_0013: Unknown result type (might be due to invalid IL or missing references) //IL_0018: Unknown result type (might be due to invalid IL or missing references) //IL_001f: Unknown result type (might be due to invalid IL or missing references) //IL_0024: Unknown result type (might be due to invalid IL or missing references) //IL_0026: Unknown result type (might be due to invalid IL or missing references) //IL_002b: Unknown result type (might be due to invalid IL or missing references) //IL_003b: Expected O, but got Unknown //IL_003d: 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_0044: Unknown result type (might be due to invalid IL or missing references) //IL_0049: Unknown result type (might be due to invalid IL or missing references) //IL_0059: Expected O, but got Unknown //IL_005b: Unknown result type (might be due to invalid IL or missing references) //IL_0060: Unknown result type (might be due to invalid IL or missing references) //IL_0062: Unknown result type (might be due to invalid IL or missing references) //IL_0067: Unknown result type (might be due to invalid IL or missing references) //IL_0077: Expected O, but got Unknown //IL_0079: Unknown result type (might be due to invalid IL or missing references) //IL_007e: Unknown result type (might be due to invalid IL or missing references) //IL_0080: Unknown result type (might be due to invalid IL or missing references) //IL_0085: Unknown result type (might be due to invalid IL or missing references) //IL_0095: Expected O, but got Unknown //IL_009b: 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_00a7: Unknown result type (might be due to invalid IL or missing references) //IL_00b2: Unknown result type (might be due to invalid IL or missing references) //IL_00be: Expected O, but got Unknown //IL_00c5: Expected O, but got Unknown //IL_00cc: 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_00dc: Unknown result type (might be due to invalid IL or missing references) //IL_00de: Unknown result type (might be due to invalid IL or missing references) //IL_00e3: Unknown result type (might be due to invalid IL or missing references) //IL_00ea: Unknown result type (might be due to invalid IL or missing references) //IL_00ef: Unknown result type (might be due to invalid IL or missing references) //IL_00f1: Unknown result type (might be due to invalid IL or missing references) //IL_00f6: Unknown result type (might be due to invalid IL or missing references) //IL_010e: Expected O, but got Unknown //IL_0110: Unknown result type (might be due to invalid IL or missing references) //IL_0115: Unknown result type (might be due to invalid IL or missing references) //IL_0117: Unknown result type (might be due to invalid IL or missing references) //IL_011c: Unknown result type (might be due to invalid IL or missing references) //IL_012c: Expected O, but got Unknown //IL_012e: Unknown result type (might be due to invalid IL or missing references) //IL_0133: Unknown result type (might be due to invalid IL or missing references) //IL_0135: Unknown result type (might be due to invalid IL or missing references) //IL_013a: Unknown result type (might be due to invalid IL or missing references) //IL_014a: Expected O, but got Unknown //IL_014c: Unknown result type (might be due to invalid IL or missing references) //IL_0151: Unknown result type (might be due to invalid IL or missing references) //IL_0153: Unknown result type (might be due to invalid IL or missing references) //IL_0158: Unknown result type (might be due to invalid IL or missing references) //IL_0168: Expected O, but got Unknown //IL_016e: Unknown result type (might be due to invalid IL or missing references) //IL_0175: 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_0185: Unknown result type (might be due to invalid IL or missing references) //IL_0191: Expected O, but got Unknown //IL_0198: Expected O, but got Unknown SL_Recipe val = new SL_Recipe { UID = "app.advsick", StationType = (CraftingType)2, Ingredients = new List<Ingredient> { new Ingredient { Type = (ActionTypes)1, SelectorValue = "2000060" }, new Ingredient { Type = (ActionTypes)1, SelectorValue = "6400070" }, new Ingredient { Type = (ActionTypes)1, SelectorValue = "4000240" }, new Ingredient { Type = (ActionTypes)1, SelectorValue = "6400080" } }, Results = new List<ItemQty> { new ItemQty { ItemID = -31006, Quantity = 1 } } }; ((ContentTemplate)val).ApplyTemplate(); SL_Recipe val2 = new SL_Recipe { UID = "app.expsick", StationType = (CraftingType)2, Ingredients = new List<Ingredient> { new Ingredient { Type = (ActionTypes)1, SelectorValue = (-31006).ToString() }, new Ingredient { Type = (ActionTypes)1, SelectorValue = "6300030" }, new Ingredient { Type = (ActionTypes)1, SelectorValue = "6000410" }, new Ingredient { Type = (ActionTypes)1, SelectorValue = "6000400" } }, Results = new List<ItemQty> { new ItemQty { ItemID = -31007, Quantity = 1 } } }; ((ContentTemplate)val2).ApplyTemplate(); } public static void CreateMasterRecipes() { } public static void CreateRecipeScrolls() { //IL_0001: Unknown result type (might be due to invalid IL or missing references) //IL_0006: Unknown result type (might be due to invalid IL or missing references) //IL_0011: Unknown result type (might be due to invalid IL or missing references) //IL_001c: Unknown result type (might be due to invalid IL or missing references) //IL_0027: Unknown result type (might be due to invalid IL or missing references) //IL_0032: Unknown result type (might be due to invalid IL or missing references) //IL_003d: Unknown result type (might be due to invalid IL or missing references) //IL_003e: Unknown result type (might be due to invalid IL or missing references) //IL_0043: Unknown result type (might be due to invalid IL or missing references) //IL_0055: Expected O, but got Unknown //IL_0056: Expected O, but got Unknown //IL_005d: Unknown result type (might be due to invalid IL or missing references) //IL_0062: Unknown result type (might be due to invalid IL or missing references) //IL_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_008e: Unknown result type (might be due to invalid IL or missing references) //IL_0099: Unknown result type (might be due to invalid IL or missing references) //IL_009a: Unknown result type (might be due to invalid IL or missing references) //IL_009f: Unknown result type (might be due to invalid IL or missing references) //IL_00b1: Expected O, but got Unknown //IL_00b2: Expected O, but got Unknown //IL_00b9: 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_00c9: Unknown result type (might be due to invalid IL or missing references) //IL_00d4: Unknown result type (might be due to invalid IL or missing references) //IL_00df: Unknown result type (might be due to invalid IL or missing references) //IL_00ea: 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_00f6: Unknown result type (might be due to invalid IL or missing references) //IL_00fb: Unknown result type (might be due to invalid IL or missing references) //IL_010d: Expected O, but got Unknown //IL_010e: Expected O, but got Unknown //IL_0115: Unknown result type (might be due to invalid IL or missing references) //IL_011a: Unknown result type (might be due to invalid IL or missing references) //IL_0125: Unknown result type (might be due to invalid IL or missing references) //IL_0130: Unknown result type (might be due to invalid IL or missing references) //IL_013b: Unknown result type (might be due to invalid IL or missing references) //IL_0146: Unknown result type (might be due to invalid IL or missing references) //IL_0151: Unknown result type (might be due to invalid IL or missing references) //IL_0152: Unknown result type (might be due to invalid IL or missing references) //IL_0157: Unknown result type (might be due to invalid IL or missing references) //IL_0169: Expected O, but got Unknown //IL_016a: Expected O, but got Unknown //IL_0171: Unknown result type (might be due to invalid IL or missing references) //IL_0176: Unknown result type (might be due to invalid IL or missing references) //IL_0181: Unknown result type (might be due to invalid IL or missing references) //IL_018c: Unknown result type (might be due to invalid IL or missing references) //IL_0197: Unknown result type (might be due to invalid IL or missing references) //IL_01a2: Unknown result type (might be due to invalid IL or missing references) //IL_01ad: Unknown result type (might be due to invalid IL or missing references) //IL_01ae: Unknown result type (might be due to invalid IL or missing references) //IL_01b3: Unknown result type (might be due to invalid IL or missing references) //IL_01c5: Expected O, but got Unknown //IL_01c7: Expected O, but got Unknown //IL_01cf: Unknown result type (might be due to invalid IL or missing references) //IL_01d4: Unknown result type (might be due to invalid IL or missing references) //IL_01df: Unknown result type (might be due to invalid IL or missing references) //IL_01ea: Unknown result type (might be due to invalid IL or missing references) //IL_01f5: Unknown result type (might be due to invalid IL or missing references) //IL_0200: Unknown result type (might be due to invalid IL or missing references) //IL_020b: Unknown result type (might be due to invalid IL or missing references) //IL_020c: Unknown result type (might be due to invalid IL or missing references) //IL_0211: Unknown result type (might be due to invalid IL or missing references) //IL_0223: Expected O, but got Unknown //IL_0225: Expected O, but got Unknown SL_RecipeItem val = new SL_RecipeItem { RecipeUID = "app.advpick", Target_ItemID = 5700187, New_ItemID = -31010, Name = "Crafting: Advanced Mining Pick", Description = "Schematic that teaches the user how to craft an Advanced Mining Pick", StatsHolder = new SL_ItemStats { BaseValue = 75 } }; ((ContentTemplate)val).ApplyTemplate(); SL_RecipeItem val2 = new SL_RecipeItem { RecipeUID = "app.exppick", Target_ItemID = 5700187, New_ItemID = -31012, Name = "Crafting: Expert Mining Pick", Description = "Schematic that teaches the user how to craft an Expert Mining Pick", StatsHolder = new SL_ItemStats { BaseValue = 125 } }; ((ContentTemplate)val2).ApplyTemplate(); SL_RecipeItem val3 = new SL_RecipeItem { RecipeUID = "app.advpoon", Target_ItemID = 5700187, New_ItemID = -31011, Name = "Crafting: Advanced Fishing Harpoon", Description = "Schematic that teaches the user how to craft an Advanced Fishing Harpoon", StatsHolder = new SL_ItemStats { BaseValue = 75 } }; ((ContentTemplate)val3).ApplyTemplate(); SL_RecipeItem val4 = new SL_RecipeItem { RecipeUID = "app.expoon", Target_ItemID = 5700187, New_ItemID = -31013, Name = "Crafting: Expert Fishing Harpoon", Description = "Schematic that teaches the user how to craft an Expert Fishing Harpoon", StatsHolder = new SL_ItemStats { BaseValue = 125 } }; ((ContentTemplate)val4).ApplyTemplate(); SL_RecipeItem val5 = new SL_RecipeItem { RecipeUID = "app.advsick", Target_ItemID = 5700187, New_ItemID = -31016, Name = "Crafting: Advanced Sickle", Description = "Schematic that teaches the user how to craft an Advanced Harvesting Sickle", StatsHolder = new SL_ItemStats { BaseValue = 75 } }; ((ContentTemplate)val5).ApplyTemplate(); SL_RecipeItem val6 = new SL_RecipeItem { RecipeUID = "app.expsick", Target_ItemID = 5700187, New_ItemID = -31017, Name = "Crafting: Expert Sickle", Description = "Schematic that teaches the user how to craft an Expert Harvesting Sickle", StatsHolder = new SL_ItemStats { BaseValue = 125 } }; ((ContentTemplate)val6).ApplyTemplate(); } public static void AddRecipesToMerchants() { //IL_0000: Unknown result type (might be due to invalid IL or missing references) //IL_0005: Unknown result type (might be due to invalid IL or missing references) //IL_0010: Unknown result type (might be due to invalid IL or missing references) //IL_0017: Unknown result type (might be due to invalid IL or missing references) //IL_001c: Unknown result type (might be due to invalid IL or missing references) //IL_0027: 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_003a: Expected O, but got Unknown //IL_003b: Unknown result type (might be due to invalid IL or missing references) //IL_0040: Unknown result type (might be due to invalid IL or missing references) //IL_004b: Unknown result type (might be due to invalid IL or missing references) //IL_0052: Unknown result type (might be due to invalid IL or missing references) //IL_005e: Expected O, but got Unknown //IL_005f: Unknown result type (might be due to invalid IL or missing references) //IL_0064: Unknown result type (might be due to invalid IL or missing references) //IL_006f: Unknown result type (might be due to invalid IL or missing references) //IL_0076: Unknown result type (might be due to invalid IL or missing references) //IL_0082: Expected O, but got Unknown //IL_0088: Expected O, but got Unknown //IL_008e: Unknown result type (might be due to invalid IL or missing references) //IL_0093: Unknown result type (might be due to invalid IL or missing references) //IL_009e: Unknown result type (might be due to invalid IL or missing references) //IL_00a5: Unknown result type (might be due to invalid IL or missing references) //IL_00aa: Unknown result type (might be due to invalid IL or missing references) //IL_00b5: Unknown result type (might be due to invalid IL or missing references) //IL_00bc: Unknown result type (might be due to invalid IL or missing references) //IL_00c8: Expected O, but got Unknown //IL_00c9: Unknown result type (might be due to invalid IL or missing references) //IL_00ce: Unknown result type (might be due to invalid IL or missing references) //IL_00d9: Unknown result type (might be due to invalid IL or missing references) //IL_00e0: Unknown result type (might be due to invalid IL or missing references) //IL_00ec: Expected O, but got Unknown //IL_00ed: Unknown result type (might be due to invalid IL or missing references) //IL_00f2: Unknown result type (might be due to invalid IL or missing references) //IL_00fd: Unknown result type (might be due to invalid IL or missing references) //IL_0104: Unknown result type (might be due to invalid IL or missing references) //IL_0110: Expected O, but got Unknown //IL_0116: Expected O, but got Unknown //IL_011c: Unknown result type (might be due to invalid IL or missing references) //IL_0121: Unknown result type (might be due to invalid IL or missing references) //IL_0137: Unknown result type (might be due to invalid IL or missing references) //IL_013c: Unknown result type (might be due to invalid IL or missing references) SL_DropTable val = new SL_DropTable { UID = "gothiska.advtools", GuaranteedDrops = new List<SL_ItemDrop> { new SL_ItemDrop { DroppedItemID = -31010, MinQty = 1, MaxQty = 1 }, new SL_ItemDrop { DroppedItemID = -31011, MinQty = 1, MaxQty = 1 }, new SL_ItemDrop { DroppedItemID = -31016, MinQty = 1, MaxQty = 1 } } }; ((ContentTemplate)val).ApplyTemplate(); SL_DropTable val2 = new SL_DropTable { UID = "gothiska.exptools", GuaranteedDrops = new List<SL_ItemDrop> { new SL_ItemDrop { DroppedItemID = -31012, MinQty = 1, MaxQty = 1 }, new SL_ItemDrop { DroppedItemID = -31013, MinQty = 1, MaxQty = 1 }, new SL_ItemDrop { DroppedItemID = -31017, MinQty = 1, MaxQty = 1 } } }; ((ContentTemplate)val2).ApplyTemplate(); ((ContentTemplate)new SL_DropTableAddition { DropTableUIDsToAdd = { val.UID } }).ApplyTemplate(); ((ContentTemplate)new SL_DropTableAddition { DropTableUIDsToAdd = { val2.UID } }).ApplyTemplate(); } }

using System; using System.Collections; using System.Collections.Generic; using System.Diagnostics; using System.IO; using System.Linq; using System.Reflection; using System.Runtime.CompilerServices; using System.Runtime.InteropServices; using System.Runtime.Versioning; using System.Security; using System.Security.Permissions; using System.Threading; using AlternateStart.Characters; using AlternateStart.StartScenarios; using BepInEx; using HarmonyLib; using NodeCanvas.DialogueTrees; using NodeCanvas.Framework; using NodeCanvas.Tasks.Actions; using SideLoader; using SideLoader.Managers; using SideLoader.Model; using UnityEngine; using UnityEngine.SceneManagement; [assembly: CompilationRelaxations(8)] [assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)] [assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)] [assembly: AssemblyTitle("OutwardModTemplate")] [assembly: AssemblyDescription("")] [assembly: AssemblyConfiguration("")] [assembly: AssemblyCompany("")] [assembly: AssemblyProduct("OutwardModTemplate")] [assembly: AssemblyCopyright("Copyright © 2021")] [assembly: AssemblyTrademark("")] [assembly: ComVisible(false)] [assembly: Guid("c5450fe0-edcf-483f-b9ea-4b1ef9d36da7")] [assembly: AssemblyFileVersion("1.0.0.0")] [assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")] [assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)] [assembly: AssemblyVersion("1.0.0.0")] [module: UnverifiableCode] namespace AlternateStart { public enum ScenarioPassives { NONE = 0, Random = -2200, Vanilla = -2201, VanillaAlt = -2202, VanillaBerg = -2203, VanillaLevant = -2204, VanillaMonsoon = -2205, VanillaHarmattan = -2206, LevantSlums = -2207, EnmerkarHunter = -2208, PriestElatt = -2209, Claustrophobic = -2210, VendavelSlave = -2211, GiantRisen = -2212, ConfluxWatcher = -2213, Veteran = -2214, WolfgangMercenary = -2215, RobbedTrader = -2216, Survivor = -2217, CorruptedSoul = -2218, ChosenOne = -2219, Unbound = -2220, Cannibal = -2221, SandBandit = -2222, Nightmare = -2223 } public enum ScenarioQuest { Quest_Test = -2300, Quest_Vanilla = -2301, Quest_VanillaAlt = -2302, Quest_VanillaBerg = -2303, Quest_VanillaLevant = -2304, Quest_VanillaMonsoon = -2305, Quest_VanillaHarmattan = -2306, Quest_LevantSlums = -2307, Quest_EmercarHunter = -2308, Quest_PriestElatt = -2309, Quest_Claustro = -2310, Quest_VendavelSlave = -2311, Quest_GiantRisen = -2312, Quest_ConfluxWatcher = -2313, Quest_Veteran = -2314, Quest_WolfgangMercenary = -2315, Quest_RobbedTrader = -2316, Quest_Survivor = -2317, Quest_CorruptedSoul = -2318, Quest_ChosenOne = -2319, Quest_Unbound = -2320, Quest_Cannibal = -2321, Quest_SandBandit = -2322 } public enum ScenarioTheme { None, Magic, Stamina, Tanky, Freeform } public enum ScenarioType { WIPtest = 0, VanillaLike = -2207, Normal = -2208, Outlaw = -2209 } internal static class QuestExtensions { internal static void UpdateLogEntry(this QuestProgress progress, QuestLogEntrySignature signature, bool displayTime) { //IL_0002: Unknown result type (might be due to invalid IL or missing references) progress.UpdateLogEntry(signature.UID, displayTime, signature); } } public class ExtrasManager : MonoBehaviour { public static ExtrasManager Instance; private Vector3 spawn = new Vector3(1284.4f, -3.7f, 1622.2f); private Vector3 spawnRot = new Vector3(0f, 203f, 0f); public List<Character> allPlayers; internal void Awake() { Instance = this; allPlayers = new List<Character>(); } } public static class GearManager { internal static void Init() { } public static void StartingGear() { foreach (PlayerSystem item in Global.Lobby.PlayersInLobby) { Character controlledCharacter = item.ControlledCharacter; CharacterSkillKnowledge skillKnowledge = controlledCharacter.Inventory.SkillKnowledge; foreach (Scenario value in ScenarioManager.startScenarios.Values) { if (((CharacterKnowledge)skillKnowledge).IsItemLearned((int)value.Passive)) { Debug.Log((object)"adding scenario gear"); value.Gear(controlledCharacter); break; } } } } public static void RandomPassive() { } } [BepInPlugin("com.iggy.altstart", "Alternate Start", "1.0")] [BepInDependency(/*Could not decode attribute arguments.*/)] public class Plugin : BaseUnityPlugin { private const string GUID = "com.iggy.altstart"; private const string NAME = "Alternate Start"; private const string VERSION = "1.0"; public static Plugin Instance; public const string SL_PACK_NAME = "iggythemad AlternateStart"; public const string QUEST_EVENT_FAMILY_NAME = "A_Iggy_AlternateStart"; internal void Awake() { //IL_0042: Unknown result type (might be due to invalid IL or missing references) Instance = this; ((BaseUnityPlugin)this).Logger.LogMessage((object)"Alternate Start Awake()"); ((Component)this).gameObject.AddComponent<ExtrasManager>(); ScenarioManager.Init(); GearManager.Init(); SL.OnPacksLoaded += SL_OnPacksLoaded; new Harmony("com.iggy.altstart").PatchAll(); } internal void OnGUI() { } private void SL_OnPacksLoaded() { TrainerManager.Init(); } internal static void Log(object log) { ((BaseUnityPlugin)Instance).Logger.LogMessage((object)(log?.ToString() ?? string.Empty)); } internal static void LogWarning(object log) { ((BaseUnityPlugin)Instance).Logger.LogWarning((object)(log?.ToString() ?? string.Empty)); } internal static void LogError(object log) { ((BaseUnityPlugin)Instance).Logger.LogError((object)(log?.ToString() ?? string.Empty)); } } public static class ScenarioManager { [HarmonyPatch(typeof(NetworkLevelLoader), "LoadLevel", new Type[] { typeof(int), typeof(int), typeof(float), typeof(bool) })] public class NetworkLevelLoader_LoadLevel { internal static void Prefix(ref int _buildIndex) { try { CharacterSave chosenSave = SplitScreenManager.Instance.LocalPlayers[0].ChosenSave; if (!((CharacterSaveData)chosenSave.PSave).NewSave && !string.IsNullOrEmpty(chosenSave.PSave.AreaName)) { return; } for (int i = 0; i < SceneManager.sceneCountInBuildSettings; i++) { string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(SceneUtility.GetScenePathByBuildIndex(i)); if (fileNameWithoutExtension != null && fileNameWithoutExtension == "DreamWorld") { _buildIndex = i; break; } } } catch { } } } [HarmonyPatch(typeof(CharacterSkillKnowledge), "AddItem", new Type[] { typeof(Item) })] private static class CharacterSkillKnowledge_AddItem { internal static void Postfix(Item _item) { //IL_0067: Unknown result type (might be due to invalid IL or missing references) if (!((Object)(object)((EffectSynchronizer)_item).OwnerCharacter == (Object)null) && ((EffectSynchronizer)_item).OwnerCharacter.IsLocalPlayer && !QuestEventManager.Instance.HasQuestEvent("iggythemad.altstart.destinyChosen") && _item.ItemID <= 0 && !(SceneManagerHelper.ActiveSceneName != "DreamWorld")) { ((EffectSynchronizer)_item).OwnerCharacter.StatusEffectMngr.AddStatusEffect("StartTag"); ((EffectSynchronizer)_item).OwnerCharacter.AutoKnock(true, Vector3.back, ((EffectSynchronizer)_item).OwnerCharacter); if ((Object)(object)CharacterManager.Instance.GetWorldHostCharacter() == (Object)(object)((EffectSynchronizer)_item).OwnerCharacter) { ((MonoBehaviour)Plugin.Instance).StartCoroutine(CheckStartPassives(((EffectSynchronizer)_item).OwnerCharacter, _item)); } } } } [HarmonyPatch(typeof(InteractionTriggerBase), "TryActivateBasicAction", new Type[] { typeof(Character), typeof(int) })] public class InteractionTriggerBase_TryActivateBasicAction { [HarmonyPrefix] public static bool Prefix(InteractionTriggerBase __instance, Character _character, int _toggleState) { if (!_character.IsLocalPlayer || SceneManagerHelper.ActiveSceneName != "DreamWorld") { return true; } if (_character.StatusEffectMngr.HasStatusEffect("StartTag")) { return false; } return true; } } public static readonly Dictionary<ScenarioPassives, Scenario> startScenarios = new Dictionary<ScenarioPassives, Scenario>(); internal static QuestEventSignature QE_DestinyChosen; private const string QE_DESTINY_CHOSEN_UID = "iggythemad.altstart.destinyChosen"; private const string FULL_STOP_STATUS_IDENTIFIER = "fullstop"; private const string startTag = "StartTag"; internal static void Init() { QE_DestinyChosen = CustomQuests.CreateQuestEvent("iggythemad.altstart.destinyChosen", false, false, true, "A_Iggy_AlternateStart", "CustomEvent", "A custom event created with SideLoader"); SL.OnGameplayResumedAfterLoading += SL_OnGameplayResumedAfterLoading; Type[] types = typeof(Scenario).Assembly.GetTypes(); foreach (Type type in types) { if (type.IsSubclassOf(typeof(Scenario))) { Scenario scenario = Activator.CreateInstance(type) as Scenario; scenario.Init(); startScenarios.Add(scenario.Passive, scenario); } } } private static void SL_OnGameplayResumedAfterLoading() { if (!(SceneManagerHelper.ActiveSceneName == "DreamWorld") || QuestEventManager.Instance.HasQuestEvent(QE_DestinyChosen)) { return; } foreach (Item learnedItem in ((CharacterKnowledge)CharacterManager.Instance.GetWorldHostCharacter().Inventory.SkillKnowledge).m_learnedItems) { if (Enum.IsDefined(typeof(ScenarioPassives), learnedItem.ItemID)) { Debug.Log((object)"HAS START SCENARIO"); return; } } foreach (PlayerSystem item in Global.Lobby.PlayersInLobby) { item.ControlledCharacter.Inventory.RemoveMoney(27, true); } ((MonoBehaviour)Plugin.Instance).StartCoroutine(DreamworldStopper()); } private static IEnumerator DreamworldStopper() { yield return (object)new WaitForSeconds(0.2f); Vector3 spawn = new Vector3(-12.2f, 0.2f, -0.6f); Vector3 spawnRot = new Vector3(0f, 75.2f, 0f); while (SceneManagerHelper.ActiveSceneName == "DreamWorld") { foreach (PlayerSystem item in Global.Lobby.PlayersInLobby) { if (item.IsLocalPlayer && Vector3.Distance(((Component)item.ControlledCharacter).transform.position, spawn) > 3f) { item.ControlledCharacter.Teleport(spawn, spawnRot); } } yield return (object)new WaitForSeconds(0.5f); } } internal static void SetFullStop(bool add) { if (PhotonNetwork.isNonMasterClientInRoom) { return; } foreach (PlayerSystem item in Global.Lobby.PlayersInLobby) { if (add) { item.ControlledCharacter.StatusEffectMngr.AddStatusEffect("fullstop"); } else { item.ControlledCharacter.StatusEffectMngr.RemoveStatusWithIdentifierName("fullstop"); } } } private static IEnumerator CheckStartPassives(Character character, Item _item) { yield return (object)new WaitForSeconds(0.2f); List<Character> characterList = new List<Character>(); while (true) { LobbySystem lobby = Global.Lobby; if (((lobby != null) ? lobby.PlayersInLobby : null) == null) { yield return null; continue; } break; } while (characterList.Count < Global.Lobby.PlayersInLobby.Count) { yield return (object)new WaitForSeconds(1f); foreach (PlayerSystem item in Global.Lobby.PlayersInLobby) { if (item.ControlledCharacter.StatusEffectMngr.HasStatusEffect("StartTag") && !characterList.Contains(item.ControlledCharacter)) { characterList.Add(item.ControlledCharacter); } } } if (((CharacterKnowledge)character.Inventory.SkillKnowledge).IsItemLearned(-2200)) { ((MonoBehaviour)Plugin.Instance).StartCoroutine(PickAndStartScenario()); } else if (IsAnyChosen<ScenarioPassives>(character)) { ScenarioPassives itemID = (ScenarioPassives)_item.ItemID; ((MonoBehaviour)Plugin.Instance).StartCoroutine(startScenarios[itemID].StartScenario()); } foreach (PlayerSystem item2 in Global.Lobby.PlayersInLobby) { if (item2.ControlledCharacter.StatusEffectMngr.HasStatusEffect("StartTag")) { item2.ControlledCharacter.StatusEffectMngr.RemoveStatusWithIdentifierName("StartTag"); } } } private static bool IsAnyChosen<T>(Character character) where T : Enum { T choice; return TryGetChoice<T>(character, out choice); } private static bool TryGetChoice<T>(Character character, out T choice) where T : Enum { foreach (object value in Enum.GetValues(typeof(T))) { if (((CharacterKnowledge)character.Inventory.SkillKnowledge).IsItemLearned((int)value)) { choice = (T)value; return true; } } choice = default(T); return false; } private static IEnumerator PickAndStartScenario() { Character worldHostCharacter = CharacterManager.Instance.GetWorldHostCharacter(); _ = worldHostCharacter.Inventory.SkillKnowledge; TryGetChoice<ScenarioPassives>(worldHostCharacter, out var choice); List<Scenario> list = new List<Scenario>(); foreach (Scenario value in startScenarios.Values) { if (value.Difficulty != 0 && value.Difficulty != ScenarioType.Outlaw) { list.Add(value); } } if (!list.Any()) { CharacterManager.Instance.GetWorldHostCharacter().CharacterUI.NotificationPanel.ShowNotification($"Sorry, there are no {choice} scenarios!"); yield break; } Plugin.Log("Eligable scenarios: " + string.Join(",", list.Select((Scenario it) => it.GetType().Name))); Scenario scenario = list[Random.Range(0, list.Count)]; Plugin.Log("Chosen scenario: " + scenario.GetType().Name); ((MonoBehaviour)Plugin.Instance).StartCoroutine(scenario.StartScenario()); foreach (PlayerSystem item in Global.Lobby.PlayersInLobby) { if (((CharacterKnowledge)item.ControlledCharacter.Inventory.SkillKnowledge).IsItemLearned(-2200)) { if ((Object)(object)worldHostCharacter == (Object)(object)item.ControlledCharacter) { item.ControlledCharacter.Inventory.ReceiveSkillReward((int)scenario.Passive); continue; } Scenario scenario2 = list[Random.Range(0, list.Count)]; item.ControlledCharacter.Inventory.ReceiveSkillReward((int)scenario2.Passive); } } } } public static class TrainerManager { internal static SL_Character bergSpellblade; private static SLPack pack; public static void Init() { pack = SL.GetSLPack("iggythemad AlternateStart"); bergSpellblade = pack.CharacterTemplates["com.iggy.berg.spellblade.trainer"]; bergSpellblade.OnSpawn += SpellbladeSetup; SL.OnGameplayResumedAfterLoading += spawnSpellblade; } private static void spawnSpellblade() { //IL_006a: 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) if (SceneManagerHelper.ActiveSceneName == "Berg" && CharacterManager.Instance.GetWorldHostCharacter().IsLocalPlayer && QuestEventManager.Instance.HasQuestEvent(QuestEventDictionary.GetQuestEvent("lDHL_XMS7kKEs0uOqrLQjw"))) { Vector3 trainerPos = default(Vector3); ((Vector3)(ref trainerPos))..ctor(1284.4f, -3.7f, 1622.2f); Vector3 trainerRot = default(Vector3); ((Vector3)(ref trainerRot))..ctor(0f, 203f, 0f); SpawnCharacter("com.iggy.berg.spellblade.trainer", trainerPos, trainerRot); } } public static Character SpawnCharacter(string trainerID, Vector3 trainerPos, Vector3 trainerRot) { //IL_0010: Unknown result type (might be due to invalid IL or missing references) //IL_0011: Unknown result type (might be due to invalid IL or missing references) //IL_0012: Unknown result type (might be due to invalid IL or missing references) return pack.CharacterTemplates[trainerID].Spawn(trainerPos, trainerRot, UID.op_Implicit(UID.Generate()), (string)null); } public static void SpellbladeSetup(Character trainer, string _) { GenericTrainerSetup(trainer, bergSpellblade, "com.iggy.bergspellblade", "You are alive! It's good to see a familiar face.", "What can you teach me?", "What happened to Cierzo?", "What should I do now?", "The Vendavel Scum. We were not prepared for an attack. I tried to fight back, but it was too late.", "Move on. Join a faction. Rissa is here, but you are free to do as you like."); } public static void GenericTrainerSetup(Character trainer, SL_Character currentCharacter, string treeUID, string introDialogue, string ask1, string ask2, string ask3, string reply2, string reply3) { //IL_0032: Unknown result type (might be due to invalid IL or missing references) //IL_0037: Unknown result type (might be due to invalid IL or missing references) //IL_0079: Unknown result type (might be due to invalid IL or missing references) //IL_0083: Expected O, but got Unknown //IL_009c: Unknown result type (might be due to invalid IL or missing references) //IL_00a1: 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_00a7: Unknown result type (might be due to invalid IL or missing references) //IL_00b4: Expected O, but got Unknown //IL_00b9: Expected O, but got Unknown //IL_00bf: Unknown result type (might be due to invalid IL or missing references) //IL_00c4: Unknown result type (might be due to invalid IL or missing references) //IL_00c5: Unknown result type (might be due to invalid IL or missing references) //IL_00ca: Unknown result type (might be due to invalid IL or missing references) //IL_00d7: Expected O, but got Unknown //IL_00dc: Expected O, but got Unknown //IL_00e2: Unknown result type (might be due to invalid IL or missing references) //IL_00e7: Unknown result type (might be due to invalid IL or missing references) //IL_00e8: Unknown result type (might be due to invalid IL or missing references) //IL_00ed: Unknown result type (might be due to invalid IL or missing references) //IL_00fa: Expected O, but got Unknown //IL_00ff: Expected O, but got Unknown //IL_0135: Unknown result type (might be due to invalid IL or missing references) //IL_013f: Expected O, but got Unknown //IL_0158: Unknown result type (might be due to invalid IL or missing references) //IL_0162: Expected O, but got Unknown Object.DestroyImmediate((Object)(object)((Component)trainer).GetComponent<CharacterStats>()); Object.DestroyImmediate((Object)(object)((Component)trainer).GetComponent<StartingEquipment>()); DialogueActor componentInChildren = ((Component)trainer).GetComponentInChildren<DialogueActor>(); componentInChildren.SetName(currentCharacter.Name); Trainer componentInChildren2 = ((Component)trainer).GetComponentInChildren<Trainer>(); componentInChildren2.m_skillTreeUID = new UID(treeUID); Graph graph = ((GraphOwner)((Component)trainer).GetComponentInChildren<DialogueTreeController>()).graph; List<ActorParameter> actorParameters = ((DialogueTree)((graph is DialogueTree) ? graph : null))._actorParameters; actorParameters[0].actor = (IDialogueActor)(object)componentInChildren; actorParameters[0].name = componentInChildren.name; StatementNodeExt val = graph.AddNode<StatementNodeExt>(); val.statement = new Statement(introDialogue); val.SetActorName(componentInChildren.name); MultipleChoiceNodeExt val2 = graph.AddNode<MultipleChoiceNodeExt>(); val2.availableChoices.Add(new Choice { statement = new Statement { text = ask1 } }); val2.availableChoices.Add(new Choice { statement = new Statement { text = ask2 } }); val2.availableChoices.Add(new Choice { statement = new Statement { text = ask3 } }); Node obj = graph.allNodes[1]; ActionNode val3 = (ActionNode)(object)((obj is ActionNode) ? obj : null); ActionTask action = val3.action; ((TrainDialogueAction)((action is TrainDialogueAction) ? action : null)).Trainer = new BBParameter<Trainer>(componentInChildren2); StatementNodeExt val4 = graph.AddNode<StatementNodeExt>(); val4.statement = new Statement(reply2); val4.SetActorName(componentInChildren.name); StatementNodeExt val5 = graph.AddNode<StatementNodeExt>(); val5.statement = new Statement(reply3); val5.SetActorName(componentInChildren.name); graph.allNodes.Clear(); graph.allNodes.Add((Node)(object)val); graph.allNodes.Add((Node)(object)val2); graph.allNodes.Add((Node)(object)val3); graph.allNodes.Add((Node)(object)val4); graph.allNodes.Add((Node)(object)val5); graph.primeNode = (Node)(object)val; graph.ConnectNodes((Node)(object)val, (Node)(object)val2, -1, -1); graph.ConnectNodes((Node)(object)val2, (Node)(object)val3, 0, -1); graph.ConnectNodes((Node)(object)val2, (Node)(object)val4, 1, -1); graph.ConnectNodes((Node)(object)val4, (Node)(object)val, -1, -1); graph.ConnectNodes((Node)(object)val2, (Node)(object)val5, 2, -1); graph.ConnectNodes((Node)(object)val5, (Node)(object)val, -1, -1); ((Component)trainer).gameObject.SetActive(true); } } public static class VanillaQuestsHelper { public const int lookingToTheFutureQ = 7011002; public const int callToAdventureQ = 7011001; public const int enrollmentQ = 7011400; public const string playerInCierzo = "sm812Cio9ki5ssbsiPr3Fw"; public const string tutorialIntroFinished = "HteYicnCK0atCgd4j5TV1Q"; public const string introPlayerHouse = "z23QoIdtkU6cUPoUOfDn6w"; public const string grandmother = "YQD53MKgwke6juWiSWI7jQ"; public const string rissaBegExtension = "nt9KhXoJtkOalZ-wtfueDA"; public const string rissaTalk = "n_3w-BcFfEW52Ht4Q3ZCjw"; public const string debtPAID = "8GvHUbDz90OOJWurd-RZlg"; public const string callToAdventureENDa = "g3EX5w1mwUaYW1o0cpj0SQ"; public const string notLighthouseOwner = "-Ku9dHjTl0KeUPxWk0ZWWQ"; public const string lostLightHouse = "qPEx275DTUSPbnv-PnFn7w"; public const string debtNOTpaid = "sAc2Dj-T_kysKXFV48Hp0A"; public const string callToAdventureENDb = "8iAJYhhqj02ODuwZ9VvXMw"; public const string bergHouse = "g403vlCU6EG0s1mI6t_rFA"; public const string harmattanHouse = "0r087PIxTUqoj6N7z2HFNw"; public const string levantHouse = "LpVUuoxfhkaWOgh6XLbarA"; public const string monsoonHouse = "shhCMFa-lUqbIYS9hRcsdg"; public const int vendavelQ = 7011004; public const string cierzoDestroy = "lDHL_XMS7kKEs0uOqrLQjw"; public const string cierzoWarning = "-vFSY-MNoUuLH1XXBkcqvQ"; public const string cierzoTimer = "bm3rB3abI0KFok2x5P0lrg"; public const string cierzoFail = "WvGjemEntk6quLjy4rLrJQ"; public const string factionCommit = "bjVloYMQxk6KXx0gph2A1Q"; public const string directionRISA = "seEIFfM9SkeZxc4CpR40oQ"; public const string directionOLIELE = "Bo4-Xvq4_kudPDnOgkI3VA"; public const string directionYSAN = "gAJAjuzl7ESFpMooq1oOCg"; public const string olieleMonsoon = "3_soGcNagk-KcYSeqpEgMg"; public const string yzanLevant = "BgpOoGQF10O7IQyiB9HODw"; public const string rissaBerg = "1a6Zs9A_gEmScBetAraQaw"; public const string readyToChoose = "jNfNsLGBpk2iMRts9kkerw"; public const string BCproposition = "fo2uI7yiw0WSRE7MsbYFyw"; public const string HKproposition = "JlFMC_51RUalSa8yLkhTmg"; public const string HMproposition = "JqL0_JD55US2gL0-GbOBow"; public const string argensonMet = "QMe_j2TIWEKpssXkLHMMZA"; public const string argensonStash = "h8jI-dDsfkStb3XkCjqMPw"; public const string YzanFriendship = "nr9KDCbQzUae1Gwf-6yOIQ"; public const string callAdventureExpired = "zoKR1_bqiUiAetJ3uxw-Ug"; public const string callAdventureCompleted = "ZYzrMi1skUiJ4BgXXQ3sfw"; public const string ashAllyFail = "nDy01eTHlUa_BPDlbIhZPQ"; public const string ashCompleteFail = "f1JVZyhg2UiBA8xmC-w6Hw"; public const string ashFight = "XqlcpbTJC0aTDZfjD4xCTg"; public const string ashWarp = "oGkuUgWvfkej_El-rhz2gw"; internal static void SkipHostToFactionChoice(bool keepHouse, bool complete) { Character worldHostCharacter = CharacterManager.Instance.GetWorldHostCharacter(); worldHostCharacter.Inventory.QuestKnowledge.ReceiveQuest(7011001); worldHostCharacter.Inventory.QuestKnowledge.ReceiveQuest(7011002); ((MonoBehaviour)Plugin.Instance).StartCoroutine(AddPrefactionEvents(keepHouse, complete)); } internal static void DestroyCierzo(bool instant, bool receiveQ) { Character worldHostCharacter = CharacterManager.Instance.GetWorldHostCharacter(); AddQuestEvent("-vFSY-MNoUuLH1XXBkcqvQ"); AddQuestEvent("bm3rB3abI0KFok2x5P0lrg"); if (receiveQ) { worldHostCharacter.Inventory.QuestKnowledge.ReceiveQuest(7011004); } if (instant) { AddQuestEvent("lDHL_XMS7kKEs0uOqrLQjw"); AddQuestEvent("WvGjemEntk6quLjy4rLrJQ"); } } internal static void AddQuestEvent(string questUID) { QuestEventManager.Instance.AddEvent(QuestEventDictionary.GetQuestEvent(questUID), 1); } internal static void RemoveEvent(string questUID) { QuestEventManager.Instance.RemoveEvent(questUID, true); } internal static IEnumerator AddPrefactionEvents(bool keepHouse, bool complete) { Character host = CharacterManager.Instance.GetWorldHostCharacter(); yield return (object)new WaitForSeconds(0.1f); AddQuestEvent("sm812Cio9ki5ssbsiPr3Fw"); AddQuestEvent("HteYicnCK0atCgd4j5TV1Q"); AddQuestEvent("z23QoIdtkU6cUPoUOfDn6w"); AddQuestEvent("nt9KhXoJtkOalZ-wtfueDA"); AddQuestEvent("YQD53MKgwke6juWiSWI7jQ"); AddQuestEvent("n_3w-BcFfEW52Ht4Q3ZCjw"); if (keepHouse) { AddQuestEvent("8GvHUbDz90OOJWurd-RZlg"); AddQuestEvent("g3EX5w1mwUaYW1o0cpj0SQ"); } else { AddQuestEvent("-Ku9dHjTl0KeUPxWk0ZWWQ"); AddQuestEvent("qPEx275DTUSPbnv-PnFn7w"); AddQuestEvent("sAc2Dj-T_kysKXFV48Hp0A"); AddQuestEvent("8iAJYhhqj02ODuwZ9VvXMw"); } AddQuestEvent("seEIFfM9SkeZxc4CpR40oQ"); AddQuestEvent("jNfNsLGBpk2iMRts9kkerw"); AddQuestEvent("3_soGcNagk-KcYSeqpEgMg"); AddQuestEvent("Bo4-Xvq4_kudPDnOgkI3VA"); AddQuestEvent("JqL0_JD55US2gL0-GbOBow"); AddQuestEvent("JlFMC_51RUalSa8yLkhTmg"); AddQuestEvent("BgpOoGQF10O7IQyiB9HODw"); AddQuestEvent("gAJAjuzl7ESFpMooq1oOCg"); AddQuestEvent("QMe_j2TIWEKpssXkLHMMZA"); AddQuestEvent("h8jI-dDsfkStb3XkCjqMPw"); AddQuestEvent("nr9KDCbQzUae1Gwf-6yOIQ"); AddQuestEvent("zoKR1_bqiUiAetJ3uxw-Ug"); AddQuestEvent("ZYzrMi1skUiJ4BgXXQ3sfw"); if (complete) { AddQuestEvent("fo2uI7yiw0WSRE7MsbYFyw"); AddQuestEvent("1a6Zs9A_gEmScBetAraQaw"); host.Inventory.QuestKnowledge.ReceiveQuest(7011400); } } internal static void StartHouseTimer() { CharacterManager.Instance.GetWorldHostCharacter().Inventory.QuestKnowledge.ReceiveQuest(7011001); ((MonoBehaviour)Plugin.Instance).StartCoroutine(AddHouseTimerEvents()); } private static IEnumerator AddHouseTimerEvents() { yield return (object)new WaitForSeconds(0.5f); AddQuestEvent("sm812Cio9ki5ssbsiPr3Fw"); AddQuestEvent("HteYicnCK0atCgd4j5TV1Q"); AddQuestEvent("z23QoIdtkU6cUPoUOfDn6w"); AddQuestEvent("n_3w-BcFfEW52Ht4Q3ZCjw"); AddQuestEvent("zoKR1_bqiUiAetJ3uxw-Ug"); } } } namespace AlternateStart.StartScenarios { public class ChosenOneScenario : Scenario { [HarmonyPatch(typeof(PlayerCharacterStats), "get_RemainingBreakthrough")] private class PlayerCharacterStats_RemainingBreakthrough { public static bool Prefix(ref int __result, PlayerCharacterStats __instance) { if (((CharacterStats)__instance).m_character.IsLocalPlayer && ((CharacterKnowledge)((CharacterStats)__instance).m_character.Inventory.SkillKnowledge).IsItemLearned(-2219)) { __result = Mathf.Clamp(maxBreakthroughs - __instance.m_usedBreakthroughCount, 0, 20); return false; } return true; } } [HarmonyPatch(typeof(SkillUnlockRequirementDisplay), "RefreshDisplay", new Type[] { typeof(SkillTreeSlotDisplay) })] public class SkillUnlockRequirementDisplay_RefreshDisplay { [HarmonyPostfix] public static void Postfix(SkillUnlockRequirementDisplay __instance, SkillTreeSlotDisplay _display) { if (!((Object)(object)_display == (Object)null) && ((UIElement)_display).LocalCharacter.IsLocalPlayer && ((CharacterKnowledge)((UIElement)_display).LocalCharacter.Inventory.SkillKnowledge).IsItemLearned(-2219)) { if (!StoredCosts.Keys.Contains(((Item)_display.FocusedSkillSlot.Skill).ItemID)) { StoredCosts.Add(((Item)_display.FocusedSkillSlot.Skill).ItemID, _display.FocusedSkillSlot.RequiredMoney); } StoredCosts.TryGetValue(((Item)_display.FocusedSkillSlot.Skill).ItemID, out var value); value = (int)Math.Round((float)value * 1.25f); _display.FocusedSkillSlot.m_requiredMoney = value; } } } private const string LogSignature_A = "chosen.objective.a"; private const string LogSignature_B = "chosen.objective.b"; private const string LogSignature_C = "chosen.objective.c"; private QuestEventSignature QE_FixedLimitlessStart; private static int maxBreakthroughs = 4; public static Dictionary<int, int> StoredCosts = new Dictionary<int, int>(); public override ScenarioQuest Type => ScenarioQuest.Quest_ChosenOne; public override ScenarioType Difficulty => ScenarioType.Normal; public override ScenarioPassives Passive => ScenarioPassives.ChosenOne; public override AreaEnum SpawnScene => (AreaEnum)101; public override Vector3 SpawnPosition => new Vector3(865.8f, 212.7f, 880.1f); public override Vector3 SpawnRotation => new Vector3(0f, 225.7f, 0f); public override bool HasQuest => true; public override string QuestName => "Angelic Descend"; public override Dictionary<string, string> QuestLogSignatures => new Dictionary<string, string> { { "chosen.objective.a", "Visit any city. Learn about the factions and their conflicts. Save Aurai." }, { "chosen.objective.b", "You've learned about the factions." }, { "chosen.objective.c", "You are ready to join a faction." } }; public override void Gear(Character character) { character.Inventory.ReceiveItemReward(4100550, 5, false); character.Inventory.ReceiveItemReward(3000009, 1, true); character.Inventory.ReceiveItemReward(3000002, 1, true); character.Inventory.ReceiveItemReward(2010050, 1, false); character.Inventory.ReceiveItemReward(5100500, 1, true); character.Inventory.ReceiveItemReward(5300040, 1, true); } public override void Init() { base.Init(); QE_FixedLimitlessStart = CustomQuests.CreateQuestEvent("iggythemad.chosenone.fixedstart", false, true, true, "A_Iggy_AlternateStart", "CustomEvent", "A custom event created with SideLoader"); SL.OnGameplayResumedAfterLoading += SL_OnGameplayResumedAfterLoading; } private void SL_OnGameplayResumedAfterLoading() { if (!PhotonNetwork.isNonMasterClientInRoom && base.IsActiveScenario) { Character worldHostCharacter = CharacterManager.Instance.GetWorldHostCharacter(); if (((CharacterKnowledge)worldHostCharacter.Inventory.QuestKnowledge).IsItemLearned((int)Type)) { Item itemFromItemID = ((CharacterKnowledge)worldHostCharacter.Inventory.QuestKnowledge).GetItemFromItemID((int)Type); Quest quest = (Quest)(object)((itemFromItemID is Quest) ? itemFromItemID : null); UpdateQuestProgress(quest); } } } public override void UpdateQuestProgress(Quest quest) { //IL_006b: Unknown result type (might be due to invalid IL or missing references) //IL_00b1: Unknown result type (might be due to invalid IL or missing references) //IL_00c8: Unknown result type (might be due to invalid IL or missing references) if (!PhotonNetwork.isNonMasterClientInRoom && base.IsActiveScenario) { CharacterManager.Instance.GetWorldHostCharacter(); int eventCurrentStack = QuestEventManager.Instance.GetEventCurrentStack(QE_FixedLimitlessStart.EventUID); QuestProgress questProgress = quest.m_questProgress; if (eventCurrentStack < 1) { QuestEventManager.Instance.AddEvent(QE_FixedLimitlessStart, 1); eventCurrentStack = QuestEventManager.Instance.GetEventCurrentStack(QE_FixedLimitlessStart.EventUID); questProgress.UpdateLogEntry(questProgress.GetLogSignature(UID.op_Implicit("chosen.objective.a")), displayTime: true); ShowUIMessage("The world needs me. I should find about the troubles of Aurai..."); } else if (eventCurrentStack < 2 && AreaManager.Instance.GetIsCurrentAreaTownOrCity()) { QuestEventManager.Instance.AddEvent(QE_FixedLimitlessStart, 2); questProgress.UpdateLogEntry(questProgress.GetLogSignature(UID.op_Implicit("chosen.objective.b")), displayTime: true); questProgress.UpdateLogEntry(questProgress.GetLogSignature(UID.op_Implicit("chosen.objective.c")), displayTime: true); questProgress.DisableQuest((ProgressState)3); VanillaQuestsHelper.SkipHostToFactionChoice(keepHouse: false, complete: true); ShowUIMessage("Time to learn about the people of Aurai. I will join them!"); } } } public override void OnScenarioChosen() { } public override void OnScenarioChosen(Character character) { } public override void OnStartSpawn() { GetOrGiveQuestToHost(); } public override void OnStartSpawn(Character character) { character.SpellCastAnim((SpellCastType)41, (SpellCastModifier)0, 0); } } public class ClaustroScenario : Scenario { [HarmonyPatch(typeof(CharacterInventory), "EquipItem", new Type[] { typeof(Equipment), typeof(bool) })] public class CharacterInventory_EquipItem { [HarmonyPrefix] public static void Postfix(CharacterInventory __instance, Equipment _itemToEquip, bool _playAnim, ref Character ___m_character) { Character val = ___m_character; if (!((Object)(object)___m_character == (Object)null) && ___m_character.IsLocalPlayer && ((CharacterKnowledge)val.Inventory.SkillKnowledge).IsItemLearned(-2210)) { ((MonoBehaviour)Plugin.Instance).StartCoroutine(Instance.checkHelmet(val)); } } } [HarmonyPatch(typeof(CharacterInventory), "TakeItem", new Type[] { typeof(Item), typeof(bool) })] public class CharacterInventory_TakeItem { [HarmonyPrefix] public static void Prefix(CharacterInventory __instance, Item takenItem, ref bool _tryToEquip, ref Character ___m_character) { //IL_0043: Unknown result type (might be due to invalid IL or missing references) Character val = ___m_character; if (!((Object)(object)val == (Object)null) && val.IsLocalPlayer) { Equipment val2 = (Equipment)(object)((!(takenItem is Equipment)) ? null : ((takenItem is Equipment) ? takenItem : null)); if (((CharacterKnowledge)val.Inventory.SkillKnowledge).IsItemLearned(-2210) && val2 != null && (int)val2.EquipSlot == 0) { _tryToEquip = false; } } } } [HarmonyPatch(typeof(CharacterInventory), "UnequipItem", new Type[] { typeof(Equipment), typeof(bool) })] public class CharacterInventory_UnequipItem { [HarmonyPrefix] public static void Postfix(CharacterInventory __instance, Equipment _itemToUnequip, bool _playAnim, ref Character ___m_character) { Character val = ___m_character; if (!((Object)(object)___m_character == (Object)null) && ___m_character.IsLocalPlayer && ((CharacterKnowledge)val.Inventory.SkillKnowledge).IsItemLearned(-2210)) { ((MonoBehaviour)Plugin.Instance).StartCoroutine(Instance.checkHelmet(val)); } } } [HarmonyPatch(typeof(CharacterKnowledge), "AddItem")] public class CharacterKnowledge_AddItem { [HarmonyPrefix] public static void Prefix(CharacterKnowledge __instance, Item _item, ref Character ___m_character) { Character val = ___m_character; if (!((Object)(object)val == (Object)null) && val.IsLocalPlayer && ((CharacterKnowledge)val.Inventory.SkillKnowledge).IsItemLearned(-2210)) { ((MonoBehaviour)Plugin.Instance).StartCoroutine(Instance.checkHelmet(val)); } } } private const string LogSignature_A = "claustro.objective.a"; private const string LogSignature_B = "claustro.objective.b"; private const string LogSignature_C = "claustro.objective.c"; private QuestEventSignature QE_FixedClaustroStart; private string claustroEffectID = "claustroEffect"; public override ScenarioQuest Type => ScenarioQuest.Quest_Claustro; public override ScenarioType Difficulty => ScenarioType.Normal; public override ScenarioPassives Passive => ScenarioPassives.Claustrophobic; public override AreaEnum SpawnScene => (AreaEnum)550; public override Vector3 SpawnPosition => new Vector3(1499.7f, -8.9f, 54.7f); public override Vector3 SpawnRotation => new Vector3(0f, 99.8f, 0f); public override bool HasQuest => true; public override string QuestName => "Kidnap Miracle"; public override Dictionary<string, string> QuestLogSignatures => new Dictionary<string, string> { { "claustro.objective.a", "Escape before your kidnappers return." }, { "claustro.objective.b", "Reach somewhere safe. A city perhaps." }, { "claustro.objective.c", "You are ready to join a faction." } }; internal static ClaustroScenario Instance { get; private set; } public override void Gear(Character character) { character.Stats.FullStamina(); character.Inventory.ReceiveItemReward(3000081, 1, true); character.Inventory.ReceiveItemReward(3000083, 1, true); character.Inventory.ReceiveItemReward(3000086, 1, true); } public override void Init() { base.Init(); QE_FixedClaustroStart = CustomQuests.CreateQuestEvent("iggythemad.claustro.fixedstart", false, true, true, "A_Iggy_AlternateStart", "CustomEvent", "A custom event created with SideLoader"); SL.OnGameplayResumedAfterLoading += SL_OnGameplayResumedAfterLoading; } private void SL_OnGameplayResumedAfterLoading() { if (!PhotonNetwork.isNonMasterClientInRoom && base.IsActiveScenario) { Character worldHostCharacter = CharacterManager.Instance.GetWorldHostCharacter(); if (((CharacterKnowledge)worldHostCharacter.Inventory.QuestKnowledge).IsItemLearned((int)Type)) { Item itemFromItemID = ((CharacterKnowledge)worldHostCharacter.Inventory.QuestKnowledge).GetItemFromItemID((int)Type); Quest quest = (Quest)(object)((itemFromItemID is Quest) ? itemFromItemID : null); UpdateQuestProgress(quest); } } } public override void UpdateQuestProgress(Quest quest) { //IL_006e: Unknown result type (might be due to invalid IL or missing references) //IL_00a9: Unknown result type (might be due to invalid IL or missing references) //IL_00ee: Unknown result type (might be due to invalid IL or missing references) //IL_0105: Unknown result type (might be due to invalid IL or missing references) if (PhotonNetwork.isNonMasterClientInRoom || !base.IsActiveScenario) { return; } int num = 3; int eventCurrentStack = QuestEventManager.Instance.GetEventCurrentStack(QE_FixedClaustroStart.EventUID); QuestProgress questProgress = quest.m_questProgress; if (eventCurrentStack >= num) { questProgress.DisableQuest((ProgressState)3); return; } if (eventCurrentStack < 1) { QuestEventManager.Instance.AddEvent(QE_FixedClaustroStart, 1); eventCurrentStack = QuestEventManager.Instance.GetEventCurrentStack(QE_FixedClaustroStart.EventUID); questProgress.UpdateLogEntry(questProgress.GetLogSignature(UID.op_Implicit("claustro.objective.a")), displayTime: true); ShowUIMessage("Something happened... this is my chance to escape."); } else if (eventCurrentStack < 2) { QuestEventManager.Instance.AddEvent(QE_FixedClaustroStart, 1); questProgress.UpdateLogEntry(questProgress.GetLogSignature(UID.op_Implicit("claustro.objective.b")), displayTime: false); ShowUIMessage("I should go somewhere safe..."); } if (eventCurrentStack < 3 && AreaManager.Instance.GetIsCurrentAreaTownOrCity()) { QuestEventManager.Instance.AddEvent(QE_FixedClaustroStart, 2); questProgress.UpdateLogEntry(questProgress.GetLogSignature(UID.op_Implicit("claustro.objective.b")), displayTime: true); questProgress.UpdateLogEntry(questProgress.GetLogSignature(UID.op_Implicit("claustro.objective.c")), displayTime: true); questProgress.DisableQuest((ProgressState)3); VanillaQuestsHelper.SkipHostToFactionChoice(keepHouse: false, complete: true); ShowUIMessage("It would be safer to join a faction..."); } ReloadLogs(eventCurrentStack, questProgress); } public void ReloadLogs(int stack, QuestProgress progress) { //IL_0044: Unknown result type (might be due to invalid IL or missing references) int num = 0; foreach (KeyValuePair<string, string> questLogSignature in QuestLogSignatures) { if (num < stack && questLogSignature.Key != null) { Debug.Log((object)("log: " + questLogSignature.Key)); progress.UpdateLogEntry(progress.GetLogSignature(UID.op_Implicit(questLogSignature.Key)), displayTime: false); num++; } } } public override void OnScenarioChosen(Character character) { } public override void OnStartSpawn() { GetOrGiveQuestToHost(); } public override void OnStartSpawn(Character character) { } public ClaustroScenario() { Instance = this; } private IEnumerator checkHelmet(Character player) { player.StatusEffectMngr.RemoveStatusWithIdentifierName(claustroEffectID); yield return (object)new WaitForSeconds(0.5f); player.StatusEffectMngr.AddStatusEffect(claustroEffectID); } } public class ConfluxWatcherScenario : Scenario { private const string LogSignature_A = "watcher.objective.a"; private const string LogSignature_B = "watcher.objective.b"; private const string LogSignature_C = "watcher.objective.c"; private QuestEventSignature QE_FixedWatcherStart; public override ScenarioQuest Type => ScenarioQuest.Quest_ConfluxWatcher; public override ScenarioType Difficulty => ScenarioType.Normal; public override ScenarioPassives Passive => ScenarioPassives.ConfluxWatcher; public override AreaEnum SpawnScene => (AreaEnum)106; public override Vector3 SpawnPosition => new Vector3(-435.2f, -19.1f, -96.5f); public override Vector3 SpawnRotation => new Vector3(0f, 172.4f, 0f); public override bool HasQuest => true; public override string QuestName => "Thy watch has ended"; public override Dictionary<string, string> QuestLogSignatures => new Dictionary<string, string> { { "watcher.objective.a", "Get out into the world." }, { "watcher.objective.b", "Visit the nearby village of Cierzo." }, { "watcher.objective.c", "You are again part of the world." } }; public override void Gear(Character character) { character.Inventory.ReceiveSkillReward(8200040); character.Inventory.ReceiveSkillReward(8100220); character.Inventory.ReceiveSkillReward(8100230); character.Stats.SetManaPoint(3); character.Inventory.ReceiveItemReward(3000134, 1, true); character.Inventory.ReceiveItemReward(3000131, 1, true); character.Inventory.ReceiveItemReward(3000136, 1, true); character.Inventory.ReceiveItemReward(5100500, 1, true); } public override void Init() { base.Init(); QE_FixedWatcherStart = CustomQuests.CreateQuestEvent("iggythemad.watcher.fixedstart", false, true, true, "A_Iggy_AlternateStart", "CustomEvent", "A custom event created with SideLoader"); SL.OnGameplayResumedAfterLoading += SL_OnGameplayResumedAfterLoading; } private void SL_OnGameplayResumedAfterLoading() { if (!PhotonNetwork.isNonMasterClientInRoom && base.IsActiveScenario) { Character worldHostCharacter = CharacterManager.Instance.GetWorldHostCharacter(); if (((CharacterKnowledge)worldHostCharacter.Inventory.QuestKnowledge).IsItemLearned((int)Type)) { Item itemFromItemID = ((CharacterKnowledge)worldHostCharacter.Inventory.QuestKnowledge).GetItemFromItemID((int)Type); Quest quest = (Quest)(object)((itemFromItemID is Quest) ? itemFromItemID : null); UpdateQuestProgress(quest); } } } public override void UpdateQuestProgress(Quest quest) { //IL_006e: Unknown result type (might be due to invalid IL or missing references) //IL_00ba: Unknown result type (might be due to invalid IL or missing references) //IL_0104: Unknown result type (might be due to invalid IL or missing references) //IL_011b: Unknown result type (might be due to invalid IL or missing references) if (PhotonNetwork.isNonMasterClientInRoom || !base.IsActiveScenario) { return; } int num = 3; int eventCurrentStack = QuestEventManager.Instance.GetEventCurrentStack(QE_FixedWatcherStart.EventUID); QuestProgress questProgress = quest.m_questProgress; if (eventCurrentStack >= num) { questProgress.DisableQuest((ProgressState)3); return; } if (eventCurrentStack < 1) { QuestEventManager.Instance.AddEvent(QE_FixedWatcherStart, 1); eventCurrentStack = QuestEventManager.Instance.GetEventCurrentStack(QE_FixedWatcherStart.EventUID); questProgress.UpdateLogEntry(questProgress.GetLogSignature(UID.op_Implicit("watcher.objective.a")), displayTime: true); ShowUIMessage("My watch is over. The world might need me."); } else if (eventCurrentStack < 2 && SceneManagerHelper.ActiveSceneName == "ChersoneseNewTerrain") { QuestEventManager.Instance.AddEvent(QE_FixedWatcherStart, 1); questProgress.UpdateLogEntry(questProgress.GetLogSignature(UID.op_Implicit("watcher.objective.b")), displayTime: false); ShowUIMessage("There used to be a village nearby...Cierzo, is it?"); } if (eventCurrentStack < 3 && SceneManagerHelper.ActiveSceneName == "CierzoNewTerrain") { QuestEventManager.Instance.AddEvent(QE_FixedWatcherStart, 2); questProgress.UpdateLogEntry(questProgress.GetLogSignature(UID.op_Implicit("watcher.objective.b")), displayTime: true); questProgress.UpdateLogEntry(questProgress.GetLogSignature(UID.op_Implicit("watcher.objective.c")), displayTime: true); questProgress.DisableQuest((ProgressState)3); VanillaQuestsHelper.SkipHostToFactionChoice(keepHouse: false, complete: false); ShowUIMessage("I should ask around..."); } ReloadLogs(eventCurrentStack, questProgress); } public void ReloadLogs(int stack, QuestProgress progress) { //IL_0044: Unknown result type (might be due to invalid IL or missing references) int num = 0; foreach (KeyValuePair<string, string> questLogSignature in QuestLogSignatures) { if (num < stack && questLogSignature.Key != null) { Debug.Log((object)("log: " + questLogSignature.Key)); progress.UpdateLogEntry(progress.GetLogSignature(UID.op_Implicit(questLogSignature.Key)), displayTime: false); num++; } } } public override void OnScenarioChosen() { } public override void OnStartSpawn() { GetOrGiveQuestToHost(); } public override void OnStartSpawn(Character character) { } public override void OnScenarioChosen(Character character) { } } public class CorruptedScenario : Scenario { private const string LogSignature_A = "corrupted.objective.a"; private const string LogSignature_B = "corrupted.objective.b"; private const string LogSignature_C = "corrupted.objective.c"; private QuestEventSignature QE_FixedCorruptedStart; public override ScenarioQuest Type => ScenarioQuest.Quest_CorruptedSoul; public override ScenarioType Difficulty => ScenarioType.Normal; public override ScenarioPassives Passive => ScenarioPassives.CorruptedSoul; public override AreaEnum SpawnScene => (AreaEnum)108; public override Vector3 SpawnPosition => new Vector3(-37.3f, -7f, -126.4f); public override Vector3 SpawnRotation => new Vector3(0f, 222.9f, 0f); public override bool HasQuest => true; public override string QuestName => "Corruption Reborn"; public override Dictionary<string, string> QuestLogSignatures => new Dictionary<string, string> { { "corrupted.objective.a", "Whatever happend to you. Find a way out. " }, { "corrupted.objective.b", "Head to a nearby settlement" }, { "corrupted.objective.c", "You are ready to join a faction." } }; internal static CorruptedScenario Instance { get; private set; } public override void Gear(Character character) { character.Inventory.ReceiveItemReward(3000044, 1, true); character.Inventory.ReceiveItemReward(3000046, 1, true); character.Inventory.ReceiveItemReward(2150001, 1, false); character.Inventory.ReceiveItemReward(5100060, 1, true); character.Inventory.ReceiveSkillReward(8201029); character.Stats.SetManaPoint(2); character.Inventory.ReceiveSkillReward(8200040); character.Inventory.ReceiveItemReward(6400130, 5, true); character.Inventory.ReceiveItemReward(4400010, 5, true); } public override void Init() { base.Init(); QE_FixedCorruptedStart = CustomQuests.CreateQuestEvent("iggythemad.corrupted.fixedstart", false, true, true, "A_Iggy_AlternateStart", "CustomEvent", "A custom event created with SideLoader"); SL.OnGameplayResumedAfterLoading += SL_OnGameplayResumedAfterLoading; } private void SL_OnGameplayResumedAfterLoading() { foreach (Character value in CharacterManager.Instance.Characters.Values) { if (value.IsLocalPlayer && ((CharacterKnowledge)value.Inventory.SkillKnowledge).IsItemLearned(-2218) && value.PlayerStats.Corruption < 0f) { value.PlayerStats.AffectCorruptionLevel(0f, false); } } Character worldHostCharacter = CharacterManager.Instance.GetWorldHostCharacter(); if (((CharacterKnowledge)worldHostCharacter.Inventory.QuestKnowledge).IsItemLearned((int)Type)) { Item itemFromItemID = ((CharacterKnowledge)worldHostCharacter.Inventory.QuestKnowledge).GetItemFromItemID((int)Type); Quest quest = (Quest)(object)((itemFromItemID is Quest) ? itemFromItemID : null); UpdateQuestProgress(quest); } } public override void UpdateQuestProgress(Quest quest) { //IL_006e: Unknown result type (might be due to invalid IL or missing references) //IL_00a9: Unknown result type (might be due to invalid IL or missing references) //IL_00ee: Unknown result type (might be due to invalid IL or missing references) //IL_0105: Unknown result type (might be due to invalid IL or missing references) if (PhotonNetwork.isNonMasterClientInRoom || !base.IsActiveScenario) { return; } int num = 3; int eventCurrentStack = QuestEventManager.Instance.GetEventCurrentStack(QE_FixedCorruptedStart.EventUID); QuestProgress questProgress = quest.m_questProgress; if (eventCurrentStack >= num) { questProgress.DisableQuest((ProgressState)3); return; } if (eventCurrentStack < 1) { QuestEventManager.Instance.AddEvent(QE_FixedCorruptedStart, 1); eventCurrentStack = QuestEventManager.Instance.GetEventCurrentStack(QE_FixedCorruptedStart.EventUID); questProgress.UpdateLogEntry(questProgress.GetLogSignature(UID.op_Implicit("corrupted.objective.a")), displayTime: true); ShowUIMessage("What... Where am I?"); } else if (eventCurrentStack < 2) { QuestEventManager.Instance.AddEvent(QE_FixedCorruptedStart, 1); questProgress.UpdateLogEntry(questProgress.GetLogSignature(UID.op_Implicit("corrupted.objective.b")), displayTime: false); ShowUIMessage("I should find others... Living, preferably."); } if (eventCurrentStack < 3 && AreaManager.Instance.GetIsCurrentAreaTownOrCity()) { QuestEventManager.Instance.AddEvent(QE_FixedCorruptedStart, 2); questProgress.UpdateLogEntry(questProgress.GetLogSignature(UID.op_Implicit("corrupted.objective.b")), displayTime: true); questProgress.UpdateLogEntry(questProgress.GetLogSignature(UID.op_Implicit("corrupted.objective.c")), displayTime: true); questProgress.DisableQuest((ProgressState)3); VanillaQuestsHelper.SkipHostToFactionChoice(keepHouse: false, complete: true); ShowUIMessage("I'm somehow back to life. I should do something with it."); } ReloadLogs(eventCurrentStack, questProgress); } public void ReloadLogs(int stack, QuestProgress progress) { //IL_0044: Unknown result type (might be due to invalid IL or missing references) int num = 0; foreach (KeyValuePair<string, string> questLogSignature in QuestLogSignatures) { if (num < stack && questLogSignature.Key != null) { Debug.Log((object)("log: " + questLogSignature.Key)); progress.UpdateLogEntry(progress.GetLogSignature(UID.op_Implicit(questLogSignature.Key)), displayTime: false); num++; } } } public override void OnScenarioChosen() { } public override void OnStartSpawn() { GetOrGiveQuestToHost(); } public override void OnScenarioChosen(Character character) { } public override void OnStartSpawn(Character character) { } public CorruptedScenario() { Instance = this; } } public class EnmerkarHunterScenario : Scenario { [HarmonyPatch(typeof(LocalCharacterControl), "DetectMovementInputs")] public class LocalCharacterControl_DetectMovementInputs { [HarmonyPostfix] public static void Postfix(LocalCharacterControl __instance, ref Character ___m_character) { //IL_0043: Unknown result type (might be due to invalid IL or missing references) //IL_0052: Unknown result type (might be due to invalid IL or missing references) //IL_0057: Unknown result type (might be due to invalid IL or missing references) //IL_005c: Unknown result type (might be due to invalid IL or missing references) //IL_0063: Unknown result type (might be due to invalid IL or missing references) //IL_0068: Unknown result type (might be due to invalid IL or missing references) //IL_0077: Unknown result type (might be due to invalid IL or missing references) //IL_007c: Unknown result type (might be due to invalid IL or missing references) //IL_0081: Unknown result type (might be due to invalid IL or missing references) //IL_0086: Unknown result type (might be due to invalid IL or missing references) if (!((Object)(object)__instance == (Object)null) && ((CharacterControl)__instance).Character.IsLocalPlayer && ((CharacterKnowledge)((CharacterControl)__instance).Character.Inventory.SkillKnowledge).IsItemLearned(-2208) && ((CharacterControl)__instance).Character.CurrentlyChargingAttack) { ((CharacterControl)__instance).m_moveInput = ((CharacterControl)__instance).m_moveInput * new Vector2(0.3f, 0.3f); __instance.m_modifMoveInput = Vector2.op_Implicit(Vector2.op_Implicit(__instance.m_modifMoveInput) * new Vector2(0.6f, 0.6f)); ((MonoBehaviour)Plugin.Instance).StartCoroutine(Instance.checkBowDraw(((CharacterControl)__instance).Character)); } } } [HarmonyPatch(typeof(CharacterInventory), "EquipItem", new Type[] { typeof(Equipment), typeof(bool) })] public class CharacterInventory_EquipItem { [HarmonyPrefix] public static void Postfix(CharacterInventory __instance, Equipment _itemToEquip, bool _playAnim, ref Character ___m_character) { Character val = ___m_character; if (!((Object)(object)val == (Object)null) && val.IsLocalPlayer && ((CharacterKnowledge)val.Inventory.SkillKnowledge).IsItemLearned(-2208)) { ((MonoBehaviour)Plugin.Instance).StartCoroutine(Instance.checkBow(val)); } } } [HarmonyPatch(typeof(CharacterInventory), "UnequipItem", new Type[] { typeof(Equipment), typeof(bool) })] public class CharacterInventory_UnequipItem { [HarmonyPrefix] public static void Postfix(CharacterInventory __instance, Equipment _itemToUnequip, bool _playAnim, ref Character ___m_character) { Character val = ___m_character; if (!((Object)(object)val == (Object)null) && val.IsLocalPlayer && ((CharacterKnowledge)val.Inventory.SkillKnowledge).IsItemLearned(-2208)) { ((MonoBehaviour)Plugin.Instance).StartCoroutine(Instance.checkBow(val)); } } } [HarmonyPatch(typeof(CharacterKnowledge), "AddItem")] public class CharacterKnowledge_AddItem { [HarmonyPrefix] public static void Prefix(CharacterKnowledge __instance, Item _item, ref Character ___m_character) { Character val = ___m_character; if (!((Object)(object)val == (Object)null) && val.IsLocalPlayer && ((CharacterKnowledge)val.Inventory.SkillKnowledge).IsItemLearned(-2208)) { ((MonoBehaviour)Plugin.Instance).StartCoroutine(Instance.checkBow(val)); } } } private const string LogSignature_A = "hunter.objective.a"; private const string LogSignature_B = "hunter.objective.b"; private const string LogSignature_C = "hunter.objective.c"; private QuestEventSignature QE_FixedHunterStart; private string bowmanEffect = "bowmanEffect"; public override ScenarioQuest Type => ScenarioQuest.Quest_EmercarHunter; public override ScenarioType Difficulty => ScenarioType.Normal; public override ScenarioPassives Passive => ScenarioPassives.EnmerkarHunter; public override AreaEnum SpawnScene => (AreaEnum)550; public override Vector3 SpawnPosition => new Vector3(600.6f, 0.8f, 8.1f); public override Vector3 SpawnRotation => new Vector3(0f, 29.3f, 0f); public override bool HasQuest => true; public override string QuestName => "A Good Hunt"; public override Dictionary<string, string> QuestLogSignatures => new Dictionary<string, string> { { "hunter.objective.a", "Leave your hut." }, { "hunter.objective.b", "Go to any city to sell your goods." }, { "hunter.objective.c", "You are ready to join a faction." } }; internal static EnmerkarHunterScenario Instance { get; private set; } public override void Gear(Character character) { character.Inventory.ReceiveItemReward(9000010, 13, false); character.Inventory.ReceiveItemReward(3000020, 1, true); character.Inventory.ReceiveItemReward(3000022, 1, true); character.Inventory.ReceiveItemReward(2200000, 1, false); character.Inventory.ReceiveItemReward(5200001, 30, true); character.Inventory.ReceiveItemReward(4000060, 4, false); } public override void Init() { base.Init(); QE_FixedHunterStart = CustomQuests.CreateQuestEvent("iggythemad.hunter.fixedstart", false, true, true, "A_Iggy_AlternateStart", "CustomEvent", "A custom event created with SideLoader"); SL.OnGameplayResumedAfterLoading += SL_OnGameplayResumedAfterLoading; } private void SL_OnGameplayResumedAfterLoading() { if (!PhotonNetwork.isNonMasterClientInRoom && base.IsActiveScenario) { Character worldHostCharacter = CharacterManager.Instance.GetWorldHostCharacter(); if (((CharacterKnowledge)worldHostCharacter.Inventory.QuestKnowledge).IsItemLearned((int)Type)) { Item itemFromItemID = ((CharacterKnowledge)worldHostCharacter.Inventory.QuestKnowledge).GetItemFromItemID((int)Type); Quest quest = (Quest)(object)((itemFromItemID is Quest) ? itemFromItemID : null); UpdateQuestProgress(quest); } } } public override void UpdateQuestProgress(Quest quest) { //IL_006e: Unknown result type (might be due to invalid IL or missing references) //IL_00a9: Unknown result type (might be due to invalid IL or missing references) //IL_00ee: Unknown result type (might be due to invalid IL or missing references) //IL_0105: Unknown result type (might be due to invalid IL or missing references) if (PhotonNetwork.isNonMasterClientInRoom || !base.IsActiveScenario) { return; } int num = 3; int eventCurrentStack = QuestEventManager.Instance.GetEventCurrentStack(QE_FixedHunterStart.EventUID); QuestProgress questProgress = quest.m_questProgress; if (eventCurrentStack >= num) { questProgress.DisableQuest((ProgressState)3); return; } if (eventCurrentStack < 1) { QuestEventManager.Instance.AddEvent(QE_FixedHunterStart, 1); eventCurrentStack = QuestEventManager.Instance.GetEventCurrentStack(QE_FixedHunterStart.EventUID); questProgress.UpdateLogEntry(questProgress.GetLogSignature(UID.op_Implicit("hunter.objective.a")), displayTime: true); ShowUIMessage("Today's was a good hunt..."); } else if (eventCurrentStack < 2) { QuestEventManager.Instance.AddEvent(QE_FixedHunterStart, 1); questProgress.UpdateLogEntry(questProgress.GetLogSignature(UID.op_Implicit("hunter.objective.b")), displayTime: false); ShowUIMessage("I should sell my goods in the city..."); } if (eventCurrentStack < 3 && AreaManager.Instance.GetIsCurrentAreaTownOrCity()) { QuestEventManager.Instance.AddEvent(QE_FixedHunterStart, 2); questProgress.UpdateLogEntry(questProgress.GetLogSignature(UID.op_Implicit("hunter.objective.b")), displayTime: true); questProgress.UpdateLogEntry(questProgress.GetLogSignature(UID.op_Implicit("hunter.objective.c")), displayTime: true); questProgress.DisableQuest((ProgressState)3); VanillaQuestsHelper.SkipHostToFactionChoice(keepHouse: false, complete: true); ShowUIMessage("Huh... Should I join a faction?"); } ReloadLogs(eventCurrentStack, questProgress); } public void ReloadLogs(int stack, QuestProgress progress) { //IL_0044: Unknown result type (might be due to invalid IL or missing references) int num = 0; foreach (KeyValuePair<string, string> questLogSignature in QuestLogSignatures) { if (num < stack && questLogSignature.Key != null) { Debug.Log((object)("log: " + questLogSignature.Key)); progress.UpdateLogEntry(progress.GetLogSignature(UID.op_Implicit(questLogSignature.Key)), displayTime: false); num++; } } } public override void OnScenarioChosen() { } public override void OnScenarioChosen(Character character) { } public override void OnStartSpawn() { GetOrGiveQuestToHost(); } public override void OnStartSpawn(Character character) { character.Inventory.ReceiveSkillReward(8205160); } public EnmerkarHunterScenario() { Instance = this; } private IEnumerator checkBowDraw(Character player) { player.Animator.speed = 2.2f; while (player.CurrentlyChargingAttack) { yield return (object)new WaitForSeconds(0.1f); } player.Animator.speed = 1f; } private IEnumerator checkBow(Character player) { player.StatusEffectMngr.RemoveStatusWithIdentifierName(bowmanEffect); yield return (object)new WaitForSeconds(0.5f); if ((int)player.CurrentWeapon.Type != 200) { player.StatusEffectMngr.AddStatusEffect(bowmanEffect); } } } public class GiantRisenScenario : Scenario { [HarmonyPatch(typeof(Character), "DodgeInput", new Type[] { typeof(Vector3) })] public class Character_DodgeInput { [HarmonyPostfix] public static void Postfix(Character __instance, Vector3 _direction) { if (__instance.IsLocalPlayer && ((CharacterKnowledge)__instance.Inventory.SkillKnowledge).IsItemLearned(-2212) && !__instance.DodgeRestricted) { ((MonoBehaviour)Plugin.Instance).StartCoroutine(Instance.DodgeSlower(__instance)); } } } private const string LogSignature_A = "giant.objective.a"; private const string LogSignature_B = "giant.objective.b"; private const string LogSignature_C = "giant.objective.c"; private QuestEventSignature QE_FixedGiantRisenStart; public override ScenarioQuest Type => ScenarioQuest.Quest_GiantRisen; public override ScenarioType Difficulty => ScenarioType.Normal; public override ScenarioPassives Passive => ScenarioPassives.GiantRisen; public override AreaEnum SpawnScene => (AreaEnum)203; public override Vector3 SpawnPosition => default(Vector3); public override bool HasQuest => true; public override string QuestName => "Giant Mistake"; public override Dictionary<string, string> QuestLogSignatures => new Dictionary<string, string> { { "giant.objective.a", "The giants have disowned you! Run for your life!" }, { "giant.objective.b", "Find a new home..." }, { "giant.objective.c", "You are ready to join a faction." } }; internal static GiantRisenScenario Instance { get; private set; } public override void Gear(Character character) { character.Inventory.ReceiveItemReward(3000221, 1, true); character.Inventory.ReceiveItemReward(3000220, 1, true); character.Inventory.ReceiveItemReward(3000222, 1, true); character.Inventory.ReceiveItemReward(2110000, 1, true); } public override void Init() { base.Init(); QE_FixedGiantRisenStart = CustomQuests.CreateQuestEvent("iggythemad.giantrisen.fixedstart", false, true, true, "A_Iggy_AlternateStart", "CustomEvent", "A custom event created with SideLoader"); SL.OnGameplayResumedAfterLoading += SL_OnGameplayResumedAfterLoading; } public override void OnScenarioChosen() { } public override void OnScenarioChosen(Character character) { } public override void OnStartSpawn() { GetOrGiveQuestToHost(); VanillaQuestsHelper.AddQuestEvent("XqlcpbTJC0aTDZfjD4xCTg"); } public override void OnStartSpawn(Character character) { } private void SL_OnGameplayResumedAfterLoading() { if (!PhotonNetwork.isNonMasterClientInRoom && base.IsActiveScenario) { Character worldHostCharacter = CharacterManager.Instance.GetWorldHostCharacter(); if (((CharacterKnowledge)worldHostCharacter.Inventory.QuestKnowledge).IsItemLearned((int)Type)) { Item itemFromItemID = ((CharacterKnowledge)worldHostCharacter.Inventory.QuestKnowledge).GetItemFromItemID((int)Type); Quest quest = (Quest)(object)((itemFromItemID is Quest) ? itemFromItemID : null); UpdateQuestProgress(quest); } } } public override void UpdateQuestProgress(Quest quest) { //IL_0058: Unknown result type (might be due to invalid IL or missing references) //IL_0096: Unknown result type (might be due to invalid IL or missing references) //IL_00e6: Unknown result type (might be due to invalid IL or missing references) //IL_00fd: Unknown result type (might be due to invalid IL or missing references) if (PhotonNetwork.isNonMasterClientInRoom || !base.IsActiveScenario) { return; } int num = 3; int eventCurrentStack = QuestEventManager.Instance.GetEventCurrentStack(QE_FixedGiantRisenStart.EventUID); QuestProgress questProgress = quest.m_questProgress; if (eventCurrentStack >= num) { questProgress.DisableQuest((ProgressState)3); return; } if (eventCurrentStack < 1) { QuestEventManager.Instance.AddEvent(QE_FixedGiantRisenStart, 1); questProgress.UpdateLogEntry(questProgress.GetLogSignature(UID.op_Implicit("giant.objective.a")), displayTime: true); ShowUIMessage("I've been exiled! I should flee!"); } else if (eventCurrentStack < 2) { QuestEventManager.Instance.AddEvent(QE_FixedGiantRisenStart, 1); questProgress.UpdateLogEntry(questProgress.GetLogSignature(UID.op_Implicit("giant.objective.b")), displayTime: false); ShowUIMessage("I need to find a new home..."); } else if (eventCurrentStack < 3 && AreaManager.Instance.GetIsCurrentAreaTownOrCity()) { QuestEventManager.Instance.AddEvent(QE_FixedGiantRisenStart, 1); questProgress.UpdateLogEntry(questProgress.GetLogSignature(UID.op_Implicit("giant.objective.b")), displayTime: true); questProgress.UpdateLogEntry(questProgress.GetLogSignature(UID.op_Implicit("giant.objective.c")), displayTime: true); questProgress.DisableQuest((ProgressState)3); VanillaQuestsHelper.RemoveEvent("oGkuUgWvfkej_El-rhz2gw"); VanillaQuestsHelper.RemoveEvent("XqlcpbTJC0aTDZfjD4xCTg"); VanillaQuestsHelper.RemoveEvent("nDy01eTHlUa_BPDlbIhZPQ"); VanillaQuestsHelper.RemoveEvent("f1JVZyhg2UiBA8xmC-w6Hw"); VanillaQuestsHelper.SkipHostToFactionChoice(keepHouse: false, complete: true); ShowUIMessage("Maybe I should join a new faction..."); } ReloadLogs(eventCurrentStack, questProgress); } public void ReloadLogs(int stack, QuestProgress progress) { //IL_0044: Unknown result type (might be due to invalid IL or missing references) int num = 0; foreach (KeyValuePair<string, string> questLogSignature in QuestLogSignatures) { if (num < stack && questLogSignature.Key != null) { Debug.Log((object)("log: " + questLogSignature.Key)); progress.UpdateLogEntry(progress.GetLogSignature(UID.op_Implicit(questLogSignature.Key)), displayTime: false); num++; } } } public GiantRisenScenario() { Instance = this; } public IEnumerator DodgeSlower(Character _character) { if (_character.Dodging) { _character.Animator.speed = 0.6f; while (_character.Dodging) { yield return (object)new WaitForSeconds(0.2f); } yield return (object)new WaitForSeconds(0.2f); _character.Animator.speed = 1f; } } } public class LimitlessScenario : Scenario { private const string LogSignature_A = "unbound.objective.a"; private const string LogSignature_B = "unbound.objective.b"; private const string LogSignature_C = "unbound.objective.c"; private QuestEventSignature QE_FixedUnboundStart; public int questTrigger; public override ScenarioQuest Type => ScenarioQuest.Quest_Unbound; public override ScenarioType Difficulty => ScenarioType.WIPtest; public override ScenarioPassives Passive => ScenarioPassives.Unbound; public override AreaEnum SpawnScene => (AreaEnum)501; public override Vector3 SpawnPosition => new Vector3(1053.8f, -32f, 1155.6f); public override Vector3 SpawnRotation => new Vector3(0f, 230.2f, 0f); public override bool HasQuest => true; public override string QuestName => "Unbound. Unlimited."; public override Dictionary<string, string> QuestLogSignatures => new Dictionary<string, string> { { "unbound.objective.a", "You've unlocked your true potential. You are unbound. Find any trainer to learn from." }, { "unbound.objective.b", "Purchase your first skill. No restrictions. Choose wisely." }, { "unbound.objective.c", "You are ready to face the world. You are ready to join a faction." } }; public override void Gear(Character character) { character.Inventory.AddMoney(37); character.Inventory.ReceiveItemReward(4100550, 3, false); character.Inventory.ReceiveItemReward(3000091, 1, true); character.Inventory.ReceiveItemReward(3000282, 1, true); character.Inventory.ReceiveItemReward(2160020, 1, false); character.Inventory.ReceiveItemReward(5110030, 1, false); } public override void Init() { base.Init(); QE_FixedUnboundStart = CustomQuests.CreateQuestEvent("iggythemad.unbound.fixedstart", false, true, true, "A_Iggy_AlternateStart", "CustomEvent", "A custom event created with SideLoader"); SL.OnGameplayResumedAfterLoading += SL_OnGameplayResumedAfterLoading; } private void SL_OnGameplayResumedAfterLoading() { if (!PhotonNetwork.isNonMasterClientInRoom && base.IsActiveScenario) { Character worldHostCharacter = CharacterManager.Instance.GetWorldHostCharacter(); if (((CharacterKnowledge)worldHostCharacter.Inventory.QuestKnowledge).IsItemLearned((int)Type)) { Item itemFromItemID = ((CharacterKnowledge)worldHostCharacter.Inventory.QuestKnowledge).GetItemFromItemID((int)Type); Quest quest = (Quest)(object)((itemFromItemID is Quest) ? itemFromItemID : null); UpdateQuestProgress(quest); } } } public override void UpdateQuestProgress(Quest quest) { //IL_006b: Unknown result type (might be due to invalid IL or missing references) //IL_00b5: Unknown result type (might be due to invalid IL or missing references) //IL_00f9: Unknown result type (might be due to invalid IL or missing references) if (!PhotonNetwork.isNonMasterClientInRoom && base.IsActiveScenario) { CharacterManager.Instance.GetWorldHostCharacter(); int eventCurrentStack = QuestEventManager.Instance.GetEventCurrentStack(QE_FixedUnboundStart.EventUID); QuestProgress questProgress = quest.m_questProgress; if (eventCurrentStack < 1) { QuestEventManager.Instance.AddEvent(QE_FixedUnboundStart, 1); eventCurrentStack = QuestEventManager.Instance.GetEventCurrentStack(QE_FixedUnboundStart.EventUID); questProgress.UpdateLogEntry(questProgress.GetLogSignature(UID.op_Implicit("unbound.objective.a")), displayTime: true); ShowUIMessage("I feel... free. Unbound. I need power!"); } else if (eventCurrentStack < 2 && AreaManager.Instance.GetIsCurrentAreaTownOrCity()) { QuestEventManager.Instance.AddEvent(QE_FixedUnboundStart, 1); questProgress.UpdateLogEntry(questProgress.GetLogSignature(UID.op_Implicit("unbound.objective.b")), displayTime: true); ShowUIMessage("So many choices... I gotta choose wisely."); } else if (eventCurrentStack < 3 && questTrigger == 1) { QuestEventManager.Instance.AddEvent(QE_FixedUnboundStart, 2); questProgress.UpdateLogEntry(questProgress.GetLogSignature(UID.op_Implicit("unbound.objective.c")), displayTime: true); questProgress.DisableQuest((ProgressState)3); VanillaQuestsHelper.SkipHostToFactionChoice(keepHouse: false, complete: true); } ReloadLogs(eventCurrentStack, questProgress); } } public void ReloadLogs(int stack, QuestProgress progress) { //IL_0044: Unknown result type (might be due to invalid IL or missing references) int num = 0; foreach (KeyValuePair<string, string> questLogSignature in QuestLogSignatures) { if (num < stack && questLogSignature.Key != null) { Debug.Log((object)("log: " + questLogSignature.Key)); progress.UpdateLogEntry(progress.GetLogSignature(UID.op_Implicit(questLogSignature.Key)), displayTime: false); num++; } } } public override void OnScenarioChosen() { } public override void OnScenarioChosen(Character character) { } public override void OnStartSpawn() { GetOrGiveQuestToHost(); } public override void OnStartSpawn(Character character) { } } public class PriestElattScenario : Scenario { public override ScenarioQuest Type => ScenarioQuest.Quest_PriestElatt; public override ScenarioType Difficulty => ScenarioType.Normal; public override ScenarioPassives Passive => ScenarioPassives.PriestElatt; public override AreaEnum SpawnScene => (AreaEnum)200; public override Vector3 SpawnPosition => new Vector3(-175.2f, -1514.6f, 751.9f); public override Vector3 SpawnRotation => new Vector3(0f, 359f, 0f); public override bool HasQuest => false; public override string QuestName => ""; public override Dictionary<string, string> QuestLogSignatures => new Dictionary<string, string>(); internal static PriestElattScenario Instance { get; private set; } public override void Gear(Character character) { character.Inventory.ReceiveItemReward(9000010, 32, true); character.Inventory.ReceiveItemReward(3000071, 1, true); character.Inventory.ReceiveItemReward(3000070, 1, true); character.Stats.SetManaPoint(2); character.Inventory.ReceiveItemReward(3000174, 1, true); character.Inventory.ReceiveItemReward(2020010, 1, true); character.Inventory.ReceiveSkillReward(8200040); } public override void OnScenarioChosen() { } public override void OnScenarioChosen(Character character) { } public override void OnStartSpawn() { VanillaQuestsHelper.SkipHostToFactionChoice(keepHouse: false, complete: true); } public override void OnStartSpawn(Character character) { } public override void UpdateQuestProgress(Quest quest) { } public PriestElattScenario() { Instance = this; } } public class RobbedTraderScenario : Scenario { [HarmonyPatch(typeof(DefeatScenariosManager), "StartDefeat")] public class DefeatScenariosManager_StartDefeat { [HarmonyPrefix] public static bool Prefix(DefeatScenariosManager __instance) { if (!Instance.IsActiveScenario || PhotonNetwork.isNonMasterClientInRoom) { return true; } if (QuestEventManager.Instance.HasQuestEvent(QuestEventDictionary.GetQuestEvent("jNfNsLGBpk2iMRts9kkerw"))) { return true; } foreach (PlayerSystem item in Global.Lobby.PlayersInLobby) { item.ControlledCharacter.Resurrect(); } NetworkLevelLoader.Instance.RequestSwitchArea(AreaManager.Instance.GetArea((AreaEnum)101).SceneName, 0, 1.5f, false); return false; } } [HarmonyPatch(typeof(InteractionTriggerBase), "TryActivateBasicAction", new Type[] { typeof(Character), typeof(int) })] public class InteractionTriggerBase_TryActivateBasicAction { [HarmonyPrefix] public static bool Prefix(InteractionTriggerBase __instance, Character _character, int _toggleState) { //IL_0179: Unknown result type (might be due to invalid IL or missing references) //IL_0183: Unknown result type (might be due to invalid IL or missing references) //IL_0094: Unknown result type (might be due to invalid IL or missing references) //IL_009e: Unknown result type (might be due to invalid IL or missing references) //IL_010f: Unknown result type (might be due to invalid IL or missing references) //IL_0119: Unknown result type (might be due to invalid IL or missing references) if (!Instance.IsActiveScenario || PhotonNetwork.isNonMasterClientInRoom || !Object.op_Implicit((Object)(object)_character)) { return true; } if (!_character.IsLocalPlayer) { return true; } if (QuestEventManager.Instance.HasQuestEvent(QuestEventDictionary.GetQuestEvent("jNfNsLGBpk2iMRts9kkerw"))) { return true; } EventActivator currentTriggerManager = __instance.CurrentTriggerManager; if (Object.op_Implicit((Object)(object)((currentTriggerManager is InteractionActivator) ? currentTriggerManager : null))) { EventActivator currentTriggerManager2 = __instance.CurrentTriggerManager; InteractionActivator val = (InteractionActivator)(object)((currentTriggerManager2 is InteractionActivator) ? currentTriggerManager2 : null); if (val.BasicInteraction != null) { IInteraction basicInteraction = val.BasicInteraction; if (SceneManagerHelper.ActiveSceneName == "CierzoNewTerrain") { if (basicInteraction is InteractionMerchantDialogue && Vector3.Distance(((Component)_character).transform.position, Instance.traderPosition) < 5f) { if (_character.Inventory.OwnsOrHasEquipped(-2353)) { Instance.ShowUIMessage("I need to sell the goods before leaving.", instant: true); } else { VanillaQuestsHelper.SkipHostToFactionChoice(keepHouse: false, complete: true); NetworkLevelLoader.Instance.RequestSwitchArea(AreaManager.Instance.GetArea((AreaEnum)400).SceneName, 0, 1.5f, false); } return false; } if (basicInteraction is InteractionMerchantDialogue && Vector3.Distance(((Component)_character).transform.position, Instance.alchemistPosition) < 5f) { return true; } if (_character.Inventory.OwnsOrHasEquipped(-2353)) { Instance.ShowUIMessage("I have no time for this...", instant: true); } else { Instance.ShowUIMessage("I should go back to harmattan...", instant: true); } return false; } if (SceneManagerHelper.ActiveSceneName == "ChersoneseNewTerrain") { if (Vector3.Distance(((Component)_character).transform.position, Instance.cierzoEntrance) < 5f) { return true; } Instance.ShowUIMessage("There is no time for this.", instant: true); return false; } } } return true; } } public string enemyID = "com.iggy.banditgeneric"; public Vector3 traderPosition = new Vector3(1408.7f, 5.9f, 1663.8f); public Vector3 alchemistPosition = new Vector3(1384.9f, 7.8f, 1649.1f); public Vector3 chersoneseFailSpawn = new Vector3(181.5f, 32.6f, 1444.4f); public Vector3 cierzoEntrance = new Vector3(131.9f, 34.9f, 1461.7f); internal static RobbedTraderScenario Instance { get; private set; } public override ScenarioQuest Type => ScenarioQuest.Quest_RobbedTrader; public override ScenarioType Difficulty => ScenarioType.Normal; public override ScenarioPassives Passive => ScenarioPassives.RobbedTrader; public override AreaEnum SpawnScene => (AreaEnum)101; public override Vector3 SpawnPosition => new Vector3(300.3f, 37.3f, 1423.9f); public override Vector3 SpawnRotation => new Vector3(0f, 285.7f, 0f); public override bool HasQuest => false; public override string QuestName => ""; public override Dictionary<string, string> QuestLogSignatures => new Dictionary<string, string>(); public override void Gear(Character character) { character.Inventory.ReceiveItemReward(9000010, 56, false); character.Inventory.ReceiveItemReward(3000190, 1, true); character.Inventory.ReceiveItemReward(3000004, 1, true); character.Inventory.ReceiveItemReward(-2353, 1, true); } public override void Init() { base.Init(); SL.OnGameplayResumedAfterLoading += SL_OnGameplayResumedAfterLoading; } public RobbedTraderScenario() { //IL_001b: Unknown result type (might be due to invalid IL or missing references) //IL_0020: Unknown result type (might be due to invalid IL or missing references) //IL_0035: Unknown result type (might be due to invalid IL or missing references) //IL_003a: Unknown result type (might be due to invalid IL or missing references) //IL_004f: Unknown result type (might be due to invalid IL or missing references) //IL_0054: Unknown result type (might be due to invalid IL or missing references) //IL_0069: Unknown result type (might be due to invalid IL or missing references) //IL_006e: Unknown result type (might be due to invalid IL or missing references) Instance = this; } public override void OnScenarioChosen() { } public override void OnScenarioChosen(Character character) { } public override void OnStartSpawn() { } public override void OnStartSpawn(Character character) { ShowUIMessage("I can see the lighthouse! Got to sell the goods in Cierzo!"); } private void SL_OnGameplayResumedAfterLoading() { if (Instance.IsActiveScenario) { _ = PhotonNetwork.isNonMasterClientInRoom; } } public override void UpdateQuestProgress(Quest quest) { } } public class SandBanditScenario : Scenario { [HarmonyPatch(typeof(CharacterStats), "ReceiveDamage")] public class Character_ReceiveDamage { [HarmonyPostfix] public static void Postfix(CharacterStats __instance, ref float _damage, ref Character ___m_character) { if (Instance.IsActiveScenario && ___m_character.IsAI && !(SceneManagerHelper.ActiveSceneName != "Abrassar_Dungeon6") && _damage > __instance.CurrentHealth) { ((MonoBehaviour)Plugin.Instance).StartCoroutine(Instance.LeftAlive()); } } } [HarmonyPatch(typeof(CharacterManager), "RequestAreaSwitch")] public class CharacterManager_RequestAreaSwitch { [HarmonyPrefix] public static bool Prefix(CharacterManager __instance, Character _character, Area _areaToSwitchTo, int _longTravelTime, int _spawnPoint, float _offset, string _overrideLocKey) { if (!Instance.IsActiveScenario) { return true; } if (PhotonNetwork.isNonMasterClientInRoom) { return true; } if (_areaToSwitchTo.SceneName == "Levant") { _character.CharacterUI.ShowInfoNotification("You are not welcome here"); return false; } return true; } } private const float GRACE_PERIOD_INGAMETIME = 0.3f; private const string LogSignature_A = "sandbandits.objective.a"; private const string LogSignature_B = "sandbandits.objective.b"; private static QuestEventSignature QE_StartTimer; private Coroutine delayedQuestUpdate; internal static DialogueCharacter levantGuard; public override ScenarioQuest Type => ScenarioQuest.Quest_SandBandit; public override ScenarioType Difficulty => ScenarioType.WIPtest; public override ScenarioPassives Passive => ScenarioPassives.SandBandit; public override AreaEnum SpawnScene => (AreaEnum)307; public override Vector3 SpawnPosition => new Vector3(-53.3f, 0.5f, 55.1f); public override Vector3 SpawnRotation => new Vector3(0f, 227.3f, 0f); public override bool HasQuest => true; public override string QuestName => "Sand Corsair Exile"; public override Dictionary<string, string> QuestLogSignatures => new Dictionary<string, string> { { "sandbandits.objective.a", "You have been exiled from the Sand Corsairs, leave before they turn on you!" }, { "sandbandits.objective.b", "Your grace period is over, Old Levant is no longer your ally." } }; internal static SandBanditScenario Instance { get; private set; } public override void Gear(Character character) { character.Inventory.ReceiveItemReward(9000010, 26, false); character.Inventory.ReceiveItemReward(5100010, 1, true); character.Inventory.ReceiveItemReward(3000087, 1, true); character.Inventory.ReceiveItemReward(3000201, 1, true); character.Inventory.ReceiveItemReward(3000205, 1, true); character.Inventory.ReceiveItemReward(2000110, 1, true); } public SandBanditScenario() { Instance = this; } public override void Init() { base.Init(); QE_StartTimer = CustomQuests.CreateQuestEvent("iggythemad.sandbandits.starttimer", true, false, true, "A_Iggy_AlternateStart", "CustomEvent", "A custom event created with SideLoader"); SL.OnGameplayResumedAfterLoading += SL_OnGameplayResumedAfterLoading; SetupTestCharacter(); } public override void OnScenarioChosen() { VanillaQuestsHelper.SkipHostToFactionChoice(keepHouse: false, complete: true); } public override void OnScenarioChosen(Character character) { } public override void OnStartSpawn() { ChangeCharactersFactions((Factions)2, QuestLogSignatures["sandbandits.objective.a"]); QuestEventManager.Instance.AddEvent(QE_StartTimer, 1); GetOrGiveQuestToHost(); StartDelayedQuestUpdate(); } public override void OnStartSpawn(Character character) { } private void ChangeCharactersFactions(Factions faction, string notifText) { //IL_002c: 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_0035: Unknown result type (might be due to invalid IL or missing references) foreach (string value in CharacterManager.Instance.PlayerCharacters.Values) { Character character = CharacterManager.Instance.GetCharacter(value); if (character.Faction != faction) { character.ChangeFaction(faction, true); if (!string.IsNullOrEmpty(notifText)) { ShowUIMessage(notifText); } } } } private void SL_OnGameplayResumedAfterLoading() { //IL_008e: Unknown result type (might be due to invalid IL or missing references) //IL_0094: Invalid comparison between Unknown and I4 if (PhotonNetwork.isNonMasterClientInRoom || !base.IsActiveScenario) { return; } Character worldHostCharacter = CharacterManager.Instance.GetWorldHostCharacter(); if (((CharacterKnowledge)worldHostCharacter.Inventory.QuestKnowledge).IsItemLearned((int)Type)) { Item itemFromItemID = ((CharacterKnowledge)worldHostCharacter.Inventory.QuestKnowledge).GetItemFromItemID((int)Type); Quest quest = (Quest)(object)((itemFromItemID is Quest) ? itemFromItemID : null); UpdateQuestProgress(quest); } if (SceneManagerHelper.ActiveSceneName == "Abrassar_Dungeon6") { Character[] array = Object.FindObjectsOfType<Character>(); int num = 0; Character[] array2 = array; foreach (Character val in array2) { if (val.Alive && val.IsAI && (int)val.Faction == 2) { num++; } } Instance.ShowUIMessage(num + " former friends left alive."); } else if (SceneManagerHelper.ActiveSceneName == "Levant") { NetworkLevelLoader.Instance.RequestSwitchArea(AreaManager.Instance.GetArea((AreaEnum)301).SceneName, 0, 1.5f, false); } } private void StartDelayedQuestUpdate() { if (delayedQuestUpdate != null) { ((MonoBehaviour)Plugin.Instance).StopCoroutine(delayedQuestUpdate); } delayedQuestUpdate = ((MonoBehaviour)Plugin.Instance).StartCoroutine(UpdateQuestAfterDelay()); } private IEnumerator UpdateQuestAfterDelay() { float eventActiveTimeDelta = QuestEventManager.Instance.GetEventActiveTimeDelta(QE_StartTimer.EventUID); while (eventActiveTimeDelta < 0.3f) { yield return (object)new WaitForSeconds(1f); if (!((Object)(object)QuestEventManager.Instance == (Object)null)) { CharacterManager instance = CharacterManager.Instance; if (!Object.op_Implicit((Object)(object)((instance != null) ? instance.GetWorldHostCharacter() : null))) { yield break; } eventActiveTimeDelta = QuestEventManager.Instance.GetEventActiveTimeDelta(QE_StartTimer.EventUID); continue; } yield break; } CharacterManager instance2 = CharacterManager.Instance; Character val = ((instance2 != null) ? instance2.GetWorldHostCharacter() : null); if (Object.op_Implicit((Object)(object)val)) { if (((CharacterKnowledge)val.Inventory.QuestKnowledge).IsItemLearned((int)Type)) { Item itemFromItemID = ((CharacterKnowledge)val.Inventory.QuestKnowledge).GetItemFromItemID((int)Type); Quest quest = (Quest)(object)((itemFromItemID is Quest) ? itemFromItemID : null); UpdateQuestProgress(quest); } delayedQuestUpdate = null; } } public override void UpdateQuestProgress(Quest quest) { //IL_0033: Unknown result type (might be due to invalid IL or missing references) //IL_005c: Unknown result type (might be due to invalid IL or missing references) if (!PhotonNetwork.isNonMasterClientInRoom && base.IsActiveScenario) { float eventActiveTimeDelta = QuestEventManager.Instance.GetEventActiveTimeDelta(QE_StartTimer.EventUID); QuestProgress questProgress = quest.m_questProgress; questProgress.UpdateLogEntry(questProgress.GetLogSignature(UID.op_Implicit("sandbandits.objective.a")), eventActiveTimeDelta >= 0.3f); if (eventActiveTimeDelta >= 0.3f) { questProgress.UpdateLogEntry(questProgress.GetLogSignature(UID.op_Implicit("sandbandits.objective.b")), displayTime: true); ChangeCharactersFactions((Factions)1, QuestLogSignatures["sandbandits.objective.b"]); questProgress.DisableQuest((ProgressState)3); } else { ChangeCharactersFactions((Factions)2, string.Empty); StartDelayedQuestUpdate(); } } } private IEnumerator LeftAlive() { yield return (object)new WaitForSeconds(0.5f); Character[] array = Object.FindObjectsOfType<Character>(); int num = 0; Character[] array2 = array; foreach (Character val in array2) { if (val.Alive && val.IsAI && (int)val.Faction == 2) { num++; } } Instance.ShowUIMessage(num + " former friends left alive."); if (num > 0) { Instance.ShowUIMessage(num + " former friends left alive."); } } private void SetupTestCharacter() { //IL_0036: Unknown result type (might be due to invalid IL or missing references) //IL_0050: Unknown result type (might be due to invalid IL or missing references) levantGuard = new DialogueCharacter { UID = "levantguard.character", Name = "Levant Guard", SpawnSceneBuildName = "Abrassar", SpawnPosition = new Vector3(-159.4f, 131.8f, -532.7f), SpawnRotation = new Vector3(0f, 43.7f, 0f), HelmetID = 3000115, ChestID = 3000112, BootsID = 3000118, WeaponID = 2130305, StartingPose = (SpellCastType)42 }; SL_Character obj = levantGuard.CreateAndApplyTemplate(); levantGuard.OnSetupDialogueGraph += TestCharacter_OnSetupDialogueGraph; obj.ShouldSpawn = () => base.IsActiveScenario; } private void TestCharacter_OnSetupDialogueGraph(DialogueTree graph, Character character) { //IL_001a: Unknown result type (might be due to invalid IL or missing references) //IL_0024: Expected O, but got Unknown //IL_0042: Unknown result type (might be due to invalid IL or missing references) //IL_004c: Expected O, but got Unknown //IL_0047: Unknown result type (might be due to invalid IL or missing references) //IL_0051: Expected O, but got Unknown //IL_005c: Unknown result type (might be due to invalid IL or missing references) //IL_0066: Expected O, but got Unknown //IL_0061: Unknown result type (might be due to invalid IL or missing references) //IL_006b: Expected O, but got Unknown //IL_0076: Unknown result type (might be due to invalid IL or missing references) //IL_0080: Expected O, but got Unknown //IL_007b: Unknown result type (might be due to invalid IL or missing references) //IL_0085: Expected O, but got Unknown //IL_0092: Unknown result type (might be due to invalid IL or missing references) //IL_009c: Expected O, but got Unknown //IL_00b7: Unknown result type (might be due to invalid IL or missing references) //IL_00c1: Expected O, but got Unknown //IL_00dd: Unknown result type (might be due to invalid IL or missing references) //IL_00e7: Expected O, but got Unknown ActorParameter val = graph.actorParameters[0]; StatementNodeExt val2 = ((Graph)graph).AddNode<StatementNodeExt>(); val2.statement = new Statement("Halt! You are not welcome here, bandit. Go away or I'll make you."); val2.SetActorName(val.name); MultipleChoiceNodeExt val3 = ((Graph)graph).AddNode<MultipleChoiceNodeExt>(); val3.availableChoices.Add(new Choice(new Statement("Why dont you trust me?"))); val3.availableChoices.Add(new Choice(new Statement("I've left the corsairs behind. Let me in."))); val3.availableChoices.Add(new Choice(new Statement("How can I prove my loyalty to the king?"))); StatementNodeExt val4 = ((Graph)graph).AddNode<StatementNodeExt>(); val4.statement = new Statement("We have seen your bunch. Nothing more than soon-to-be-dead outlaws."); val4.SetActorName(val.name); StatementNodeExt val5 = ((Graph)graph).AddNode<StatementNodeExt>(); val5.statement = new Statement("Should we just believe you? Just like that? Piss off, kid. I'm watching you."); val5.SetActorName(val.name); StatementNodeExt val6 = ((Graph)graph).AddNode<StatementNodeExt>(); val6.statement = new Statement("Pfff-You can't be serious... Well I suppose getting rid of your people in the Sand Rose cave could ear you a way in."); val6.SetActorName(val.name); ((Graph)graph).allNodes.Clear(); ((Graph)graph).allNodes.Add((Node)(object)val2); ((Graph)graph).primeNode = (Node)(object)val2; ((Graph)graph).allNodes.Add((Node)(object)val3); ((Graph)graph).allNodes.Add((Node)(object)val4); ((Graph)graph).allNodes.Add((Node)(object)val5); ((Graph)graph).allNodes.Add((Node)(object)val6); ((Graph)graph).ConnectNodes((Node)(object)val2, (Node)(object)val3, -1, -1); ((Graph)graph).ConnectNodes((Node)(object)val3, (Node)(object)val4, 0, -1); ((Graph)graph).ConnectNodes((Node)(object)val4, (Node)(object)val2, -1, -1); ((Graph)graph).ConnectNodes((Node)(object)val3, (Node)(object)val5, 1, -1); ((Graph)graph).ConnectNodes((Node)(object)val5, (Node)(object)val2, -1, -1); ((Graph)graph).ConnectNodes((Node)(object)val3, (Node)(object)val6, 2, -1); ((Graph)graph).ConnectNodes((Node)(object)val6, (Node)(object)val2, -1, -1); } } public abstract class Scenario { public abstract ScenarioQuest Type { get; } public abstract ScenarioType Difficulty { get; } [Obsolete("Not yet implemented.")] public virtual ScenarioTheme Theme { get; } public abstract ScenarioPassives Passive { get; } public abstract AreaEnum SpawnScene { get; } public abstract Vector3 SpawnPosition { get; } public virtual Vector3 SpawnRotation { get { //IL_0000: Unknown result type (might be due to invalid IL or missing references) //IL_0005: Unknown result type (might be due to invalid IL or missing references) //IL_0008: Unknown result type (might be due to invalid IL or missing references) Quaternion identity = Quaternion.identity; return ((Quaternion)(ref identity)).eulerAngles; } } public abstract bool HasQuest { get; } public SL_Quest QuestTemplate { get; private set; } public virtual string QuestName { get; } public virtual Dictionary<string, string> QuestLogSignatures { get; } public QuestEventSignature QE_ScenarioQuestEvent { get; private set; } public string QE_Scenario_UID => "iggythemad.scenarios." + GetType().Name; public bool IsActiveScenario => QuestEventManager.Instance.HasQuestEvent(QE_ScenarioQuestEvent); public virtual void Gear(Character character) { } public virtual void OnStartDestiny() { Debug.Log((object)"OnStartDestiny"); GearManager.StartingGear(); } public abstract void OnStartSpawn(); public abstract void UpdateQuestProgress(Quest quest); public virtual void Init() { SL.OnPacksLoaded += OnPacksLoaded; QE_ScenarioQuestEvent = CustomQuests.CreateQuestEvent(QE_Scenario_UID, false, false, true, "A_Iggy_AlternateStart", "CustomEvent", "A custom event created with SideLoader"); } public virtual void OnPacksLoaded() { if (HasQuest) { PrepareSLQuest(); } } public virtual void OnScenarioChosen() { foreach (string value in CharacterManager.Instance.PlayerCharacters.Values) { Character character = CharacterManager.Instance.GetCharacter(value); OnScenarioChosen(character); } } public virtual void OnScenarioChosen(Character character) { } public virtual void OnStartSpawn(Character character) { } public IEnumerator StartScenario() { QuestEventManager.Instance.AddEvent(ScenarioManager.QE_DestinyChosen, 1); QuestEventManager.Instance.AddEvent(QE_ScenarioQuestEvent, 1); OnScenarioChosen(); foreach (string value in CharacterManager.Instance.PlayerCharacters.Values) { Character character = CharacterManager.Instance.GetCharacter(value); character.AutoKnock(true, Vector3.back, character); OnScenarioChosen(character); } yield return (object)new WaitForSeconds(1f); CharacterManager.Instance.GetWorldHostCharacter(); if (Object.op_Implicit((Object)(object)CharacterManager.Instance.GetFirstLocalCharacter())) { NetworkLevelLoader.Instance.RequestSwitchArea(AreaManager.Instance.GetArea(SpawnScene).SceneName, 0, 1.5f, false); } SL.OnGameplayResumedAfterLoading += OnGameplayResumedAfterScenarioStart; } private void OnGameplayResumedAfterScenarioStart() { //IL_002c: Unknown result type (might be due to invalid IL or missing references) //IL_0033: Unknown result type (might be due to invalid IL or missing references) //IL_0039: Unknown result type (might be due to invalid IL or missing references) //IL_0043: Unknown result type (might be due to invalid IL or missing references) //IL_0049: Unknown result type (might be due to invalid IL or missing references) foreach (string value in CharacterManager.Instance.PlayerCharacters.Values) { Character character = CharacterManager.Instance.GetCharacter(value); if (SpawnPosition != default(Vector3)) { character.Teleport(SpawnPosition, SpawnRotation); } character.SpellCastProcess(29, 0, 0, 0f); OnStartSpawn(character); } OnStartSpawn(); OnStartDestiny(); SL.OnGameplayResumedAfterLoading -= OnGameplayResumedAfterScenarioStart; } private void PrepareSLQuest() { //IL_0001: Unknown result type (might be due to invalid IL or missing references) //IL_0007: Expected O, but got Unknown //IL_003f: Unknown result type (might be due to invalid IL or missing references) //IL_0045: Expected O, but got Unknown //IL_006d: Unknown result type (might be due to invalid IL or missing references) //IL_0072: Unknown result type (might be due to invalid IL or missing references) //IL_007f: Unknown result type (might be due to invalid IL or missing references) //IL_008c: Unknown result type (might be due to invalid IL or missing references) //IL_008e: Unknown result type (might be due to invalid IL or missing references) //IL_0098: Expected O, but got Unknown SL_Quest val = new SL_Quest(); ((SL_Item)val).Target_ItemID = 7011620; ((SL_Item)val).New_ItemID = (int)Type; ((SL_Item)val).Name = QuestName; val.IsSideQuest = false; ((SL_Item)val).ItemExtensions = (SL_ItemExtension[])(object)new SL_ItemExtension[1] { (SL_ItemExtension)new SL_QuestProgress() }; QuestTemplate = val; List<SL_QuestLogEntrySignature> list = new List<SL_QuestLogEntrySignature>(); foreach (KeyValuePair<string, string> questLogSignature in QuestLogSignatures) { list.Add(new SL_QuestLogEntrySignature { UID = questLogSignature.Key, Text = questLogSignature.Value, Type = (QuestLogEntrySignatureType)0 }); } SL_ItemExtension obj = ((SL_Item)QuestTemplate).ItemExtensions[0]; ((SL_QuestProgress)((obj is SL_QuestProgress) ? obj : null)).LogSignatures = list.ToArray(); ((ContentTemplate)QuestTemplate).ApplyTemplate(); QuestTemplate.OnQuestLoaded += UpdateQuestProgress; } public Quest GetOrGiveQuestToHost() { //IL_0088: Unknown result type (might be due to invalid IL or missing references) Character worldHostCharacter = CharacterManager.Instance.GetWorldHostCharacter(); if (((CharacterKnowledge)worldHostCharacter.Inventory.QuestKnowledge).IsItemLearned((int)Type)) { Item itemFromItemID = ((CharacterKnowledge)worldHostCharacter.Inventory.QuestKnowledge).GetItemFromItemID((int)Type); return (Quest)(object)((itemFromItemID is Quest) ? itemFromItemID : null); } Item obj = ItemManager.Instance.GenerateItemNetwork((int)Type); Quest val = (Quest)(object)((obj is Quest) ? obj : null); ((Component)val).transform.SetParent(((Component)worldHostCharacter.Inventory.QuestKnow

using System; using System.Collections; using System.Collections.Generic; using System.Diagnostics; using System.Linq; using System.Reflection; using System.Runtime.CompilerServices; using System.Runtime.InteropServices; using System.Runtime.Versioning; using System.Security; using System.Security.Permissions; using BepInEx; using BepInEx.Configuration; using HarmonyLib; using SideLoader; using UnityEngine; [assembly: CompilationRelaxations(8)] [assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)] [assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)] [assembly: AssemblyTitle("HardcoreRebalance")] [assembly: AssemblyDescription("")] [assembly: AssemblyConfiguration("")] [assembly: AssemblyCompany("")] [assembly: AssemblyProduct("HardcoreRebalance")] [assembly: AssemblyCopyright("Copyright © 2021")] [assembly: AssemblyTrademark("")] [assembly: ComVisible(false)] [assembly: Guid("42fa9a70-4056-4212-8387-b19532e9b8ae")] [assembly: AssemblyFileVersion("1.0.0.0")] [assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")] [assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)] [assembly: AssemblyVersion("1.0.0.0")] [module: UnverifiableCode] namespace HardcoreRebalance; internal class ContentTweks { [HarmonyPatch(typeof(InteractionTriggerBase), "TryActivateBasicAction", new Type[] { typeof(Character), typeof(int) })] public class InteractionTriggerBase_TryActivateBasicAction { [HarmonyPrefix] public static bool Prefix(InteractionTriggerBase __instance, Character _character, int _toggleState) { //IL_0046: Unknown result type (might be due to invalid IL or missing references) //IL_004b: Unknown result type (might be due to invalid IL or missing references) if (!Object.op_Implicit((Object)(object)_character) || !_character.IsLocalPlayer) { return true; } EventActivator currentTriggerManager = __instance.CurrentTriggerManager; if (Object.op_Implicit((Object)(object)((currentTriggerManager is InteractionActivator) ? currentTriggerManager : null))) { EventActivator currentTriggerManager2 = __instance.CurrentTriggerManager; InteractionActivator val = (InteractionActivator)(object)((currentTriggerManager2 is InteractionActivator) ? currentTriggerManager2 : null); if (val.BasicInteraction != null && val.BasicInteraction is InteractionToggleContraption && Vector3.Distance(_character.CenterPosition, CabalLeverPos) < leverDist) { _character.CharacterUI.ShowInfoNotification("The lever is stuck..."); return false; } } return true; } } private static Vector3 CabalLeverPos = new Vector3(-1.6f, 12.5f, 44f); private static float leverDist = 2f; } public static class CraftingLimits { [HarmonyPatch(typeof(CraftingMenu), "TryCraft")] public class CraftingMenu_TryCraft { [HarmonyPrefix] public static bool Prefix(CraftingMenu __instance) { if ((Object)(object)((__instance != null) ? ((UIElement)__instance).LocalCharacter : null) != (Object)null && ((UIElement)__instance).LocalCharacter.IsLocalPlayer) { bool flag = false; if (Object.op_Implicit((Object)(object)((ItemDisplay)__instance.m_recipeResultDisplay).RefItem) || !HardcoreRebalanceBase.CraftLimitsStored) { return true; } if (__instance.m_ingredientSelectors.Length <= 1) { flag = true; } else { int num = 0; for (int i = 0; i < __instance.m_ingredientSelectors.Length; i++) { IngredientSelector obj = __instance.m_ingredientSelectors[i]; if (obj == null) { continue; } CompatibleIngredient assignedIngredient = obj.AssignedIngredient; if (assignedIngredient == null) { continue; } _ = assignedIngredient.ItemID; if (true) { num++; if (ExceptionIDs.CraftExceptions.Values.Contains(__instance.m_ingredientSelectors[i].AssignedIngredient.ItemID) || __instance.m_ingredientSelectors[i].AssignedIngredient.ItemPrefab.Name.Contains("Lantern") || __instance.m_ingredientSelectors[i].AssignedIngredient.ItemPrefab.Name.Contains("Tsar")) { flag = true; break; } } } if (num == 1) { flag = true; } } if (flag) { return true; } int num2 = ((__instance.m_lastRecipeIndex != -1) ? __instance.m_complexeRecipes[__instance.m_lastRecipeIndex].Key : __instance.m_lastFreeRecipeIndex); if (num2 != -1) { int num3 = 0; while (true) { int num4 = num3; Recipe obj2 = __instance.m_allRecipes[num2]; if (!(num4 < ((obj2 == null) ? null : obj2.Results?.Length))) { break; } ItemReferenceQuantity obj3 = __instance.m_allRecipes[num2].Results[num3]; if (obj3 != null && obj3.ItemID < -1) { Debug.Log((object)("itemID: " + __instance.m_allRecipes[num2].Results[num3].ItemID)); ((UIElement)__instance).LocalCharacter.CharacterUI.ShowInfoNotification("Mod craft allowed."); return true; } num3++; } } ((UIElement)__instance).LocalCharacter.CharacterUI.ShowInfoNotification("No recipe known..."); return false; } return true; } } internal static void Awake() { SL.OnGameplayResumedAfterLoading += StartingRecipe; } private static void StartingRecipe() { foreach (PlayerSystem item in Global.Lobby.PlayersInLobby) { if (!item.IsLocalPlayer) { continue; } foreach (string value2 in ExceptionIDs.StartingRecipees.Values) { if (!item.ControlledCharacter.Inventory.RecipeKnowledge.IsRecipeLearned(value2)) { RecipeManager.Instance.m_recipes.TryGetValue(value2, out var value); item.ControlledCharacter.Inventory.RecipeKnowledge.LearnRecipe(value); } } } SL.OnGameplayResumedAfterLoading -= StartingRecipe; } } internal static class DeathMortality { [HarmonyPatch(typeof(DefeatScenariosManager), "OnAllPlayersDefeated")] public class DefeatScenariosManager_OnAllPlayersDefeated { [HarmonyPrefix] public static void Prefix(DefeatScenariosManager __instance) { if (!CharacterManager.Instance.GetFirstLocalCharacter().IsWorldHost) { return; } foreach (Character value in CharacterManager.Instance.Characters.Values) { if (value.IsAI && value.Stats.CurrentHealth > 0f) { value.Stats.AffectHealth(value.Stats.MaxHealth * HardcoreBalance.deathEnemyHealMult); } } Item itemPrefab = ResourcesPrefabManager.Instance.GetItemPrefab(-2057); foreach (PlayerSystem item in Global.Lobby.PlayersInLobby) { Character controlledCharacter = item.ControlledCharacter; int num = 0; int num2 = Random.Range(1, 11); num = (controlledCharacter.HardcoreMode ? ((num2 <= 4) ? 1 : ((num2 <= 9) ? 2 : 3)) : ((num2 <= 7) ? 1 : ((num2 <= 9) ? 2 : 3))); controlledCharacter.Inventory.GenerateItem(itemPrefab, num, false); foreach (Item ownedItem in controlledCharacter.Inventory.GetOwnedItems(-2057)) { controlledCharacter.Inventory.TakeItemToPouch(ownedItem); } ((MonoBehaviour)HardcoreRebalanceBase.Instance).StartCoroutine(MoveToPouch(controlledCharacter)); int num3 = Random.Range(500, 2500); controlledCharacter.Inventory.OnCharacterReceivedHit((float)num3, false); } } } [HarmonyPatch(typeof(CharacterUI), "ShowMenu", new Type[] { typeof(MenuScreens) })] public class CharacterUI_ShowMenu { [HarmonyPrefix] public static void Prefix(CharacterUI __instance, MenuScreens _menu) { Character targetCharacter = __instance.TargetCharacter; if (!((Object)(object)targetCharacter == (Object)null) && targetCharacter.IsLocalPlayer) { CheckMortality(); } } } private static bool reviver; public static List<Character> allPlayers; private static int onlinePlayersNo; internal static void Awake() { SL.OnGameplayResumedAfterLoading += Fixer; } private static void Fixer() { Debug.Log((object)"CHECKING MORTALITY----"); CheckMortality(); } private static void CheckMortality() { foreach (PlayerSystem item in Global.Lobby.PlayersInLobby) { Character controlledCharacter = item.ControlledCharacter; if (!controlledCharacter.IsLocalPlayer || !controlledCharacter.Inventory.OwnsItem(-2057)) { continue; } int num = controlledCharacter.Inventory.ItemCount(-2057); for (int i = 0; i < num; i++) { controlledCharacter.StatusEffectMngr.AddStatusEffect(HardcoreEffects.Mortality.ToString()); } controlledCharacter.Inventory.RemoveItem(-2057, num); bool flag = false; foreach (Blessings value in Enum.GetValues(typeof(Blessings))) { if (((CharacterKnowledge)controlledCharacter.Inventory.SkillKnowledge).IsItemLearned((int)value)) { Item itemFromItemID = ((CharacterKnowledge)controlledCharacter.Inventory.SkillKnowledge).GetItemFromItemID((int)value); ItemManager.Instance.DestroyItem(itemFromItemID); ((CharacterKnowledge)controlledCharacter.Inventory.SkillKnowledge).RemoveItem(itemFromItemID); flag = true; } } if (flag) { controlledCharacter.CharacterUI.ShowInfoNotification("Blessings lost"); } } } private static IEnumerator MoveToPouch(Character xplayer) { yield return (object)new WaitForSeconds(0.1f); foreach (Item ownedItem in xplayer.Inventory.GetOwnedItems(-2057)) { xplayer.Inventory.TakeItemToPouch(ownedItem); } } public static void GetNewScenario(DefeatScenariosManager defeatManager) { DefeatScenario val = defeatManager.m_scerariosContainer.ChooseScenario(); defeatManager.ForceDefeat(val); } } public static class ExceptionIDs { private const string CRYSTAL_POWDER_RECIPE_UID = "-SEtMHRqWUmvrmyvryV8Ng"; public static readonly Dictionary<string, string> StartingRecipees; public static readonly Dictionary<string, int> CraftExceptions; static ExceptionIDs() { StartingRecipees = new Dictionary<string, string> { ["Crystal Powder"] = "-SEtMHRqWUmvrmyvryV8Ng", ["Trinket of Elatt"] = "com.iggy.trinketrecipe", ["Flint and Steel"] = "com.dub.flintandsteelrecipe", ["Makeshift Hatchet"] = "com.dub.makeshifthatchetrecipe", ["Makeshift Mining Pick"] = "com.dub.makeshiftminingpickrecipe", ["Makeshift Fishing Harpoon"] = "com.dub.fishingharpoonrecipe", ["Elixir of Memory Echoes"] = "4300192", ["Sugar"] = "OE10NFgta0ulLYZCrcChnw", ["Salt Water"] = "saltwater-recipe", ["Racid Water clear"] = "c9nZOQ_BmUaFBmB7xEadnQ", ["River Water clear"] = "SK6LKVhmx0CFs1-uwKJvaA", ["charcoal"] = "com.dub.charcoal", ["Healing Poultice"] = "com.dub.healingpoultice", ["First Aid Tools"] = "com.dub.Firstaidtools", ["Soaked Bandages"] = "com.dub.SoakedBandages", ["Camping Gear"] = "com.dub.campinggear", ["Crafting Influence"] = "com.dub.influencerecipe", ["Crafting Fletching Feathers"] = "com.dub.fletchingfeathers" }; CraftExceptions = new Dictionary<string, int> { ["Explorer Lantern"] = 5100000, ["Old Lantern"] = 5100010, ["Glowstone Lantern"] = 5100020, ["Firefly Lantern"] = 5100030, ["Lantern of Souls"] = 5100080, ["Coil Lantern"] = 5100090, ["Virgin Lantern"] = 5100100, ["Djinn’s Lamp"] = 5100110, ["Calixa’s Relic"] = 6600225, ["Elatt’s Relic"] = 6600222, ["Gep’s Generosity"] = 6600220, ["Haunted Memory"] = 6600224, ["Leyline Figment"] = 6600226, ["Pearlbird’s Courage"] = 6600221, ["Scourge’s Tears"] = 6600223, ["Vendavel's Hospitality"] = 6600227, ["Flowering Corruption"] = 6600228, ["Metalized Bones"] = 6600230, ["Enchanted Mask"] = 6600229, ["Noble’s Greed"] = 6600232, ["Scarlet Whisper"] = 6600231, ["Calygrey’s Wisdom"] = 6600233, ["Hailfrost Claymore"] = 2100270, ["Hailfrost Mace"] = 2020290, ["Hailfrost Hammer"] = 2120240, ["Hailfrost Axe"] = 2010250, ["Hailfrost Greataxe"] = 2110230, ["Hailfrost Spear"] = 2130280, ["Hailfrost Halberd"] = 2150110, ["Hailfrost Pistol"] = 5110270, ["Hailfrost Knuckles"] = 2160200, ["Hailfrost Sword"] = 2000280, ["Hailfrost Dagger"] = 5110015, ["Mysterious Blade"] = 2000320, ["Mysterious Long Blade"] = 2100300, ["Ceremonial Bow"] = 2200190, ["Cracked Red Moon"] = 2150180, ["Compasswood Staff"] = 2150030, ["Scarred Dagger"] = 5110340, ["De-powered Bludgeon"] = 2120270, ["Unusual Knuckles"] = 2160230, ["Strange Rusted Sword"] = 2000151 }; } } public static class NightGates { [HarmonyPatch(typeof(CharacterManager), "RequestAreaSwitch")] public class CharacterManager_RequestAreaSwitch { [HarmonyPrefix] public static bool Prefix(CharacterManager __instance, Character _character, Area _areaToSwitchTo, int _longTravelTime, int _spawnPoint, float _offset, string _overrideLocKey) { if (!HardcoreRebalanceBase.NightGatesStored) { return true; } Debug.Log((object)("Time is: " + EnvironmentConditions.Instance.TimeOfDay)); if (EnvironmentConditions.Instance.TimeOfDay > 20f || EnvironmentConditions.Instance.TimeOfDay < 4f) { if ((_areaToSwitchTo.SceneName == "CierzoNewTerrain" && SceneManagerHelper.ActiveSceneName == "ChersoneseNewTerrain") || (_areaToSwitchTo.SceneName == "Berg" && SceneManagerHelper.ActiveSceneName == "Emercar")) { return GetBribeStage(_character, 25); } if (_areaToSwitchTo.SceneName == "Levant" && SceneManagerHelper.ActiveSceneName == "Abrassar") { return GetBribeStage(_character, 35); } if (_areaToSwitchTo.SceneName == "Harmattan" && SceneManagerHelper.ActiveSceneName == "AntiqueField") { return GetBribeStage(_character, 30); } if (!(_areaToSwitchTo.SceneName == "Monsoon") || !(SceneManagerHelper.ActiveSceneName == "HallowedMarshNewTerrain")) { return true; } return GetBribeStage(_character, 20, isBoat: true); } return true; } } private static int BribeAttempt; private static Coroutine bribeCO; private static bool GetBribeStage(Character _character, int bribeCost, bool isBoat = false) { if (BribeAttempt == 0) { if (isBoat) { _character.CharacterUI.ShowInfoNotification("No sailing at night...unless..."); } else { _character.CharacterUI.ShowInfoNotification("Gates are closed at night...unless..."); } } else if (BribeAttempt == 1) { if (isBoat) { _character.CharacterUI.ShowInfoNotification("Convince boatman for " + bribeCost + " silver?"); } else { _character.CharacterUI.ShowInfoNotification("Bribe guard for " + bribeCost + " silver?"); } } else if (BribeAttempt == 2) { if (isBoat) { _character.CharacterUI.ShowInfoNotification("Wanna pay? Convince boatman for " + bribeCost + " silver?"); } else { _character.CharacterUI.ShowInfoNotification("Wanna pay? Bribe guard for " + bribeCost + " silver?"); } } if (bribeCO != null) { ((MonoBehaviour)HardcoreRebalanceBase.Instance).StopCoroutine(bribeCO); bribeCO = null; } bribeCO = ((MonoBehaviour)HardcoreRebalanceBase.Instance).StartCoroutine(resetBribe()); if (BribeAttempt == 3) { BribeAttempt = 0; if (_character.Inventory.AvailableMoney > bribeCost) { _character.Inventory.RemoveMoney(bribeCost, false); return true; } _character.CharacterUI.ShowInfoNotification("Not enough silver..."); _character.Knock(true); return false; } if (BribeAttempt < 3) { BribeAttempt++; } return false; } private static IEnumerator resetBribe() { yield return (object)new WaitForSeconds(5f); BribeAttempt = 0; } } internal class Tester { } public enum HardcoreItems { ElattCleanse = -2051, ElattTrinket = -2052, ElattPiece = -2053, MortalAdd = -2057 } public enum Blessings { BlessingWisdom = -2054, BlessingPower = -2055, BlessingCourage = -2056, BlessingDetermination = -59000, BlessingInfluence = -59001, BlessingTolerance = -59002 } public enum HardcoreEffects { EnemyHealing, Mortality, CombatEquiping, TrapAware } public static class HardcoreBalance { public static int trinketDropChance = 1; public static float deathEnemyHealMult = 0.6f; public static int flintBreakChance = 30; public static float reviveTimer = 4f; public static float timeToEquip = 2f; } public static class EventsManager { [HarmonyPatch(typeof(NetworkLevelLoader), "UnPauseGameplay")] public class NetworkLevelLoader_UnPauseGameplay { [HarmonyPostfix] public static void Postfix(NetworkLevelLoader __instance, string _identifier) { if (HardcoreRebalanceBase.PerCityStashStored) { _cachedStash = null; } } } [HarmonyReversePatch(/*Could not decode attribute arguments.*/)] [HarmonyPatch(typeof(ItemContainer), "ShowContent")] public class ItemContainer_ShowContent { [HarmonyReversePatch(/*Could not decode attribute arguments.*/)] public static void Reversefix(ItemContainer __instance, Character _character) { } } [HarmonyPatch(typeof(TreasureChest), "ShowContent")] public class TreasureChest_ShowContent { [HarmonyPrefix] public static bool Prefix(TreasureChest __instance, Character _character) { //IL_000a: Unknown result type (might be due to invalid IL or missing references) //IL_0010: Invalid comparison between Unknown and I4 if (!HardcoreRebalanceBase.PerCityStashStored) { return true; } if ((int)((ItemContainer)__instance).SpecialType == 4 && TryGetStash(_character, out var stash)) { _character.CharacterUI.StashPanel.SetStash(stash); } ItemContainer_ShowContent.Reversefix((ItemContainer)(object)__instance, _character); return false; } } [HarmonyPatch(typeof(TreasureChest), "InitDrops")] public class TreasureChest_InitDrops { [HarmonyPostfix] public static void Postfix(TreasureChest __instance) { //IL_0009: Unknown result type (might be due to invalid IL or missing references) if (HardcoreRebalanceBase.PerCityStashStored) { _ = ((ItemContainer)__instance).SpecialType; _ = 4; } } } [HarmonyPatch(typeof(CharacterKnowledge), "AddItem")] public class CharacterKnowledge_AddItem { [HarmonyPostfix] public static void Postfix(CharacterKnowledge __instance, Item _item, ref Character ___m_character) { Character val = ___m_character; if ((Object)(object)val != (Object)null && val.IsLocalPlayer && _item.ItemID == -2051) { int num = 4; if (val.HardcoreMode) { num = 2; } val.StatusEffectMngr.ReduceStatusLevel(HardcoreEffects.Mortality.ToString(), num); ItemManager.Instance.DestroyItem(_item.UID); ((CharacterKnowledge)val.Inventory.SkillKnowledge).RemoveItem(_item); } } } [HarmonyPatch(typeof(Item), "Use", new Type[] { typeof(Character) })] public class Item_Usage { [HarmonyPrefix] public static bool Prefix(Item __instance, Character _character) { if (!_character.IsLocalPlayer) { return true; } if (__instance.ItemID == -2052) { int num = 10; _character.StatusEffectMngr.ReduceStatusLevel(HardcoreEffects.Mortality.ToString(), num); _character.Inventory.RemoveItem(-2052, 1); _character.SpellCastAnim((SpellCastType)25, (SpellCastModifier)0, 0); } return true; } } [HarmonyPatch(typeof(BasicDeployable), "TryDeploying", new Type[] { typeof(Character) })] public class BasicDeployable_TryDeploying { [HarmonyPrefix] public static bool Prefix(BasicDeployable __instance, Character _usingCharacter) { //IL_002c: Unknown result type (might be due to invalid IL or missing references) //IL_0037: Unknown result type (might be due to invalid IL or missing references) if ((Object)(object)_usingCharacter == (Object)null || !_usingCharacter.IsLocalPlayer) { return true; } if (AreaManager.Instance.GetIsCurrentAreaTownOrCity() && ((ItemExtension)__instance).Item.IsSleepKit) { float num = Vector3.Distance(levantSlums, ((Component)_usingCharacter).transform.position); if (SceneManagerHelper.ActiveSceneName == "Levant" && num < 30f) { return true; } _usingCharacter.CharacterUI.ShowInfoNotification("Vagrancy is not allowed"); return false; } return true; } } private enum CampingActivities { None = 0, Sleep = 2, Guard = 4, Repair = 8 } [HarmonyPatch(typeof(RestingMenu), "Show")] public class RestingMenu_Show { [HarmonyPrefix] public static void Prefix(RestingMenu __instance) { //IL_002b: Unknown result type (might be due to invalid IL or missing references) //IL_0031: Expected O, but got Unknown if (!HardcoreRebalanceBase.CampingGuardStored) { return; } Debug.Log((object)"Showing Menu----"); foreach (Transform item in ((Component)__instance.m_restingActivitiesHolder).transform) { Transform val = item; CampingActivities[] array = new CampingActivities[3] { CampingActivities.Sleep, CampingActivities.Guard, CampingActivities.Repair }; for (int i = 0; i < array.Length; i++) { _ = array[i]; if (((Object)((Component)val).gameObject).name.Contains(CampingActivities.Guard.ToString())) { ((Component)val).gameObject.SetActive(false); } } } Debug.Log((object)"Disabling Guard----"); } } [HarmonyPatch(typeof(Item), "OnUse")] public class Item_OnUse { [HarmonyPostfix] public static void Postfix(Item __instance, Character _targetChar) { if (__instance.ItemID == 5600010 && ((EffectSynchronizer)__instance).OwnerCharacter.IsLocalPlayer && Random.Range(1, 101) <= HardcoreBalance.flintBreakChance) { __instance.RemoveQuantity(1); __instance.m_ownerCharacter.CharacterUI.ShowInfoNotification("Flint and Steel broke on use."); } } } [HarmonyPatch(typeof(Character), "UpdateReviveInteraction")] public class Character_UpdateReviveInteraction { [HarmonyPostfix] public static void Prefix(Character __instance) { if (!((Object)(object)__instance == (Object)null)) { Transform val = ((Component)__instance).transform.Find("ReviveInteraction"); if ((Object)(object)val != (Object)null) { ((InteractionBase)((Component)val).GetComponent<InteractionRevive>()).HoldActivationTime = HardcoreBalance.reviveTimer; } } } } [HarmonyPatch(typeof(DefeatCoinLost), "Activate")] public class DefeatCoinLost_Activate { [HarmonyPrefix] public static void Prefix(DefeatCoinLost __instance, Character _affectedCharacter, ref int ___m_minLostCoins, ref int ___m_maxLostCoins, ref int ___m_minPercentLost, ref int ___m_maxPerentLost) { if ((Object)(object)_affectedCharacter != (Object)null && _affectedCharacter.IsLocalPlayer) { Debug.Log((object)"lossing COINS"); ___m_minLostCoins = 50; ___m_maxLostCoins = 500; ___m_minPercentLost = 30; ___m_maxPerentLost = 90; } } } [HarmonyPatch(typeof(DefeatDamageEquipment), "Activate")] public class DefeatDamageEquipment_Activate { [HarmonyPrefix] public static void Prefix(DefeatDamageEquipment __instance, Character _affectedCharacter, ref int ___m_minDamage, ref int ___m_maxDamage) { if ((Object)(object)_affectedCharacter != (Object)null && _affectedCharacter.IsLocalPlayer) { Debug.Log((object)"breaking ARMOR"); ___m_minDamage = 100; ___m_maxDamage = 800; } } } [HarmonyPatch(typeof(CharacterEquipment), "RepairEquipment")] public class CharacterEquipmen_RepairEquipment { [HarmonyPrefix] public static void Prefix(CharacterEquipment __instance, bool _forceRepair, ref EquipmentSlot[] ___m_equipmentSlots) { if (__instance.m_character.IsLocalPlayer && ___m_equipmentSlots != null) { EquipmentSlot[] array = ___m_equipmentSlots; foreach (EquipmentSlot val in array) { if ((Object)(object)val != (Object)null && (Object)(object)val.EquippedItem != (Object)null && val.HasItemEquipped) { Debug.Log((object)("SHOULD REPAIR: " + val.SlotName)); ((Item)val.EquippedItem).RepairedInRest = true; } } } else { Debug.Log((object)"HARD ERROR ---------------"); } } } [HarmonyPatch(typeof(CharacterEquipment), "RepairEquipmentAfterRest")] public class CharacterEquipmen_RepairEquipmentAfterRest { [HarmonyPrefix] public static void Prefix(CharacterEquipment __instance, ref EquipmentSlot[] ___m_equipmentSlots) { if (__instance.m_character.IsLocalPlayer && ___m_equipmentSlots != null) { EquipmentSlot[] array = ___m_equipmentSlots; foreach (EquipmentSlot val in array) { if ((Object)(object)val != (Object)null && (Object)(object)val.EquippedItem != (Object)null && val.HasItemEquipped && ((Item)val.EquippedItem).CurrentDurability <= 0f) { ((Item)val.EquippedItem).RepairedInRest = false; Debug.Log((object)("BROKEN ITEM: " + val.SlotName)); } } } else { Debug.Log((object)"HARD ERROR ---------------"); } } } [HarmonyPatch(typeof(ItemDropper), "GenerateItem")] public class ItemDropper_GenerateItem { [HarmonyPrefix] public static void Prefix(ItemDropper __instance, ItemContainer _container, BasicItemDrop _itemDrop, int _spawnAmount) { if ((Object)(object)player != (Object)null && player.IsWorldHost && Random.Range(1, 200) <= HardcoreBalance.trinketDropChance) { ItemManager.Instance.GenerateItemNetwork(-2053).ChangeParent(((Component)_container).transform); } } } public static AreaManager areaManager; public static Character player; private static bool reviver = false; public static List<Character> allPlayers; private static int onlinePlayersNo; private static List<Character> oversleptPlayers; private static List<Character> wellPlayers; private static Vector3 levantSlums = new Vector3(-160f, 4.4f, 66f); private static int minAmbush = 20; private static bool startStash; private static readonly Dictionary<AreaEnum, (string UID, Vector3[] Positions)> CityStashData = new Dictionary<AreaEnum, (string, Vector3[])> { [(AreaEnum)100] = ("ImqRiGAT80aE2WtUHfdcMw", (Vector3[])(object)new Vector3[2] { new Vector3(-367.85f, -1488.25f, 596.277f), new Vector3(-373.539f, -1488.25f, 583.187f) }), [(AreaEnum)500] = ("ImqRiGAT80aE2WtUHfdcMw", (Vector3[])(object)new Vector3[2] { new Vector3(-386.62f, -1493.132f, 773.86f), new Vector3(-372.41f, -1493.132f, 773.86f) }), [(AreaEnum)200] = ("ImqRiGAT80aE2WtUHfdcMw", (Vector3[])(object)new Vector3[1] { new Vector3(-371.628f, -1493.41f, 569.91f) }), [(AreaEnum)300] = ("ZbPXNsPvlUeQVJRks3zBzg", (Vector3[])(object)new Vector3[2] { new Vector3(-369.28f, -1502.535f, 592.85f), new Vector3(-380.53f, -1502.535f, 593.08f) }), [(AreaEnum)400] = ("ImqRiGAT80aE2WtUHfdcMw", (Vector3[])(object)new Vector3[4] { new Vector3(-178.672f, -1515.915f, 597.934f), new Vector3(-182.373f, -1515.915f, 606.291f), new Vector3(-383.484f, -1504.82f, 583.343f), new Vector3(-392.681f, -1504.82f, 586.551f) }), [(AreaEnum)601] = ("IqUugGqBBkaOcQdRmhnMng", (Vector3[])(object)new Vector3[0]) }; private static ItemContainer _cachedStash; internal static void Awake() { SL.OnGameplayResumedAfterLoading += startItemsKill; allPlayers = new List<Character>(); oversleptPlayers = new List<Character>(); wellPlayers = new List<Character>(); } private static void startItemsKill() { SL.OnGameplayResumedAfterLoading -= startItemsKill; if (!PhotonNetwork.isNonMasterClientInRoom && !startStash) { startStash = true; QuestEventManager.Instance.AddEvent(QuestEventDictionary.GetQuestEvent("dlMPJtXDWU6R1YEfsezlSA"), 1); QuestEventManager.Instance.AddEvent(QuestEventDictionary.GetQuestEvent("ypT9_eYB6UK2gnAaqJVA3g"), 1); QuestEventManager.Instance.AddEvent(QuestEventDictionary.GetQuestEvent("EEdVb-dL10qjF70lw0UZKw"), 1); QuestEventManager.Instance.AddEvent(QuestEventDictionary.GetQuestEvent("1iyLYN6eXUCQY9ZjD0kd1w"), 1); QuestEventManager.Instance.AddEvent(QuestEventDictionary.GetQuestEvent("Q-U-VKV68Uezx3jM4ZB8Jg"), 1); QuestEventManager.Instance.AddEvent(QuestEventDictionary.GetQuestEvent("_P9lL0G5RUOfVC4ydwa1kQ"), 1); } } public static bool TryGetStash(Character character, out ItemContainer stash) { //IL_0046: Unknown result type (might be due to invalid IL or missing references) //IL_0050: Expected O, but got Unknown if ((Object)(object)_cachedStash == (Object)null && AreaManager.Instance.CurrentArea != null && CityStashData.TryGetValue((AreaEnum)AreaManager.Instance.CurrentArea.ID, out (string, Vector3[]) value)) { _cachedStash = (ItemContainer)(TreasureChest)ItemManager.Instance.GetItem(value.Item1); } stash = _cachedStash; return (Object)(object)stash != (Object)null; } } public static class AIManager { [HarmonyPatch(typeof(Character), "UpdateStability")] public class Character_UpdateStability { [HarmonyPrefix] public static bool Prefix(Character __instance) { if (!__instance.IsLocalPlayer) { return true; } if (__instance.Blocking) { return false; } return true; } } [HarmonyPatch(typeof(Character), "OnReceiveHit")] public class Character_OnReceiveHit { [HarmonyPrefix] public static void Prefix(Character __instance, Weapon _weapon, float _damage, DamageList _damageList, Vector3 _hitDir, Vector3 _hitPoint, float _angle, float _angleDir, Character _dealerChar, float _knockBack) { //IL_00e1: Unknown result type (might be due to invalid IL or missing references) //IL_00ec: Unknown result type (might be due to invalid IL or missing references) if (!HardcoreRebalanceBase.EnemyHealingStored || !player.IsWorldHost || (Object)(object)_dealerChar == (Object)null) { return; } if (!__instance.IsAI && _dealerChar.IsAI && _knockBack > 1f) { _dealerChar.StatusEffectMngr.AddStatusEffect(HardcoreEffects.EnemyHealing.ToString()); } else if (__instance.IsAI && !_dealerChar.IsAI && _knockBack > 1f) { if (__instance.StatusEffectMngr.HasStatusEffect(HardcoreEffects.EnemyHealing.ToString())) { __instance.StatusEffectMngr.RemoveStatusWithIdentifierName(HardcoreEffects.EnemyHealing.ToString()); } } else { if (!__instance.IsAI || !_dealerChar.IsAI) { return; } foreach (PlayerSystem item in Global.Lobby.PlayersInLobby) { Character controlledCharacter = item.ControlledCharacter; if (Vector3.Distance(((Component)__instance).transform.position, ((Component)controlledCharacter).transform.position) < botDmgRange) { _damage *= botDmgMult; return; } } _damage = 0f; } } } [HarmonyPatch(typeof(Character), "StabilityHit")] public class Character_StabilityHit { [HarmonyPrefix] public static void Prefix(Character __instance, ref float _knockValue, float _angle, bool _block, Character _dealerChar) { if (Object.op_Implicit((Object)(object)__instance) && Object.op_Implicit((Object)(object)_dealerChar) && __instance.Blocking) { if (__instance.IsLocalPlayer) { _knockValue *= 1.4f; } else if (__instance.IsAI) { _knockValue *= 1.2f; } } } } [HarmonyPatch(typeof(Character), "StabilityHit")] public class Character_StabilityHitPost { [HarmonyPostfix] public static void Postfix(Character __instance, ref float _knockValue, float _angle, bool _block, Character _dealerChar) { if (Object.op_Implicit((Object)(object)__instance) && Object.op_Implicit((Object)(object)_dealerChar) && __instance.Blocking) { if (__instance.IsAI) { _dealerChar.StabilityHit(_knockValue / 2f, _angle * -1f, false, (Character)null); } if (__instance.IsLocalPlayer) { _dealerChar.StabilityHit(_knockValue / 3f, _angle * -1f, false, (Character)null); } } } } [HarmonyPatch(typeof(CharacterStats), "UseMana")] public class Character_UseMana { [HarmonyPostfix] public static void Postfix(CharacterStats __instance, Tag[] _tags, ref float _amount, ref Character ___m_character) { if (___m_character.IsLocalPlayer) { drainStability(___m_character, _amount, isMana: true); } } } [HarmonyPatch(typeof(AIPreset), "ApplyToCharAI")] private class AIFix { [HarmonyPostfix] public static void Postfix(CharacterAI _charAI) { if ((Object)(object)player != (Object)null && HardcoreRebalanceBase.EnhancedAIStored) { Debug.Log((object)"APPLYING Enhanced AI--------------"); AICEnemyDetection[] componentsInChildren = ((Component)_charAI).GetComponentsInChildren<AICEnemyDetection>(true); foreach (AICEnemyDetection obj in componentsInChildren) { obj.GoodViewAngle = goodViewAngle; obj.ViewAngle = viewAngle; obj.LowViewRange = lowViewRange; obj.ViewRange = viewRange; obj.ViewVisDetect = viewVisDetect; obj.HearingDetect = hearingDetect; obj.HearingDetectRange = hearingDetectRange; obj.HearingCanDetect = true; obj.SuspiciousMult = suspiciousMult; obj.SuspiciousDelay = suspiciousDelay; } } } } private static Character player; private static Character[] players; private static List<Character> allPlayers; private static float goodViewAngle = 40f; private static float viewAngle = 160f; private static float viewRange = 80f; private static float viewVisDetect = 80f; private static float lowViewRange = 35f; private static float suspiciousMult = 20f; private static float suspiciousDelay = 10f; private static float hearingDetect = 30f; private static float hearingDetectRange = 40f; private static float chanceToSwitchTargetOnHurt = 80f; private static int playersNo = 0; private static int counterNum = 0; private static List<UID> enemyHOTs; private static List<int> enemyTimers; private static int botRegenTimer = 20; private static float botDmgRange = 40f; private static float botDmgMult = 0.2f; private static int pullEnemiesTimer = 3; private static Coroutine pullCO; internal static void Awake() { enemyHOTs = new List<UID>(); enemyTimers = new List<int>(); players = (Character[])(object)new Character[2]; allPlayers = new List<Character>(); SL.OnGameplayResumedAfterLoading += Fixer; SL.OnGameplayResumedAfterLoading += NerfStability; } private static void NerfStability() { foreach (PlayerSystem item in Global.Lobby.PlayersInLobby) { item.ControlledCharacter.Stats.m_stabilityRegen.BaseValue = 5f; } } private static void Fixer() { counterNum = 0; player = CharacterManager.Instance.GetFirstLocalCharacter(); if (player.IsWorldHost) { if (pullCO != null) { ((MonoBehaviour)HardcoreRebalanceBase.Instance).StopCoroutine(pullCO); } pullCO = ((MonoBehaviour)HardcoreRebalanceBase.Instance).StartCoroutine(EnemyPull()); ((MonoBehaviour)HardcoreRebalanceBase.Instance).StartCoroutine(EnemyHealer()); } } private static IEnumerator EnemyHealer() { yield return (object)new WaitForSeconds(2f); List<Character> list = new List<Character>(); CharacterManager.Instance.FindCharactersInRange(player.CenterPosition, botDmgRange, ref list); foreach (Character item in list) { if (item.IsAI && item.Alive && !item.IsDead && item.Stats.CurrentHealth > 2f) { item.Stats.AffectHealth(1000f); } } } private static IEnumerator EnemyPull() { while ((Object)(object)player != (Object)null) { foreach (PlayerSystem item in Global.Lobby.PlayersInLobby) { Character nplayer = item.ControlledCharacter; if (!((Object)(object)nplayer != (Object)null)) { continue; } List<Character> list = new List<Character>(); CharacterManager.Instance.FindCharactersInRange(nplayer.CenterPosition, botDmgRange, ref list); foreach (Character enemy in list) { yield return (object)new WaitForSeconds(Random.Range(0.1f, (float)pullEnemiesTimer)); TargetingSystem targetingSystem = enemy.TargetingSystem; if ((Object)(object)((targetingSystem != null) ? targetingSystem.LockingPoint : null) != (Object)null && !enemy.IsAlly(nplayer) && enemy.IsAI && enemy.Stats.CurrentHealth > 0f && !Physics.Linecast(enemy.CenterPosition, ((Component)((Component)nplayer).gameObject.GetComponent<Collider>()).transform.position, Global.SightHideMask) && Random.Range(1, 3) == 1) { enemy.TargetingSystem.SwitchTarget(nplayer.LockingPoint); } } } } } private static void drainStability(Character player, float _amount, bool isMana = false) { _amount = ((!isMana) ? (_amount * 1f) : (_amount * 2.5f)); if (_amount >= 30f) { _amount = 30f; } player.m_stability = Mathf.Clamp(player.m_stability - _amount, 0f, 100f); _ = player.Stability; _ = 1f; } } [BepInPlugin("com.iggy.hardcorere", "True Hardcore", "3.1.0")] [BepInDependency("com.sinai.SideLoader", "3.7.7")] public class HardcoreRebalanceBase : BaseUnityPlugin { private const string GUID = "com.iggy.hardcorere"; private const string NAME = "True Hardcore"; private const string VERSION = "3.1.0"; public static ConfigEntry<bool> EnhancedAI; public static ConfigEntry<bool> PickupAnim; public static ConfigEntry<bool> PerCityStash; public static ConfigEntry<bool> CampingGuard; public static ConfigEntry<bool> CraftLimits; public static ConfigEntry<bool> NightGates; public static ConfigEntry<bool> EnemyHealing; public static bool EnhancedAIStored; public static bool PickupAnimStored; public static bool PerCityStashStored; public static bool CampingGuardStored; public static bool CraftLimitsStored; public static bool NightGatesStored; public static bool EnemyHealingStored; public static string OptionsName = "Weenie Hut Jrs Options (RESTART REQUIRED)"; public static HardcoreRebalanceBase Instance; internal void Awake() { //IL_0110: Unknown result type (might be due to invalid IL or missing references) Instance = this; Debug.Log((object)"True Hardcoreawake"); EnhancedAI = ((BaseUnityPlugin)this).Config.Bind<bool>(OptionsName, "Improve enemies AI", true, "Disable to: Remove Improved enemies sight, aggresiveness and hearing."); PickupAnim = ((BaseUnityPlugin)this).Config.Bind<bool>(OptionsName, "OoC Animations", true, "Disable to: Remove looting and equiping animations while out of combat"); PerCityStash = ((BaseUnityPlugin)this).Config.Bind<bool>(OptionsName, "Per City Stash", true, "Disable to: Make stashes universal again, instead of per city."); CampingGuard = ((BaseUnityPlugin)this).Config.Bind<bool>(OptionsName, "Unsafe Camping", true, "Disable to: Allow players to guard while camping."); CraftLimits = ((BaseUnityPlugin)this).Config.Bind<bool>(OptionsName, "Crafting Limits", true, "Disable to: Allow VANILLA items to be crafted without recipee knowledge too. By default only MOD items can be crafted with no recipee."); NightGates = ((BaseUnityPlugin)this).Config.Bind<bool>(OptionsName, "Night Gates", true, "Disable to: Allow players to enter cities freely at night."); EnemyHealing = ((BaseUnityPlugin)this).Config.Bind<bool>(OptionsName, "Enemy Healing", true, "Disable to: Stop enemies from healing when damaging players."); _ = ((Component)this).gameObject; EventsManager.Awake(); AIManager.Awake(); CraftingLimits.Awake(); DeathMortality.Awake(); new Harmony("com.iggy.hardcorere").PatchAll(); } internal void Start() { EnhancedAIStored = EnhancedAI.Value; PickupAnimStored = PickupAnim.Value; PerCityStashStored = PerCityStash.Value; CampingGuardStored = CampingGuard.Value; CraftLimitsStored = CraftLimits.Value; NightGatesStored = NightGates.Value; EnemyHealingStored = EnemyHealing.Value; Debug.Log((object)"True HardcoreLoaded"); } } internal static class TrapAwareness { [HarmonyPatch(typeof(TrapTrigger), "OnTriggerEnter")] public class TrapTrigger_OnTriggerEnter { [HarmonyPrefix] public static bool Prefix(TrapTrigger __instance, Collider _other) { //IL_0077: Unknown result type (might be due to invalid IL or missing references) //IL_007d: Invalid comparison between Unknown and I4 //IL_008d: Unknown result type (might be due to invalid IL or missing references) //IL_0093: Invalid comparison between Unknown and I4 //IL_009c: Unknown result type (might be due to invalid IL or missing references) if (AreaManager.Instance.GetIsCurrentAreaTownOrCity()) { return true; } if ((Object)(object)_other == (Object)null) { return true; } if ((Object)(object)NetworkLevelLoader.Instance == (Object)null || !NetworkLevelLoader.Instance.IsOverallLoadingDone) { if (!__instance.m_pendingActivation.Contains(_other)) { __instance.m_pendingActivation.Add(_other); } return true; } Character component = ((Component)_other).GetComponent<Character>(); if ((Object)(object)component == (Object)null || __instance.m_charactersInTrigger.Contains(component)) { return true; } if (__instance.IgnoreFaction || ((int)__instance.m_targetType == 1 && Object.op_Implicit((Object)(object)component.OwnerPlayerSys)) || ((int)__instance.m_targetType == 2 && UnityEngineExtensions.Contains<Factions>(__instance.m_targetableFactions, component.Faction))) { if (component.StatusEffectMngr.HasStatusEffect(HardcoreEffects.TrapAware.ToString())) { return false; } Debug.Log((object)(component.Name + " Added Awareness")); component.StatusEffectMngr.AddStatusEffect(HardcoreEffects.TrapAware.ToString()); return true; } return true; } } }

using System; using System.Collections; using System.Collections.Generic; using System.Diagnostics; using System.IO; using System.Linq; using System.Reflection; using System.Runtime.CompilerServices; using System.Runtime.InteropServices; using System.Runtime.Versioning; using System.Security; using System.Security.Permissions; using BepInEx; using BepInEx.Configuration; using BepInEx.Logging; using HarmonyLib; using SideLoader; using SideLoader.Model; using SideLoader.Model.Status; using SideLoader_ExtendedEffects.Events; using SideLoader_ExtendedEffects.Item_Context_Menu; using SideLoader_ExtendedEffects.Released; using TravelSpeed.Extensions; using UnityEngine; [assembly: CompilationRelaxations(8)] [assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)] [assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)] [assembly: AssemblyTitle("SideLoader Custom Effects")] [assembly: AssemblyDescription("")] [assembly: AssemblyConfiguration("")] [assembly: AssemblyCompany("")] [assembly: AssemblyProduct("SideLoader Custom Effects")] [assembly: AssemblyCopyright("Copyright © 2021")] [assembly: AssemblyTrademark("")] [assembly: ComVisible(false)] [assembly: Guid("c5450fe0-edcf-483f-b9ea-4b1ef9d36da7")] [assembly: AssemblyFileVersion("1.0.0.0")] [assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")] [assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)] [assembly: AssemblyVersion("1.0.0.0")] [module: UnverifiableCode] namespace TravelSpeed.Patches { [HarmonyPatch(typeof(Effect))] public static class EffectPatches { [HarmonyPatch("TryActivateLocally")] [HarmonyPrefix] public static bool Effect_TryActivateLocally_Prefix(Effect __instance, Character _affectedCharacter, object[] _infos) { return (Object)(object)__instance.m_parentStatusEffect == (Object)null || !__instance.m_parentStatusEffect.IsEffectSuspended(); } } [HarmonyPatch(typeof(StatusEffectDetailDisplay))] public static class StatusEffectDetailDisplayPatches { [HarmonyPatch("RefreshDisplay")] [HarmonyPostfix] public static void StatusEffectDetailDisplay_RefreshDisplay_Postfix(StatusEffectDetailDisplay __instance) { if ((Object)(object)__instance.m_statusEffect != (Object)null && __instance.m_statusEffect.IsTimerSuspended() && Object.op_Implicit((Object)(object)__instance.m_lblTimer)) { __instance.m_lblTimer.text = "Suspended"; } } } [HarmonyPatch(typeof(StatusEffect))] public static class StatusEffectPatches { [HarmonyPatch("UpdateTotalData")] [HarmonyPrefix] public static void StatusEffect_UpdateTotalData_Prefix(StatusEffect __instance, ref bool _updateDelta) { if (__instance.IsTimerSuspended()) { _updateDelta = false; } } } } namespace TravelSpeed.Extensions { public class StatusEffectExt { private bool timerSuspended = false; private bool effectSuspended = false; public bool TimerSuspended { get { return timerSuspended; } set { timerSuspended = value; } } public bool EffectSuspended { get { return effectSuspended; } set { effectSuspended = value; } } } public static class StatusEffectExtensions { private static ConditionalWeakTable<StatusEffect, StatusEffectExt> SuspendedEffects = new ConditionalWeakTable<StatusEffect, StatusEffectExt>(); public static void SetTimerSuspended(this StatusEffect statusEffect, bool suspended) { StatusEffectExt value = SuspendedEffects.GetValue(statusEffect, (StatusEffect key) => new StatusEffectExt()); value.TimerSuspended = suspended; } public static bool IsTimerSuspended(this StatusEffect statusEffect) { if (SuspendedEffects.TryGetValue(statusEffect, out var value)) { return value.TimerSuspended; } return false; } public static void SetEffectSuspended(this StatusEffect statusEffect, bool suspended) { StatusEffectExt value = SuspendedEffects.GetValue(statusEffect, (StatusEffect key) => new StatusEffectExt()); value.EffectSuspended = suspended; } public static bool IsEffectSuspended(this StatusEffect statusEffect) { if (SuspendedEffects.TryGetValue(statusEffect, out var value)) { return value.EffectSuspended; } return false; } } } namespace SideLoader_ExtendedEffects { public class CustomItemMenuManager { public Dictionary<int, CustomItemDisplayMenuOption> CustomItemOptions { get; private set; } public CustomItemMenuManager() { CustomItemOptions = new Dictionary<int, CustomItemDisplayMenuOption>(); } public void RegisterCustomMenuOption(int NewActionID, string ActionString, Action<Character, Item, ItemDisplayOptionPanel, int> OnCustomActionPressed, Func<Character, Item, ItemDisplayOptionPanel, int, bool> ShouldAddAction) { ExtendedEffects.Instance?.DebugLogMessage($"Registering custom action with ID {NewActionID} String {ActionString}"); if (!CustomItemOptions.ContainsKey(NewActionID)) { CustomItemOptions.Add(NewActionID, new CustomItemDisplayMenuOption(NewActionID, ActionString, OnCustomActionPressed, ShouldAddAction)); } else { ExtendedEffects.Instance?.DebugLogMessage($"Custom Action already exists with ID {NewActionID}"); } } public void UnRegisterCustomMenuOption(int CustomActionID) { if (CustomItemOptions.ContainsKey(CustomActionID)) { ExtendedEffects.Instance?.DebugLogMessage($"UnRegistering custom action ID {CustomActionID}"); CustomItemOptions.Remove(CustomActionID); } } } [BepInPlugin("sideloaderextendedeffects.extendedeffects", "SideLoader Extended Effects", "1.2.4")] public class ExtendedEffects : BaseUnityPlugin { public const string GUID = "sideloaderextendedeffects.extendedeffects"; public const string NAME = "SideLoader Extended Effects"; public const string VERSION = "1.2.4"; internal static ManualLogSource _Log; public const string SL_VISUAL_TRANSFORM = "SLVISUALCONTAINER"; public static ConfigEntry<bool> AddTestItems; public static ConfigEntry<bool> AddItemDebug; public static ConfigEntry<bool> ShowDebugLog; private static Dictionary<string, string> _SkillTreeOverrides = new Dictionary<string, string>(); public static ExtendedEffects Instance { get; private set; } public CustomItemMenuManager CustomItemMenuManager { get; private set; } public static Dictionary<string, string> SkillTreeOverrides => _SkillTreeOverrides; internal void Awake() { //IL_0032: Unknown result type (might be due to invalid IL or missing references) _Log = ((BaseUnityPlugin)this).Logger; Instance = this; CustomItemMenuManager = new CustomItemMenuManager(); InitializeSL(); InitializeConfig(); new Harmony("sideloaderextendedeffects.extendedeffects").PatchAll(); } private void InitializeSL() { SL.BeforePacksLoaded += SL_BeforePacksLoaded; } private void InitializeConfig() { AddItemDebug = ((BaseUnityPlugin)this).Config.Bind<bool>("SideLoader Extended Effects", "Add Debug Menu options to Items", false, "Add Debug Menu options to Items."); AddTestItems = ((BaseUnityPlugin)this).Config.Bind<bool>("SideLoader Extended Effects", "Add Test Items", false, "Adds test items, spawnable using the debug mode menu (requires restart)"); ShowDebugLog = ((BaseUnityPlugin)this).Config.Bind<bool>("SideLoader Extended Effects", "Show Debug Log", true, "Enables the Debug Log for SideLoader Extended Effects."); } private void SL_BeforePacksLoaded() { if (AddTestItems.Value) { DefineTestItems(); } if (AddItemDebug.Value) { CustomItemMenuManager.RegisterCustomMenuOption(101010, "Debug Log Item", delegate(Character Character, Item Item, ItemDisplayOptionPanel ItemDisplayOptionPanel, int someInt) { ((BaseUnityPlugin)this).Logger.LogMessage((object)Item); ((BaseUnityPlugin)this).Logger.LogMessage((object)$"Item Name {Item.DisplayName} Item ID {Item.ItemID} Item UID {Item.UID}"); ((BaseUnityPlugin)this).Logger.LogMessage((object)$"Item Current Slot {Item.CurrentEquipmentSlot}"); ((BaseUnityPlugin)this).Logger.LogMessage((object)$"Durability {Item.CurrentDurability} / {Item.MaxDurability}"); }, null); CustomItemMenuManager.RegisterCustomMenuOption(101110, "Repair Item", delegate(Character Character, Item Item, ItemDisplayOptionPanel ItemDisplayOptionPanel, int someInt) { Item.RepairAmount(9000f); }, null); } } public static void AddSkillTreeOverride(string trainerUID, string customTreeUID) { if (!SkillTreeOverrides.ContainsKey(trainerUID)) { SkillTreeOverrides.Add(trainerUID, customTreeUID); } else { _Log.LogMessage((object)"Override already found for this Trainer! Not sure how to handle this!"); } } public static bool HasSkillTreeOverride(string trainerUID) { return SkillTreeOverrides.ContainsKey(trainerUID); } private void DefineTestItems() { //IL_0001: Unknown result type (might be due to invalid IL or missing references) //IL_0007: Expected O, but got Unknown //IL_0034: Unknown result type (might be due to invalid IL or missing references) //IL_0039: Unknown result type (might be due to invalid IL or missing references) //IL_0040: Unknown result type (might be due to invalid IL or missing references) //IL_0045: Unknown result type (might be due to invalid IL or missing references) //IL_0050: Unknown result type (might be due to invalid IL or missing references) //IL_0052: Unknown result type (might be due to invalid IL or missing references) //IL_005c: Expected O, but got Unknown //IL_0062: Unknown result type (might be due to invalid IL or missing references) //IL_0077: Expected O, but got Unknown //IL_0080: Unknown result type (might be due to invalid IL or missing references) //IL_0087: Expected O, but got Unknown //IL_00b1: Unknown result type (might be due to invalid IL or missing references) //IL_00b8: Expected O, but got Unknown //IL_00eb: Unknown result type (might be due to invalid IL or missing references) //IL_0107: Unknown result type (might be due to invalid IL or missing references) //IL_010e: Expected O, but got Unknown //IL_0139: Unknown result type (might be due to invalid IL or missing references) //IL_0140: Expected O, but got Unknown //IL_0167: Unknown result type (might be due to invalid IL or missing references) //IL_0176: Unknown result type (might be due to invalid IL or missing references) //IL_017d: Expected O, but got Unknown SL_MeleeWeapon val = new SL_MeleeWeapon(); ((SL_Item)val).Target_ItemID = 2000031; ((SL_Item)val).New_ItemID = -26999; ((SL_Item)val).Name = "Emo Test Blade of Testing"; ((SL_Item)val).Description = "WHACK"; ((SL_Item)val).StatsHolder = (SL_ItemStats)new SL_WeaponStats { BaseDamage = new List<SL_Damage> { new SL_Damage { Damage = 25f, Type = (Types)0 } }, AttackSpeed = 0.9f }; SL_EffectTransform[] array = new SL_EffectTransform[1]; SL_EffectTransform val2 = new SL_EffectTransform(); val2.TransformName = "Activation"; val2.Effects = (SL_Effect[])(object)new SL_Effect[0]; array[0] = val2; ((SL_Item)val).EffectTransforms = (SL_EffectTransform[])(object)array; SL_MeleeWeapon val3 = val; ((ContentTemplate)val3).ApplyTemplate(); SL_Item val4 = new SL_Item(); val4.Target_ItemID = 4300130; val4.New_ItemID = -26987; val4.Name = "Emo Test Potion"; val4.Description = "Test Potion"; val4.EffectBehaviour = (EditBehaviours)2; val4.QtyRemovedOnUse = 0; SL_EffectTransform[] array2 = new SL_EffectTransform[1]; val2 = new SL_EffectTransform(); val2.TransformName = "Effects"; val2.Effects = (SL_Effect[])(object)new SL_Effect[0]; array2[0] = val2; val4.EffectTransforms = (SL_EffectTransform[])(object)array2; SL_Item val5 = val4; ((ContentTemplate)val5).ApplyTemplate(); SL_Skill val6 = new SL_Skill(); ((SL_Item)val6).Target_ItemID = 8100120; ((SL_Item)val6).New_ItemID = -26986; ((SL_Item)val6).Name = "Emo Test Skill"; ((SL_Item)val6).EffectBehaviour = (EditBehaviours)1; SL_EffectTransform[] array3 = new SL_EffectTransform[1]; val2 = new SL_EffectTransform(); val2.TransformName = "Activation"; val2.Effects = (SL_Effect[])(object)new SL_Effect[2] { new SL_RemoveItemFromInventory { ItemID = 4000010, ItemQuantity = 5 }, new SL_RemoveItemFromInventory { ItemID = 2000010, ItemQuantity = 2 } }; array3[0] = val2; ((SL_Item)val6).EffectTransforms = (SL_EffectTransform[])(object)array3; SL_Skill val7 = val6; ((ContentTemplate)val7).ApplyTemplate(); } public void DebugLogMessage(object logMessage) { if (ShowDebugLog.Value && _Log != null) { _Log.LogMessage(logMessage); } } } public class InstancedEvent<TInstance, TEvent> where TEvent : Delegate { private readonly Dictionary<TInstance, TEvent> dictionary = new Dictionary<TInstance, TEvent>(); public void AddListener(TInstance instance, TEvent listener) { if (!dictionary.ContainsKey(instance)) { dictionary.Add(instance, listener); return; } TEvent a = dictionary[instance]; a = Delegate.Combine(a, listener) as TEvent; dictionary[instance] = a; } public void RemoveListener(TInstance instance, TEvent listener) { if (dictionary.TryGetValue(instance, out var value)) { value = Delegate.Remove(value, listener) as TEvent; if (!value.GetInvocationList().Any()) { dictionary.Remove(instance); } else { dictionary[instance] = value; } } } internal void InvokeForInstance(TInstance instance, params object[] args) { if (dictionary.TryGetValue(instance, out var value)) { value.DynamicInvoke(args); } } } public static class OutwardEvents { public static InstancedEvent<Character, Action<Character, CharacterDamageEvent>> OnCharacterRecievedHit; } public static class OutwardHelpers { public static string Emission_Property_Value = "_EmissionColor"; public static void UpdateWeaponDamage(Weapon WeaponInstance, DamageList newDamageList) { WeaponInstance.Damage.Clear(); WeaponInstance.Stats.BaseDamage = newDamageList; WeaponInstance.m_baseDamage = WeaponInstance.Stats.BaseDamage.Clone(); WeaponInstance.m_activeBaseDamage = WeaponInstance.Stats.BaseDamage.Clone(); WeaponInstance.baseDamage = WeaponInstance.Stats.BaseDamage.Clone(); WeaponInstance.Stats.Attacks = SL_WeaponStats.GetScaledAttackData(WeaponInstance); } public static MeshFilter TryGetWeaponMesh(Equipment weaponGameObject, bool IncludeInActive = true) { BoxCollider[] componentsInChildren = ((Component)((Item)weaponGameObject).GetItemVisual()).GetComponentsInChildren<BoxCollider>(true); foreach (BoxCollider val in componentsInChildren) { ExtendedEffects.Instance.DebugLogMessage("BoxCollider GO Name " + ((Object)((Component)val).transform).name); if (((Component)((Component)val).transform.parent).gameObject.activeInHierarchy) { return ((Component)val).GetComponent<MeshFilter>(); } } return null; } public static Transform TryGetHumanBone(Character character, HumanBodyBones bone) { //IL_0018: Unknown result type (might be due to invalid IL or missing references) return ((Object)(object)character.Animator != (Object)null) ? character.Animator.GetBoneTransform(bone) : null; } public static T GetFromAssetBundle<T>(string SLPackName, string AssetBundle, string key) where T : Object { if (!SL.PacksLoaded) { return default(T); } return SL.GetSLPack(SLPackName).AssetBundles[AssetBundle].LoadAsset<T>(key); } public static List<T> GetTypeFromColliders<T>(Collider[] colliders) where T : Component { List<T> list = new List<T>(); foreach (Collider val in colliders) { T componentInChildren = ((Component)val).GetComponentInChildren<T>(); if ((Object)(object)componentInChildren != (Object)null) { list.Add(componentInChildren); } } return list; } public static Tag GetTagFromName(string tagName) { //IL_0013: Unknown result type (might be due to invalid IL or missing references) //IL_0018: Unknown result type (might be due to invalid IL or missing references) //IL_001a: Unknown result type (might be due to invalid IL or missing references) //IL_003d: Unknown result type (might be due to invalid IL or missing references) //IL_0043: Unknown result type (might be due to invalid IL or missing references) //IL_0045: Unknown result type (might be due to invalid IL or missing references) //IL_002b: Unknown result type (might be due to invalid IL or missing references) //IL_002c: Unknown result type (might be due to invalid IL or missing references) //IL_0049: Unknown result type (might be due to invalid IL or missing references) Tag[] tags = TagSourceManager.Instance.m_tags; foreach (Tag val in tags) { if (val.TagName == tagName) { return val; } } return default(Tag); } } public struct CharacterDamageEvent { public Character DamageTarget; public object DamageSource; public float TotalDamage; public DamageList DamageDone; public Vector3 DamageDirection; public Vector3 DamagePosition; public float HitAngle; public float HitAngleDirection; public Character DamageSourceCharacter; public float KnocksBack; public bool DamageInventory; } public struct BagEventData { public Bag Bag; public Character CharacterOwner; } public class SL_AffectCooldown : SL_Effect, ICustomModel { public float Amount; public bool IsModifier; public bool OnOwner; public int[] AllowedSkills; public Type SLTemplateModel => typeof(SL_AffectCooldown); public Type GameModel => typeof(AffectCooldown); public override void ApplyToComponent<T>(T component) { AffectCooldown affectCooldown = component as AffectCooldown; affectCooldown.Amount = Amount; affectCooldown.IsModifier = IsModifier; affectCooldown.OnOwner = OnOwner; affectCooldown.AllowedSkills = AllowedSkills; } public override void SerializeEffect<T>(T effect) { AffectCooldown affectCooldown = effect as AffectCooldown; Amount = affectCooldown.Amount; IsModifier = affectCooldown.IsModifier; OnOwner = affectCooldown.OnOwner; AllowedSkills = affectCooldown.AllowedSkills; } } public class AffectCooldown : Effect, ICustomModel { public float Amount; public bool IsModifier; public bool OnOwner; public int[] AllowedSkills; public Type SLTemplateModel => typeof(SL_AffectCooldown); public Type GameModel => typeof(AffectCooldown); public override void ActivateLocally(Character _affectedCharacter, object[] _infos) { Character val = (OnOwner ? ((Effect)this).OwnerCharacter : _affectedCharacter); IList<string> learnedActiveSkillUIDs = val.Inventory.SkillKnowledge.GetLearnedActiveSkillUIDs(); foreach (string item2 in learnedActiveSkillUIDs) { Item item = ItemManager.Instance.GetItem(item2); Skill val2 = (Skill)(object)((item is Skill) ? item : null); SL.Log(((Item)val2).Name + " " + ((Item)val2).ItemID); if (AllowedSkills != null && AllowedSkills.Length != 0 && !Extensions.Contains(AllowedSkills, ((Item)val2).ItemID)) { SL.Log("Not Whitelisted"); continue; } float num = (IsModifier ? (val2.RealCooldown * Amount / 100f) : Amount); val2.m_remainingCooldownTime -= num; val2.UpdateCooldownRatio(); } } } public class SL_ApplyEnchantment : SL_Effect, ICustomModel { public EquipmentSlotIDs EquipmentSlot; public int EnchantmentID; public bool ApplyPermanently; public Type SLTemplateModel => typeof(SL_ApplyEnchantment); public Type GameModel => typeof(ApplyEnchantment); public override void ApplyToComponent<T>(T component) { //IL_000f: Unknown result type (might be due to invalid IL or missing references) //IL_0014: Unknown result type (might be due to invalid IL or missing references) ApplyEnchantment applyEnchantment = component as ApplyEnchantment; applyEnchantment.EquipmentSlot = EquipmentSlot; applyEnchantment.EnchantmentId = EnchantmentID; applyEnchantment.ApplyPermanently = ApplyPermanently; } public override void SerializeEffect<T>(T effect) { //IL_001b: Unknown result type (might be due to invalid IL or missing references) //IL_0020: Unknown result type (might be due to invalid IL or missing references) ApplyEnchantment applyEnchantment = effect as ApplyEnchantment; EnchantmentID = applyEnchantment.EnchantmentId; EquipmentSlot = applyEnchantment.EquipmentSlot; ApplyPermanently = applyEnchantment.ApplyPermanently; } } public class ApplyEnchantment : Effect, ICustomModel { public EquipmentSlotIDs EquipmentSlot; public int EnchantmentId; public bool ApplyPermanently; [SerializeField] private UID affectedItem = UID.Empty; public Type SLTemplateModel => typeof(SL_ApplyEnchantment); public Type GameModel => typeof(ApplyEnchantment); public override void ActivateLocally(Character _affectedCharacter, object[] _infos) { //IL_0033: Unknown result type (might be due to invalid IL or missing references) //IL_0057: Unknown result type (might be due to invalid IL or missing references) //IL_0069: Unknown result type (might be due to invalid IL or missing references) //IL_006f: Unknown result type (might be due to invalid IL or missing references) //IL_00c5: Unknown result type (might be due to invalid IL or missing references) //IL_00ca: Unknown result type (might be due to invalid IL or missing references) if ((Object)(object)_affectedCharacter == (Object)null) { ExtendedEffects.Instance.DebugLogMessage("Affected Character null"); } else if (_affectedCharacter.Inventory.Equipment.EquipmentSlots[EquipmentSlot].HasItemEquipped) { Equipment equippedItem = _affectedCharacter.Inventory.Equipment.EquipmentSlots[EquipmentSlot].EquippedItem; if (UID.op_Implicit(((Item)equippedItem).UID) != affectedItem) { ExtendedEffects.Instance.DebugLogMessage("Item has Changed"); if (!((UID)(ref affectedItem)).IsNull) { ExtendedEffects.Instance.DebugLogMessage("Cleaning Affected Item"); CleanAffectedItem(); } affectedItem = UID.op_Implicit(((Item)equippedItem).UID); if (!equippedItem.m_enchantmentIDs.Contains(EnchantmentId)) { ExtendedEffects.Instance.DebugLogMessage($"Adding Enchant {EnchantmentId} to {((Item)equippedItem).Name}"); equippedItem.AddEnchantment(EnchantmentId, false); } } } else if (!((UID)(ref affectedItem)).IsNull) { CleanAffectedItem(); } } public override void StopAffectLocally(Character _affectedCharacter) { if (!((UID)(ref affectedItem)).IsNull) { CleanAffectedItem(); } ((Effect)this).StopAffectLocally(_affectedCharacter); } private void CleanAffectedItem() { //IL_0016: Unknown result type (might be due to invalid IL or missing references) //IL_00c9: Unknown result type (might be due to invalid IL or missing references) //IL_00ce: Unknown result type (might be due to invalid IL or missing references) if (ApplyPermanently) { return; } Item item = ItemManager.Instance.GetItem(UID.op_Implicit(affectedItem)); Equipment val = (Equipment)(object)((item is Equipment) ? item : null); val.m_enchantmentIDs.Remove(EnchantmentId); foreach (Enchantment activeEnchantment in val.m_activeEnchantments) { if (((EffectPreset)activeEnchantment).PresetID == EnchantmentId) { val.m_activeEnchantments.Remove(activeEnchantment); activeEnchantment.UnapplyEnchantment(); float durabilityRatio = ((Item)val).DurabilityRatio; val.RefreshEnchantmentModifiers(); if (durabilityRatio != ((Item)val).DurabilityRatio) { ((Item)val).SetDurabilityRatio(durabilityRatio); } break; } } affectedItem = UID.Empty; } } public class SL_ChangeMaterialTimed : SL_Effect, ICustomModel { public string SLPackName; public string AssetBundleName; public string PrefabName; public float ChangeTime; public Type SLTemplateModel => typeof(SL_ChangeMaterialTimed); public Type GameModel => typeof(ChangeMaterialTimed); public override void ApplyToComponent<T>(T component) { ChangeMaterialTimed changeMaterialTimed = component as ChangeMaterialTimed; changeMaterialTimed.ChangeTime = ChangeTime; changeMaterialTimed.SLPackName = SLPackName; changeMaterialTimed.AssetBundleName = AssetBundleName; changeMaterialTimed.PrefabName = PrefabName; } public override void SerializeEffect<T>(T effect) { ChangeMaterialTimed changeMaterialTimed = effect as ChangeMaterialTimed; ChangeTime = changeMaterialTimed.ChangeTime; SLPackName = changeMaterialTimed.SLPackName; AssetBundleName = changeMaterialTimed.AssetBundleName; PrefabName = changeMaterialTimed.PrefabName; } } public class ChangeMaterialTimed : Effect, ICustomModel { public string SLPackName; public string AssetBundleName; public string PrefabName; public float ChangeTime; private bool IsChanged; private Dictionary<Renderer, Material> CurrentRenderers = new Dictionary<Renderer, Material>(); public Type SLTemplateModel => typeof(SL_ChangeMaterialTimed); public Type GameModel => typeof(ChangeMaterialTimed); public override void ActivateLocally(Character _affectedCharacter, object[] _infos) { if (IsChanged) { return; } Material fromAssetBundle = OutwardHelpers.GetFromAssetBundle<Material>(SLPackName, AssetBundleName, PrefabName); if ((Object)(object)fromAssetBundle != (Object)null) { CacheOriginalMaterials(_affectedCharacter); ChangeMaterialForRenderers(fromAssetBundle); if (ChangeTime > 0f) { ((MonoBehaviour)this).StartCoroutine(DelayRevert(_affectedCharacter)); } IsChanged = true; } } private IEnumerator DelayRevert(Character _affectedCharacter) { yield return (object)new WaitForSeconds(ChangeTime); ReturnToOriginalMaterials(); } public override void StopAffectLocally(Character _affectedCharacter) { ((Effect)this).StopAffectLocally(_affectedCharacter); if (ChangeTime <= 0f) { ReturnToOriginalMaterials(); } } private void CacheOriginalMaterials(Character _affectedCharacter) { //IL_00b6: Unknown result type (might be due to invalid IL or missing references) //IL_00c0: Expected O, but got Unknown if ((Object)(object)_affectedCharacter == (Object)null) { return; } if (CurrentRenderers.Count > 0) { ReturnToOriginalMaterials(); } CurrentRenderers.Clear(); ExtendedEffects.Instance.DebugLogMessage("Caching Original Materials"); Renderer[] renderers = GetRenderers(_affectedCharacter.VisualHolderTrans, IncludeInActive: false); Renderer[] array = renderers; foreach (Renderer val in array) { if ((Object)(object)val != (Object)null) { ExtendedEffects.Instance.DebugLogMessage("Cached " + ((Object)((Component)val).transform).name + " " + ((Object)val.material).name); CurrentRenderers.Add(val, new Material(val.material)); } } } private void ChangeMaterialForRenderers(Material NewMaterial) { foreach (KeyValuePair<Renderer, Material> currentRenderer in CurrentRenderers) { if (!((Object)(object)currentRenderer.Key == (Object)null) && !((Object)(object)currentRenderer.Value == (Object)null) && CurrentRenderers.TryGetValue(currentRenderer.Key, out var _)) { ExtendedEffects.Instance.DebugLogMessage($"Changing {((Object)((Component)currentRenderer.Key).transform).name} to {NewMaterial}"); currentRenderer.Key.material = NewMaterial; } } } private void ReturnToOriginalMaterials() { foreach (KeyValuePair<Renderer, Material> currentRenderer in CurrentRenderers) { if (!((Object)(object)currentRenderer.Key == (Object)null) && !((Object)(object)currentRenderer.Value == (Object)null) && CurrentRenderers.TryGetValue(currentRenderer.Key, out var value)) { ExtendedEffects.Instance.DebugLogMessage($"Reverting {((Object)((Component)currentRenderer.Key).transform).name} to {currentRenderer.Value}"); currentRenderer.Key.material = value; } } IsChanged = false; } private Renderer[] GetRenderers(Transform transform, bool IncludeInActive) { return ((Component)transform).GetComponentsInChildren<Renderer>(IncludeInActive); } } public class SL_CustomImbueVFX : SL_Effect, ICustomModel { public string SLPackName; public string AssetBundleName; public string PrefabName; public Vector3 PositionOffset; public Vector3 RotationOffset; public bool IsMainHand = true; public Type SLTemplateModel => typeof(SL_CustomImbueVFX); public Type GameModel => typeof(SLEx_CustomImbueVFX); public override void ApplyToComponent<T>(T component) { //IL_0033: Unknown result type (might be due to invalid IL or missing references) //IL_0038: Unknown result type (might be due to invalid IL or missing references) //IL_003f: Unknown result type (might be due to invalid IL or missing references) //IL_0044: Unknown result type (might be due to invalid IL or missing references) SLEx_CustomImbueVFX sLEx_CustomImbueVFX = component as SLEx_CustomImbueVFX; sLEx_CustomImbueVFX.SLPackName = SLPackName; sLEx_CustomImbueVFX.AssetBundleName = AssetBundleName; sLEx_CustomImbueVFX.PrefabName = PrefabName; sLEx_CustomImbueVFX.PositionOffset = PositionOffset; sLEx_CustomImbueVFX.RotationOffset = RotationOffset; sLEx_CustomImbueVFX.IsMainHand = IsMainHand; } public override void SerializeEffect<T>(T effect) { //IL_0033: Unknown result type (might be due to invalid IL or missing references) //IL_0038: Unknown result type (might be due to invalid IL or missing references) //IL_003f: Unknown result type (might be due to invalid IL or missing references) //IL_0044: Unknown result type (might be due to invalid IL or missing references) SLEx_CustomImbueVFX sLEx_CustomImbueVFX = effect as SLEx_CustomImbueVFX; SLPackName = sLEx_CustomImbueVFX.SLPackName; AssetBundleName = sLEx_CustomImbueVFX.AssetBundleName; PrefabName = sLEx_CustomImbueVFX.PrefabName; PositionOffset = sLEx_CustomImbueVFX.PositionOffset; RotationOffset = sLEx_CustomImbueVFX.RotationOffset; IsMainHand = sLEx_CustomImbueVFX.IsMainHand; } } public class SLEx_CustomImbueVFX : Effect, ICustomModel { public string SLPackName; public string AssetBundleName; public string PrefabName; public Vector3 PositionOffset; public Vector3 RotationOffset; public bool IsMainHand; private GameObject Instance; private Equipment LastEquipmentInstance = null; public Type SLTemplateModel => typeof(SL_CustomImbueVFX); public Type GameModel => typeof(SLEx_CustomImbueVFX); public override void ActivateLocally(Character _affectedCharacter, object[] _infos) { if ((Object)(object)_affectedCharacter == (Object)null) { return; } if ((Object)(object)LastEquipmentInstance != (Object)null && (Object)(object)_affectedCharacter.CurrentWeapon != (Object)(object)LastEquipmentInstance) { if ((Object)(object)Instance != (Object)null) { Object.Destroy((Object)(object)Instance); } LastEquipmentInstance = null; } Equipment val = FindCurrentWeapon(_affectedCharacter); if ((Object)(object)val == (Object)null) { return; } GameObject fromAssetBundle = OutwardHelpers.GetFromAssetBundle<GameObject>(SLPackName, AssetBundleName, PrefabName); if ((Object)(object)fromAssetBundle != (Object)null) { ParticleSystem[] componentsInChildren = fromAssetBundle.GetComponentsInChildren<ParticleSystem>(); if (componentsInChildren.Length == 0) { ExtendedEffects.Instance?.DebugLogMessage("SLEx_CustomImbueVFX prefab " + PrefabName + " and its children do not contain a particle system."); return; } MeshFilter val2 = OutwardHelpers.TryGetWeaponMesh(val, IncludeInActive: false); if ((Object)(object)val2 == (Object)null) { ExtendedEffects.Instance?.DebugLogMessage("SLEx_CustomImbueVFX Mesh Filter For " + ((Item)val).Name + " cant be found."); return; } if ((Object)(object)Instance == (Object)null) { Instance = Object.Instantiate<GameObject>(fromAssetBundle); } UpdateParticleSystemMesh(Instance, val, val2); LastEquipmentInstance = val; } else { ExtendedEffects.Instance?.DebugLogMessage("SLEx_CustomImbueVFX Prefab from AssetBundle " + AssetBundleName + " was null."); } } private void UpdateParticleSystemMesh(GameObject Instance, Equipment CurrentWeapon, MeshFilter meshFilter) { //IL_00c7: Unknown result type (might be due to invalid IL or missing references) //IL_00cc: Unknown result type (might be due to invalid IL or missing references) //IL_0034: Unknown result type (might be due to invalid IL or missing references) //IL_0039: Unknown result type (might be due to invalid IL or missing references) //IL_003d: Unknown result type (might be due to invalid IL or missing references) //IL_0043: Invalid comparison between Unknown and I4 //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_002a: Unknown result type (might be due to invalid IL or missing references) //IL_0031: Invalid comparison between Unknown and I4 //IL_0108: Unknown result type (might be due to invalid IL or missing references) //IL_00f2: Unknown result type (might be due to invalid IL or missing references) //IL_011b: Unknown result type (might be due to invalid IL or missing references) //IL_0050: Unknown result type (might be due to invalid IL or missing references) //IL_0055: Unknown result type (might be due to invalid IL or missing references) //IL_007b: Unknown result type (might be due to invalid IL or missing references) //IL_0088: Unknown result type (might be due to invalid IL or missing references) //IL_0095: Unknown result type (might be due to invalid IL or missing references) ParticleSystem[] componentsInChildren = Instance.GetComponentsInChildren<ParticleSystem>(); ParticleSystem[] array = componentsInChildren; foreach (ParticleSystem val in array) { ShapeModule shape; if ((Object)(object)val != (Object)null) { shape = val.shape; if ((int)((ShapeModule)(ref shape)).shapeType == 13) { goto IL_004e; } } shape = val.shape; if ((int)((ShapeModule)(ref shape)).shapeType != 6) { continue; } goto IL_004e; IL_004e: ShapeModule shape2 = val.shape; ((ShapeModule)(ref shape2)).mesh = meshFilter.sharedMesh; ((ShapeModule)(ref shape2)).meshRenderer = ((Component)meshFilter).GetComponent<MeshRenderer>(); ((ShapeModule)(ref shape2)).scale = ((Component)CurrentWeapon).transform.localScale; ((ShapeModule)(ref shape2)).position = Vector3.zero; ((ShapeModule)(ref shape2)).rotation = Vector3.zero; } Instance.transform.parent = ((Component)((Item)CurrentWeapon).LoadedVisual).transform; if (RotationOffset == Vector3.zero) { Instance.transform.localEulerAngles = new Vector3(90f, 270f, 0f); } else { Instance.transform.localEulerAngles = RotationOffset; } Instance.transform.localPosition = PositionOffset; } private Equipment FindCurrentWeapon(Character _affectedCharacter) { Equipment val = null; EquipmentSlot matchingSlot = _affectedCharacter.Inventory.Equipment.GetMatchingSlot((EquipmentSlotIDs)6); if (IsMainHand) { if ((Object)(object)_affectedCharacter.CurrentWeapon == (Object)null) { ExtendedEffects.Instance.DebugLogMessage("SLEx_CustomImbueVFX Current Weapon is null"); return null; } val = (Equipment)(object)_affectedCharacter.CurrentWeapon; } else { if ((Object)(object)matchingSlot == (Object)null) { ExtendedEffects.Instance.DebugLogMessage("SLEx_CustomImbueVFX OffHand EquipmentSlot cannot be found"); return null; } if (!matchingSlot.HasItemEquipped) { ExtendedEffects.Instance?.DebugLogMessage("SLEx_CustomImbueVFX OffHand EquipmentSlotitem is null"); return null; } val = matchingSlot.EquippedItem; } return val; } public override void CleanUpOnDestroy() { ((Effect)this).CleanUpOnDestroy(); if (Object.op_Implicit((Object)(object)Instance)) { ExtendedEffects.Instance.DebugLogMessage("SLEx_CustomImbueVFX Cleaning up Instance"); Object.Destroy((Object)(object)Instance); } } public override void StopAffectLocally(Character _affectedCharacter) { if (Object.op_Implicit((Object)(object)Instance)) { ExtendedEffects.Instance.DebugLogMessage("SLEx_CustomImbueVFX destroying Instance"); Object.Destroy((Object)(object)Instance); } } } public class SL_ForceAIState : SL_Effect, ICustomModel { public int AIState; public Type SLTemplateModel => typeof(SL_ForceAIState); public Type GameModel => typeof(SLEx_ForceAIStateForTime); public override void ApplyToComponent<T>(T component) { SLEx_ForceAIStateForTime sLEx_ForceAIStateForTime = component as SLEx_ForceAIStateForTime; sLEx_ForceAIStateForTime.AIState = AIState; } public override void SerializeEffect<T>(T effect) { SLEx_ForceAIStateForTime sLEx_ForceAIStateForTime = effect as SLEx_ForceAIStateForTime; AIState = sLEx_ForceAIStateForTime.AIState; } } public class SLEx_ForceAIStateForTime : Effect, ICustomModel { public int AIState; public Type SLTemplateModel => typeof(SL_ForceAIState); public Type GameModel => typeof(SLEx_ForceAIStateForTime); public override void ActivateLocally(Character _affectedCharacter, object[] _infos) { if (AIState <= 3) { CharacterAI component = ((Component)_affectedCharacter).GetComponent<CharacterAI>(); if (Object.op_Implicit((Object)(object)component)) { ForceCharacterAIState(component, AIState); } } } private void ForceCharacterAIState(CharacterAI CharacterAI, int state) { CharacterAI.SwitchAiState(state); } } public class SL_HidePlayer : SL_Effect, ICustomModel { public float HideTime; public Type SLTemplateModel => typeof(SL_HidePlayer); public Type GameModel => typeof(SLEx_HidePlayer); public override void ApplyToComponent<T>(T component) { SLEx_HidePlayer sLEx_HidePlayer = component as SLEx_HidePlayer; sLEx_HidePlayer.HideTime = HideTime; } public override void SerializeEffect<T>(T effect) { SLEx_HidePlayer sLEx_HidePlayer = effect as SLEx_HidePlayer; HideTime = sLEx_HidePlayer.HideTime; } } public class SLEx_HidePlayer : Effect, ICustomModel { public float HideTime; private bool IsRunning = false; public Type SLTemplateModel => typeof(SL_HidePlayer); public Type GameModel => typeof(SLEx_HidePlayer); public override void ActivateLocally(Character _affectedCharacter, object[] _infos) { SL.Log("Activating Locally"); if (!IsRunning) { ((MonoBehaviour)this).StartCoroutine(ToggleCharacterVisual(((Effect)this).OwnerCharacter)); } } private IEnumerator ToggleCharacterVisual(Character _affectedCharacter) { IsRunning = true; ((Component)_affectedCharacter.VisualHolderTrans).gameObject.SetActive(false); yield return (object)new WaitForSeconds(HideTime); ((Component)_affectedCharacter.VisualHolderTrans).gameObject.SetActive(true); IsRunning = false; } } public class SL_PlayAssetBundleVFX : SL_Effect, ICustomModel { public string SLPackName; public string AssetBundleName; public string PrefabName; public Vector3 PositionOffset; public Vector3 RotationOffset; public bool ParentToAffected; public bool PositionOffsetAsRelativeDirection; public bool RotateToPlayerDirection; public float LifeTime; public virtual Type SLTemplateModel => typeof(SL_PlayAssetBundleVFX); public virtual Type GameModel => typeof(SLEx_PlayAssetBundleVFX); public override void ApplyToComponent<T>(T component) { //IL_0033: Unknown result type (might be due to invalid IL or missing references) //IL_0038: Unknown result type (might be due to invalid IL or missing references) //IL_003f: Unknown result type (might be due to invalid IL or missing references) //IL_0044: Unknown result type (might be due to invalid IL or missing references) SLEx_PlayAssetBundleVFX sLEx_PlayAssetBundleVFX = component as SLEx_PlayAssetBundleVFX; sLEx_PlayAssetBundleVFX.SLPackName = SLPackName; sLEx_PlayAssetBundleVFX.AssetBundleName = AssetBundleName; sLEx_PlayAssetBundleVFX.PrefabName = PrefabName; sLEx_PlayAssetBundleVFX.PositionOffset = PositionOffset; sLEx_PlayAssetBundleVFX.RotationOffset = RotationOffset; sLEx_PlayAssetBundleVFX.ParentToAffected = ParentToAffected; sLEx_PlayAssetBundleVFX.PositionOffsetAsRelativeDirection = PositionOffsetAsRelativeDirection; sLEx_PlayAssetBundleVFX.RotateToPlayerDirection = RotateToPlayerDirection; sLEx_PlayAssetBundleVFX.LifeTime = LifeTime; } public override void SerializeEffect<T>(T effect) { //IL_0033: Unknown result type (might be due to invalid IL or missing references) //IL_0038: Unknown result type (might be due to invalid IL or missing references) //IL_003f: Unknown result type (might be due to invalid IL or missing references) //IL_0044: Unknown result type (might be due to invalid IL or missing references) SLEx_PlayAssetBundleVFX sLEx_PlayAssetBundleVFX = effect as SLEx_PlayAssetBundleVFX; SLPackName = sLEx_PlayAssetBundleVFX.SLPackName; AssetBundleName = sLEx_PlayAssetBundleVFX.AssetBundleName; PrefabName = sLEx_PlayAssetBundleVFX.PrefabName; PositionOffset = sLEx_PlayAssetBundleVFX.PositionOffset; RotationOffset = sLEx_PlayAssetBundleVFX.RotationOffset; ParentToAffected = sLEx_PlayAssetBundleVFX.ParentToAffected; RotateToPlayerDirection = sLEx_PlayAssetBundleVFX.RotateToPlayerDirection; LifeTime = sLEx_PlayAssetBundleVFX.LifeTime; } } public class SLEx_PlayAssetBundleVFX : Effect, ICustomModel { public string SLPackName; public string AssetBundleName; public string PrefabName; public Vector3 PositionOffset; public Vector3 RotationOffset; public bool ParentToAffected; public bool PositionOffsetAsRelativeDirection; public bool RotateToPlayerDirection; public float LifeTime; private GameObject Instance; public virtual Type SLTemplateModel => typeof(SL_PlayAssetBundleVFX); public virtual Type GameModel => typeof(SLEx_PlayAssetBundleVFX); public override void ActivateLocally(Character _affectedCharacter, object[] _infos) { //IL_00bd: Unknown result type (might be due to invalid IL or missing references) //IL_0074: Unknown result type (might be due to invalid IL or missing references) //IL_00d8: Unknown result type (might be due to invalid IL or missing references) //IL_00e4: Unknown result type (might be due to invalid IL or missing references) //IL_00e9: Unknown result type (might be due to invalid IL or missing references) //IL_00ee: Unknown result type (might be due to invalid IL or missing references) //IL_00cb: Unknown result type (might be due to invalid IL or missing references) //IL_009a: Unknown result type (might be due to invalid IL or missing references) //IL_0093: Unknown result type (might be due to invalid IL or missing references) //IL_00f3: Unknown result type (might be due to invalid IL or missing references) //IL_011f: Unknown result type (might be due to invalid IL or missing references) //IL_0112: Unknown result type (might be due to invalid IL or missing references) GameObject fromAssetBundle = OutwardHelpers.GetFromAssetBundle<GameObject>(SLPackName, AssetBundleName, PrefabName); if ((Object)(object)fromAssetBundle != (Object)null) { if ((Object)(object)Instance == (Object)null) { Instance = Object.Instantiate<GameObject>(fromAssetBundle); } if (ParentToAffected) { Instance.transform.parent = _affectedCharacter.VisualHolderTrans; Instance.transform.localPosition = PositionOffset; Instance.transform.localEulerAngles = (RotateToPlayerDirection ? Vector3.zero : RotationOffset); } else { Instance.transform.position = ((Component)_affectedCharacter).transform.position + (PositionOffsetAsRelativeDirection ? (((Component)_affectedCharacter).transform.forward + ((Component)_affectedCharacter).transform.TransformVector(PositionOffset)) : PositionOffset); Instance.transform.eulerAngles = (RotateToPlayerDirection ? ((Component)_affectedCharacter).transform.eulerAngles : RotationOffset); } if (LifeTime > 0f) { ExtendedEffects.Instance.DebugLogMessage($"SLEx_PlayAssetBundleVFX LIFETIME IS {LifeTime}"); Object.Destroy((Object)(object)Instance, LifeTime); } } else { ExtendedEffects.Instance.DebugLogMessage("SLEx_PlayAssetBundleVFX Prefab from AssetBundle " + AssetBundleName + " was null."); } } public override void CleanUpOnDestroy() { ((Effect)this).CleanUpOnDestroy(); if (LifeTime == 0f && Object.op_Implicit((Object)(object)Instance)) { Object.Destroy((Object)(object)Instance); } } public override void StopAffectLocally(Character _affectedCharacter) { if (LifeTime == 0f && Object.op_Implicit((Object)(object)Instance)) { Object.Destroy((Object)(object)Instance); } } } public class SL_PlayAssetBundleVFX_Bones : SL_PlayAssetBundleVFX { public int BoneID; public override Type SLTemplateModel => typeof(SL_PlayAssetBundleVFX_Bones); public override Type GameModel => typeof(SLEx_PlayAssetBundleVFX_Bones); public override void ApplyToComponent<T>(T component) { //IL_0033: Unknown result type (might be due to invalid IL or missing references) //IL_0038: Unknown result type (might be due to invalid IL or missing references) //IL_003f: Unknown result type (might be due to invalid IL or missing references) //IL_0044: Unknown result type (might be due to invalid IL or missing references) SLEx_PlayAssetBundleVFX_Bones sLEx_PlayAssetBundleVFX_Bones = component as SLEx_PlayAssetBundleVFX_Bones; sLEx_PlayAssetBundleVFX_Bones.SLPackName = SLPackName; sLEx_PlayAssetBundleVFX_Bones.AssetBundleName = AssetBundleName; sLEx_PlayAssetBundleVFX_Bones.PrefabName = PrefabName; sLEx_PlayAssetBundleVFX_Bones.PositionOffset = PositionOffset; sLEx_PlayAssetBundleVFX_Bones.RotationOffset = RotationOffset; sLEx_PlayAssetBundleVFX_Bones.ParentToAffected = ParentToAffected; sLEx_PlayAssetBundleVFX_Bones.PositionOffsetAsRelativeDirection = PositionOffsetAsRelativeDirection; sLEx_PlayAssetBundleVFX_Bones.LifeTime = LifeTime; sLEx_PlayAssetBundleVFX_Bones.RotateToPlayerDirection = RotateToPlayerDirection; sLEx_PlayAssetBundleVFX_Bones.BoneID = BoneID; } public override void SerializeEffect<T>(T effect) { //IL_0033: Unknown result type (might be due to invalid IL or missing references) //IL_0038: Unknown result type (might be due to invalid IL or missing references) //IL_003f: Unknown result type (might be due to invalid IL or missing references) //IL_0044: Unknown result type (might be due to invalid IL or missing references) SLEx_PlayAssetBundleVFX_Bones sLEx_PlayAssetBundleVFX_Bones = effect as SLEx_PlayAssetBundleVFX_Bones; SLPackName = sLEx_PlayAssetBundleVFX_Bones.SLPackName; AssetBundleName = sLEx_PlayAssetBundleVFX_Bones.AssetBundleName; PrefabName = sLEx_PlayAssetBundleVFX_Bones.PrefabName; PositionOffset = sLEx_PlayAssetBundleVFX_Bones.PositionOffset; RotationOffset = sLEx_PlayAssetBundleVFX_Bones.RotationOffset; ParentToAffected = sLEx_PlayAssetBundleVFX_Bones.ParentToAffected; PositionOffsetAsRelativeDirection = sLEx_PlayAssetBundleVFX_Bones.PositionOffsetAsRelativeDirection; LifeTime = sLEx_PlayAssetBundleVFX_Bones.LifeTime; BoneID = sLEx_PlayAssetBundleVFX_Bones.BoneID; } } public class SLEx_PlayAssetBundleVFX_Bones : SLEx_PlayAssetBundleVFX { public int BoneID; private GameObject Instance; public override Type SLTemplateModel => typeof(SL_PlayAssetBundleVFX_Bones); public override Type GameModel => typeof(SLEx_PlayAssetBundleVFX_Bones); public override void ActivateLocally(Character _affectedCharacter, object[] _infos) { //IL_00d8: Unknown result type (might be due to invalid IL or missing references) //IL_00a1: Unknown result type (might be due to invalid IL or missing references) //IL_00b8: Unknown result type (might be due to invalid IL or missing references) //IL_00f4: Unknown result type (might be due to invalid IL or missing references) //IL_00f9: Unknown result type (might be due to invalid IL or missing references) //IL_00e6: Unknown result type (might be due to invalid IL or missing references) //IL_00fe: Unknown result type (might be due to invalid IL or missing references) //IL_012a: Unknown result type (might be due to invalid IL or missing references) //IL_011d: Unknown result type (might be due to invalid IL or missing references) GameObject fromAssetBundle = OutwardHelpers.GetFromAssetBundle<GameObject>(SLPackName, AssetBundleName, PrefabName); if ((Object)(object)fromAssetBundle != (Object)null) { Transform val = OutwardHelpers.TryGetHumanBone(_affectedCharacter, (HumanBodyBones)BoneID); if ((Object)(object)val == (Object)null) { ExtendedEffects.Instance.DebugLogMessage("SLEx_PlayAssetBundleVFX_Bone cannot find target bone"); return; } if ((Object)(object)Instance == (Object)null) { Instance = Object.Instantiate<GameObject>(fromAssetBundle); } if (ParentToAffected) { Instance.transform.parent = val; Instance.transform.localPosition = PositionOffset; Instance.transform.localEulerAngles = RotationOffset; } else { Instance.transform.position = ((Component)val).transform.position + (PositionOffsetAsRelativeDirection ? ((Component)_affectedCharacter).transform.TransformPoint(PositionOffset) : PositionOffset); Instance.transform.eulerAngles = (RotateToPlayerDirection ? ((Component)_affectedCharacter).transform.eulerAngles : RotationOffset); } if (LifeTime > 0f) { ExtendedEffects.Instance.DebugLogMessage($"SLEx_PlayAssetBundleVFX_Bones LIFETIME IS {LifeTime}"); Object.Destroy((Object)(object)Instance, LifeTime); } } else { ExtendedEffects.Instance.DebugLogMessage("SLEx_PlayAssetBundleVFX_Bones Prefab from AssetBundle " + AssetBundleName + " was null."); } } public override void CleanUpOnDestroy() { base.CleanUpOnDestroy(); if (LifeTime == 0f && Object.op_Implicit((Object)(object)Instance)) { Object.Destroy((Object)(object)Instance); } } public override void StopAffectLocally(Character _affectedCharacter) { if (LifeTime == 0f && Object.op_Implicit((Object)(object)Instance)) { Object.Destroy((Object)(object)Instance); } } } public class SL_SetWeaponEmission : SL_Effect, ICustomModel { public Vector3 Color; public float ColorIntensity = 4f; public float ColorLerpTime = 0.5f; public Type SLTemplateModel => typeof(SL_SetWeaponEmission); public Type GameModel => typeof(SLEx_SetWeaponEmission); public override void ApplyToComponent<T>(T component) { //IL_001b: Unknown result type (might be due to invalid IL or missing references) //IL_0020: Unknown result type (might be due to invalid IL or missing references) SLEx_SetWeaponEmission sLEx_SetWeaponEmission = component as SLEx_SetWeaponEmission; sLEx_SetWeaponEmission.ColorIntensity = ColorIntensity; sLEx_SetWeaponEmission.NewColor = Color; sLEx_SetWeaponEmission.ColorLerpTime = ColorLerpTime; } public override void SerializeEffect<T>(T component) { //IL_000f: Unknown result type (might be due to invalid IL or missing references) //IL_0014: Unknown result type (might be due to invalid IL or missing references) SLEx_SetWeaponEmission sLEx_SetWeaponEmission = component as SLEx_SetWeaponEmission; Color = sLEx_SetWeaponEmission.NewColor; ColorIntensity = sLEx_SetWeaponEmission.ColorIntensity; ColorLerpTime = sLEx_SetWeaponEmission.ColorLerpTime; } } public class SLEx_SetWeaponEmission : Effect, ICustomModel { public Vector3 NewColor; public float ColorIntensity; public float ColorLerpTime; private bool IsRunning = false; public Type SLTemplateModel => typeof(SL_SetWeaponEmission); public Type GameModel => typeof(SLEx_SetWeaponEmission); public override void ActivateLocally(Character _affectedCharacter, object[] _infos) { //IL_0075: Unknown result type (might be due to invalid IL or missing references) Weapon currentWeapon = ((Effect)this).OwnerCharacter.CurrentWeapon; if ((Object)(object)currentWeapon != (Object)null) { Renderer component = ((Component)((Component)((Item)currentWeapon).LoadedVisual).GetComponentInChildren<BoxCollider>()).GetComponent<Renderer>(); if ((Object)(object)component != (Object)null && !IsRunning) { ((MonoBehaviour)this).StartCoroutine(LerpMaterialEmissionColor(component, ColorLerpTime, new Color(NewColor.x, NewColor.y, NewColor.z, 1f), ColorIntensity)); } } } private IEnumerator LerpMaterialEmissionColor(Renderer Renderer, float lerpTime, Color newColor, float Intensity) { //IL_001c: Unknown result type (might be due to invalid IL or missing references) //IL_001d: Unknown result type (might be due to invalid IL or missing references) IsRunning = true; Color OriginalColor = Renderer.material.GetColor("_EmissionColor"); float timer = 0f; while (timer < lerpTime) { float currentPercent = timer / lerpTime; Renderer.material.SetColor("_EmissionColor", Color.Lerp(OriginalColor, newColor * Intensity, currentPercent)); timer += Time.deltaTime; yield return null; } IsRunning = false; } } public class SL_SummonExtension : SL_Effect, ICustomModel { public Vector3 NewBaseColor; public Vector3 NewParticlesColor; public SL_Damage NewWeaponDamage; public string StatusEffectOnSpawn; public Type SLTemplateModel => typeof(SL_SummonExtension); public Type GameModel => typeof(SummonExtension); public override void ApplyToComponent<T>(T component) { //IL_000f: Unknown result type (might be due to invalid IL or missing references) //IL_0014: Unknown result type (might be due to invalid IL or missing references) //IL_001b: Unknown result type (might be due to invalid IL or missing references) //IL_0020: Unknown result type (might be due to invalid IL or missing references) //IL_002c: Unknown result type (might be due to invalid IL or missing references) //IL_003c: Unknown result type (might be due to invalid IL or missing references) //IL_0046: Expected O, but got Unknown SummonExtension summonExtension = component as SummonExtension; summonExtension.NewBaseColor = NewBaseColor; summonExtension.NewParticlesColor = NewParticlesColor; summonExtension.NewWeaponDamage = new DamageType(NewWeaponDamage.Type, NewWeaponDamage.Damage); summonExtension.StatusEffectOnSpawn = StatusEffectOnSpawn; } public override void SerializeEffect<T>(T effect) { //IL_000f: Unknown result type (might be due to invalid IL or missing references) //IL_0014: Unknown result type (might be due to invalid IL or missing references) //IL_001b: Unknown result type (might be due to invalid IL or missing references) //IL_0020: Unknown result type (might be due to invalid IL or missing references) //IL_0032: Unknown result type (might be due to invalid IL or missing references) //IL_0037: Unknown result type (might be due to invalid IL or missing references) //IL_0048: 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_0054: Unknown result type (might be due to invalid IL or missing references) //IL_005e: Expected O, but got Unknown SummonExtension summonExtension = effect as SummonExtension; NewBaseColor = summonExtension.NewBaseColor; NewParticlesColor = summonExtension.NewParticlesColor; StatusEffectOnSpawn = summonExtension.StatusEffectOnSpawn; NewWeaponDamage = new SL_Damage { Damage = summonExtension.NewWeaponDamage.Damage, Type = summonExtension.NewWeaponDamage.Type }; } } public class SummonExtension : Effect { public Vector3 NewBaseColor; public Vector3 NewParticlesColor; public DamageType NewWeaponDamage; public string StatusEffectOnSpawn; public override void ActivateLocally(Character _affectedCharacter, object[] _infos) { if ((Object)(object)_affectedCharacter.CurrentSummon != (Object)null) { UpdateSummonBaseColor(_affectedCharacter); UpdateSummonParticles(_affectedCharacter); if (!string.IsNullOrEmpty(StatusEffectOnSpawn)) { AddSummonStatusEffects(_affectedCharacter.CurrentSummon); } if (NewWeaponDamage != null) { OverrideSummonWeaponDamage(_affectedCharacter.CurrentSummon); } } } private void UpdateSummonBaseColor(Character _affectedCharacter) { //IL_0048: Unknown result type (might be due to invalid IL or missing references) Renderer[] componentsInChildren = ((Component)((Effect)this).OwnerCharacter.CurrentSummon).GetComponentsInChildren<Renderer>(); foreach (Renderer val in componentsInChildren) { val.material.SetColor("_Color", new Color(NewBaseColor.x, NewBaseColor.y, NewBaseColor.z)); } } private void UpdateSummonParticles(Character _affectedCharacter) { //IL_0028: Unknown result type (might be due to invalid IL or missing references) //IL_002d: Unknown result type (might be due to invalid IL or missing references) //IL_0052: Unknown result type (might be due to invalid IL or missing references) //IL_0057: Unknown result type (might be due to invalid IL or missing references) ParticleSystem[] componentsInChildren = ((Component)((Effect)this).OwnerCharacter.CurrentSummon).GetComponentsInChildren<ParticleSystem>(); foreach (ParticleSystem val in componentsInChildren) { if (Object.op_Implicit((Object)(object)val)) { MainModule main = val.main; ((MainModule)(ref main)).startColor = MinMaxGradient.op_Implicit(new Color(NewParticlesColor.x, NewParticlesColor.y, NewParticlesColor.z)); } } } private void AddSummonStatusEffects(Character _summonCharacter) { StatusEffect statusEffectPrefab = ResourcesPrefabManager.Instance.GetStatusEffectPrefab(StatusEffectOnSpawn); if ((Object)(object)statusEffectPrefab != (Object)null) { _summonCharacter.StatusEffectMngr.AddStatusEffect(statusEffectPrefab.StatusName); } else { ExtendedEffects._Log.LogMessage((object)("SL_SummonExtension : Could not find Status by name " + StatusEffectOnSpawn)); } } private void OverrideSummonWeaponDamage(Character _summonCharacter) { //IL_002c: Unknown result type (might be due to invalid IL or missing references) //IL_0036: Expected O, but got Unknown if ((Object)(object)_summonCharacter.CurrentWeapon != (Object)null && NewWeaponDamage != null) { OutwardHelpers.UpdateWeaponDamage(_summonCharacter.CurrentWeapon, new DamageList(NewWeaponDamage)); } } } public class SL_SuspendStatusEffect : SL_Effect, ICustomModel { public string[] StatusEffectIdentifiers; public Type SLTemplateModel => typeof(SL_SuspendStatusEffect); public Type GameModel => typeof(SLEx_SuspendStatusEffect); public override void ApplyToComponent<T>(T component) { SLEx_SuspendStatusEffect sLEx_SuspendStatusEffect = component as SLEx_SuspendStatusEffect; sLEx_SuspendStatusEffect.StatusEffectIdentifiers = StatusEffectIdentifiers; } public override void SerializeEffect<T>(T effect) { SLEx_SuspendStatusEffect sLEx_SuspendStatusEffect = effect as SLEx_SuspendStatusEffect; StatusEffectIdentifiers = sLEx_SuspendStatusEffect.StatusEffectIdentifiers; } } public class SLEx_SuspendStatusEffect : Effect, ICustomModel { public string[] StatusEffectIdentifiers; public Type SLTemplateModel => typeof(SL_SuspendStatusEffect); public Type GameModel => typeof(SLEx_SuspendStatusEffect); private void SetSuspendedEffects(Character _affectedCharacter, bool suspended) { if (StatusEffectIdentifiers == null || StatusEffectIdentifiers.Length == 0) { ExtendedEffects._Log.LogDebug((object)"SLEx_SuspendStatusEffect defined without effects. Please specify the StatusEffectIdentifiers to suspend."); return; } foreach (StatusEffect status in _affectedCharacter.StatusEffectMngr.Statuses) { if (UnityEngineExtensions.Contains<string>(StatusEffectIdentifiers, status.IdentifierName) && status.IsEffectSuspended() != suspended) { ExtendedEffects._Log.LogDebug((object)$"Suspending effect of {status.IdentifierName} = {suspended}"); status.SetEffectSuspended(suspended); } } } public override void ActivateLocally(Character _affectedCharacter, object[] _infos) { SetSuspendedEffects(_affectedCharacter, suspended: true); } public override void StopAffectLocally(Character _affectedCharacter) { SetSuspendedEffects(_affectedCharacter, suspended: false); } } public class SL_SuspendStatusTimer : SL_Effect, ICustomModel { public string[] StatusEffectIdentifiers; public Type SLTemplateModel => typeof(SL_SuspendStatusTimer); public Type GameModel => typeof(SLEx_SuspendStatusTimer); public override void ApplyToComponent<T>(T component) { SLEx_SuspendStatusTimer sLEx_SuspendStatusTimer = component as SLEx_SuspendStatusTimer; sLEx_SuspendStatusTimer.StatusEffectIdentifiers = StatusEffectIdentifiers; } public override void SerializeEffect<T>(T effect) { SLEx_SuspendStatusTimer sLEx_SuspendStatusTimer = effect as SLEx_SuspendStatusTimer; StatusEffectIdentifiers = sLEx_SuspendStatusTimer.StatusEffectIdentifiers; } } public class SLEx_SuspendStatusTimer : Effect, ICustomModel { public string[] StatusEffectIdentifiers; public Type SLTemplateModel => typeof(SL_SuspendStatusTimer); public Type GameModel => typeof(SLEx_SuspendStatusTimer); private void SetSuspendedTimers(Character _affectedCharacter, bool suspended) { if (StatusEffectIdentifiers == null || StatusEffectIdentifiers.Length == 0) { ExtendedEffects._Log.LogDebug((object)"SLEx_SuspendStatusTimer defined without effects. Please specify the StatusEffectIdentifiers to suspend."); return; } foreach (StatusEffect status in _affectedCharacter.StatusEffectMngr.Statuses) { if (UnityEngineExtensions.Contains<string>(StatusEffectIdentifiers, status.IdentifierName) && status.IsTimerSuspended() != suspended) { ExtendedEffects._Log.LogDebug((object)$"Suspending timer of {status.IdentifierName} = {suspended}"); status.SetTimerSuspended(suspended); } } } public override void ActivateLocally(Character _affectedCharacter, object[] _infos) { SetSuspendedTimers(_affectedCharacter, suspended: true); } public override void StopAffectLocally(Character _affectedCharacter) { SetSuspendedTimers(_affectedCharacter, suspended: false); } } [Serializable] public class SkillTreeOverride { public string OriginalSkillTreeUID; public string NewSkillTreeUID; public SkillTreeOverride(string originalSkillTreeUID, string newSkillTreeUID) { OriginalSkillTreeUID = originalSkillTreeUID; NewSkillTreeUID = newSkillTreeUID; } } } namespace SideLoader_ExtendedEffects.Containers { public class SL_EffectLifecycleEffect : SL_ParentEffect { } public class EffectLifecycleEffect : ParentEffect, ICustomModel { private bool activated = false; public Type SLTemplateModel => typeof(SL_EffectLifecycleEffect); public Type GameModel => typeof(EffectLifecycleEffect); public override void ActivateLocally(Character _affectedCharacter, object[] _infos) { if (!activated) { ((EffectSynchronizer)((Effect)this).m_subEffects[0]).SynchronizeEffects((EffectCategories)2, ((Effect)this).OwnerCharacter); activated = true; } ((EffectSynchronizer)((Effect)this).m_subEffects[0]).SynchronizeEffects((EffectCategories)1, ((Effect)this).OwnerCharacter); } public override void StopAffectLocally(Character _affectedCharacter) { ((EffectSynchronizer)((Effect)this).m_subEffects[0]).SynchronizeEffects((EffectCategories)5, ((Effect)this).OwnerCharacter); activated = false; ((EffectSynchronizer)((Effect)this).m_subEffects[0]).StopAllEffects((EffectCategories)5, ((Effect)this).OwnerCharacter); ((EffectSynchronizer)((Effect)this).m_subEffects[0]).StopAllEffects((EffectCategories)2, ((Effect)this).OwnerCharacter); ((EffectSynchronizer)((Effect)this).m_subEffects[0]).StopAllEffects((EffectCategories)1, ((Effect)this).OwnerCharacter); base.StopAffectLocally(_affectedCharacter); } } public abstract class SL_ParentEffect : SL_Effect { public EditBehaviours EffectBehavior = (EditBehaviours)2; public SL_EffectTransform[] ChildEffects; public int ActivationLimit; public override void ApplyToComponent<T>(T component) { //IL_000e: Unknown result type (might be due to invalid IL or missing references) //IL_0014: Expected O, but got Unknown //IL_0052: Unknown result type (might be due to invalid IL or missing references) try { ParentEffect parentEffect = component as ParentEffect; GameObject val = new GameObject(); Object.DontDestroyOnLoad((Object)(object)val); val.SetActive(false); parentEffect.ActivationLimit = ActivationLimit; parentEffect.ChildEffects = val.gameObject.AddComponent<SubEffect>(); SL_EffectTransform.ApplyTransformList(((Component)parentEffect.ChildEffects).transform, ChildEffects, EffectBehavior); } catch (Exception ex) { SL.Log((object)ex); } } public override void SerializeEffect<T>(T effect) { //IL_0046: Unknown result type (might be due to invalid IL or missing references) //IL_004d: Expected O, but got Unknown try { ParentEffect parentEffect = effect as ParentEffect; if (((Component)parentEffect.ChildEffects).transform.childCount > 0) { List<SL_EffectTransform> list = new List<SL_EffectTransform>(); foreach (Transform item in ((Component)parentEffect.ChildEffects).transform) { Transform val = item; SL_EffectTransform val2 = SL_EffectTransform.ParseTransform(val); if (val2.HasContent) { list.Add(val2); } } ChildEffects = list.ToArray(); } ActivationLimit = parentEffect.ActivationLimit; } catch (Exception ex) { SL.Log((object)ex); } } } public abstract class ParentEffect : Shooter { public SubEffect ChildEffects; public int ActivationLimit; private float lastApplyTime = 0f; private Dictionary<Character, int> affectedThisInterval; public override void Setup(Factions[] _targetFactions, Transform _parent) { try { SL.Log("Set Up"); SL.Log("own parent: " + ((Object)((Effect)this).m_parentSynchronizer).name); ((Shooter)this).Setup(_targetFactions, _parent); if (((Effect)this).m_subEffects == null) { ((Effect)this).m_subEffects = (SubEffect[])(object)new SubEffect[1] { Object.Instantiate<SubEffect>(ChildEffects) }; } ((Component)((Effect)this).m_subEffects[0]).gameObject.SetActive(true); ((Effect)this).m_subEffects[0].Setup((Effect)(object)this, 0, _targetFactions, _parent); SL.Log((object)((Effect)this).m_subEffects[0].m_parentEffect); ((Effect)this).m_subEffects[0].m_parentEffect = (Effect)(object)this; Effect[] componentsInChildren = ((Component)((Component)((Effect)this).m_subEffects[0]).transform).GetComponentsInChildren<Effect>(); foreach (Effect val in componentsInChildren) { } } catch (Exception ex) { SL.Log("=========Setup Error!==========="); SL.Log((object)ex); } } public override void StopAffectLocally(Character _affectedCharacter) { //IL_001f: Unknown result type (might be due to invalid IL or missing references) //IL_0024: Unknown result type (might be due to invalid IL or missing references) //IL_002e: Unknown result type (might be due to invalid IL or missing references) foreach (EffectCategories value in Enum.GetValues(typeof(EffectCategories))) { ((EffectSynchronizer)((Effect)this).m_subEffects[0]).StopAllEffects(value, _affectedCharacter); } ((Effect)this).StopAffectLocally(_affectedCharacter); } public virtual void StartApply(EffectCategories[] categories, Character affectedCharacter, Vector3 pos, Vector3 dir) { //IL_00bf: Unknown result type (might be due to invalid IL or missing references) //IL_00ca: 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_00ce: Unknown result type (might be due to invalid IL or missing references) if (Time.time - lastApplyTime > 0f) { lastApplyTime = Time.time; if (affectedThisInterval == null) { affectedThisInterval = new Dictionary<Character, int>(); } else { affectedThisInterval.Clear(); } } int value = 0; if (!affectedThisInterval.TryGetValue(affectedCharacter, out value)) { affectedThisInterval.Add(affectedCharacter, 0); } if (ActivationLimit == 0 || value < ActivationLimit) { affectedThisInterval[affectedCharacter]++; foreach (EffectCategories val in categories) { ((EffectSynchronizer)((Effect)this).m_subEffects[0]).SynchronizeEffects(val, affectedCharacter, pos, dir); } } } public virtual void StopApply(EffectCategories[] categories, Character affectedCharacter) { //IL_000b: Unknown result type (might be due to invalid IL or missing references) //IL_0015: Unknown result type (might be due to invalid IL or missing references) foreach (EffectCategories val in categories) { ((EffectSynchronizer)((Effect)this).m_subEffects[0]).StopAllEffects(val, affectedCharacter); } } public virtual void Apply(EffectCategories[] categories, Character affectedCharacter, Vector3 pos, Vector3 dir) { //IL_0004: Unknown result type (might be due to invalid IL or missing references) //IL_0005: Unknown result type (might be due to invalid IL or missing references) StartApply(categories, affectedCharacter, pos, dir); StopApply(categories, affectedCharacter); } } } namespace SideLoader_ExtendedEffects.Containers.Triggers { public class SL_OnEquipEffect : SL_ParentEffect { public EquipmentSlotIDs[] AllowedSlots; public override void ApplyToComponent<T>(T component) { base.ApplyToComponent(component); OnEquipEffect onEquipEffect = component as OnEquipEffect; onEquipEffect.AllowedSlots = AllowedSlots; } public override void SerializeEffect<T>(T effect) { base.SerializeEffect(effect); OnEquipEffect onEquipEffect = effect as OnEquipEffect; AllowedSlots = onEquipEffect.AllowedSlots; } } public class OnEquipEffect : TriggeredEffect<EquipEvent>, ICustomModel { public EquipmentSlotIDs[] AllowedSlots; public Type SLTemplateModel => typeof(SL_OnEquipEffect); public Type GameModel => typeof(OnEquipEffect); public override void OnEvent(object sender, EquipEvent args) { //IL_0034: Unknown result type (might be due to invalid IL or missing references) //IL_00c9: Unknown result type (might be due to invalid IL or missing references) //IL_00d4: Unknown result type (might be due to invalid IL or missing references) //IL_0084: 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) if (!((Object)(object)args.character != (Object)(object)((Effect)this).OwnerCharacter) && (AllowedSlots == null || AllowedSlots.Length == 0 || UnityEngineExtensions.Contains<EquipmentSlotIDs>(AllowedSlots, args.slot))) { if (args.equipped) { ExtendedEffects.Instance.DebugLogMessage("Equipped item"); StartApply((EffectCategories[])(object)new EffectCategories[2] { (EffectCategories)2, (EffectCategories)1 }, args.character, args.character.m_lastPosition, args.character.m_lastForward); } else { ExtendedEffects.Instance.DebugLogMessage("Unequipped item"); StartApply((EffectCategories[])(object)new EffectCategories[2] { (EffectCategories)5, (EffectCategories)1 }, args.character, args.character.m_lastPosition, args.character.m_lastForward); } } } } public class SL_OnHitEffect : SL_ParentEffect { public OnHitEffect.DamageSourceType RequiredSourceType; public Types[] DamageTypes; public bool RequireAllTypes; public int MinDamage; public bool OnlyCountRequiredTypes; public bool UseHighestType; public bool IgnoreDamageReduction; public override void ApplyToComponent<T>(T component) { base.ApplyToComponent(component); OnHitEffect onHitEffect = component as OnHitEffect; onHitEffect.RequiredSourceType = RequiredSourceType; onHitEffect.DamageTypes = DamageTypes; onHitEffect.RequireAllTypes = RequireAllTypes; onHitEffect.MinDamage = MinDamage; onHitEffect.OnlyCountRequiredTypes = OnlyCountRequiredTypes; onHitEffect.UseHighestType = UseHighestType; onHitEffect.IgnoreDamageReduction = IgnoreDamageReduction; } public override void SerializeEffect<T>(T effect) { base.SerializeEffect(effect); OnHitEffect onHitEffect = effect as OnHitEffect; RequiredSourceType = onHitEffect.RequiredSourceType; DamageTypes = onHitEffect.DamageTypes; RequireAllTypes = onHitEffect.RequireAllTypes; MinDamage = onHitEffect.MinDamage; OnlyCountRequiredTypes = onHitEffect.OnlyCountRequiredTypes; UseHighestType = onHitEffect.UseHighestType; IgnoreDamageReduction = onHitEffect.IgnoreDamageReduction; } } public class OnHitEffect : TriggeredEffect<HitEvent>, ICustomModel { public enum DamageSourceType { ANY, WEAPON, NON_WEAPON } public DamageSourceType RequiredSourceType; public Types[] DamageTypes; public bool RequireAllTypes; public int MinDamage; public bool OnlyCountRequiredTypes; public bool UseHighestType; public bool IgnoreDamageReduction; public Type SLTemplateModel => typeof(SL_OnHitEffect); public Type GameModel => typeof(OnHitEffect); public override void OnEvent(object sender, HitEvent args) { //IL_036e: Unknown result type (might be due to invalid IL or missing references) //IL_0374: Unknown result type (might be due to invalid IL or missing references) //IL_038d: Unknown result type (might be due to invalid IL or missing references) //IL_0393: Unknown result type (might be due to invalid IL or missing references) //IL_034b: Unknown result type (might be due to invalid IL or missing references) //IL_0351: Unknown result type (might be due to invalid IL or missing references) //IL_01e7: Unknown result type (might be due to invalid IL or missing references) //IL_01f0: Unknown result type (might be due to invalid IL or missing references) //IL_015c: Unknown result type (might be due to invalid IL or missing references) //IL_0257: Unknown result type (might be due to invalid IL or missing references) //IL_0263: Unknown result type (might be due to invalid IL or missing references) try { if ((RequiredSourceType == DamageSourceType.NON_WEAPON && args.source is Weapon) || (RequiredSourceType == DamageSourceType.WEAPON && !(args.source is Weapon))) { ExtendedEffects.Instance.DebugLogMessage("Wrong Hit Type"); return; } if (!IgnoreDamageReduction) { if (args.source is Weapon) { ? val = args.target; EffectSynchronizer source = args.source; ((Character)val).ProcessDamageReduction((Weapon)(object)((source is Weapon) ? source : null), args.damage, false); } else if (args.source is StatusEffect) { ? val2 = args.target; DamageList damage = args.damage; EffectSynchronizer source2 = args.source; ((Character)val2).ProcessDamageReduction((Weapon)null, damage, ((StatusEffect)((source2 is StatusEffect) ? source2 : null)).IgnoreBarrier); } else { args.target.ProcessDamageReduction((Weapon)null, args.damage, false); } } if (UseHighestType) { int dTypeOfHighestDamage = args.damage.GetDTypeOfHighestDamage((IList<int>)(List<int>)DamageType.TypeList); if (DamageTypes != null && DamageTypes.Length != 0 && ((DamageTypes != null && DamageTypes.Length > 1 && RequireAllTypes) || !UnityEngineExtensions.Contains<Types>(DamageTypes, args.damage[dTypeOfHighestDamage].Type))) { ExtendedEffects.Instance.DebugLogMessage("Highest Damage Type Wrong"); return; } if (args.damage[dTypeOfHighestDamage].Damage < (float)MinDamage) { ExtendedEffects.Instance.DebugLogMessage("Highest Damage Too Low"); return; } } else if (RequireAllTypes) { Types[] damageTypes = DamageTypes; foreach (Types val3 in damageTypes) { if (!args.damage.Contains(val3)) { ExtendedEffects.Instance.DebugLogMessage("Not All Types Present"); return; } } } else if (DamageTypes != null && DamageTypes.Length != 0) { Types[] damageTypes2 = DamageTypes; foreach (Types val4 in damageTypes2) { bool flag = false; if (args.damage.Contains(val4)) { flag = true; break; } if (!flag) { ExtendedEffects.Instance.DebugLogMessage("None Of Types Present"); return; } } } List<EffectCategories> list = new List<EffectCategories>(); List<EffectCategories> list2 = new List<EffectCategories>(); if ((Object)(object)args.target == (Object)(object)((Effect)this).OwnerCharacter) { try { list.Add((EffectCategories)6); list2.Add((EffectCategories)5); } catch (Exception logMessage) { ExtendedEffects.Instance.DebugLogMessage(logMessage); } } if ((Object)(object)args.dealer == (Object)(object)((Effect)this).OwnerCharacter) { list2.Add((EffectCategories)4); list.Add((EffectCategories)1); } if ((Object)(object)args.dealer == (Object)(object)args.target) { list.AddRange(list2); Apply(list.ToArray(), args.dealer, args.hitLocation, args.hitDirection); } else { Apply(list.ToArray(), args.dealer, args.hitLocation, args.hitDirection); Apply(list2.ToArray(), args.target, args.hitLocation, args.hitDirection); } } catch (Exception logMessage2) { ExtendedEffects.Instance.DebugLogMessage("=============Hit Event Error============"); ExtendedEffects.Instance.DebugLogMessage(logMessage2); } } } public abstract class TriggeredEffect<Event> : ParentEffect where Event : struct { private bool registered = false; public override void ActivateLocally(Character _affectedCharacter, object[] _infos) { if (!registered) { ExtendedEffects.Instance.DebugLogMessage("Registering Event"); ExtendedEffects.Instance.DebugLogMessage(new EventHandler<Event>(OnEvent).Method.DeclaringType); Publisher<Event>.Handler += OnEvent; registered = true; } else { ExtendedEffects.Instance.DebugLogMessage("Event already registered"); } } public override void StopAffectLocally(Character _affectedCharacter) { if (registered) { ExtendedEffects.Instance.DebugLogMessage("Deregistering Event"); Publisher<Event>.Handler -= OnEvent; registered = false; } else { ExtendedEffects.Instance.DebugLogMessage("Event not registered"); } base.StopAffectLocally(_affectedCharacter); } public abstract void OnEvent(object sender, Event args); } } namespace SideLoader_ExtendedEffects.Patches { [HarmonyPatch(typeof(ItemDisplayOptionPanel))] public static class ItemDisplayOptionPanelPatches { [HarmonyPatch("GetActiveActions")] [HarmonyPostfix] private static void EquipmentMenu_GetActiveActions_Postfix(ItemDisplayOptionPanel __instance, GameObject pointerPress, ref List<int> __result) { if ((Object)(object)__instance.m_pendingItem == (Object)null || ((UIElement)__instance).LocalCharacter.IsAI) { return; } foreach (KeyValuePair<int, CustomItemDisplayMenuOption> customItemOption in ExtendedEffects.Instance.CustomItemMenuManager.CustomItemOptions) { if (__result.Contains(customItemOption.Key)) { continue; } if (customItemOption.Value.ShouldAddActionDelegate != null) { if (customItemOption.Value.ShouldAddActionDelegate(((UIElement)__instance).LocalCharacter, __instance.m_pendingItem, __instance, customItemOption.Key)) { __result.Add(customItemOption.Key); } } else { __result.Add(customItemOption.Key); } } } [HarmonyPatch("ActionHasBeenPressed")] [HarmonyPrefix] private static void EquipmentMenu_ActionHasBeenPressed_Prefix(ItemDisplayOptionPanel __instance, int _actionID) { Character targetCharacter = ((UIElement)__instance).m_characterUI.TargetCharacter; Item pendingItem = __instance.m_pendingItem; if (!Object.op_Implicit((Object)(object)targetCharacter) || !Object.op_Implicit((Object)(object)pendingItem) || !targetCharacter.Inventory.OwnsOrHasEquipped(pendingItem.ItemID)) { return; } foreach (KeyValuePair<int, CustomItemDisplayMenuOption> customItemOption in ExtendedEffects.Instance.CustomItemMenuManager.CustomItemOptions) { if (_actionID == customItemOption.Key) { customItemOption.Value?.OnCustomActionPressed(targetCharacter, pendingItem, __instance, _actionID); } } } [HarmonyPatch("GetActionText")] [HarmonyPrefix] private static bool EquipmentMenu_GetActionText_Prefix(ItemDisplayOptionPanel __instance, int _actionID, ref string __result) { foreach (KeyValuePair<int, CustomItemDisplayMenuOption> customItemOption in ExtendedEffects.Instance.CustomItemMenuManager.CustomItemOptions) { if (_actionID == customItemOption.Key) { __result = customItemOption.Value.ActionString; return false; } } return true; } } [HarmonyPatch(typeof(Trainer))] public static class TrainerPatches { [HarmonyPatch("GetSkillTree")] [HarmonyPrefix] public static bool GetSkillTreeOverridePrefix(Trainer __instance, ref SkillSchool __result) { //IL_0041: 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_007a: Unknown result type (might be due to invalid IL or missing references) SNPC val = ((Component)__instance).GetComponentInParent<SNPC>(); string empty = string.Empty; if ((Object)(object)val == (Object)null) { val = ((Component)((Component)__instance).transform.parent.parent).GetComponentInChildren<SNPC>(); empty = __instance.HolderUID.m_value; } else { empty = val.HolderUID.m_value; } if ((Object)(object)val != (Object)null) { if (ExtendedEffects.HasSkillTreeOverride(empty)) { string text = ExtendedEffects.SkillTreeOverrides[empty]; SkillSchool skillTreeFromUID = SkillTreeHolder.Instance.GetSkillTreeFromUID(UID.op_Implicit(text)); if ((Object)(object)skillTreeFromUID != (Object)null) { __result = skillTreeFromUID; return false; } ExtendedEffects._Log.LogMessage((object)("Could not find a valid SkillSchool with UID " + text)); } else { ExtendedEffects._Log.LogMessage((object)("No Override For Trainer with UID " + empty)); } } else { ExtendedEffects._Log.LogMessage((object)"Character isn't a trainer."); } return true; } } } namespace SideLoader_ExtendedEffects.Item_Context_Menu { public class CustomItemDisplayMenuOption { public int CustomEquipActionID = 10000; public string ActionString = "Activate "; public Action<Character, Item, ItemDisplayOptionPanel, int> OnCustomActionPressed; public Func<Character, Item, ItemDisplayOptionPanel, int, bool> ShouldAddActionDelegate; public CustomItemDisplayMenuOption(int customEquipActionID, string equip_String, Action<Character, Item, ItemDisplayOptionPanel, int> onCustomActionPressed, Func<Character, Item, ItemDisplayOptionPanel, int, bool> shouldAddActionDelegate) { CustomEquipActionID = customEquipActionID; ActionString = equip_String; OnCustomActionPressed = onCustomActionPressed; ShouldAddActionDelegate = shouldAddActionDelegate; } } } namespace SideLoader_ExtendedEffects.Extensions { public static class SLEffectExtensions { public static void ApplyIcon(this SL_StatusEffect effect) { //IL_0032: Unknown result type (might be due to invalid IL or missing references) //IL_0038: Expected O, but got Unknown //IL_0066: Unknown result type (might be due to invalid IL or missing references) //IL_006b: Unknown result type (might be due to invalid IL or missing references) //IL_0070: Unknown result type (might be due to invalid IL or missing references) //IL_007d: Expected O, but got Unknown SLPack sLPack = SL.GetSLPack(((SL_StatusBase)effect).SLPackName); string path = sLPack.FolderPath + "\\StatusEffects\\" + effect.StatusIdentifier + "\\icon.png"; byte[] array = File.ReadAllBytes(path); Texture2D val = new Texture2D(2, 2); ImageConversion.LoadImage(val, array); Sprite val2 = CustomTextures.CreateSprite(val, (SpriteBorderTypes)0); StatusEffect statusEffectPrefab = ResourcesPrefabManager.Instance.GetStatusEffectPrefab(effect.StatusIdentifier); statusEffectPrefab.OverrideIcon = val2; statusEffectPrefab.m_defaultStatusIcon = new StatusTypeIcon(Tag.None) { Icon = val2 }; } } } namespace SideLoader_ExtendedEffects.Released { public class SL_AffectCurrentHP : SL_Effect, ICustomModel { public float Modifier; public Type SLTemplateModel => typeof(SL_AffectCurrentHP); public Type GameModel => typeof(AffectCurrentHP); public override void ApplyToComponent<T>(T component) { AffectCurrentHP affectCurrentHP = component as AffectCurrentHP; affectCurrentHP.Modifier = Modifier; } public override void SerializeEffect<T>(T effect) { AffectCurrentHP affectCurrentHP = effect as AffectCurrentHP; Modifier = affectCurrentHP.Modifier; } } public class AffectCurrentHP : Effect { public float Modifier; public override void ActivateLocally(Character _affectedCharacter, object[] _infos) { if (!(Modifier <= 0f)) { float num = _affectedCharacter.Health * Modifier; _affectedCharacter.Stats.AffectHealth(num); } } } public class SL_ApplyCharacterAuraVFX : SL_Effect, ICustomModel { public string SLPackName; public string AssetBundleName; public string PrefabName; public float LifeTime; public Type SLTemplateModel => typeof(SL_ApplyCharacterAuraVFX); public Type GameModel => typeof(ApplyCharacterAuraVFX); public override void ApplyToComponent<T>(T component) { ApplyCharacterAuraVFX applyCharacterAuraVFX = component as ApplyCharacterAuraVFX; applyCharacterAuraVFX.SLPackName = SLPackName; applyCharacterAuraVFX.AssetBundleName = AssetBundleName; applyCharacterAuraVFX.PrefabName = PrefabName; applyCharacterAuraVFX.LifeTime = LifeTime; } public override void SerializeEffect<T>(T effect) { ApplyCharacterAuraVFX applyCharacterAuraVFX = effect as ApplyCharacterAuraVFX; SLPackName = applyCharacterAuraVFX.SLPackName; AssetBundleName = applyCharacterAuraVFX.AssetBundleName; PrefabName = applyCharacterAuraVFX.PrefabName; LifeTime = applyCharacterAuraVFX.LifeTime; } } public class ApplyCharacterAuraVFX : Effect { public string SLPackName; public string AssetBundleName; public string PrefabName; public float LifeTime; private GameObject Instance; private GameObject Prefab = null; private SkinnedMeshRenderer BodyMesh = null; private ParticleSystem[] CachedPS = null; public override void ActivateLocally(Character _affectedCharacter, object[] _infos) { if ((Object)(object)Prefab == (Object)null) { Prefab = OutwardHelpers.GetFromAssetBundle<GameObject>(SLPackName, AssetBundleName, PrefabName); } if ((Object)(object)Prefab != (Object)null) { if ((Object)(object)BodyMesh == (Object)null) { BodyMesh = FindBaseBody(_affectedCharacter); } if ((Object)(object)BodyMesh == (Object)null) { ExtendedEffects.Instance.DebugLogMessage("ApplyCharacterAuraVFX cant find body mesh"); return; } if ((Object)(object)Instance == (Object)null) { Instance = Object.Instantiate<GameObject>(Prefab); } Instance.transform.parent = _affectedCharacter.VisualHolderTrans; if ((Object)(object)BodyMesh != (Object)null) { UpdateVFXParticleSystem(Instance, BodyMesh); } } else { ExtendedEffects.Instance.DebugLogMessage("ApplyCharacterAuraVFX Prefab is null."); } } public override void CleanUpOnDestroy() { ((Effect)this).CleanUpOnDestroy(); if (Object.op_Implicit((Object)(object)Instance)) { ExtendedEffects.Instance.DebugLogMessage("ApplyCharacterAuraVFX Cleaning up Instance"); Object.Destroy((Object)(object)Instance); } } public override void StopAffectLocally(Character _affectedCharacter) { if (Object.op_Implicit((Object)(object)Instance)) { ExtendedEffects.Instance.DebugLogMessage("ApplyCharacterAuraVFX destroying Instance"); Object.Destroy((Object)(object)Instance); } } private SkinnedMeshRenderer FindBaseBody(Character _affectedCharacter) { SkinnedMeshRenderer[] componentsInChildren = ((Component)_affectedCharacter.VisualHolderTrans).GetComponentsInChildren<SkinnedMeshRenderer>(true); SkinnedMeshRenderer[] array = componentsInChildren; foreach (SkinnedMeshRenderer val in array) { if (((Object)((Component)val).transform).name.Contains("Body")) { return val; } } return null; } private void UpdateVFXParticleSystem(GameObject VFXInstance, SkinnedMeshRenderer SkinnedMeshRenderer) { //IL_00c0: Unknown result type (might be due to invalid IL or missing references) //IL_0059: Unknown result type (might be due to invalid IL or missing references) //IL_005e: Unknown result type (might be due to invalid IL or missing references) //IL_0062: Unknown result type (might be due to invalid IL or missing references) //IL_0069: Invalid comparison between Unknown and I4 //IL_0077: Unknown result type (might be due to invalid IL or missing references) //IL_007c: Unknown result type (might be due to invalid IL or missing references) //IL_0089: Unknown result type (might be due to invalid IL or missing references) //IL_0096: Unknown result type (might be due to invalid IL or missing references) //IL_00a3: Unknown result type (might be due to invalid IL or missing references) if (CachedPS == null) { CachedPS = VFXInstance.GetComponentsInChildren<ParticleSystem>(); } if (CachedPS == null || CachedPS.Length == 0) { return; } ParticleSystem[] cachedPS = CachedPS; foreach (ParticleSystem val in cachedPS) { if ((Object)(object)val != (Object)null) { ShapeModule shape = val.shape; if ((int)((ShapeModule)(ref shape)).shapeType == 14) { ShapeModule shape2 = val.shape; ((ShapeModule)(ref shape2)).skinnedMeshRenderer = SkinnedMeshRenderer; ((ShapeModule)(ref shape2)).scale = Vector3.one; ((ShapeModule)(ref shape2)).position = Vector3.zero; ((ShapeModule)(ref shape2)).rotation = Vector3.zero; } } } VFXInstance.transform.localPosition = Vector3.zero; } } public class SL_RemoveItemFromInventory : SL_Effect, ICustomModel { public int ItemID; public int ItemQuantity; public Type SLTemplateModel => typeof(SL_RemoveItemFromInventory); public Type GameModel => typeof(RemoveItemFromInventory); public override void ApplyToComponent<T>(T component) { RemoveItemFromInventory removeItemFromInventory = component as RemoveItemFromInventory; removeItemFromInventory.ItemID = ItemID; removeItemFromInventory.ItemQuantity = ItemQuantity; } public override void SerializeEffect<T>(T effect) { RemoveItemFromInventory removeItemFromInventory = effect as RemoveItemFromInventory; ItemID = removeItemFromInventory.ItemID; ItemQuantity = removeItemFromInventory.ItemQuantity; } } public class RemoveItemFromInventory : Effect { public int ItemID; public int ItemQuantity; public override void ActivateLocally(Character _affectedCharacter, object[] _infos) { if (_affectedCharacter.IsAI || (Object)(object)_affectedCharacter.Inventory == (Object)null) { return; } List<Item> ownedItems = _affectedCharacter.Inventory.GetOwnedItems(ItemID); if (ownedItems.Count > 0) { Item val = ownedItems[0]; if (val.IsStackable) { if (val.RemainingAmount >= ItemQuantity) { val.RemoveQuantity(ItemQuantity); } else { ExtendedEffects.Instance.DebugLogMessage("RemoveItemFromInventory :: Not enough items in stack"); } } else if (ownedItems.Count >= ItemQuantity) { _affectedCharacter.Inventory.RemoveItem(ItemID, ItemQuantity); } } else { ExtendedEffects.Instance.DebugLogMessage($"RemoveItemFromInventory :: No Items found with ID {ItemID}"); } } } public class SL_ScalingWeaponDamage : SL_Effect, ICustomModel { public SL_Damage[] DamageModifiers; public float KnockbackAmount; public bool HitInventory; public Type SLTemplateModel => typeof(SL_ScalingWeaponDamage); public Type GameModel => typeof(SLEx_ScalingWeaponDamage); public override void ApplyToComponent<T>(T component) { SLEx_ScalingWeaponDamage sLEx_ScalingWeaponDamage = component as SLEx_ScalingWeaponDamage; sLEx_ScalingWeaponDamage.KnockbackAmount = KnockbackAmount; sLEx_ScalingWeaponDamage.HitInventory = HitInventory; sLEx_ScalingWeaponDamage.DamageModifiers = DamageModifiers.ToList(); } public override void SerializeEffect<T>(T effect) { SLEx_ScalingWeaponDamage sLEx_ScalingWeaponDamage = effect as SLEx_ScalingWeaponDamage; KnockbackAmount = sLEx_ScalingWeaponDamage.KnockbackAmount; HitInventory = sLEx_ScalingWeaponDamage.HitInventory; DamageModifiers = sLEx_ScalingWeaponDamage.DamageModifiers.ToArray(); } } public class SLEx_ScalingWeaponDamage : Effect, ICustomModel { public List<SL_Damage> DamageModifiers; public float KnockbackAmount; public bool HitInventory; public Type SLTemplateModel => typeof(SL_ScalingWeaponDamage); public Type GameModel => typeof(SLEx_ScalingWeaponDamage); public override void ActivateLocally(Character _affectedCharacter, object[] _infos) { //IL_0026: 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_003b: Unknown result type (might be due to invalid IL or missing references) //IL_004a: Unknown result type (might be due to invalid IL or missing references) //IL_0051: Unknown result type (might be due to invalid IL or missing references) Character ownerCharacter = base.m_parentSynchronizer.OwnerCharacter; Weapon currentWeapon = ownerCharacter.CurrentWeapon; if ((Object)(object)currentWeapon != (Object)null) { Vector3 val = ((Component)ownerCharacter).transform.position - ((Component)_affectedCharacter).transform.position; _affectedCharacter.ReceiveHit((Object)(object)((Effect)this).OwnerCharacter, CalculateWeaponDamage(currentWeapon), val, ((Component)_affectedCharacter).transform.position, 0f, 0f, ownerCharacter, KnockbackAmount, HitInventory); } else { ExtendedEffects.Instance.DebugLogMessage("SLEx_ScalingWeapon Owner has no weapon equipped!"); } } private DamageList CalculateWeaponDamage(Weapon weapon) { DamageList NewList = weapon.Damage.Clone(); if (DamageModifiers != null && DamageModifiers.Count > 0) { int i; for (i = 0; i < NewList.Count; i++) { SL_Damage val = DamageModifiers.Find((SL_Damage x) => x.Type == NewList[i].Type); if (val != null) { DamageType obj = NewList[i]; obj.Damage *= val.Damage; } } } return NewList; } } } namespace SideLoader_ExtendedEffects.Released.Conditions { public class SL_EquipmentSlotHasTag : SL_EffectCondition, ICustomModel { public string EquipmentSlotID; public string TagName; public Type SLTemplateModel => typeof(SL_EquipmentSlotHasTag); public Type GameModel => typeof(EquipmentSlotHasTag); public override void ApplyToComponent<T>(T component) { //IL_0023: Unknown result type (might be due to invalid IL or missing references) //IL_0028: Unknown result type (might be due to invalid IL or missing references) EquipmentSlotHasTag equipmentSlotHasTag = component as EquipmentSlotHasTag; equipmentSlotHasTag.EquipmentSlot = (EquipmentSlotIDs)Enum.Parse(typeof(EquipmentSlotIDs), EquipmentSlotID); equipmentSlotHasTag.TagName = TagName; } public override void SerializeEffect<T>(T component) { EquipmentSlotHasTag equipmentSlotHasTag = component as EquipmentSlotHasTag; EquipmentSlotID = ((object)(EquipmentSlotIDs)(ref equipmentSlotHasTag.EquipmentSlot)).ToString(); TagName = equipmentSlotHasTag.TagName; } } public class EquipmentSlotHasTag : EffectCondition { public EquipmentSlotIDs EquipmentSlot; public string TagName; public override bool CheckIsValid(Character _affectedCharacter) { //IL_000d: 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_0022: Unknown result type (might be due to invalid IL or missing references) //IL_0027: Unknown result type (might be due to invalid IL or missing references) //IL_0028: Unknown result type (might be due to invalid IL or missing references) //IL_002b: 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_0048: Unknown result type (might be due to invalid IL or missing references) //IL_0068: Unknown result type (might be due to invalid IL or missing references) if (_affectedCharacter.Inventory.Equipment.HasItemEquipped(EquipmentSlot)) { Tag tagFromName = OutwardHelpers.GetTagFromName(TagName); if (tagFromName != default(Tag)) { Equipment equippedItem = _affectedCharacter.Inventory.Equipment.GetMatchingSlot(EquipmentSlot).EquippedItem; return (Object)(object)equippedItem != (Object)null && ((Item)equippedItem).HasTag(tagFromName); } ExtendedEffects.Instance.DebugLogMessage("Couldn't find tag with name " + TagName); } ExtendedEffects.Instance.DebugLogMessage($"Has no equipped Item in the specified slot {EquipmentSlot}"); return false; } } public class SL_HasStat : SL_EffectCondition, ICustomModel { public string TagName; public float StatValue; public bool IsAbsolute = true; public Type SLTemplateModel => typeof(SL_HasStat); public Type GameModel => typeof(HasStat); public override void ApplyToComponent<T>(T component) { HasStat hasStat = component as HasStat; hasStat.TagName = TagName; hasStat.StatValue = StatValue; hasStat.IsAbsolute = IsAbsolute; } public override void SerializeEffect<T>(T component) { HasStat hasStat = component as HasStat; TagName = hasStat.TagName; StatValue = hasStat.StatValue; IsAbsolute = hasStat.IsAbsolute; } } public class HasStat : EffectCondition { public string TagName; public float StatValue; public bool IsAbsolute = true; public override bool CheckIsValid(Character _affectedCharacter) { //IL_0007: Unknown result type (might be due to invalid IL or missing references) //IL_000c: Unknown result type (might be due to invalid IL or missing references) //IL_000d: Unknown result type (might be due to invalid IL or missing references) //IL_0010: Unknown result type (might be due to invalid IL or missing references) //IL_0016: Unknown result type (might be due to invalid IL or missing references) //IL_0027: Unknown result type (might be due to invalid IL or missing references) Tag tagFromName = OutwardHelpers.GetTagFromName(TagName); if (tagFromName != default(Tag)) { Stat stat = _affectedCharacter.Stats.GetStat(tagFromName); if (stat == null) { ExtendedEffects._Log.LogMessage((object)"FoundStat was null"); return false; } if (IsAbsolute) { return stat.CurrentValue <= StatValue; } float num = stat.CurrentValue / stat.MaxRange * 100f; return num <= StatValue; } ExtendedEffects._Log.LogMessage((object)("Stat Tag (" + TagName + ") could not be found")); return false; } } public class SL_IsAllowedScene : SL_EffectCondition, ICustomModel { public List<string> AllowedScenes; public Type SLTemplateModel => typeof(SL_IsAllowedScene); public Type GameModel => typeof(IsAllowedSceneCondition); public override void ApplyToComponent<T>(T component) { IsAllowedSceneCondition isAllowedSceneCondition = component as IsAllowedSceneCondition;

Outward

OuthardAdditionalContent

Details

BepInEx/plugins/exp111-SkilledAtMeditation/SkilledAtMeditation.dll

BepInEx/plugins/gothiska-APP/APP.dll

BepInEx/plugins/IggyTheMad-AlternateStart/AlternateStart.dll

BepInEx/plugins/IggyTheMad-TrueHardcore/HardcoreRebalance.dll

BepInEx/plugins/SLExtendedEffects-SideLoader_ExtendedEffects/SideLoader_ExtendedEffects.dll

BepInEx/plugins/exp111-SkilledAtMeditation/SkilledAtMeditation.dll

BepInEx/plugins/gothiska-APP/APP.dll

BepInEx/plugins/IggyTheMad-AlternateStart/AlternateStart.dll

BepInEx/plugins/IggyTheMad-TrueHardcore/HardcoreRebalance.dll

BepInEx/plugins/SLExtendedEffects-SideLoader_ExtendedEffects/SideLoader_ExtendedEffects.dll