using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using SuperFantasyKingdom;
using SuperFantasyKingdom.Buildings;
using SuperFantasyKingdom.Clickable;
using SuperFantasyKingdom.Spawner;
using SuperFantasyKingdom.Spells;
using SuperFantasyKingdom.Tavern;
using SuperFantasyKingdom.UI;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.InputSystem;
using UnityEngine.UI;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyCompany("MoreRelics")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+f98f1699223006a870c71b5365fcb9d67bf33b8d")]
[assembly: AssemblyProduct("More Relics")]
[assembly: AssemblyTitle("MoreRelics")]
[assembly: AssemblyVersion("1.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Embedded]
[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
internal sealed class RefSafetyRulesAttribute : Attribute
{
public readonly int Version;
public RefSafetyRulesAttribute(int P_0)
{
Version = P_0;
}
}
}
namespace MoreRelics
{
internal sealed class Cornucopia : RelicEntry
{
private const int MinPerDay = 1;
private const int MaxPerDay = 2;
private const int SeedSalt = 4123;
private static readonly ResourceType[] Gathered;
private static readonly RelicDef Definition;
public override RelicDef Def => Definition;
public override void OnMorning(int day)
{
//IL_0065: Unknown result type (might be due to invalid IL or missing references)
//IL_0082: Unknown result type (might be due to invalid IL or missing references)
//IL_0092: 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)
Random random = new Random((((Object)(object)GameManager.Instance != (Object)null) ? GameManager.Instance.GetSeed() : 0) * 7 + 4123 + day);
BuildingCastle val = (((Object)(object)CityManager.Instance != (Object)null) ? CityManager.Instance.GetCastle() : null);
int num = random.Next(1, 3);
for (int i = 0; i < num; i++)
{
ResourceType val2 = Gathered[random.Next(Gathered.Length)];
if ((Object)(object)val == (Object)null || (Object)(object)DroppedShardSpawner.Instance == (Object)null)
{
ResourceManager.Instance.AddResource(val2, 1);
}
else
{
DroppedShardSpawner.Instance.Spawn(((BuildingCity)val).GetPosition(), 1, val2, false);
}
}
}
static Cornucopia()
{
//IL_0055: Unknown result type (might be due to invalid IL or missing references)
ResourceType[] array = new ResourceType[7];
RuntimeHelpers.InitializeArray(array, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
Gathered = (ResourceType[])(object)array;
Definition = new RelicDef
{
id = "ownly_Cornucopia",
cloneFrom = new string[4] { "GreenHouse", "BetterBerries", "Fruitarian", "SpawnTrees" },
rarity = (Rarity)2,
cost = 8,
title = "Cornucopia",
description = "1-2 random resources every morning."
};
}
}
internal sealed class Grimoire : RelicEntry
{
private static readonly RelicDef Definition = new RelicDef
{
id = "ownly_Grimoire",
cloneFrom = new string[4] { "GreenHouse", "BetterBerries", "Fruitarian", "SpawnTrees" },
rarity = (Rarity)3,
cost = 9,
title = "Grimoire",
description = "A new spell no longer replaces the old one. Click the second slot to switch."
};
public override RelicDef Def => Definition;
public override void OnAcquired()
{
Preview.Refresh();
}
public override void OnMorning(int day)
{
Preview.Refresh();
}
internal static bool Active()
{
return Registry.Find(Definition.id)?.Held() ?? false;
}
internal static void Swap()
{
//IL_002a: Unknown result type (might be due to invalid IL or missing references)
//IL_002f: Unknown result type (might be due to invalid IL or missing references)
//IL_0039: Unknown result type (might be due to invalid IL or missing references)
//IL_003c: Unknown result type (might be due to invalid IL or missing references)
//IL_003e: Unknown result type (might be due to invalid IL or missing references)
//IL_0046: Unknown result type (might be due to invalid IL or missing references)
//IL_005e: Unknown result type (might be due to invalid IL or missing references)
//IL_0075: Unknown result type (might be due to invalid IL or missing references)
//IL_006c: Unknown result type (might be due to invalid IL or missing references)
SpellManager instance = SpellManager.Instance;
if ((Object)(object)instance == (Object)null)
{
return;
}
bool flag = instance.IsOnBattlefield();
SpellBase val = (flag ? instance.GetCombatSpell() : instance.GetCitySpell());
SpellType val2 = Reserve.Get(flag);
if (!((Object)(object)val == (Object)null) && (int)val2 != 0 && val2 != val.GetSpellType() && !((Object)(object)instance.GetSpell(val2) == (Object)null))
{
instance.Cancel(false);
Reserve.Set(flag, val.GetSpellType());
if (flag)
{
instance.SetCombatSpell(val2);
}
else
{
instance.SetCitySpell(val2);
}
Traverse.Create(typeof(SpellManager)).Field("OnSwitch").GetValue<Action<bool>>()?.Invoke(flag);
Preview.Refresh();
}
}
}
internal static class Preview
{
private const float Scale = 0.62f;
private const float OffsetX = 0f;
private const float OffsetY = -0.85f;
private static readonly Color Dimmed = new Color(1f, 1f, 1f, 0.8f);
private static Image s_Image;
private static Sprite s_Unknown;
internal static bool Hovering;
internal static void Build(Image icon)
{
//IL_0025: Unknown result type (might be due to invalid IL or missing references)
//IL_002a: Unknown result type (might be due to invalid IL or missing references)
//IL_003d: Unknown result type (might be due to invalid IL or missing references)
//IL_0042: Unknown result type (might be due to invalid IL or missing references)
//IL_0043: Unknown result type (might be due to invalid IL or missing references)
//IL_004b: Unknown result type (might be due to invalid IL or missing references)
//IL_0057: Unknown result type (might be due to invalid IL or missing references)
//IL_0063: Unknown result type (might be due to invalid IL or missing references)
//IL_006e: Unknown result type (might be due to invalid IL or missing references)
//IL_0079: Unknown result type (might be due to invalid IL or missing references)
//IL_007f: Unknown result type (might be due to invalid IL or missing references)
//IL_008a: Unknown result type (might be due to invalid IL or missing references)
//IL_008f: Unknown result type (might be due to invalid IL or missing references)
//IL_009b: Unknown result type (might be due to invalid IL or missing references)
//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
Hovering = false;
RectTransform rectTransform = ((Graphic)icon).rectTransform;
GameObject val = new GameObject("GrimoireReserve", new Type[1] { typeof(RectTransform) });
val.transform.SetParent(((Transform)rectTransform).parent, false);
Vector2 sizeDelta = rectTransform.sizeDelta;
RectTransform component = val.GetComponent<RectTransform>();
component.anchorMin = rectTransform.anchorMin;
component.anchorMax = rectTransform.anchorMax;
component.pivot = rectTransform.pivot;
((Transform)component).localScale = Vector3.one;
component.sizeDelta = sizeDelta * 0.62f;
component.anchoredPosition = rectTransform.anchoredPosition + new Vector2(sizeDelta.x * 0f, sizeDelta.y * -0.85f);
s_Image = val.AddComponent<Image>();
((Graphic)s_Image).material = ((Graphic)icon).material;
s_Image.preserveAspect = true;
((Graphic)s_Image).raycastTarget = true;
EventTrigger trigger = val.AddComponent<EventTrigger>();
Hover(trigger, (EventTriggerType)0, over: true);
Hover(trigger, (EventTriggerType)1, over: false);
Refresh();
}
internal static void Refresh()
{
//IL_0040: Unknown result type (might be due to invalid IL or missing references)
//IL_0045: Unknown result type (might be due to invalid IL or missing references)
//IL_004f: Unknown result type (might be due to invalid IL or missing references)
//IL_0056: Unknown result type (might be due to invalid IL or missing references)
//IL_009a: Unknown result type (might be due to invalid IL or missing references)
//IL_007b: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)s_Image == (Object)null)
{
return;
}
bool flag = Grimoire.Active();
((Component)s_Image).gameObject.SetActive(flag);
if (flag)
{
SpellManager instance = SpellManager.Instance;
SpellType val = (SpellType)(((Object)(object)instance != (Object)null) ? ((int)Reserve.Get(instance.IsOnBattlefield())) : 0);
SpellBase val2 = (((Object)(object)instance != (Object)null && (int)val != 0) ? instance.GetSpell(val) : null);
if ((Object)(object)val2 != (Object)null)
{
s_Image.sprite = val2.GetIcon();
((Graphic)s_Image).color = Color.white;
}
else
{
s_Image.sprite = Unknown();
((Graphic)s_Image).color = Dimmed;
}
}
}
private static void Hover(EventTrigger trigger, EventTriggerType type, bool over)
{
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
//IL_0014: Unknown result type (might be due to invalid IL or missing references)
//IL_001a: Expected O, but got Unknown
Entry val = new Entry
{
eventID = type
};
((UnityEvent<BaseEventData>)(object)val.callback).AddListener((UnityAction<BaseEventData>)delegate
{
Hovering = over;
});
trigger.triggers.Add(val);
}
private static Sprite Unknown()
{
//IL_0055: Unknown result type (might be due to invalid IL or missing references)
//IL_005b: Expected O, but got Unknown
//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)s_Unknown != (Object)null)
{
return s_Unknown;
}
Stream manifestResourceStream = typeof(Plugin).Assembly.GetManifestResourceStream("MoreRelics.Icons.SlotUnknown.png");
if (manifestResourceStream == null)
{
return null;
}
byte[] array = new byte[manifestResourceStream.Length];
manifestResourceStream.Read(array, 0, array.Length);
manifestResourceStream.Dispose();
Texture2D val = new Texture2D(2, 2, (TextureFormat)4, false);
if (!ImageConversion.LoadImage(val, array))
{
ManualLogSource log = Plugin.Log;
if (log != null)
{
log.LogError((object)"could not decode SlotUnknown.png");
}
return null;
}
((Texture)val).filterMode = (FilterMode)0;
((Object)val).hideFlags = (HideFlags)61;
s_Unknown = Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f), (float)((Texture)val).width);
((Object)s_Unknown).hideFlags = (HideFlags)61;
return s_Unknown;
}
}
internal static class Reserve
{
private static SpellType s_City;
private static SpellType s_Combat;
private static string s_Key;
private static int s_Seed;
private static int CurrentSeed()
{
if (!((Object)(object)GameManager.Instance != (Object)null))
{
return 0;
}
return GameManager.Instance.GetSeed();
}
public static SpellType Get(bool combat)
{
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
Load();
if (!combat)
{
return s_City;
}
return s_Combat;
}
public static void Set(bool combat, SpellType spell)
{
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
Load();
if (combat)
{
s_Combat = spell;
}
else
{
s_City = spell;
}
Write();
}
public static void Clear()
{
//IL_0006: 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)
Load();
s_City = (SpellType)0;
s_Combat = (SpellType)0;
Write();
}
private static string Key()
{
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
//IL_001e: Unknown result type (might be due to invalid IL or missing references)
string obj = (((Object)(object)RaceManager.Instance != (Object)null) ? ((object)RaceManager.Instance.GetRace()/*cast due to .constrained prefix*/).ToString() : "None");
string text = (((Object)(object)SettingsManager.Instance != (Object)null) ? SettingsManager.Instance.GetProfile().ToString() : "0");
bool flag = (Object)(object)MainManager.Instance != (Object)null && MainManager.Instance.IsChallenge();
return obj + "_" + text + (flag ? "_challenge" : "");
}
private static string Path()
{
return System.IO.Path.Combine(Paths.ConfigPath, "MoreRelics", s_Key + ".txt");
}
private static void Load()
{
//IL_0032: Unknown result type (might be due to invalid IL or missing references)
//IL_0038: Unknown result type (might be due to invalid IL or missing references)
//IL_0118: Unknown result type (might be due to invalid IL or missing references)
//IL_011e: Unknown result type (might be due to invalid IL or missing references)
//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
string text = Key();
int num = CurrentSeed();
if (text == s_Key && (num == 0 || num == s_Seed))
{
return;
}
s_Key = text;
s_Seed = num;
s_City = (SpellType)0;
s_Combat = (SpellType)0;
int result = 0;
try
{
string path = Path();
if (!File.Exists(path))
{
return;
}
string[] array = File.ReadAllLines(path);
foreach (string text2 in array)
{
int num2 = text2.IndexOf('=');
if (num2 <= 0)
{
continue;
}
string text3 = text2.Substring(num2 + 1).Trim();
if (text2.StartsWith("seed"))
{
int.TryParse(text3, out result);
}
else if (Enum.IsDefined(typeof(SpellType), text3))
{
SpellType val = (SpellType)Enum.Parse(typeof(SpellType), text3);
if (text2.StartsWith("city"))
{
s_City = val;
}
else if (text2.StartsWith("combat"))
{
s_Combat = val;
}
}
}
if (num != 0 && result != num)
{
s_City = (SpellType)0;
s_Combat = (SpellType)0;
Write();
}
}
catch (Exception ex)
{
ManualLogSource log = Plugin.Log;
if (log != null)
{
log.LogError((object)("grimoire could not read its spells: " + ex));
}
}
}
private static void Write()
{
try
{
string path = Path();
Directory.CreateDirectory(System.IO.Path.GetDirectoryName(path));
File.WriteAllText(path, "city=" + ((object)Unsafe.As<SpellType, SpellType>(ref s_City)/*cast due to .constrained prefix*/).ToString() + "\ncombat=" + ((object)Unsafe.As<SpellType, SpellType>(ref s_Combat)/*cast due to .constrained prefix*/).ToString() + "\nseed=" + CurrentSeed() + "\n");
}
catch (Exception ex)
{
ManualLogSource log = Plugin.Log;
if (log != null)
{
log.LogError((object)("grimoire could not write its spells: " + ex));
}
}
}
}
[HarmonyPatch]
internal static class Patch_GrimoireKeep
{
[HarmonyPatch(typeof(SpellManager), "SetCitySpell", new Type[] { typeof(SpellBase) })]
[HarmonyPrefix]
private static void City(SpellManager __instance, SpellBase spell)
{
Keep(__instance.GetCitySpell(), spell, combat: false);
}
[HarmonyPatch(typeof(SpellManager), "SetCombatSpell", new Type[] { typeof(SpellBase) })]
[HarmonyPrefix]
private static void Combat(SpellManager __instance, SpellBase spell)
{
Keep(__instance.GetCombatSpell(), spell, combat: true);
}
private static void Keep(SpellBase outgoing, SpellBase incoming, bool combat)
{
//IL_0025: Unknown result type (might be due to invalid IL or missing references)
//IL_002a: Unknown result type (might be due to invalid IL or missing references)
//IL_002b: Unknown result type (might be due to invalid IL or missing references)
//IL_003b: Unknown result type (might be due to invalid IL or missing references)
//IL_002e: Unknown result type (might be due to invalid IL or missing references)
//IL_0030: Unknown result type (might be due to invalid IL or missing references)
try
{
if (!((Object)(object)outgoing == (Object)null) && !((Object)(object)incoming == (Object)null) && !((Object)(object)outgoing == (Object)(object)incoming) && Grimoire.Active())
{
SpellType val = Reserve.Get(combat);
if ((int)val == 0 || val == incoming.GetSpellType())
{
Reserve.Set(combat, outgoing.GetSpellType());
Preview.Refresh();
}
}
}
catch (Exception ex)
{
ManualLogSource log = Plugin.Log;
if (log != null)
{
log.LogError((object)("grimoire failed to keep the old spell: " + ex));
}
}
}
}
[HarmonyPatch(typeof(SpellManager), "SetDefaultSpells")]
internal static class Patch_GrimoireReset
{
private static void Postfix()
{
try
{
Reserve.Clear();
Preview.Refresh();
}
catch (Exception ex)
{
ManualLogSource log = Plugin.Log;
if (log != null)
{
log.LogError((object)("grimoire failed to clear its spells: " + ex));
}
}
}
}
[HarmonyPatch(typeof(UISpells), "Awake")]
internal static class Patch_GrimoireSlot
{
private static void Postfix(UISpells __instance)
{
try
{
Image value = Traverse.Create((object)__instance).Field("icon").GetValue<Image>();
if (!((Object)(object)value == (Object)null))
{
Preview.Build(value);
SpellManager.OnSwitch -= OnSwitch;
SpellManager.OnSwitch += OnSwitch;
}
}
catch (Exception ex)
{
ManualLogSource log = Plugin.Log;
if (log != null)
{
log.LogError((object)("grimoire could not build its slot: " + ex));
}
}
}
private static void OnSwitch(bool combat)
{
Preview.Refresh();
}
}
[HarmonyPatch(typeof(GameInputManager), "GameClick")]
internal static class Patch_GrimoireClick
{
private static bool Prefix(CallbackContext context)
{
try
{
if (!((CallbackContext)(ref context)).performed || !Preview.Hovering || !Grimoire.Active())
{
return true;
}
Grimoire.Swap();
return false;
}
catch (Exception ex)
{
ManualLogSource log = Plugin.Log;
if (log != null)
{
log.LogError((object)("grimoire failed on click: " + ex));
}
return true;
}
}
}
internal sealed class MasterKey : RelicEntry
{
private const string Id = "ownly_MasterKey";
private const int FaithPerMorning = 2;
private static readonly RelicDef Definition = new RelicDef
{
id = "ownly_MasterKey",
cloneFrom = new string[4] { "GreenHouse", "BetterBerries", "Fruitarian", "SpawnTrees" },
rarity = (Rarity)1,
cost = 6,
title = "Master Key",
description = "Relics ignore all their requirements.\n" + 2 + "<sprite name=ResourceFaith> every morning."
};
public override RelicDef Def => Definition;
public override void OnMorning(int day)
{
//IL_0076: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)TaxManager.Instance != (Object)null)
{
TaxManager.Instance.AddToStatistics((ResourceType)13, 2);
}
BuildingCity val = null;
if ((Object)(object)CityManager.Instance != (Object)null)
{
val = (BuildingCity)(object)CityManager.Instance.GetChurch();
if ((Object)(object)val == (Object)null)
{
val = (BuildingCity)(object)CityManager.Instance.GetCastle();
}
}
if ((Object)(object)val == (Object)null || (Object)(object)DroppedShardSpawner.Instance == (Object)null)
{
ResourceManager.Instance.AddResource((ResourceType)13, 2);
return;
}
for (int i = 0; i < 2; i++)
{
DroppedShardSpawner.Instance.Spawn(val.GetPosition(), 1, (ResourceType)13, false);
}
}
internal static bool Active()
{
return Registry.Find("ownly_MasterKey")?.Held() ?? false;
}
}
[HarmonyPatch(typeof(Relic), "GetRequiredBuilding")]
internal static class Patch_RelicBuilding
{
private static void Postfix(ref BuildingType __result)
{
try
{
if (MasterKey.Active())
{
__result = (BuildingType)666;
}
}
catch
{
}
}
}
[HarmonyPatch(typeof(DropBossChest), "PreparePool")]
internal static class Patch_BossChestPool
{
private static void Postfix(DropBossChest __instance)
{
try
{
if (!MasterKey.Active())
{
return;
}
List<string> value = Traverse.Create((object)__instance).Field("RelicPool").GetValue<List<string>>();
if (value == null)
{
return;
}
foreach (KeyValuePair<string, Unit> allUnit in AddressablesManager.Instance.GetAllUnits())
{
List<string> list = (((Object)(object)allUnit.Value != (Object)null) ? ((UnitBase)allUnit.Value).GetRelatedRelics() : null);
if (list == null)
{
continue;
}
foreach (string item in list)
{
if (RelicManager.Instance.IsUnlocked(item) && !RelicManager.Instance.HasRelic(item) && !value.Contains(item))
{
value.Add(item);
}
}
}
}
catch
{
}
}
}
[HarmonyPatch(typeof(Relic), "GetRequiredKingdomLevel")]
internal static class Patch_RelicLevel
{
private static void Postfix(ref int __result)
{
try
{
if (MasterKey.Active())
{
__result = 0;
}
}
catch
{
}
}
}
internal sealed class Millstone : RelicEntry
{
internal const float ExtraDuration = 0.1f;
private static readonly RelicDef Definition = new RelicDef
{
id = "ownly_Millstone",
cloneFrom = new string[4] { "GreenHouse", "BetterBerries", "Fruitarian", "SpawnTrees" },
rarity = (Rarity)2,
cost = 10,
title = "Millstone",
description = "<sprite name=ResourceWheat> to <sprite name=ResourceBread> in Bakery."
};
public override RelicDef Def => Definition;
public override bool Available => !Chainloader.PluginInfos.ContainsKey("ownly.bakeryuseswheat");
public override void OnAcquired()
{
Convert();
}
public override void OnMorning(int day)
{
Convert();
}
internal static bool Rewrite(BuildingResource building)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0008: Invalid comparison between Unknown and I4
//IL_002e: Unknown result type (might be due to invalid IL or missing references)
//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
//IL_00be: Unknown result type (might be due to invalid IL or missing references)
//IL_00c4: Invalid comparison between Unknown and I4
//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
//IL_004c: Unknown result type (might be due to invalid IL or missing references)
//IL_0052: Invalid comparison between Unknown and I4
//IL_005e: Unknown result type (might be due to invalid IL or missing references)
if ((int)((Building)building).GetBuildingType() != 18)
{
return false;
}
bool result = false;
BuildingCrafting val = (BuildingCrafting)(object)((building is BuildingCrafting) ? building : null);
if (val != null)
{
List<CraftingRecipe> craftingRecipes = ((BuildingCity)val).GetCraftingRecipes(false);
if (craftingRecipes != null)
{
for (int i = 0; i < craftingRecipes.Count; i++)
{
ResourceAmount[] ingredients = craftingRecipes[i].ingredients;
if (ingredients == null)
{
continue;
}
for (int j = 0; j < ingredients.Length; j++)
{
if ((int)ingredients[j].type == 8)
{
ingredients[j].type = (ResourceType)7;
result = true;
}
}
}
}
}
ResourceStorage storage = ((Building)building).GetStorage();
if ((Object)(object)storage == (Object)null)
{
return result;
}
List<ResourceAmount> value = Traverse.Create((object)storage).Field("storage").GetValue<List<ResourceAmount>>();
if (value == null)
{
return result;
}
for (int k = 0; k < value.Count; k++)
{
if ((int)value[k].type == 8)
{
value[k] = new ResourceAmount((ResourceType)7, value[k].amount);
result = true;
}
}
return result;
}
private void Convert()
{
if ((Object)(object)CityManager.Instance == (Object)null)
{
return;
}
BuildingCity building = CityManager.Instance.GetBuilding((BuildingType)18);
BuildingCrafting val = (BuildingCrafting)(object)((building is BuildingCrafting) ? building : null);
if (val == null)
{
return;
}
ResourceStorage storage = ((Building)val).GetStorage();
int num = (((Object)(object)storage != (Object)null) ? storage.GetStorageSpace((ResourceType)8) : 0);
if (Rewrite((BuildingResource)(object)val))
{
val.SelectRecipe(Traverse.Create((object)val).Field("m_SelectedRecipe").GetValue<int>());
if ((Object)(object)storage != (Object)null)
{
storage.SetStorageSpace((ResourceType)7, num);
storage.SetStorageSpace((ResourceType)8, 0);
}
float timer = ((Building)val).GetTimer();
((Building)val).SetTimer(timer * 1.1f);
}
}
}
[HarmonyPatch(typeof(BuildingResource), "Init")]
internal static class Patch_Millstone
{
private static void Prefix(BuildingResource __instance, out bool __state)
{
__state = false;
try
{
RelicEntry relicEntry = Registry.Find("ownly_Millstone");
if (relicEntry != null && relicEntry.Held())
{
__state = Millstone.Rewrite(__instance);
}
}
catch (Exception ex)
{
ManualLogSource log = Plugin.Log;
if (log != null)
{
log.LogError((object)("millstone failed on building init: " + ex));
}
}
}
private static void Postfix(BuildingResource __instance, bool __state)
{
if (!__state)
{
return;
}
try
{
float timer = ((Building)__instance).GetTimer();
((Building)__instance).SetTimer(timer * 1.1f);
}
catch (Exception ex)
{
ManualLogSource log = Plugin.Log;
if (log != null)
{
log.LogError((object)("millstone failed on building init: " + ex));
}
}
}
}
internal sealed class Phalanx : RelicEntry
{
private const string Id = "ownly_Phalanx";
private const int Lanes = 10;
private const int MaxRank = 5;
private const int LastFieldSpot = 45;
private static readonly RelicDef Definition = new RelicDef
{
id = "ownly_Phalanx",
cloneFrom = new string[4] { "GreenHouse", "BetterBerries", "Fruitarian", "SpawnTrees" },
rarity = (Rarity)3,
cost = 12,
title = "Phalanx",
description = "Only the first unit of each column can be hurt.",
bossOnly = true
};
public override RelicDef Def => Definition;
internal static bool Covered(Entity entity)
{
UnitBase val = (UnitBase)(object)((entity is UnitBase) ? entity : null);
if ((Object)(object)val == (Object)null || (Object)(object)GridManager.Instance == (Object)null)
{
return false;
}
int gridPosition = val.GetGridPosition();
if (gridPosition < 1 || gridPosition > 45)
{
return false;
}
int num = gridPosition % 10;
int num2 = gridPosition / 10;
if (num < 1 || num > 5)
{
return false;
}
for (int i = num + 1; i <= 5; i++)
{
UnitBase unitByGridPosition = GridManager.Instance.GetUnitByGridPosition(num2 * 10 + i);
if ((Object)(object)unitByGridPosition != (Object)null && !unitByGridPosition.IsDead() && !unitByGridPosition.IsAway())
{
return true;
}
}
return false;
}
}
[HarmonyPatch(typeof(UnitHealth), "ReceiveDamage", new Type[]
{
typeof(Damage),
typeof(bool),
typeof(bool)
})]
internal static class Patch_Phalanx
{
private static bool Prefix(UnitHealth __instance, ref float __result)
{
try
{
RelicEntry relicEntry = Registry.Find("ownly_Phalanx");
if (relicEntry == null || !relicEntry.Held() || !Phalanx.Covered(((Health)__instance).GetEntity()))
{
return true;
}
__result = 0f;
return false;
}
catch
{
return true;
}
}
}
[BepInPlugin("ownly.morerelics", "More Relics", "1.0.0")]
public class Plugin : BaseUnityPlugin
{
internal static ManualLogSource Log;
private void Awake()
{
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
Log = ((BaseUnityPlugin)this).Logger;
try
{
new Harmony(((BaseUnityPlugin)this).Info.Metadata.GUID).PatchAll();
}
catch (Exception ex)
{
Log.LogError((object)("PatchAll THREW, later patches did not apply: " + ex));
}
}
}
internal static class Registry
{
public static readonly RelicEntry[] Entries = new RelicEntry[6]
{
new Cornucopia(),
new Millstone(),
new MasterKey(),
new Phalanx(),
new SousChef(),
new Grimoire()
};
public static RelicEntry Find(string identifier)
{
RelicEntry[] entries = Entries;
foreach (RelicEntry relicEntry in entries)
{
if (relicEntry.Def.id == identifier && relicEntry.Available)
{
return relicEntry;
}
}
return null;
}
}
internal sealed class RelicDef
{
public string id;
public string[] cloneFrom;
public Rarity rarity;
public int cost;
public string title;
public string description;
public int requiredKingdomLevel;
public bool bossOnly;
}
internal abstract class RelicEntry
{
public abstract RelicDef Def { get; }
public virtual bool Available => true;
public virtual void OnMorning(int day)
{
}
public virtual void OnAcquired()
{
}
public bool Held()
{
if ((Object)(object)RelicManager.Instance != (Object)null)
{
return RelicManager.Instance.HasRelic(Def.id);
}
return false;
}
}
[HarmonyPatch(typeof(AddressablesManager), "IsLoaded")]
internal static class Patch_Register
{
private static bool s_Done;
private static void Postfix(AddressablesManager __instance, bool __result)
{
if (!__result || s_Done)
{
return;
}
s_Done = true;
try
{
Register(__instance);
}
catch (Exception ex)
{
ManualLogSource log = Plugin.Log;
if (log != null)
{
log.LogError((object)("relic registration failed: " + ex));
}
}
}
private static void Register(AddressablesManager addressables)
{
//IL_010f: Unknown result type (might be due to invalid IL or missing references)
//IL_02da: Unknown result type (might be due to invalid IL or missing references)
//IL_02e4: Expected O, but got Unknown
//IL_036b: Unknown result type (might be due to invalid IL or missing references)
//IL_0372: Expected O, but got Unknown
//IL_03b3: 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_03e1: Unknown result type (might be due to invalid IL or missing references)
//IL_03f0: Unknown result type (might be due to invalid IL or missing references)
Dictionary<string, Relic> allRelics = addressables.GetAllRelics();
List<string> allRelicIdentifiers = addressables.GetAllRelicIdentifiers();
RelicEntry[] entries = Registry.Entries;
foreach (RelicEntry relicEntry in entries)
{
RelicDef def = relicEntry.Def;
if (!relicEntry.Available)
{
ManualLogSource log = Plugin.Log;
if (log != null)
{
log.LogInfo((object)("skipping " + def.id + ", another mod already covers it"));
}
}
else
{
if (allRelics.ContainsKey(def.id))
{
continue;
}
Relic val = Donor(allRelics, def);
if ((Object)(object)val == (Object)null)
{
ManualLogSource log2 = Plugin.Log;
if (log2 != null)
{
log2.LogError((object)("no donor prefab for " + def.id));
}
continue;
}
Relic val2 = Object.Instantiate<Relic>(val);
Object.DontDestroyOnLoad((Object)(object)((Component)val2).gameObject);
((Component)val2).gameObject.SetActive(false);
((Object)val2).name = def.id;
Traverse val3 = Traverse.Create((object)val2);
val3.Field("identifier").SetValue((object)def.id);
val3.Field("rarity").SetValue((object)def.rarity);
val3.Field("cost").SetValue((object)def.cost);
val3.Field("generic").SetValue((object)false);
val3.Field("racial").SetValue((object)false);
val3.Field("unlockedByDefault").SetValue((object)true);
val3.Field("triggerOnLoad").SetValue((object)false);
val3.Field("triggerLater").SetValue((object)false);
val3.Field("requiredKingdomLevel").SetValue((object)def.requiredKingdomLevel);
val3.Field("upgrade").SetValue((object)null);
val3.Field("soldAtCartographer1").SetValue((object)(!def.bossOnly));
val3.Field("soldAtCartographer2").SetValue((object)(!def.bossOnly));
val3.Field("soldAtCartographer3").SetValue((object)(!def.bossOnly));
val3.Field("soldAtCartographer4").SetValue((object)(!def.bossOnly));
val3.Field("requiredBuilding").SetValue((object)(BuildingType)666);
val3.Field("relatedUnit").SetValue((object)"");
val3.Field("kingdom").SetValue((object)(Races)11);
val3.Field("keywords").SetValue((object)new EffectKeywordType[0]);
val3.Field("attack").SetValue((object)new Attack());
val3.Field("cooldown").SetValue((object)1E+09f);
Sprite icon = ((Item)val).GetIcon();
Stream manifestResourceStream = typeof(Plugin).Assembly.GetManifestResourceStream("MoreRelics.Icons." + relicEntry.GetType().Name + ".png");
if (manifestResourceStream != null)
{
byte[] array = new byte[manifestResourceStream.Length];
manifestResourceStream.Read(array, 0, array.Length);
manifestResourceStream.Dispose();
Texture2D val4 = new Texture2D(2, 2, (TextureFormat)4, false);
if (ImageConversion.LoadImage(val4, array))
{
((Texture)val4).filterMode = (FilterMode)0;
((Object)val4).hideFlags = (HideFlags)61;
float num;
if (!((Object)(object)icon != (Object)null))
{
num = 100f;
}
else
{
float pixelsPerUnit = icon.pixelsPerUnit;
float num2 = ((Texture)val4).width;
Rect rect = icon.rect;
num = pixelsPerUnit * (num2 / ((Rect)(ref rect)).width);
}
float num3 = num;
Sprite val5 = Sprite.Create(val4, new Rect(0f, 0f, (float)((Texture)val4).width, (float)((Texture)val4).height), new Vector2(0.5f, 0.5f), num3);
((Object)val5).hideFlags = (HideFlags)61;
val3.Field("icon").SetValue((object)val5);
Image component = ((Component)val2).GetComponent<Image>();
if ((Object)(object)component != (Object)null)
{
component.sprite = val5;
}
}
else
{
ManualLogSource log3 = Plugin.Log;
if (log3 != null)
{
log3.LogError((object)("could not decode the icon png for " + def.id));
}
}
}
allRelics[def.id] = val2;
if (!allRelicIdentifiers.Contains(def.id))
{
allRelicIdentifiers.Add(def.id);
}
ManualLogSource log4 = Plugin.Log;
if (log4 != null)
{
log4.LogInfo((object)("registered " + def.id + " cloned from " + ((Object)val).name));
}
}
}
}
private static Relic Donor(Dictionary<string, Relic> relics, RelicDef def)
{
string[] cloneFrom = def.cloneFrom;
foreach (string key in cloneFrom)
{
if (relics.TryGetValue(key, out var value) && (Object)(object)value != (Object)null)
{
return value;
}
}
foreach (KeyValuePair<string, Relic> relic in relics)
{
if ((Object)(object)relic.Value != (Object)null && Registry.Find(relic.Key) == null)
{
return relic.Value;
}
}
return null;
}
}
[HarmonyPatch(typeof(RelicManager), "SpawnRelic", new Type[] { typeof(Relic) })]
internal static class Patch_SpawnActive
{
private static void Postfix(Relic __result)
{
if ((Object)(object)__result != (Object)null && Registry.Find(((Item)__result).GetIdentifier()) != null)
{
((Component)__result).gameObject.SetActive(true);
}
}
}
[HarmonyPatch(typeof(RelicManager), "IsUnlocked")]
internal static class Patch_IsUnlocked
{
private static void Postfix(string relic, ref bool __result)
{
__result = __result || Registry.Find(relic) != null;
}
}
[HarmonyPatch(typeof(RaceDataManager), "GetStartingRelic")]
internal static class Patch_StartingRelic
{
private static void Postfix(ref string __result)
{
if (!string.IsNullOrEmpty(__result) && (Object)(object)AddressablesManager.Instance != (Object)null && (Object)(object)AddressablesManager.Instance.GetRelic(__result) == (Object)null)
{
ManualLogSource log = Plugin.Log;
if (log != null)
{
log.LogWarning((object)("starting relic " + __result + " does not exist, dropping it"));
}
__result = "";
}
}
}
internal static class BossOnly
{
public static void Stamp()
{
//IL_0020: Unknown result type (might be due to invalid IL or missing references)
//IL_0025: Unknown result type (might be due to invalid IL or missing references)
//IL_007b: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)RaceManager.Instance == (Object)null || (Object)(object)AddressablesManager.Instance == (Object)null)
{
return;
}
Races race = RaceManager.Instance.GetRace();
RelicEntry[] entries = Registry.Entries;
foreach (RelicEntry relicEntry in entries)
{
if (relicEntry.Def.bossOnly && relicEntry.Available)
{
Relic relic = AddressablesManager.Instance.GetRelic(relicEntry.Def.id);
if ((Object)(object)relic != (Object)null)
{
Traverse.Create((object)relic).Field("kingdom").SetValue((object)race);
}
}
}
}
}
[HarmonyPatch(typeof(DropBossChest), "PreparePool")]
internal static class Patch_BossPoolStamp
{
private static void Prefix()
{
try
{
BossOnly.Stamp();
}
catch (Exception ex)
{
ManualLogSource log = Plugin.Log;
if (log != null)
{
log.LogError((object)("boss pool stamp failed: " + ex));
}
}
}
}
[HarmonyPatch(typeof(Item), "GetTitle")]
internal static class Patch_Title
{
private static void Postfix(Item __instance, ref string __result)
{
RelicEntry relicEntry = Registry.Find(__instance.GetIdentifier());
if (relicEntry != null)
{
__result = relicEntry.Def.title;
}
}
}
[HarmonyPatch(typeof(Item), "GetDescription")]
internal static class Patch_Description
{
private static void Postfix(Item __instance, ref string __result)
{
RelicEntry relicEntry = Registry.Find(__instance.GetIdentifier());
if (relicEntry != null)
{
__result = relicEntry.Def.description;
}
}
}
[HarmonyPatch(typeof(RelicManager), "Awake")]
internal static class Patch_Hook
{
private static int s_LastDay = -1;
private static void Postfix()
{
s_LastDay = -1;
try
{
BossOnly.Stamp();
}
catch (Exception ex)
{
ManualLogSource log = Plugin.Log;
if (log != null)
{
log.LogError((object)("boss only stamp failed: " + ex));
}
}
DaytimeManager.BeforeMorningStart -= Morning;
DaytimeManager.BeforeMorningStart += Morning;
RelicManager.OnRelicFound -= Found;
RelicManager.OnRelicFound += Found;
}
private static void Found(Relic relic)
{
RelicEntry relicEntry = (((Object)(object)relic != (Object)null) ? Registry.Find(((Item)relic).GetIdentifier()) : null);
if (relicEntry == null)
{
return;
}
try
{
relicEntry.OnAcquired();
}
catch (Exception ex)
{
ManualLogSource log = Plugin.Log;
if (log != null)
{
log.LogError((object)(relicEntry.Def.id + " failed on pickup: " + ex));
}
}
}
private static void Morning(int day)
{
if (day == s_LastDay)
{
return;
}
s_LastDay = day;
RelicEntry[] entries = Registry.Entries;
foreach (RelicEntry relicEntry in entries)
{
try
{
if (relicEntry.Held())
{
relicEntry.OnMorning(day);
}
}
catch (Exception ex)
{
ManualLogSource log = Plugin.Log;
if (log != null)
{
log.LogError((object)(relicEntry.Def.id + " failed on morning: " + ex));
}
}
}
}
}
internal sealed class SousChef : RelicEntry
{
internal const int ExtraMeat = 1;
private static readonly RelicDef Definition = new RelicDef
{
id = "ownly_SousChef",
cloneFrom = new string[4] { "GreenHouse", "BetterBerries", "Fruitarian", "SpawnTrees" },
rarity = (Rarity)2,
cost = 8,
title = "Sous Chef",
description = "The cook prepares one more meat per night."
};
public override RelicDef Def => Definition;
internal static bool HeldInTavern()
{
GameData val = (((Object)(object)TavernSaveManager.Instance != (Object)null) ? TavernSaveManager.Instance.GetGameData() : null);
if (val != null && val.relics != null)
{
return val.relics.Contains(Definition.id);
}
return false;
}
}
[HarmonyPatch(typeof(TavernSaveManager), "GetMeatToCook")]
internal static class Patch_SousChef
{
private static void Postfix(ref int __result)
{
try
{
if (SousChef.HeldInTavern())
{
__result++;
}
}
catch (Exception ex)
{
ManualLogSource log = Plugin.Log;
if (log != null)
{
log.LogError((object)("sous chef failed on meat to cook: " + ex));
}
}
}
}
}
