using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using HarmonyLib;
using JetBrains.Annotations;
using LocalizationManager;
using Microsoft.CodeAnalysis;
using ProtectiveWards;
using ServerSync;
using SoftReferenceableAssets;
using Splatform;
using TMPro;
using UnityEngine;
using YamlDotNet.Serialization;
[assembly: AssemblyFileVersion("1.2.11")]
[assembly: Guid("f71912b8-9b1c-4181-911a-1550f4ec2889")]
[assembly: ComVisible(false)]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCopyright("Copyright © 2023")]
[assembly: AssemblyProduct("Protective Wards")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyTitle("Protective Wards")]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: CompilationRelaxations(8)]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.2.11.0")]
[module: UnverifiableCode]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[<8f059e17-c087-458d-8ed8-eb7eea2d85fc>Embedded]
internal sealed class <8f059e17-c087-458d-8ed8-eb7eea2d85fc>EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[<8f059e17-c087-458d-8ed8-eb7eea2d85fc>Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
internal sealed class <7dc057df-d7e0-4d55-b22a-f122ce8b99e2>NullableAttribute : Attribute
{
public readonly byte[] NullableFlags;
public <7dc057df-d7e0-4d55-b22a-f122ce8b99e2>NullableAttribute(byte P_0)
{
NullableFlags = new byte[1] { P_0 };
}
public <7dc057df-d7e0-4d55-b22a-f122ce8b99e2>NullableAttribute(byte[] P_0)
{
NullableFlags = P_0;
}
}
[CompilerGenerated]
[<8f059e17-c087-458d-8ed8-eb7eea2d85fc>Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
internal sealed class <34d7319c-58c0-486d-afe2-590349447353>NullableContextAttribute : Attribute
{
public readonly byte Flag;
public <34d7319c-58c0-486d-afe2-590349447353>NullableContextAttribute(byte P_0)
{
Flag = P_0;
}
}
}
namespace LocalizationManager
{
[<34d7319c-58c0-486d-afe2-590349447353>NullableContext(1)]
[<7dc057df-d7e0-4d55-b22a-f122ce8b99e2>Nullable(0)]
[PublicAPI]
public class Localizer
{
[CompilerGenerated]
private sealed class <Load>d__12 : IEnumerator<object>, IDisposable, IEnumerator
{
private int <>1__state;
[<7dc057df-d7e0-4d55-b22a-f122ce8b99e2>Nullable(0)]
private object <>2__current;
object IEnumerator<object>.Current
{
[DebuggerHidden]
[return: <7dc057df-d7e0-4d55-b22a-f122ce8b99e2>Nullable(0)]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
[return: <7dc057df-d7e0-4d55-b22a-f122ce8b99e2>Nullable(0)]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <Load>d__12(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0040: Unknown result type (might be due to invalid IL or missing references)
//IL_004a: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<>2__current = (object)new WaitUntil((Func<bool>)(() => PlatformManager.DistributionPlatform != null && PlatformInitializer.PreferencesInitialized));
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
if (string.IsNullOrEmpty(PlatformPrefs.GetString("language", "")))
{
PlatformPrefs.SetString("language", "English");
}
LoadLocalization(Localization.instance, Localization.instance.GetSelectedLanguage());
return false;
}
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
private const string defaultLanguage = "English";
private static readonly Dictionary<string, Dictionary<string, Func<string>>> PlaceholderProcessors;
private static readonly Dictionary<string, Dictionary<string, string>> loadedTexts;
private static readonly ConditionalWeakTable<Localization, string> localizationLanguage;
private static readonly List<WeakReference<Localization>> localizationObjects;
[<7dc057df-d7e0-4d55-b22a-f122ce8b99e2>Nullable(2)]
private static BaseUnityPlugin _plugin;
private static readonly List<string> fileExtensions;
private static BaseUnityPlugin Plugin
{
get
{
//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
//IL_00b2: Expected O, but got Unknown
if (_plugin == null)
{
IEnumerable<TypeInfo> source;
try
{
source = Assembly.GetExecutingAssembly().DefinedTypes.ToList();
}
catch (ReflectionTypeLoadException ex)
{
source = from t in ex.Types
where t != null
select t.GetTypeInfo();
}
_plugin = (BaseUnityPlugin)Chainloader.ManagerObject.GetComponent((Type)source.First([<34d7319c-58c0-486d-afe2-590349447353>NullableContext(0)] (TypeInfo t) => t.IsClass && typeof(BaseUnityPlugin).IsAssignableFrom(t)));
}
return _plugin;
}
}
private static void UpdatePlaceholderText(Localization localization, string key)
{
localizationLanguage.TryGetValue(localization, out var value);
string text = loadedTexts[value][key];
if (PlaceholderProcessors.TryGetValue(key, out var value2))
{
text = value2.Aggregate(text, [<34d7319c-58c0-486d-afe2-590349447353>NullableContext(0)] (string current, KeyValuePair<string, Func<string>> kv) => current.Replace("{" + kv.Key + "}", kv.Value()));
}
localization.AddWord(key, text);
}
public static void AddPlaceholder<T>(string key, string placeholder, ConfigEntry<T> config, [<7dc057df-d7e0-4d55-b22a-f122ce8b99e2>Nullable(new byte[] { 2, 1, 1 })] Func<T, string> convertConfigValue = null)
{
if (convertConfigValue == null)
{
convertConfigValue = (T val) => val.ToString();
}
if (!PlaceholderProcessors.ContainsKey(key))
{
PlaceholderProcessors[key] = new Dictionary<string, Func<string>>();
}
config.SettingChanged += [<34d7319c-58c0-486d-afe2-590349447353>NullableContext(0)] (object _, EventArgs _) =>
{
UpdatePlaceholder();
};
if (loadedTexts.ContainsKey(Localization.instance.GetSelectedLanguage()))
{
UpdatePlaceholder();
}
void UpdatePlaceholder()
{
PlaceholderProcessors[key][placeholder] = () => convertConfigValue(config.Value);
UpdatePlaceholderText(Localization.instance, key);
}
}
public static void AddText(string key, string text)
{
List<WeakReference<Localization>> list = new List<WeakReference<Localization>>();
foreach (WeakReference<Localization> localizationObject in localizationObjects)
{
if (localizationObject.TryGetTarget(out var target))
{
Dictionary<string, string> dictionary = loadedTexts[localizationLanguage.GetOrCreateValue(target)];
if (!target.m_translations.ContainsKey(key))
{
dictionary[key] = text;
target.AddWord(key, text);
}
}
else
{
list.Add(localizationObject);
}
}
foreach (WeakReference<Localization> item in list)
{
localizationObjects.Remove(item);
}
}
[IteratorStateMachine(typeof(<Load>d__12))]
public static IEnumerator Load()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <Load>d__12(0);
}
private static void LoadLocalization(Localization __instance, string language)
{
//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
//IL_0105: Expected O, but got Unknown
//IL_01e8: Unknown result type (might be due to invalid IL or missing references)
//IL_01f2: Expected O, but got Unknown
if (!localizationLanguage.Remove(__instance))
{
localizationObjects.Add(new WeakReference<Localization>(__instance));
}
localizationLanguage.Add(__instance, language);
Dictionary<string, string> localizationFiles = new Dictionary<string, string>();
string[] prefixes = new string[2]
{
Plugin.Info.Metadata.Name + ".",
Plugin.Info.Metadata.Name.Replace(" ", "") + "."
};
Scan(Paths.ConfigPath, warn: true);
Scan(Paths.PluginPath, warn: false);
byte[] array = LoadTranslationFromAssembly("English");
if (array == null)
{
throw new Exception("Found no English localizations in mod " + Plugin.Info.Metadata.Name + ". Expected an embedded resource Translations/English.json or Translations/English.yml.");
}
Dictionary<string, string> dictionary = ((BuilderSkeleton<DeserializerBuilder>)new DeserializerBuilder()).IgnoreFields().Build().Deserialize<Dictionary<string, string>>(Encoding.UTF8.GetString(array));
if (dictionary == null)
{
throw new Exception("Localization for mod " + Plugin.Info.Metadata.Name + " failed: Localization file was empty.");
}
string text = null;
if (language != "English")
{
if (localizationFiles.ContainsKey(language))
{
text = File.ReadAllText(localizationFiles[language]);
}
else
{
byte[] array2 = LoadTranslationFromAssembly(language);
if (array2 != null)
{
text = Encoding.UTF8.GetString(array2);
}
}
}
if (text == null && localizationFiles.ContainsKey("English"))
{
text = File.ReadAllText(localizationFiles["English"]);
}
if (text != null)
{
Dictionary<string, string> dictionary2;
try
{
dictionary2 = ((BuilderSkeleton<DeserializerBuilder>)new DeserializerBuilder()).IgnoreFields().Build().Deserialize<Dictionary<string, string>>(text) ?? new Dictionary<string, string>();
}
catch (Exception arg)
{
global::ProtectiveWards.ProtectiveWards.LogInfo($"Failed to deserialize localization for language '{language}'. Using base localization only.\n{arg}");
dictionary2 = new Dictionary<string, string>();
}
foreach (KeyValuePair<string, string> item in dictionary2)
{
dictionary[item.Key] = item.Value;
}
}
loadedTexts[language] = dictionary;
foreach (KeyValuePair<string, string> item2 in dictionary)
{
UpdatePlaceholderText(__instance, item2.Key);
}
void Scan(string root, bool warn)
{
foreach (string item3 in from f in Directory.GetFiles(root, "*.*", SearchOption.AllDirectories)
where fileExtensions.Contains(Path.GetExtension(f))
select f)
{
string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(item3);
string[] array3 = prefixes;
foreach (string text2 in array3)
{
if (fileNameWithoutExtension.StartsWith(text2))
{
string text3 = fileNameWithoutExtension.Substring(text2.Length);
if (!string.IsNullOrWhiteSpace(text3))
{
if (localizationFiles.ContainsKey(text3))
{
if (warn)
{
global::ProtectiveWards.ProtectiveWards.LogInfo("Duplicate localization '" + text3 + "' for " + Plugin.Info.Metadata.Name + ". Skipping " + item3);
}
}
else
{
localizationFiles[text3] = item3;
}
}
break;
}
}
}
}
}
static Localizer()
{
//IL_0050: Unknown result type (might be due to invalid IL or missing references)
//IL_0056: Expected O, but got Unknown
//IL_0084: Unknown result type (might be due to invalid IL or missing references)
//IL_0091: Expected O, but got Unknown
PlaceholderProcessors = new Dictionary<string, Dictionary<string, Func<string>>>();
loadedTexts = new Dictionary<string, Dictionary<string, string>>();
localizationLanguage = new ConditionalWeakTable<Localization, string>();
localizationObjects = new List<WeakReference<Localization>>();
fileExtensions = new List<string> { ".json", ".yml" };
Harmony val = new Harmony("org.bepinex.helpers.LocalizationManager");
val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Localization), "LoadCSV", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Localizer), "LoadLocalization", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
}
[return: <7dc057df-d7e0-4d55-b22a-f122ce8b99e2>Nullable(2)]
private static byte[] LoadTranslationFromAssembly(string language)
{
foreach (string fileExtension in fileExtensions)
{
byte[] array = ReadEmbeddedFileBytes("translations." + language + fileExtension);
if (array != null)
{
return array;
}
}
return null;
}
[<34d7319c-58c0-486d-afe2-590349447353>NullableContext(2)]
public static byte[] ReadEmbeddedFileBytes([<7dc057df-d7e0-4d55-b22a-f122ce8b99e2>Nullable(1)] string resourceFileName, Assembly containingAssembly = null)
{
using MemoryStream memoryStream = new MemoryStream();
if ((object)containingAssembly == null)
{
containingAssembly = Assembly.GetCallingAssembly();
}
string text = containingAssembly.GetManifestResourceNames().FirstOrDefault([<34d7319c-58c0-486d-afe2-590349447353>NullableContext(0)] (string str) => str.EndsWith(resourceFileName, StringComparison.Ordinal));
if (text != null)
{
containingAssembly.GetManifestResourceStream(text)?.CopyTo(memoryStream);
}
return (memoryStream.Length == 0L) ? null : memoryStream.ToArray();
}
}
}
namespace ProtectiveWards
{
internal class FullProtection
{
[HarmonyPatch(typeof(Character), "AddFireDamage")]
public static class Character_AddFireDamage_IndirectFireDamageProtection
{
private static void Prefix(Character __instance, ref float damage)
{
//IL_0045: Unknown result type (might be due to invalid IL or missing references)
if (ProtectiveWards.modEnabled.Value && ProtectiveWards.boarsHensProtection.Value && __instance.IsTamed() && ProtectiveWards._boarsHensProtectionGroupList.Contains(__instance.m_group.ToLower()) && ProtectiveWards.InsideEnabledPlayersArea(((Component)__instance).transform.position))
{
damage = 0f;
}
}
}
[HarmonyPatch(typeof(Character), "UpdateSmoke")]
public static class Character_UpdateSmoke_IndirectSmokeDamageProtection
{
private static void Prefix(Character __instance, ref float dt)
{
//IL_0045: Unknown result type (might be due to invalid IL or missing references)
if (ProtectiveWards.modEnabled.Value && ProtectiveWards.boarsHensProtection.Value && __instance.IsTamed() && ProtectiveWards._boarsHensProtectionGroupList.Contains(__instance.m_group.ToLower()) && ProtectiveWards.InsideEnabledPlayersArea(((Component)__instance).transform.position))
{
dt = 0f;
}
}
}
[HarmonyPatch(typeof(WearNTear), "UpdateWear")]
public static class WearNTear_UpdateWear_RainProtection
{
private static void Prefix(WearNTear __instance, ref bool ___m_noRoofWear, ref bool __state)
{
//IL_0053: Unknown result type (might be due to invalid IL or missing references)
if (ProtectiveWards.modEnabled.Value && ProtectiveWards.wardRainProtection.Value && ___m_noRoofWear && !((Object)(object)__instance.m_nview == (Object)null) && __instance.m_nview.IsValid() && ProtectiveWards.InsideEnabledPlayersArea(((Component)__instance).transform.position, checkCache: true))
{
__state = ___m_noRoofWear;
___m_noRoofWear = false;
}
}
private static void Postfix(ref bool ___m_noRoofWear, bool __state)
{
if (ProtectiveWards.modEnabled.Value && ProtectiveWards.wardRainProtection.Value && __state)
{
___m_noRoofWear = __state;
}
}
}
[HarmonyPatch(typeof(Ship), "UpdateUpsideDmg")]
public static class Ship_UpdateUpsideDmg_PreventShipDamage
{
private static bool Prefix(Ship __instance)
{
//IL_0031: Unknown result type (might be due to invalid IL or missing references)
if (!ProtectiveWards.modEnabled.Value)
{
return true;
}
if (ProtectiveWards.wardShipProtection.Value == ProtectiveWards.ShipDamageType.Off)
{
return true;
}
return !ProtectiveWards.InsideEnabledPlayersArea(((Component)__instance).transform.position);
}
}
[HarmonyPatch(typeof(Ship), "UpdateWaterForce")]
public static class Ship_UpdateWaterForce_PreventShipDamage
{
private static void Prefix(Ship __instance, ref float ___m_waterImpactDamage, ref float __state)
{
//IL_002d: Unknown result type (might be due to invalid IL or missing references)
if (ProtectiveWards.modEnabled.Value && ProtectiveWards.wardShipProtection.Value != 0 && ProtectiveWards.InsideEnabledPlayersArea(((Component)__instance).transform.position))
{
__state = ___m_waterImpactDamage;
___m_waterImpactDamage = 0f;
}
}
private static void Postfix(Ship __instance, ref float ___m_waterImpactDamage, float __state)
{
if (__state != 0f)
{
___m_waterImpactDamage = __state;
}
}
}
[HarmonyPatch(typeof(Trap), "OnTriggerEnter")]
private static class Trap_OnTriggerEnter_TrapProtection
{
private static bool Prefix(Trap __instance, Collider collider)
{
//IL_0045: Unknown result type (might be due to invalid IL or missing references)
if (!ProtectiveWards.modEnabled.Value)
{
return true;
}
if (!ProtectiveWards.wardTrapProtection.Value)
{
return true;
}
if ((Object)(object)((Component)collider).GetComponentInParent<Player>() == (Object)null)
{
return true;
}
return !ProtectiveWards.InsideEnabledPlayersArea(((Component)__instance).transform.position, checkCache: true);
}
}
[HarmonyPatch(typeof(Destructible), "Damage")]
public static class Destructible_Damage_PlantProtection
{
private static void ModifyHitDamage(HitData hit, float value)
{
((DamageTypes)(ref hit.m_damage)).Modify(Math.Max(value, 0f));
}
private static void Prefix(Destructible __instance, bool ___m_destroyed, HitData hit)
{
//IL_0068: Unknown result type (might be due to invalid IL or missing references)
//IL_006e: Invalid comparison between Unknown and I4
//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
if (!ProtectiveWards.modEnabled.Value || !ProtectiveWards.wardPlantProtection.Value || (Object)(object)__instance.m_nview == (Object)null || !__instance.m_nview.IsValid() || !__instance.m_nview.IsOwner() || __instance.m_destroyed || (int)__instance.GetDestructibleType() != 1 || __instance.m_health != 1f || hit == null || !hit.HaveAttacker() || !ProtectiveWards.InsideEnabledPlayersArea(((Component)__instance).transform.position, out var area, checkCache: true))
{
return;
}
Pickable val = default(Pickable);
if ((Object)(object)((Component)__instance).GetComponent<Plant>() != (Object)null)
{
ModifyHitDamage(hit, 0f);
area.FlashShield(false);
}
else if (((Component)__instance).TryGetComponent<Pickable>(ref val))
{
GameObject itemPrefab = val.m_itemPrefab;
SharedData val2 = ((itemPrefab == null) ? null : itemPrefab.GetComponent<ItemDrop>()?.m_itemData.m_shared);
if (val2 != null && ProtectiveWards._wardPlantProtectionList.Contains(val2.m_name.ToLower()))
{
ModifyHitDamage(hit, 0f);
area.FlashShield(false);
}
}
}
}
}
internal class Multipliers
{
[HarmonyPatch(typeof(SEMan), "ModifyFallDamage")]
public static class SEMan_ModifyFallDamage_FallDamageMultiplier
{
private static void Postfix(Character ___m_character, ZNetView ___m_nview, ref float damage)
{
//IL_0023: Unknown result type (might be due to invalid IL or missing references)
if (ProtectiveWards.modEnabled.Value && !((Object)(object)___m_nview == (Object)null) && ProtectiveWards.InsideEnabledPlayersArea(((Component)___m_character).transform.position))
{
damage *= Math.Max(ProtectiveWards.fallDamageTakenMultiplier.Value, 0f);
}
}
}
[HarmonyPatch(typeof(Character), "Damage")]
public static class Character_Damage_DamageMultipliers
{
private static void Prefix(Character __instance, ref HitData hit, ZNetView ___m_nview)
{
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
if (!ProtectiveWards.modEnabled.Value || (Object)(object)___m_nview == (Object)null || !ProtectiveWards.InsideEnabledPlayersArea(((Component)__instance).transform.position, out var area) || (hit.HaveAttacker() && hit.GetAttacker().IsBoss()))
{
return;
}
if (__instance.IsPlayer())
{
ModifyHitDamage(ref hit, ProtectiveWards.playerDamageTakenMultiplier.Value);
}
else if (__instance.IsTamed())
{
ModifyHitDamage(ref hit, ProtectiveWards.tamedDamageTakenMultiplier.Value);
if (ProtectiveWards.boarsHensProtection.Value && ProtectiveWards._boarsHensProtectionGroupList.Contains(__instance.m_group.ToLower()) && (!hit.HaveAttacker() || !hit.GetAttacker().IsPlayer()))
{
if (hit.GetTotalDamage() != hit.m_damage.m_fire)
{
area.FlashShield(false);
}
ModifyHitDamage(ref hit, 0f);
}
}
else
{
ModifyHitDamage(ref hit, ProtectiveWards.playerDamageDealtMultiplier.Value);
}
}
}
[HarmonyPatch(typeof(WearNTear), "Damage")]
public static class WearNTear_Damage_DamageTakenMultiplier
{
private static void Prefix(WearNTear __instance, ref HitData hit, ZNetView ___m_nview)
{
//IL_0026: 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_0055: Invalid comparison between Unknown and I4
//IL_008c: Unknown result type (might be due to invalid IL or missing references)
//IL_0092: Invalid comparison between Unknown and I4
if (ProtectiveWards.modEnabled.Value && !((Object)(object)___m_nview == (Object)null) && ProtectiveWards.InsideEnabledPlayersArea(((Component)__instance).transform.position, checkCache: true))
{
if (ProtectiveWards.fireplaceProtection.Value && (int)hit.m_hitType == 14 && (Object)(object)((Component)__instance).GetComponent<Fireplace>() != (Object)null)
{
ModifyHitDamage(ref hit, 0f);
}
else if (ProtectiveWards.wardShipProtection.Value == ProtectiveWards.ShipDamageType.AnyButPlayerDamage && (int)hit.m_hitType != 2 && (Object)(object)((Component)__instance).GetComponent<Ship>() != (Object)null)
{
ModifyHitDamage(ref hit, 0f);
}
else if (ProtectiveWards.wardShipProtection.Value == ProtectiveWards.ShipDamageType.AnyDamage && (Object)(object)((Component)__instance).GetComponent<Ship>() != (Object)null)
{
ModifyHitDamage(ref hit, 0f);
}
else if ((Object)(object)((Component)__instance).GetComponent<Piece>() != (Object)null && (!hit.HaveAttacker() || !hit.GetAttacker().IsBoss()))
{
ModifyHitDamage(ref hit, ProtectiveWards.structureDamageTakenMultiplier.Value);
}
}
}
}
[HarmonyPatch(typeof(Player), "UpdateFood")]
public static class Player_UpdateFood_FoodDrainMultiplier
{
private static void Prefix(Player __instance, float dt, bool forceUpdate)
{
//IL_0064: Unknown result type (might be due to invalid IL or missing references)
if (!ProtectiveWards.modEnabled.Value || ProtectiveWards.foodDrainMultiplier.Value == 1f || (Object)(object)__instance == (Object)null || !(dt + __instance.m_foodUpdateTimer >= 1f || forceUpdate) || !ProtectiveWards.InsideEnabledPlayersArea(((Component)__instance).transform.position))
{
return;
}
foreach (Food food in __instance.m_foods)
{
food.m_time += 1f - Math.Max(0f, ProtectiveWards.foodDrainMultiplier.Value);
}
}
}
[HarmonyPatch(typeof(Player), "UseStamina")]
public static class Player_UseStamina_StaminaDrainMultiplier
{
private static void Prefix(Player __instance, ref float v)
{
//IL_003e: Unknown result type (might be due to invalid IL or missing references)
if (ProtectiveWards.modEnabled.Value && ProtectiveWards.staminaDrainMultiplier.Value != 1f && !((Object)(object)__instance == (Object)null) && ProtectiveWards.InsideEnabledPlayersArea(((Component)__instance).transform.position))
{
v *= Math.Max(0f, ProtectiveWards.staminaDrainMultiplier.Value);
}
}
}
[HarmonyPatch(typeof(Player), "UpdatePlacement")]
public static class Player_UseStamina_HammerDurabilityDrainMultiplier
{
private static void Prefix(Player __instance, ref float __state)
{
//IL_0052: Unknown result type (might be due to invalid IL or missing references)
if (ProtectiveWards.modEnabled.Value && ProtectiveWards.hammerDurabilityDrainMultiplier.Value != 1f && !((Object)(object)__instance == (Object)null) && ((Character)__instance).InPlaceMode() && ProtectiveWards.InsideEnabledPlayersArea(((Component)__instance).transform.position))
{
ItemData rightItem = ((Humanoid)__instance).GetRightItem();
__state = rightItem.m_shared.m_useDurabilityDrain;
SharedData shared = rightItem.m_shared;
shared.m_useDurabilityDrain *= Math.Max(0f, ProtectiveWards.hammerDurabilityDrainMultiplier.Value);
}
}
private static void Postfix(Player __instance, float __state)
{
if (__state != 0f)
{
ItemData rightItem = ((Humanoid)__instance).GetRightItem();
rightItem.m_shared.m_useDurabilityDrain = __state;
}
}
}
[HarmonyPatch(typeof(Player), "Repair")]
public static class Player_Repair_HammerDurabilityDrainMultiplier
{
private static void Prefix(Player __instance, ItemData toolItem, ref float __state)
{
//IL_0050: Unknown result type (might be due to invalid IL or missing references)
if (ProtectiveWards.modEnabled.Value && ProtectiveWards.hammerDurabilityDrainMultiplier.Value != 1f && !((Object)(object)__instance == (Object)null) && ((Character)__instance).InPlaceMode() && ProtectiveWards.InsideEnabledPlayersArea(((Component)__instance).transform.position))
{
__state = toolItem.m_shared.m_useDurabilityDrain;
SharedData shared = toolItem.m_shared;
shared.m_useDurabilityDrain *= Math.Max(0f, ProtectiveWards.hammerDurabilityDrainMultiplier.Value);
}
}
private static void Postfix(Player __instance, ItemData toolItem, float __state)
{
if (__state != 0f)
{
toolItem.m_shared.m_useDurabilityDrain = __state;
}
}
}
[HarmonyPatch(typeof(Skills), "LowerAllSkills")]
private static class Skills_OnDeath_SkillDrainMultiplier
{
private static void Prefix(ref float factor, Player ___m_player)
{
//IL_0027: Unknown result type (might be due to invalid IL or missing references)
if (ProtectiveWards.modEnabled.Value && !((Object)(object)___m_player == (Object)null) && ProtectiveWards.InsideEnabledPlayersArea(((Component)___m_player).transform.position))
{
factor *= Math.Max(0f, ProtectiveWards.skillsDrainMultiplier.Value);
}
}
}
[HarmonyPatch(typeof(Fireplace), "GetTimeSinceLastUpdate")]
private static class Fireplace_GetTimeSinceLastUpdate_FireplaceDrainMultiplier
{
private static void Postfix(Fireplace __instance, ref double __result)
{
//IL_0031: Unknown result type (might be due to invalid IL or missing references)
if (ProtectiveWards.modEnabled.Value && ProtectiveWards.fireplaceDrainMultiplier.Value != 1f && ProtectiveWards.InsideEnabledPlayersArea(((Component)__instance).transform.position, checkCache: true))
{
__result *= Math.Max(0f, ProtectiveWards.fireplaceDrainMultiplier.Value);
}
}
}
[HarmonyPatch(typeof(Smelter), "GetDeltaTime")]
private static class Smelter_GetDeltaTime_FireplaceDrainMultiplier_SmeltingSpeedMultiplier
{
private static void Postfix(Smelter __instance, ref double __result)
{
//IL_0051: Unknown result type (might be due to invalid IL or missing references)
if (ProtectiveWards.modEnabled.Value)
{
float num = ((__instance.m_name == "$piece_bathtub") ? ProtectiveWards.fireplaceDrainMultiplier.Value : ProtectiveWards.smeltingSpeedMultiplier.Value);
if (num != 1f && ProtectiveWards.InsideEnabledPlayersArea(((Component)__instance).transform.position, checkCache: true))
{
__result *= Math.Max(0f, num);
}
}
}
}
[HarmonyPatch(typeof(CookingStation), "GetDeltaTime")]
private static class CookingStation_GetDeltaTime_CookingSpeedMultiplier
{
private static void Postfix(Smelter __instance, ref float __result)
{
//IL_0031: Unknown result type (might be due to invalid IL or missing references)
if (ProtectiveWards.modEnabled.Value && ProtectiveWards.cookingSpeedMultiplier.Value != 1f && ProtectiveWards.InsideEnabledPlayersArea(((Component)__instance).transform.position, checkCache: true))
{
__result *= Math.Max(0f, ProtectiveWards.cookingSpeedMultiplier.Value);
}
}
}
[HarmonyPatch(typeof(CookingStation), "UpdateFuel")]
private static class CookingStation_UpdateFuel_FireplaceDrainMultiplier
{
private static void Prefix(Smelter __instance, ref float dt, ref float __state)
{
//IL_0048: Unknown result type (might be due to invalid IL or missing references)
if (ProtectiveWards.modEnabled.Value && (ProtectiveWards.fireplaceDrainMultiplier.Value != 1f || ProtectiveWards.cookingSpeedMultiplier.Value != 1f) && ProtectiveWards.InsideEnabledPlayersArea(((Component)__instance).transform.position, checkCache: true))
{
__state = dt;
dt *= Math.Max(0f, ProtectiveWards.fireplaceDrainMultiplier.Value);
if (ProtectiveWards.cookingSpeedMultiplier.Value > 0f)
{
dt /= ProtectiveWards.cookingSpeedMultiplier.Value;
}
}
}
private static void Postfix(Smelter __instance, ref float dt, float __state)
{
if (__state != 0f)
{
dt = __state;
}
}
}
[HarmonyPatch(typeof(Fermenter), "GetFermentationTime")]
private static class Fermenter_GetFermentationTime_FermentingSpeedMultiplier
{
private static void Postfix(Fermenter __instance, ref double __result)
{
//IL_0031: Unknown result type (might be due to invalid IL or missing references)
if (ProtectiveWards.modEnabled.Value && ProtectiveWards.fermentingSpeedMultiplier.Value != 1f && ProtectiveWards.InsideEnabledPlayersArea(((Component)__instance).transform.position, checkCache: true))
{
__result *= Math.Max(0f, ProtectiveWards.fermentingSpeedMultiplier.Value);
}
}
}
[HarmonyPatch(typeof(SapCollector), "GetTimeSinceLastUpdate")]
private static class SapCollector_GetTimeSinceLastUpdate_SapCollectingSpeedMultiplier
{
private static void Postfix(SapCollector __instance, ref float __result)
{
//IL_0031: Unknown result type (might be due to invalid IL or missing references)
if (ProtectiveWards.modEnabled.Value && ProtectiveWards.sapCollectingSpeedMultiplier.Value != 1f && ProtectiveWards.InsideEnabledPlayersArea(((Component)__instance).transform.position, checkCache: true))
{
__result *= Math.Max(0f, ProtectiveWards.sapCollectingSpeedMultiplier.Value);
}
}
}
[HarmonyPatch(typeof(Turret), "IsCoolingDown")]
private static class Turret_IsCoolingDown_turretFireRateMultiplier
{
private static void Prefix(Turret __instance, ref float ___m_attackCooldown, ref float __state)
{
//IL_0031: Unknown result type (might be due to invalid IL or missing references)
if (ProtectiveWards.modEnabled.Value && ProtectiveWards.turretFireRateMultiplier.Value != 1f && ProtectiveWards.InsideEnabledPlayersArea(((Component)__instance).transform.position, checkCache: true))
{
__state = ___m_attackCooldown;
___m_attackCooldown *= Math.Max(0f, ProtectiveWards.turretFireRateMultiplier.Value);
}
}
private static void Postfix(ref float ___m_attackCooldown, float __state)
{
if (ProtectiveWards.modEnabled.Value && __state > 0f)
{
___m_attackCooldown = __state;
}
}
}
private static void ModifyHitDamage(ref HitData hit, float value)
{
((DamageTypes)(ref hit.m_damage)).Modify(Math.Max(value, 0f));
}
}
internal class RaidProtection
{
[HarmonyPatch(typeof(Player), "UpdateBaseValue")]
public static class Player_UpdateBaseValue_SittingRaidProtection
{
public static void Postfix(Player __instance, float ___m_baseValueUpdateTimer, ref int ___m_baseValue, ZNetView ___m_nview)
{
//IL_0066: Unknown result type (might be due to invalid IL or missing references)
if (ProtectiveWards.modEnabled.Value && ProtectiveWards.sittingRaidProtection.Value && ___m_baseValueUpdateTimer == 0f && ___m_baseValue >= 3 && ((Character)__instance).IsSitting() && __instance.m_attached && ((Character)__instance).m_seman.HaveStatusEffect(SEMan.s_statusEffectCampFire) && ProtectiveWards.InsideEnabledPlayersArea(((Component)__instance).transform.position, checkCache: true))
{
___m_baseValue = ProtectiveWards.baseValueProtected;
ZNet.instance.m_serverSyncedPlayerData["baseValue"] = ___m_baseValue.ToString();
___m_nview.GetZDO().Set(ZDOVars.s_baseValue, ___m_baseValue, false);
}
}
}
[HarmonyPatch(typeof(RandEventSystem), "CheckBase")]
public static class RandEventSystem_CheckBase_SittingRaidProtection
{
public static void Postfix(PlayerEventData player, ref bool __result)
{
//IL_0027: 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_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_0053: Unknown result type (might be due to invalid IL or missing references)
if (ProtectiveWards.modEnabled.Value && ProtectiveWards.sittingRaidProtection.Value && __result && player.baseValue == ProtectiveWards.baseValueProtected)
{
ProtectiveWards.LogInfo($"Player at {player.position.x} {player.position.z} is in raid protected state.");
__result = false;
}
}
}
}
public static class WardOfferings
{
[HarmonyPatch(typeof(PrivateArea), "UseItem")]
public static class PrivateArea_UseItem_Offerings
{
private static bool Prefix(PrivateArea __instance, Humanoid user, ItemData item, ref bool __result)
{
//IL_0118: Unknown result type (might be due to invalid IL or missing references)
//IL_011e: Invalid comparison between Unknown and I4
//IL_015c: Unknown result type (might be due to invalid IL or missing references)
//IL_0163: Invalid comparison between Unknown and I4
if (!__instance.IsEnabled())
{
ProtectiveWards.LogInfo("Ward disabled");
return true;
}
if (!__instance.HaveLocalAccess())
{
ProtectiveWards.LogInfo("No access");
return true;
}
Player val = (Player)(object)((user is Player) ? user : null);
if (!Object.op_Implicit((Object)(object)val) || (Object)(object)val != (Object)(object)Player.m_localPlayer)
{
ProtectiveWards.LogInfo("UseItem user not a player");
return true;
}
ProtectiveWards.LogInfo($"{val.GetPlayerName()} used {item.m_shared.m_name} on {__instance.m_nview.GetZDO()}");
bool flag = item.m_shared.m_name == "$item_blackcore" && ProtectiveWards.offeringAugmenting.Value;
bool flag2 = flag || (item.m_shared.m_name == "$item_surtlingcore" && ProtectiveWards.offeringActiveRepair.Value);
bool flag3 = (ProtectiveWards.offeringFood.Value || ProtectiveWards.offeringMead.Value) && (int)item.m_shared.m_itemType == 2;
bool flag4 = ProtectiveWards.offeringThundertone.Value && item.m_shared.m_name == "$item_thunderstone";
bool flag5 = ProtectiveWards.offeringTrophy.Value && (int)item.m_shared.m_itemType == 13;
bool flag6 = ProtectiveWards.offeringEitr.Value && item.m_shared.m_name == "$item_eitr";
bool flag7 = (ProtectiveWards.offeringYmirRemains.Value && item.m_shared.m_name == "$item_ymirremains") || flag6;
bool flag8 = item.m_shared.m_name == "$item_dragonegg" && ZoneSystem.instance.GetGlobalKey((GlobalKeys)34);
bool flag9 = ProtectiveWards.offeringTaxi.Value && (item.m_shared.m_name == "$item_coins" || IsBossTrophy(item.m_shared.m_name) || IsItemForHildirTravel(item.m_shared.m_name) || IsItemForBogWitchTravel(item.m_shared.m_name) || item.m_shared.m_name == "$item_chest_hildir1" || item.m_shared.m_name == "$item_chest_hildir2" || item.m_shared.m_name == "$item_chest_hildir3");
if (!flag2 && !flag3 && !flag4 && !flag5 && !flag7 && !flag8 && !flag9)
{
return true;
}
if (flag2)
{
RepairNearestStructures(flag, __instance, val, item);
}
if (flag3)
{
ApplyConsumableEffectToNearestPlayers(__instance, item, val);
}
if (flag4)
{
ApplyThunderstrikeOnNearbyEnemies(__instance, item, val);
}
if (flag5)
{
ApplyTrophyEffectOnNearbyEnemies(__instance, item, val);
}
if (flag7)
{
ApplyInstantGrowthEffectOnNearbyPlants(__instance, item, val, !flag6);
}
if (flag8)
{
ApplyModerPowerEffectToNearbyPlayers(__instance, item, val);
}
if (flag9)
{
TaxiToLocation(item, val);
}
__result = true;
return false;
}
}
[HarmonyPatch(typeof(Player), "SetIntro")]
public static class Player_SetIntro_Taxi
{
private static void Postfix(Player __instance)
{
//IL_003c: Unknown result type (might be due to invalid IL or missing references)
if (ProtectiveWards.modEnabled.Value && !((Character)__instance).InIntro())
{
if (ProtectiveWards.taxiReturnBack && ProtectiveWards.canTravel)
{
ProtectiveWards.isTravelingPlayer = __instance;
((MonoBehaviour)__instance).StartCoroutine(ReturnPlayerToPosition(__instance, ProtectiveWards.taxiPlayerPositionToReturn, ProtectiveWards.offeringTaxiSecondsToFlyBack.Value));
}
else
{
ProtectiveWards.isTravelingPlayer = null;
}
}
}
}
[HarmonyPatch(typeof(Valkyrie), "Awake")]
public static class Valkyrie_Awake_Taxi
{
private static bool Prefix(Valkyrie __instance)
{
//IL_00e1: 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_00ec: Unknown result type (might be due to invalid IL or missing references)
//IL_0101: Unknown result type (might be due to invalid IL or missing references)
//IL_0106: 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_011a: 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_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_01dd: Unknown result type (might be due to invalid IL or missing references)
//IL_01e5: 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_0223: Unknown result type (might be due to invalid IL or missing references)
//IL_022e: Unknown result type (might be due to invalid IL or missing references)
//IL_0234: Unknown result type (might be due to invalid IL or missing references)
//IL_0239: Unknown result type (might be due to invalid IL or missing references)
//IL_0250: Unknown result type (might be due to invalid IL or missing references)
//IL_0256: Unknown result type (might be due to invalid IL or missing references)
//IL_025b: Unknown result type (might be due to invalid IL or missing references)
//IL_0260: Unknown result type (might be due to invalid IL or missing references)
//IL_0278: Unknown result type (might be due to invalid IL or missing references)
//IL_027d: Unknown result type (might be due to invalid IL or missing references)
//IL_0285: Unknown result type (might be due to invalid IL or missing references)
//IL_028a: Unknown result type (might be due to invalid IL or missing references)
//IL_028f: Unknown result type (might be due to invalid IL or missing references)
//IL_02bb: Unknown result type (might be due to invalid IL or missing references)
//IL_02c0: Unknown result type (might be due to invalid IL or missing references)
//IL_02d9: Unknown result type (might be due to invalid IL or missing references)
//IL_02de: Unknown result type (might be due to invalid IL or missing references)
if (!ProtectiveWards.modEnabled.Value)
{
return true;
}
if (!ProtectiveWards.offeringTaxi.Value)
{
return true;
}
if ((Object)(object)ProtectiveWards.isTravelingPlayer == (Object)null)
{
return true;
}
__instance.m_nview = ((Component)__instance).GetComponent<ZNetView>();
__instance.m_animator = ((Component)__instance).GetComponentInChildren<Animator>();
if (!__instance.m_nview.IsOwner() || ((Object)(object)Valkyrie.m_instance != (Object)null && (Object)(object)Valkyrie.m_instance != (Object)(object)__instance))
{
((Behaviour)__instance).enabled = false;
return false;
}
Valkyrie.m_instance = __instance;
__instance.m_startAltitude = 30f;
__instance.m_textDuration = 0f;
__instance.m_descentAltitude = 150f;
__instance.m_attachOffset = new Vector3(-0.1f, 1.5f, 0.1f);
__instance.m_targetPoint = ProtectiveWards.taxiTargetPosition + new Vector3(0f, __instance.m_dropHeight, 0f);
Vector3 position = ((Component)ProtectiveWards.isTravelingPlayer).transform.position;
position.y += __instance.m_startAltitude;
float num = (__instance.m_startDistance = Vector3.Distance(__instance.m_targetPoint, position));
__instance.m_startDescentDistance = Math.Min(200f, num / 5f);
__instance.m_speed = Math.Max(Math.Min(num / 90f, Math.Min(30f, ProtectiveWards.maxTaxiSpeed.Value)), 10f);
if (__instance.m_speed <= 15f)
{
EnvMan.instance.m_introEnvironment = EnvMan.instance.m_currentEnv.m_name;
}
else
{
EnvMan.instance.m_introEnvironment = "ThunderStorm";
}
ProtectiveWards.isTravelingPlayer.m_intro = true;
((Component)__instance).transform.position = position;
float num2 = Utils.DistanceXZ(__instance.m_targetPoint, ((Component)__instance).transform.position);
float num3 = Math.Max(__instance.m_descentAltitude / num2, Math.Min(__instance.m_descentAltitude * 2f / num2, 0.2f));
__instance.m_descentStart = Vector3.Lerp(__instance.m_targetPoint, ((Component)__instance).transform.position, num3);
__instance.m_descentStart.y = __instance.m_descentAltitude;
Vector3 val = __instance.m_targetPoint - __instance.m_descentStart;
val.y = 0f;
((Vector3)(ref val)).Normalize();
__instance.m_flyAwayPoint = __instance.m_targetPoint + val * __instance.m_startDescentDistance;
__instance.m_flyAwayPoint.y += 100f;
__instance.SyncPlayer(true);
Vector3 val2 = ((Component)__instance).transform.position;
string? text = ((object)(Vector3)(ref val2)).ToString();
val2 = ZNet.instance.GetReferencePosition();
ProtectiveWards.LogInfo("Setting up valkyrie " + text + " " + ((object)(Vector3)(ref val2)).ToString());
return false;
}
}
[HarmonyPatch(typeof(Valkyrie), "LateUpdate")]
public static class Valkyrie_LateUpdate_Taxi
{
private static void Prefix(Valkyrie __instance)
{
if (ProtectiveWards.modEnabled.Value && ProtectiveWards.offeringTaxi.Value && ((ZInput.GetButton("Use") && ZInput.GetButton("AltPlace")) || (ZInput.GetButton("JoyUse") && ZInput.GetButton("JoyAltPlace"))))
{
__instance.DropPlayer(false);
}
}
}
[HarmonyPatch(typeof(Valkyrie), "DropPlayer")]
public static class Valkyrie_DropPlayer_Taxi
{
private static void Postfix()
{
if (ProtectiveWards.modEnabled.Value && ProtectiveWards.offeringTaxi.Value)
{
ProtectiveWards.playerDropped = true;
if (!((Character)Player.m_localPlayer).m_seman.HaveStatusEffect(slowFallHash))
{
ProtectiveWards.castSlowFall = true;
((Character)Player.m_localPlayer).m_seman.AddStatusEffect(slowFallHash, false, 0, 0f);
ProtectiveWards.LogInfo("Cast slow fall");
}
}
}
}
[HarmonyPatch(typeof(Player), "Update")]
public static class Player_Update_Taxi
{
private static void Postfix(Player __instance)
{
if (ProtectiveWards.modEnabled.Value && ProtectiveWards.offeringTaxi.Value && !((Object)(object)Player.m_localPlayer != (Object)(object)__instance) && ProtectiveWards.playerDropped && ProtectiveWards.castSlowFall && (((Character)__instance).IsOnGround() || ((Character)__instance).IsSwimming()))
{
ProtectiveWards.castSlowFall = false;
ProtectiveWards.playerDropped = false;
if (((Character)__instance).m_seman.HaveStatusEffect(slowFallHash))
{
((Character)__instance).m_seman.RemoveStatusEffect(slowFallHash, true);
}
ProtectiveWards.LogInfo("Remove slow fall");
}
}
}
[HarmonyPatch(typeof(Valkyrie), "OnDestroy")]
public static class Valkyrie_OnDestroy_Taxi
{
private static void Prefix(Valkyrie __instance)
{
if (ProtectiveWards.modEnabled.Value)
{
ProtectiveWards.canTravel = true;
}
}
}
[HarmonyPatch(typeof(ZoneSystem), "Start")]
public static class ZoneSystem_Start_Taxi
{
private static void Postfix()
{
if (ProtectiveWards.modEnabled.Value)
{
RegisterRPCs();
}
}
}
[CompilerGenerated]
private sealed class <>c__DisplayClass3_0
{
public float amount;
public int seconds;
public Action<Character> <>9__2;
internal void <PassiveHealingEffect>b__2(Character character)
{
character.Heal(amount * (float)seconds, true);
}
}
[CompilerGenerated]
private sealed class <>c__DisplayClass3_1
{
public List<Character> characters;
internal void <PassiveHealingEffect>b__0(PrivateArea area)
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
Character.GetCharactersInRange(((Component)area).transform.position, area.m_radius, characters);
}
}
[CompilerGenerated]
private sealed class <>c__DisplayClass4_0
{
public List<Player> players;
public List<Character> characters;
internal void <LightningStrikeEffect>b__0(PrivateArea area)
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
Player.GetPlayersInRange(((Component)area).transform.position, area.m_radius, players);
}
internal void <LightningStrikeEffect>b__2(PrivateArea area)
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
Character.GetCharactersInRange(((Component)area).transform.position, area.m_radius, characters);
}
}
[CompilerGenerated]
private sealed class <InstantGrowthEffect>d__5 : IEnumerator<object>, IDisposable, IEnumerator
{
private int <>1__state;
private object <>2__current;
public PrivateArea ward;
public List<Plant> plants;
private HashSet<Plant>.Enumerator <>s__1;
private Plant <plant>5__2;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <InstantGrowthEffect>d__5(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
int num = <>1__state;
if (num == -3 || num == 2)
{
try
{
}
finally
{
<>m__Finally1();
}
}
<>s__1 = default(HashSet<Plant>.Enumerator);
<plant>5__2 = null;
<>1__state = -2;
}
private bool MoveNext()
{
//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
//IL_0105: Invalid comparison between Unknown and I4
//IL_0134: Unknown result type (might be due to invalid IL or missing references)
//IL_013e: Expected O, but got Unknown
try
{
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
if ((Object)(object)ward == (Object)null)
{
return false;
}
ProtectiveWards.LogInfo("Instant growth started");
<>2__current = wait1sec;
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
<>s__1 = plants.ToHashSet().GetEnumerator();
<>1__state = -3;
break;
case 2:
<>1__state = -3;
<plant>5__2 = null;
break;
}
while (<>s__1.MoveNext())
{
<plant>5__2 = <>s__1.Current;
if (!Object.op_Implicit((Object)(object)<plant>5__2) || (Object)(object)<plant>5__2.m_nview == (Object)null || !<plant>5__2.m_nview.IsValid() || !<plant>5__2.m_nview.IsOwner())
{
continue;
}
if ((int)<plant>5__2.m_status > 0)
{
<plant>5__2.UpdateHealth(0.0);
}
<plant>5__2.Grow();
<>2__current = (object)new WaitForSeconds(0.25f);
<>1__state = 2;
return true;
}
<>m__Finally1();
<>s__1 = default(HashSet<Plant>.Enumerator);
ProtectiveWards.LogInfo("Instant growth ended");
return false;
}
catch
{
//try-fault
((IDisposable)this).Dispose();
throw;
}
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
private void <>m__Finally1()
{
<>1__state = -1;
((IDisposable)<>s__1).Dispose();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
[CompilerGenerated]
private sealed class <LightningStrikeEffect>d__4 : IEnumerator<object>, IDisposable, IEnumerator
{
private int <>1__state;
private object <>2__current;
public PrivateArea ward;
private <>c__DisplayClass4_0 <>8__1;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <LightningStrikeEffect>d__4(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>8__1 = null;
<>1__state = -2;
}
private bool MoveNext()
{
//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
//IL_00da: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<>8__1 = new <>c__DisplayClass4_0();
if ((Object)(object)ward == (Object)null)
{
return false;
}
<>8__1.players = new List<Player>();
CollectionExtensions.Do<PrivateArea>(ProtectiveWards.ConnectedAreas(ward), (Action<PrivateArea>)delegate(PrivateArea area)
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
Player.GetPlayersInRange(((Component)area).transform.position, area.m_radius, <>8__1.players);
});
CollectionExtensions.Do<Player>((IEnumerable<Player>)<>8__1.players.ToHashSet(), (Action<Player>)delegate(Player player)
{
//IL_000b: 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)
ProtectiveWards.preLightning.Create(((Component)player).transform.position, ((Component)player).transform.rotation, (Transform)null, 1f, -1);
});
ProtectiveWards.LogInfo("Thor is preparing his strike");
<>2__current = (object)new WaitForSeconds(Random.Range(5f, 7f));
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
if (Game.IsPaused())
{
<>2__current = wait1sec;
<>1__state = 2;
return true;
}
break;
case 2:
<>1__state = -1;
break;
}
<>8__1.characters = new List<Character>();
CollectionExtensions.Do<PrivateArea>(ProtectiveWards.ConnectedAreas(ward), (Action<PrivateArea>)delegate(PrivateArea area)
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
Character.GetCharactersInRange(((Component)area).transform.position, area.m_radius, <>8__1.characters);
});
CollectionExtensions.DoIf<Character>((IEnumerable<Character>)<>8__1.characters.ToHashSet(), (Func<Character, bool>)((Character character) => character.IsMonsterFaction(Time.time)), (Action<Character>)delegate(Character character)
{
//IL_000b: 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)
Object.Instantiate<GameObject>(ProtectiveWards.lightningAOE, ((Component)character).transform.position, ((Component)character).transform.rotation);
});
return false;
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
[CompilerGenerated]
private sealed class <PassiveHealingEffect>d__3 : IEnumerator<object>, IDisposable, IEnumerator
{
private int <>1__state;
private object <>2__current;
public PrivateArea ward;
public float amount;
public int seconds;
private <>c__DisplayClass3_0 <>8__1;
private <>c__DisplayClass3_1 <>8__2;
private int <secondsLeft>5__3;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <PassiveHealingEffect>d__3(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>8__1 = null;
<>8__2 = null;
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0090: Unknown result type (might be due to invalid IL or missing references)
//IL_009a: Expected O, but got Unknown
//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
//IL_01d6: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<>8__1 = new <>c__DisplayClass3_0();
<>8__1.amount = amount;
<>8__1.seconds = seconds;
goto IL_01ee;
case 1:
<>1__state = -1;
break;
case 2:
{
<>1__state = -1;
<>8__2 = null;
goto IL_01ee;
}
IL_01ee:
<>8__2 = new <>c__DisplayClass3_1();
if ((Object)(object)ward == (Object)null)
{
return false;
}
if (Game.IsPaused())
{
<>2__current = (object)new WaitForSeconds(2f);
<>1__state = 1;
return true;
}
break;
}
if (!ProtectiveWards.wardIsHealing.TryGetValue(ward, out <secondsLeft>5__3))
{
return false;
}
if (<secondsLeft>5__3 <= 0)
{
ProtectiveWards.wardIsHealing.Remove(ward);
ProtectiveWards.LogInfo("Passive healing stopped");
return false;
}
ProtectiveWards.wardIsHealing[ward] -= <>8__1.seconds;
<>8__2.characters = new List<Character>();
CollectionExtensions.Do<PrivateArea>(ProtectiveWards.ConnectedAreas(ward), (Action<PrivateArea>)delegate(PrivateArea area)
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
Character.GetCharactersInRange(((Component)area).transform.position, area.m_radius, <>8__2.characters);
});
CollectionExtensions.DoIf<Character>((IEnumerable<Character>)<>8__2.characters.ToHashSet(), (Func<Character, bool>)((Character character) => character.IsTamed() || character.IsPlayer()), (Action<Character>)delegate(Character character)
{
character.Heal(<>8__1.amount * (float)<>8__1.seconds, true);
});
<>2__current = (object)new WaitForSecondsRealtime((float)<>8__1.seconds);
<>1__state = 2;
return true;
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
[CompilerGenerated]
private sealed class <ReturnPlayerToPosition>d__6 : IEnumerator<object>, IDisposable, IEnumerator
{
private int <>1__state;
private object <>2__current;
public Player player;
public Vector3 position;
public int seconds;
private int <i>5__1;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <ReturnPlayerToPosition>d__6(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
if ((Object)(object)player == (Object)null)
{
return false;
}
ProtectiveWards.canTravel = false;
ProtectiveWards.LogInfo("Timer of player returnal started");
<i>5__1 = seconds;
break;
case 1:
<>1__state = -1;
<i>5__1--;
break;
}
if (<i>5__1 >= 0)
{
((Character)player).Message((MessageType)((<i>5__1 > 15) ? 1 : 2), Localization.instance.Localize("$pw_msg_travel_back", new string[1] { TimeSpan.FromSeconds(<i>5__1).ToString("m\\:ss") }), 0, (Sprite)null);
<>2__current = wait1sec;
<>1__state = 1;
return true;
}
ProtectiveWards.LogInfo("Timer of player returnal ended");
((MonoBehaviour)player).StartCoroutine(TaxiToPosition(player, position));
return false;
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
[CompilerGenerated]
private sealed class <TaxiToPosition>d__26 : IEnumerator<object>, IDisposable, IEnumerator
{
private int <>1__state;
private object <>2__current;
public Player player;
public Vector3 position;
public bool returnBack;
public int waitSeconds;
private DateTime <flightInitiated>5__1;
private bool <playerShouldExit>5__2;
private GameObject <valkyrie>5__3;
private int <i>5__4;
private string <timeSpent>5__5;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <TaxiToPosition>d__26(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<valkyrie>5__3 = null;
<timeSpent>5__5 = null;
<>1__state = -2;
}
private bool MoveNext()
{
//IL_037c: Unknown result type (might be due to invalid IL or missing references)
//IL_0381: Unknown result type (might be due to invalid IL or missing references)
//IL_039c: Unknown result type (might be due to invalid IL or missing references)
//IL_03a1: Unknown result type (might be due to invalid IL or missing references)
//IL_03b6: Unknown result type (might be due to invalid IL or missing references)
//IL_03d7: Unknown result type (might be due to invalid IL or missing references)
//IL_03dc: Unknown result type (might be due to invalid IL or missing references)
//IL_03fb: Unknown result type (might be due to invalid IL or missing references)
//IL_0405: Unknown result type (might be due to invalid IL or missing references)
//IL_040f: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
ProtectiveWards.canTravel = false;
ProtectiveWards.isTravelingPlayer = player;
if (waitSeconds > 0)
{
<i>5__4 = waitSeconds;
goto IL_00d7;
}
goto IL_0124;
case 1:
<>1__state = -1;
<i>5__4--;
goto IL_00d7;
case 2:
<>1__state = -1;
goto IL_0124;
case 3:
{
<>1__state = -1;
<playerShouldExit>5__2 = ((Character)player).IsAttachedToShip() || ((Character)player).IsAttached() || ((Character)player).IsDead() || ((Character)player).IsRiding() || player.IsSleeping() || ((Character)player).IsTeleporting() || ((Character)player).InPlaceMode() || ((Character)player).InBed() || ((Character)player).InCutscene() || ((Character)player).InInterior();
<timeSpent>5__5 = null;
break;
}
IL_00d7:
if (<i>5__4 > 0)
{
((Character)player).Message((MessageType)2, Localization.instance.Localize("$pw_msg_travel_starting", new string[1] { TimeSpan.FromSeconds(<i>5__4).ToString("m\\:ss") }), 0, (Sprite)null);
<>2__current = wait1sec;
<>1__state = 1;
return true;
}
goto IL_0124;
IL_0124:
if ((Object)(object)Valkyrie.m_instance != (Object)null)
{
((Character)player).Message((MessageType)2, Localization.instance.Localize("$menu_pleasewait"), 0, (Sprite)null);
<>2__current = wait1sec;
<>1__state = 2;
return true;
}
<flightInitiated>5__1 = DateTime.Now;
<playerShouldExit>5__2 = ((Character)player).IsAttachedToShip() || ((Character)player).IsAttached() || ((Character)player).IsDead() || ((Character)player).IsRiding() || player.IsSleeping() || ((Character)player).IsTeleporting() || ((Character)player).InPlaceMode() || ((Character)player).InBed() || ((Character)player).InCutscene() || ((Character)player).InInterior();
break;
}
if (<playerShouldExit>5__2 || ((Character)player).IsEncumbered() || !IsTeleportable(player))
{
<timeSpent>5__5 = (DateTime.Now - <flightInitiated>5__1).ToString("m\\:ss");
if (<playerShouldExit>5__2)
{
((Character)player).Message((MessageType)1, Localization.instance.Localize("$pw_msg_travel_inside", new string[1] { <timeSpent>5__5 }), 0, (Sprite)null);
}
else
{
((Character)player).Message((MessageType)2, Localization.instance.Localize("$pw_msg_travel_blocked", new string[1] { <timeSpent>5__5 }) + Localization.instance.Localize(((Character)player).IsEncumbered() ? " $se_encumbered_start" : " $msg_noteleport"), 0, (Sprite)null);
}
<>2__current = wait1sec;
<>1__state = 3;
return true;
}
((Character)player).Message((MessageType)2, Localization.instance.Localize("$pw_msg_travel_start"), 0, (Sprite)null);
ProtectiveWards.taxiTargetPosition = position;
ProtectiveWards.taxiReturnBack = returnBack;
ProtectiveWards.taxiPlayerPositionToReturn = ((Component)player).transform.position;
ProtectiveWards.playerDropped = false;
Player.m_localPlayer.m_valkyrie.Load();
<valkyrie>5__3 = Object.Instantiate<GameObject>(Player.m_localPlayer.m_valkyrie.Asset, ((Component)player).transform.position, Quaternion.identity);
<valkyrie>5__3.GetComponent<ZNetView>().HoldReferenceTo((IReferenceCounted)(object)Player.m_localPlayer.m_valkyrie);
Player.m_localPlayer.m_valkyrie.Release();
ProtectiveWards.canTravel = true;
return false;
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
internal static int slowFallHash = StringExtensionMethods.GetStableHashCode("SlowFall");
internal static int moderPowerHash = StringExtensionMethods.GetStableHashCode("GP_Moder");
private static readonly WaitForSeconds wait1sec = new WaitForSeconds(1f);
[IteratorStateMachine(typeof(<PassiveHealingEffect>d__3))]
public static IEnumerator PassiveHealingEffect(PrivateArea ward, float amount, int seconds)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <PassiveHealingEffect>d__3(0)
{
ward = ward,
amount = amount,
seconds = seconds
};
}
[IteratorStateMachine(typeof(<LightningStrikeEffect>d__4))]
public static IEnumerator LightningStrikeEffect(PrivateArea ward)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <LightningStrikeEffect>d__4(0)
{
ward = ward
};
}
[IteratorStateMachine(typeof(<InstantGrowthEffect>d__5))]
public static IEnumerator InstantGrowthEffect(PrivateArea ward, List<Plant> plants)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <InstantGrowthEffect>d__5(0)
{
ward = ward,
plants = plants
};
}
[IteratorStateMachine(typeof(<ReturnPlayerToPosition>d__6))]
public static IEnumerator ReturnPlayerToPosition(Player player, Vector3 position, int seconds)
{
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <ReturnPlayerToPosition>d__6(0)
{
player = player,
position = position,
seconds = seconds
};
}
private static void RepairNearestStructures(bool augment, PrivateArea ward, Player initiator, ItemData item)
{
//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
int num = 0;
int num2 = 0;
List<Piece> pieces = new List<Piece>();
CollectionExtensions.Do<PrivateArea>(ProtectiveWards.ConnectedAreas(ward), (Action<PrivateArea>)delegate(PrivateArea area)
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
Piece.GetAllPiecesInRadius(((Component)area).transform.position, area.m_radius, pieces);
});
WearNTear val = default(WearNTear);
foreach (Piece item2 in pieces.Where((Piece piece) => piece.IsPlacedByPlayer()))
{
if (((Component)item2).TryGetComponent<WearNTear>(ref val))
{
if (val.Repair())
{
num++;
item2.m_placeEffect.Create(((Component)item2).transform.position, ((Component)item2).transform.rotation, (Transform)null, 1f, -1);
}
if (augment && (Object)(object)val.m_nview != (Object)null && val.m_nview.IsValid() && val.m_nview.IsOwner() && val.m_nview.GetZDO().GetFloat(ZDOVars.s_health, val.m_health) < val.m_health * 2f)
{
val.m_nview.GetZDO().Set(ZDOVars.s_health, val.m_health * 2f);
val.m_nview.InvokeRPC(ZNetView.Everybody, "WNTHealthChanged", new object[1] { val.m_health * 2f });
num2++;
}
}
}
if (num + num2 > 0)
{
((Humanoid)initiator).GetInventory().RemoveOneItem(item);
}
if (num2 > 0)
{
((Character)initiator).Message((MessageType)2, Localization.instance.Localize("$msg_offerdone"), 0, (Sprite)null);
if (num > 0)
{
((Character)initiator).Message((MessageType)1, Localization.instance.Localize("$msg_repaired", new string[1] { num.ToString() }), 0, (Sprite)null);
}
}
else if (num > 0)
{
((Character)initiator).Message((MessageType)2, Localization.instance.Localize("$msg_repaired", new string[1] { num.ToString() }), 0, (Sprite)null);
}
else if (augment)
{
((Character)initiator).Message((MessageType)2, Localization.instance.Localize("$msg_cantoffer"), 0, (Sprite)null);
}
else
{
string text = Localization.instance.Localize("$msg_doesnotneedrepair");
((Character)initiator).Message((MessageType)2, char.ToUpper(text[0]) + text.Substring(1), 0, (Sprite)null);
}
}
private static void GetPlantsInRange(Vector3 point, float radius, List<Plant> plants, bool growableOnly)
{
//IL_0037: 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_0058: Unknown result type (might be due to invalid IL or missing references)
//IL_005e: Invalid comparison between Unknown and I4
List<SlowUpdate> allInstaces = SlowUpdate.GetAllInstaces();
float num = radius * radius;
Plant val = default(Plant);
foreach (SlowUpdate item in allInstaces)
{
if (((Component)item).TryGetComponent<Plant>(ref val) && Utils.DistanceSqr(((Component)item).transform.position, point) < num && val.m_nview.IsOwner() && (!growableOnly || (int)val.m_status == 0))
{
plants.Add(val);
}
}
}
private static void ApplyTrophyEffectOnNearbyEnemies(PrivateArea ward, ItemData item, Player initiator)
{
//IL_0093: Unknown result type (might be due to invalid IL or missing references)
//IL_0098: Unknown result type (might be due to invalid IL or missing references)
//IL_010c: Unknown result type (might be due to invalid IL or missing references)
ProtectiveWards.trophyTargets = ((IEnumerable<Turret>)Resources.FindObjectsOfTypeAll<Turret>()).FirstOrDefault((Func<Turret, bool>)((Turret ws) => ((Object)ws).name == "piece_turret"))?.m_configTargets;
if (ProtectiveWards.trophyTargets == null)
{
return;
}
bool flag = false;
foreach (TrophyTarget item2 in ProtectiveWards.trophyTargets.Where((TrophyTarget configTarget) => item.m_shared.m_name == configTarget.m_item.m_itemData.m_shared.m_name))
{
List<Character> characters = new List<Character>();
CollectionExtensions.Do<PrivateArea>(ProtectiveWards.ConnectedAreas(ward), (Action<PrivateArea>)delegate(PrivateArea area)
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
Character.GetCharactersInRange(((Component)area).transform.position, area.m_radius, characters);
});
foreach (Character item3 in from character in characters.ToHashSet()
where character.IsMonsterFaction(Time.time)
select character)
{
foreach (Character target in item2.m_targets)
{
if (item3.m_name == target.m_name)
{
item3.SetHealth(0f);
flag = true;
}
}
}
}
if (flag)
{
((Humanoid)initiator).GetInventory().RemoveOneItem(item);
((Character)initiator).Message((MessageType)2, Localization.instance.Localize("$msg_offerdone"), 0, (Sprite)null);
}
else
{
((Character)initiator).Message((MessageType)2, Localization.instance.Localize("$msg_offerwrong"), 0, (Sprite)null);
}
}
private static void ApplyThunderstrikeOnNearbyEnemies(PrivateArea ward, ItemData item, Player initiator)
{
if (!Object.op_Implicit((Object)(object)ProtectiveWards.lightningAOE))
{
Incinerator val = Resources.FindObjectsOfTypeAll<Incinerator>().FirstOrDefault();
ProtectiveWards.lightningAOE = val.m_lightingAOEs;
ProtectiveWards.preLightning = val.m_leverEffects;
}
((MonoBehaviour)ProtectiveWards.instance).StartCoroutine(LightningStrikeEffect(ward));
((Humanoid)initiator).GetInventory().RemoveOneItem(item);
((Character)initiator).Message((MessageType)2, Localization.instance.Localize("$piece_incinerator_conversion"), 0, (Sprite)null);
}
private static void ApplyConsumableEffectToNearestPlayers(PrivateArea ward, ItemData item, Player initiator)
{
if (item.m_shared.m_food > 0f)
{
if (ProtectiveWards.wardIsHealing.ContainsKey(ward))
{
((Character)initiator).Message((MessageType)2, Localization.instance.Localize("$msg_offerwrong"), 0, (Sprite)null);
return;
}
ProtectiveWards.wardIsHealing.Add(ward, 180);
((MonoBehaviour)ProtectiveWards.instance).StartCoroutine(PassiveHealingEffect(ward, item.m_shared.m_foodRegen / 2f, 1));
ProtectiveWards.LogInfo("Passive healing begins");
((Character)initiator).Message((MessageType)2, Localization.instance.Localize("$msg_consumed: " + item.m_shared.m_name), 0, (Sprite)null);
((Humanoid)initiator).GetInventory().RemoveOneItem(item);
}
else
{
if (!Object.op_Implicit((Object)(object)item.m_shared.m_consumeStatusEffect))
{
return;
}
ProtectiveWards.LogInfo("Consumable effect offered");
List<Player> players = new List<Player>();
CollectionExtensions.Do<PrivateArea>(ProtectiveWards.ConnectedAreas(ward), (Action<PrivateArea>)delegate(PrivateArea area)
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
Player.GetPlayersInRange(((Component)area).transform.position, area.m_radius, players);
});
bool flag = false;
foreach (Player item2 in from player in players.ToHashSet()
where ((Humanoid)player).CanConsumeItem(item, false)
select player)
{
((Character)item2).m_seman.AddStatusEffect(item.m_shared.m_consumeStatusEffect.NameHash(), true, 0, 0f);
flag = true;
}
if (!flag)
{
((Character)initiator).Message((MessageType)2, Localization.instance.Localize("$msg_cantoffer"), 0, (Sprite)null);
return;
}
((Humanoid)initiator).GetInventory().RemoveOneItem(item);
((Character)initiator).Message((MessageType)2, Localization.instance.Localize("$msg_offerdone"), 0, (Sprite)null);
}
}
private static void ApplyInstantGrowthEffectOnNearbyPlants(PrivateArea ward, ItemData item, Player initiator, bool growableOnly = true)
{
List<Plant> plants = new List<Plant>();
CollectionExtensions.Do<PrivateArea>(ProtectiveWards.ConnectedAreas(ward), (Action<PrivateArea>)delegate(PrivateArea area)
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
GetPlantsInRange(((Component)area).transform.position, area.m_radius, plants, growableOnly);
});
if (plants.Count == 0)
{
((Character)initiator).Message((MessageType)2, Localization.instance.Localize("$msg_cantoffer"), 0, (Sprite)null);
return;
}
Inventory inventory = ((Humanoid)initiator).GetInventory();
if (item.m_shared.m_name == "$item_eitr" && inventory.CountItems("$item_eitr", -1, true) < 5)
{
((Character)initiator).Message((MessageType)2, Localization.instance.Localize("$msg_incompleteoffering"), 0, (Sprite)null);
return;
}
((MonoBehaviour)ward).StartCoroutine(InstantGrowthEffect(ward, plants));
if (item.m_shared.m_name == "$item_eitr")
{
((Humanoid)initiator).GetInventory().RemoveItem("$item_eitr", 5, -1, true);
ProtectiveWards.LogInfo("Offered " + item.m_shared.m_name + " x5");
}
else
{
((Humanoid)initiator).GetInventory().RemoveOneItem(item);
ProtectiveWards.LogInfo("Offered " + item.m_shared.m_name);
}
((Character)initiator).Message((MessageType)2, Localization.instance.Localize("$msg_offerdone"), 0, (Sprite)null);
}
private static void ApplyModerPowerEffectToNearbyPlayers(PrivateArea ward, ItemData item, Player initiator)
{
ProtectiveWards.LogInfo("Dragon egg offered");
List<Player> players = new List<Player>();
CollectionExtensions.Do<PrivateArea>(ProtectiveWards.ConnectedAreas(ward), (Action<PrivateArea>)delegate(PrivateArea area)
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
Player.GetPlayersInRange(((Component)area).transform.position, area.m_radius, players);
});
foreach (Player item2 in players.ToHashSet())
{
StatusEffect statusEffect = ObjectDB.instance.GetStatusEffect(moderPowerHash);
((Character)item2).GetSEMan().AddStatusEffect(statusEffect.NameHash(), true, 0, 0f);
}
((Humanoid)initiator).GetInventory().RemoveOneItem(item);
}
private static void TaxiToLocation(ItemData item, Player initiator)
{
//IL_0087: 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_00b3: 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_01e3: Unknown result type (might be due to invalid IL or missing references)
//IL_0212: Unknown result type (might be due to invalid IL or missing references)
//IL_0188: Unknown result type (might be due to invalid IL or missing references)
//IL_01be: Unknown result type (might be due to invalid IL or missing references)
if (((Character)initiator).IsEncumbered())
{
((Character)initiator).Message((MessageType)2, Localization.instance.Localize("$se_encumbered_start"), 0, (Sprite)null);
return;
}
if (!IsTeleportable(initiator))
{
((Character)initiator).Message((MessageType)2, Localization.instance.Localize("$pw_msg_notravel"), 0, (Sprite)null);
return;
}
if (!ProtectiveWards.canTravel)
{
((Character)initiator).Message((MessageType)2, Localization.instance.Localize("$pw_msg_canttravel"), 0, (Sprite)null);
return;
}
Vector3 target = Vector3.zero;
int stack = 0;
string text;
bool flag;
if (IsBossTrophy(item.m_shared.m_name))
{
text = "StartTemple";
flag = TryGetFoundLocation(text, ((Component)initiator).transform.position, ref target);
}
else if (item.m_shared.m_name == "$item_coins")
{
text = "Vendor_BlackForest";
flag = TryGetFoundLocation(text, ((Component)initiator).transform.position, ref target);
stack = (flag ? ProtectiveWards.offeringTaxiPriceHaldorDiscovered.Value : ProtectiveWards.offeringTaxiPriceHaldorUndiscovered.Value);
}
else if (IsItemForHildirTravel(item.m_shared.m_name) || item.m_shared.m_name == "$item_chest_hildir1" || item.m_shared.m_name == "$item_chest_hildir2" || item.m_shared.m_name == "$item_chest_hildir3")
{
text = "Hildir_camp";
flag = TryGetFoundLocation(text, ((Component)initiator).transform.position, ref target);
stack = 1;
}
else
{
if (!IsItemForBogWitchTravel(item.m_shared.m_name))
{
return;
}
text = "BogWitch_Camp";
flag = TryGetFoundLocation(text, ((Component)initiator).transform.position, ref target);
stack = ProtectiveWards.offeringTaxiPriceBogWitchAmount.Value;
}
if (flag)
{
StartTaxi(initiator, target, item.m_shared.m_name, stack);
}
else if (!ZNet.instance.IsServer())
{
ClosestLocationRequest(text, ((Component)initiator).transform.position, item.m_shared.m_name, stack);
}
else
{
ProtectiveWards.LogInfo("Location " + text + " is not found");
}
}
internal static void RegisterRPCs()
{
if (ZNet.instance.IsServer())
{
ZRoutedRpc.instance.Register<ZPackage>("ClosestLocationRequest", (Action<long, ZPackage>)RPC_ClosestLocationRequest);
}
else
{
ZRoutedRpc.instance.Register<ZPackage>("StartTaxi", (Action<long, ZPackage>)RPC_StartTaxi);
}
}
public static void ClosestLocationRequest(string name, Vector3 position, string itemName, int stack)
{
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
//IL_0018: Expected O, but got Unknown
//IL_0021: Unknown result type (might be due to invalid IL or missing references)
ProtectiveWards.LogInfo(name + " closest location request");
ZPackage val = new ZPackage();
val.Write(name);
val.Write(position);
val.Write(itemName);
val.Write(stack);
ZRoutedRpc.instance.InvokeRoutedRPC("ClosestLocationRequest", new object[1] { val });
}
public static void RPC_ClosestLocationRequest(long sender, ZPackage pkg)
{
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
//IL_001d: 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_0025: 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_0056: Expected O, but got Unknown
//IL_0058: Unknown result type (might be due to invalid IL or missing references)
string text = pkg.ReadString();
Vector3 position = pkg.ReadVector3();
string text2 = pkg.ReadString();
int num = pkg.ReadInt();
Vector3 target = Vector3.zero;
if (!TryGetFoundLocation(text, position, ref target))
{
ProtectiveWards.LogInfo("Location " + text + " is not found");
return;
}
ZPackage val = new ZPackage();
val.Write(target);
val.Write(text2);
val.Write(num);
ZRoutedRpc.instance.InvokeRoutedRPC(sender, "StartTaxi", new object[1] { val });
}
public static void RPC_StartTaxi(long sender, ZPackage pkg)
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0007: 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)
Vector3 position = pkg.ReadVector3();
string itemName = pkg.ReadString();
int stack = pkg.ReadInt();
ProtectiveWards.LogInfo("Server responded with closest location");
StartTaxi(Player.m_localPlayer, position, itemName, stack);
}
internal static void StartTaxi(Player initiator, Vector3 position, string itemName, int stack)
{
//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_00a7: Unknown result type (might be due to invalid IL or missing references)
if (Utils.DistanceXZ(((Component)initiator).transform.position, position) < 300f)
{
((Character)initiator).Message((MessageType)2, Localization.instance.Localize("$pw_msg_tooclose"), 0, (Sprite)null);
return;
}
if (stack > 0 && (IsItemForHildirTravel(itemName) || IsItemForBogWitchTravel(itemName) || itemName == "$item_coins"))
{
if (((Humanoid)initiator).GetInventory().CountItems(itemName, -1, true) < stack)
{
((Character)initiator).Message((MessageType)2, Localization.instance.Localize("$msg_incompleteoffering"), 0, (Sprite)null);
return;
}
((Humanoid)initiator).GetInventory().RemoveItem(itemName, stack, -1, true);
}
((MonoBehaviour)initiator).StartCoroutine(TaxiToPosition(initiator, position, returnBack: true, 10));
}
internal static bool TryGetFoundLocation(string name, Vector3 position, ref Vector3 target)
{
//IL_0056: Unknown result type (might be due to invalid IL or missing references)
//IL_005b: 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_00ab: 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_00b1: Unknown result type (might be due to invalid IL or missing references)
ZoneSystem.instance.tempIconList.Clear();
ZoneSystem.instance.GetLocationIcons(ZoneSystem.instance.tempIconList);
foreach (KeyValuePair<Vector3, string> tempIcon in ZoneSystem.instance.tempIconList)
{
if (tempIcon.Value == name)
{
target = tempIcon.Key;
ProtectiveWards.LogInfo("Found closest " + name + " in icon list");
return true;
}
}
LocationInstance val = default(LocationInstance);
if (ZoneSystem.instance.FindClosestLocation(name, position, ref val))
{
target = val.m_position;
ProtectiveWards.LogInfo("Found closest " + name + " in location list");
return true;
}
return false;
}
internal static bool IsItemForHildirTravel(string itemName)
{
return ProtectiveWards.offeringTaxiPriceHildirItem.Value != "" && itemName == ProtectiveWards.offeringTaxiPriceHildirItem.Value;
}
internal static bool IsItemForBogWitchTravel(string itemName)
{
return ProtectiveWards.offeringTaxiPriceBogWitchItem.Value != "" && itemName == ProtectiveWards.offeringTaxiPriceBogWitchItem.Value;
}
internal static bool IsBossTrophy(string itemName)
{
int result;
switch (itemName)
{
default:
result = ((itemName == "$item_trophy_fader") ? 1 : 0);
break;
case "$item_trophy_eikthyr":
case "$item_trophy_elder":
case "$item_trophy_bonemass":
case "$item_trophy_dragonqueen":
case "$item_trophy_goblinking":
case "$item_trophy_seekerqueen":
result = 1;
break;
}
return (byte)result != 0;
}
public static bool IsTeleportable(Player player)
{
if (((Humanoid)player).IsTeleportable())
{
return true;
}
foreach (ItemData allItem in ((Humanoid)player).GetInventory().GetAllItems())
{
if (allItem.m_shared.m_name == "$item_chest_hildir1" || allItem.m_shared.m_name == "$item_chest_hildir2" || allItem.m_shared.m_name == "$item_chest_hildir3" || allItem.m_shared.m_teleportable)
{
continue;
}
return false;
}
return true;
}
[IteratorStateMachine(typeof(<TaxiToPosition>d__26))]
private static IEnumerator TaxiToPosition(Player player, Vector3 position, bool returnBack = false, int waitSeconds = 0)
{
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <TaxiToPosition>d__26(0)
{
player = player,
position = position,
returnBack = returnBack,
waitSeconds = waitSeconds
};
}
}
[BepInPlugin("shudnal.ProtectiveWards", "Protective Wards", "1.2.11")]
public class ProtectiveWards : BaseUnityPlugin
{
public enum ShipDamageType
{
Off,
WaterDamage,
AnyButPlayerDamage,
AnyDamage
}
[HarmonyPatch(typeof(CircleProjector), "CreateSegments")]
public static class CircleProjector_CreateSegments_InitState
{
public static void Prefix(CircleProjector __instance, ref bool __state)
{
if (modEnabled.Value && wardAreaMarkerPatch.Value && !((Object)(object)((Component)((Component)__instance).transform.root).GetComponent<PrivateArea>() == (Object)null))
{
__instance.m_nrOfSegments = (int)(80f * (wardAreaMarkerPatch.Value ? wardAreaMarkerAmount.Value : 1f) * (__instance.m_radius / 32f));
__state = (!__instance.m_sliceLines && __instance.m_segments.Count == __instance.m_nrOfSegments) || (__instance.m_sliceLines && __instance.m_calcStart == __instance.m_start && __instance.m_calcTurns == __instance.m_turns);
}
}
public static void Postfix(CircleProjector __instance, bool __state)
{
if (__state)
{
return;
}
ZNetView componentInParent = ((Component)__instance).GetComponentInParent<ZNetView>();
if (Object.op_Implicit((Object)(object)componentInParent) && componentInParent.IsValid())
{
ZDO zDO = componentInParent.GetZDO();
if (zDO != null)
{
InitCircleProjectorState(__instance, componentInParent);
}
}
}
}
[HarmonyPatch(typeof(Door), "Interact")]
public static class Door_SetState_AutoClose
{
public static void Postfix(Door __instance, ZNetView ___m_nview, bool __result)
{
//IL_0077: Unknown result type (might be due to invalid IL or missing references)
if (!modEnabled.Value || autoCloseDoorsTime.Value == 0 || autoCloseDoorsIgnorePrefabs.Value.IndexOf(Utils.GetPrefabName(((Component)__instance).gameObject)) > -1 || !___m_nview.IsValid() || !__result || !InsideEnabledPlayersArea(((Component)__instance).transform.position, out var area, checkCache: true))
{
return;
}
if (!doorsToClose.TryGetValue(area, out var value))
{
value = new List<Door>();
}
int @int = ___m_nview.GetZDO().GetInt(ZDOVars.s_state, 0);
if (@int == 0)
{
value.Remove(__instance);
}
else if (!value.Contains(__instance))
{
value.Add(__instance);
}
if (value.Count == 0)
{
wardIsClosing.Remove(area);
doorsToClose.Remove(area);
}
else if (@int != 0)
{
doorsToClose[area] = value;
LogInfo(value.Count);
if (wardIsClosing.ContainsKey(area))
{
wardIsClosing[area] = Math.Max(autoCloseDoorsTime.Value, 2);
LogInfo($"Doors closing reset to {wardIsClosing[area]} seconds");
}
else
{
wardIsClosing[area] = Math.Max(autoCloseDoorsTime.Value, 2);
((MonoBehaviour)area).StartCoroutine(AutoClosingDoors(area));
LogInfo("Doors closing started");
}
}
}
}
[HarmonyPatch(typeof(PrivateArea), "OnDestroy")]
public static class PrivateArea_OnDestroy_ClearStatus
{
public static void Prefix(PrivateArea __instance)
{
if (modEnabled.Value)
{
areaCache.Clear();
wardIsHealing.Remove(__instance);
wardIsRepairing.Remove(__instance);
wardIsClosing.Remove(__instance);
}
}
}
[HarmonyPatch(typeof(PrivateArea), "HideMarker")]
public static class PrivateArea_HideMarker_ShowAreaMarker
{
public static bool Prefix()
{
if (!modEnabled.Value)
{
return true;
}
return !showAreaMarker.Value;
}
}
[HarmonyPatch(typeof(PrivateArea), "AddUserList")]
public static class PrivateArea_AddUserList_WardAltActionCaption
{
public static void Prefix(PrivateArea __instance, StringBuilder text)
{
if (!modEnabled.Value || !__instance.HaveLocalAccess())
{
return;
}
bool flag = __instance.IsEnabled();
if (!flag && !__instance.m_piece.IsCreator())
{
return;
}
if (!flag)
{
if (!ZInput.IsNonClassicFunctionality() || !ZInput.IsGamepadActive())
{
text.Append("\n[<color=yellow><b>$KEY_AltPlace + $KEY_Use</b></color>] $pw_ward_apply_settings");
}
else
{
text.Append("\n[<color=yellow><b>$KEY_JoyAltKeys + $KEY_Use</b></color>] $pw_ward_apply_settings");
}
return;
}
List<string> list = new List<string>();
if (wardIsRepairing.TryGetValue(__instance, out var value))
{
list.Add($"$hud_repair {value}");
}
else if (wardPassiveRepair.Value)
{
if (!ZInput.IsNonClassicFunctionality() || !ZInput.IsGamepadActive())
{
text.Append("\n[<color=yellow><b>$KEY_AltPlace + $KEY_Use</b></color>] $pw_ward_start_repair");
}
else
{
text.Append("\n[<color=yellow><b>$KEY_JoyAltKeys + $KEY_Use</b></color>] $pw_ward_start_repair");
}
}
if (wardIsHealing.TryGetValue(__instance, out var value2))
{
list.Add("$item_food_regen " + TimeSpan.FromSeconds(value2).ToString("m\\:ss"));
}
if (list.Count > 0)
{
text.Append("\n$guardianstone_hook_power_activate: ");
text.Append(string.Join(", ", list.ToArray()));
}
if (offeringsTimer < showOfferingsInHoverAfterSeconds.Value + 0.5f)
{
offeringsTimer += Time.fixedDeltaTime * 2f;
}
if (!showOfferingsInHover.Value || !(offeringsTimer > showOfferingsInHoverAfterSeconds.Value))
{
return;
}
List<string> list2 = new List<string>();
if (offeringActiveRepair.Value && (Player.m_localPlayer.IsMaterialKnown("$item_surtlingcore") || Player.m_localPlayer.NoCostCheat()))
{
list2.Add("$item_surtlingcore - $pw_ward_offering_surtlingcore_description");
}
if (offeringAugmenting.Value && (Player.m_localPlayer.IsMaterialKnown("$item_blackcore") || Player.m_localPlayer.NoCostCheat()))
{
list2.Add("$item_blackcore - $pw_ward_offering_blackcore_description");
}
if (offeringFood.Value)
{
list2.Add("$item_food - $pw_ward_offering_food_description");
}
if (offeringMead.Value)
{
list2.Add("$se_mead_name - $pw_ward_offering_mead_description");
}
if (offeringThundertone.Value && (Player.m_localPlayer.IsMaterialKnown("$item_thunderstone") || Player.m_localPlayer.NoCostCheat()))
{
list2.Add("$item_thunderstone - $pw_ward_offering_thunderstone_description");
}
if (offeringTrophy.Value)
{
list2.Add("$inventory_trophies - $pw_ward_offering_trophies_description");
list2.Add("$pw_ward_offering_bosstrophies - $pw_ward_offering_bosstrophies_description");
}
if (offeringYmirRemains.Value && (Player.m_localPlayer.IsMaterialKnown("$item_ymirremains") || Player.m_localPlayer.NoCostCheat()))
{
list2.Add("$item_ymirremains - $pw_ward_offering_ymirremains_description");
}
if (offeringEitr.Value && (Player.m_localPlayer.IsMaterialKnown("$item_eitr") || Player.m_localPlayer.NoCostCheat()))
{
list2.Add("$item_eitr - $pw_ward_offering_eitr_description");
}
if (offeringDragonEgg.Value && ((Player.m_localPlayer.IsMaterialKnown("$item_dragonegg") && ZoneSystem.instance.GetGlobalKey((GlobalKeys)34)) || Player.m_localPlayer.NoCostCheat()))
{
list2.Add("$item_dragonegg - $pw_ward_offering_dragonegg_description");
}
if (offeringTaxi.Value)
{
if (Player.m_localPlayer.IsMaterialKnown("$item_coins") || Player.m_localPlayer.NoCostCheat())
{
ZoneSystem.instance.tempIconList.Clear();
ZoneSystem.instance.GetLocationIcons(ZoneSystem.instance.tempIconList);
int num = (ZoneSystem.instance.tempIconList.Any((KeyValuePair<Vector3, string> icon) => icon.Value == "Vendor_BlackForest") ? offeringTaxiPriceHaldorDiscovered.Value : offeringTaxiPriceHaldorUndiscovered.Value);
list2.Add($"$item_coins: {num} - $pw_ward_offering_coins_description");
}
if (!Utility.IsNullOrWhiteSpace(offeringTaxiPriceHildirItem.Value) && (Player.m_localPlayer.IsMaterialKnown(offeringTaxiPriceHildirItem.Value) || Player.m_localPlayer.NoCostCheat()))
{
list2.Add(offeringTaxiPriceHildirItem.Value + " - $pw_ward_offering_hildiritem_description");
}
if (Player.m_localPlayer.IsMaterialKnown("$item_chest_hildir1") || Player.m_localPlayer.IsMaterialKnown("$item_chest_hildir2") || Player.m_localPlayer.IsMaterialKnown("$item_chest_hildir3") || Player.m_localPlayer.NoCostCheat())
{
list2.Add("$pw_ward_offering_hildirchest - $pw_ward_offering_hildirchest_description");
}
if (!Utility.IsNullOrWhiteSpace(offeringTaxiPriceBogWitchItem.Value) && (Player.m_localPlayer.IsMaterialKnown(offeringTaxiPriceBogWitchItem.Value) || Player.m_localPlayer.NoCostCheat()))
{
list2.Add(offeringTaxiPriceBogWitchItem.Value + " " + ((offeringTaxiPriceBogWitchAmount.Value > 0) ? $"x{offeringTaxiPriceBogWitchAmount.Value}" : "") + " - $pw_ward_offering_bogwitchitem_description");
}
}
if (list2.Count > 0)
{
text.Append("\n[<color=yellow><b>1-8</b></color>] $piece_offerbowl_offeritem:\n");
text.Append(string.Join("\n", list2));
text.Append('\n');
}
}
}
[HarmonyPatch(typeof(PrivateArea), "IsPermitted")]
public static class PrivateArea_AddUserList_PermittanceToEveryone
{
public static bool Prefix(ref bool __result)
{
if (!modEnabled.Value)
{
return true;
}
if (!permitEveryone.Value)
{
return true;
}
__result = true;
return false;
}
}
[HarmonyPatch(typeof(PrivateArea), "Interact")]
public static class PrivateArea_Interact_PassiveEffectWardRepair
{
private static bool Prefix(PrivateArea __instance, Humanoid human, bool hold, bool alt, Faction ___m_ownerFaction, ref bool __result)
{
//IL_0034: Unknown result type (might be due to invalid IL or missing references)
//IL_0037: Invalid comparison between Unknown and I4
//IL_0170: Unknown result type (might be due to invalid IL or missing references)
//IL_017f: Unknown result type (might be due to invalid IL or missing references)
//IL_018e: Unknown result type (might be due to invalid IL or missing references)
//IL_0198: Unknown result type (might be due to invalid IL or missing references)
//IL_01af: Unknown result type (might be due to invalid IL or missing references)
//IL_028d: Unknown result type (might be due to invalid IL or missing references)
//IL_02a7: Unknown result type (might be due to invalid IL or missing references)
//IL_02c1: Unknown result type (might be due to invalid IL or missing references)
//IL_02d6: Unknown result type (might be due to invalid IL or missing references)
//IL_03ad: Unknown result type (might be due to invalid IL or missing references)
//IL_03b8: Unknown result type (might be due to invalid IL or missing references)
//IL_0318: Unknown result type (might be due to invalid IL or missing references)
//IL_0334: Unknown result type (might be due to invalid IL or missing references)
if (!modEnabled.Value)
{
return true;
}
if (hold)
{
return true;
}
if (!alt)
{
return true;
}
if ((int)___m_ownerFaction > 0)
{
return true;
}
if (!__instance.HaveLocalAccess())
{
return true;
}
areaCache.Clear();
if (__instance.IsEnabled() && wardPassiveRepair.Value)
{
__result = true;
if (wardIsRepairing.ContainsKey(__instance))
{
return false;
}
LogInfo("Passive repairing begins");
((MonoBehaviour)instance).StartCoroutine(PassiveRepairEffect(__instance, (Player)(object)((human is Player) ? human : null)));
return false;
}
if (!__instance.IsEnabled() && __instance.m_piece.IsCreator())
{
ZDO zDO = __instance.m_nview.GetZDO();
if (zDO == null)
{
return false;
}
__result = true;
zDO.Set(s_bubbleEnabled, wardBubbleShow.Value);
if (wardBubbleShow.Value)
{
zDO.Set(s_bubbleRefractionIntensity, wardBubbleRefractionIntensity.Value);
zDO.Set(s_bubbleWaveVel, wardBubbleWaveIntensity.Value);
zDO.Set(s_bubbleColor, new Vector3(wardBubbleColor.Value.r, wardBubbleColor.Value.g, wardBubbleColor.Value.b));
zDO.Set(s_bubbleColorAlpha, wardBubbleColor.Value.a);
zDO.Set(s_bubbleGlossiness, wardBubbleGlossiness.Value);
zDO.Set(s_bubbleMetallic, wardBubbleMetallic.Value);
zDO.Set(s_bubbleNormalScale, wardBubbleNormalScale.Value);
zDO.Set(s_bubbleDepthFade, wardBubbleDepthFade.Value);
}
zDO.Set(s_customRange, setWardRange.Value);
if (setWardRange.Value)
{
zDO.Set(s_range, wardRange.Value);
}
zDO.Set(s_customColor, wardEmissionColorEnabled.Value);
if (wardEmissionColorEnabled.Value)
{
zDO.Set(s_color, new Vector3(wardEmissionColor.Value.r * wardEmissionColorMultiplier.Value, wardEmissionColor.Value.g * wardEmissionColorMultiplier.Value, wardEmissionColor.Value.b * wardEmissionColorMultiplier.Value));
}
zDO.Set(s_circleEnabled, wardAreaMarkerPatch.Value);
if (wardAreaMarkerPatch.Value)
{
zDO.Set(s_circleStartColor, ColorUtility.ToHtmlStringRGBA(wardAreaMarkerStartColor.Value));
zDO.Set(s_circleEndColor, ColorUtility.ToHtmlStringRGBA(wardAreaMarkerEndColor.Value));
zDO.Set(s_circleSpeed, wardAreaMarkerSpeed.Value);
zDO.Set(s_circleLength, wardAreaMarkerLength.Value);
zDO.Set(s_circleWidth, wardAreaMarkerWidth.Value);
zDO.Set(s_circleAmount, wardAreaMarkerAmount.Value);
}
__instance.m_addPermittedEffect.Create(((Component)__instance).transform.position, ((Component)__instance).transform.rotation, (Transform)null, 1f, -1);
LogInfo($"Ward settings applied for {zDO}");
return false;
}
return true;
}
}
[HarmonyPatch(typeof(PrivateArea), "Awake")]
public static class PrivateArea_Awake_SetWardRange
{
private static void Postfix(PrivateArea __instance, ZNetView ___m_nview)
{
if (modEnabled.Value && !((Object)(object)___m_nview == (Object)null) && ___m_nview.IsValid())
{
PatchRange(__instance);
if (showAreaMarker.Value)
{
((Component)__instance.m_areaMarker).gameObject.SetActive(true);
}
if ((Object)(object)forceField != (Object)null)
{
GameObject val = Object.Instantiate<GameObject>(forceField, ((Component)__instance).transform);
((Object)val).name = "ForceField";
InitBubbleState(__instance, val, ___m_nview);
}
if ((Object)(object)forceFieldDemister != (Object)null)
{
GameObject val2 = Object.Instantiate<GameObject>(forceFieldDemister, ((Component)__instance).transform);
((Object)val2).name = "Particle System Force Field";
InitDemisterState(__instance, val2, ___m_nview);
}
InitEmissionColor(__instance);
}
}
}
[HarmonyPatch(typeof(PrivateArea), "RPC_FlashShield")]
public static class PrivateArea_RPC_FlashShield_StopFla
