using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using RarityLib.Utils;
using UnboundLib.Cards;
using UnboundLib.GameModes;
using UnityEngine;
using UnityEngine.UI;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(/*Could not decode attribute arguments.*/)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.1", FrameworkDisplayName = ".NET Framework 4.7.1")]
[assembly: SecurityPermission(8, SkipVerification = true)]
[assembly: AssemblyVersion("0.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Embedded]
[AttributeUsage(/*Could not decode attribute arguments.*/)]
internal sealed class RefSafetyRulesAttribute : Attribute
{
public readonly int Version;
public RefSafetyRulesAttribute(int P_0)
{
Version = P_0;
}
}
}
namespace ClassesManagerReborn.Patchs
{
[Serializable]
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
internal class RarityEnumValues : Object
{
private static void Postfix(Type enumType, ref Array __result)
{
if (enumType == typeof(Rarity))
{
__result = (Array)(object)Enumerable.ToArray<Rarity>(Enumerable.Select<Rarity, Rarity>((IEnumerable<Rarity>)(object)RarityUtils.rarities.Values, (Func<Rarity, Rarity>)((Rarity v) => v.value)));
}
}
}
[Serializable]
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
internal class RarityEnumCompair : Object
{
private static bool Prefix(Enum __instance, object target, ref int __result)
{
//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_0018: 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_001e: Unknown result type (might be due to invalid IL or missing references)
//IL_002a: Unknown result type (might be due to invalid IL or missing references)
if (__instance is Rarity rarity && target is Rarity rarity2)
{
float relativeRarity = RarityUtils.GetRarityData(rarity).relativeRarity;
float relativeRarity2 = RarityUtils.GetRarityData(rarity2).relativeRarity;
if (relativeRarity == relativeRarity2)
{
__result = 0;
}
else if (relativeRarity > relativeRarity2)
{
__result = -1;
}
else
{
__result = 1;
}
return false;
}
return true;
}
}
[Serializable]
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
internal class RarityEnumNames : Object
{
private static void Postfix(Type enumType, ref string[] __result)
{
if (enumType == typeof(Rarity))
{
__result = Enumerable.ToArray<string>(Enumerable.Select<Rarity, string>((IEnumerable<Rarity>)(object)RarityUtils.rarities.Values, (Func<Rarity, string>)((Rarity r) => r.name)));
}
}
}
[Serializable]
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
internal class RarityEnumToString : Object
{
private static void Postfix(Enum __instance, ref string __result)
{
//IL_0028: Unknown result type (might be due to invalid IL or missing references)
if (((Object)__instance).GetType() == typeof(Rarity))
{
try
{
__result = Enum.GetNames(typeof(Rarity))[(Rarity)(object)__instance];
}
catch (Object)
{
}
}
}
}
}
namespace RarityLib
{
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInPlugin("root.rarity.lib", "Rarity Extention Library", "1.2.8")]
[BepInProcess("Rounds.exe")]
public class Main : BaseUnityPlugin
{
private const string ModId = "root.rarity.lib";
private const string ModName = "Rarity Extention Library";
public const string Version = "1.2.8";
private void Awake()
{
//IL_0005: 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_0042: Unknown result type (might be due to invalid IL or missing references)
new Harmony("root.rarity.lib").PatchAll();
RarityUtils.Started = true;
RarityUtils.AddRarity("Legendary", 0.025f, new Color(1f, 1f, 0f), new Color(0.7f, 0.7f, 0f));
}
private void Start()
{
RarityUtils.FinalizeRaritys();
GameModeManager.AddHook("GameStart", (Func<IGameModeHandler, IEnumerator>)((IGameModeHandler gm) => RarityUtils.Reset()), 800);
RarityAdder[] array = (RarityAdder[])(object)Resources.FindObjectsOfTypeAll(typeof(RarityAdder));
foreach (RarityAdder rarityAdder in array)
{
if (((Behaviour)rarityAdder).enabled)
{
rarityAdder.SetUp();
}
}
}
}
public class testcard : CustomCard
{
public override void OnAddCard(Player player, Gun gun, GunAmmo gunAmmo, CharacterData data, HealthHandler health, Gravity gravity, Block block, CharacterStatModifiers characterStats)
{
}
protected override GameObject GetCardArt()
{
return null;
}
protected override string GetDescription()
{
return "";
}
protected override Rarity GetRarity()
{
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
return RarityUtils.GetRarity("Legendary");
}
protected override CardInfoStat[] GetStats()
{
return (CardInfoStat[])(object)new CardInfoStat[0];
}
protected override CardThemeColorType GetTheme()
{
return (CardThemeColorType)3;
}
protected override string GetTitle()
{
return "RARITY TEST CARD";
}
}
}
namespace RarityLib.Utils
{
internal class RarityAdder : MonoBehaviour
{
public string rarityName = "Common";
internal void SetUp()
{
//IL_000c: 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)
((Component)this).GetComponent<CardInfo>().rarity = RarityUtils.GetRarity(rarityName);
}
}
public class RarityUtils : Object
{
[CompilerGenerated]
private sealed class <>c__DisplayClass11_0 : Object
{
public string rarityName;
public Rarity rarity;
internal bool <GetRarity>b__0(Rarity r)
{
return r.name == rarityName;
}
internal bool <GetRarity>b__1(int i)
{
return rarities[i] == rarity;
}
}
[CompilerGenerated]
private sealed class <>c__DisplayClass9_0 : Object
{
public string name;
internal bool <AddRarity>b__0(Rarity r)
{
return r.name == name;
}
internal bool <AddRarity>b__1(int j)
{
return rarities[j].name == name;
}
}
internal static Dictionary<int, Rarity> rarities = new Dictionary<int, Rarity>();
internal static Dictionary<CardInfo, float> CardRarities = new Dictionary<CardInfo, float>();
internal static Dictionary<CardInfo, float> CardRaritiesAdd = new Dictionary<CardInfo, float>();
internal static Dictionary<CardInfo, float> CardRaritiesMul = new Dictionary<CardInfo, float>();
internal static List<Rarity> RarityList = new List<Rarity>();
internal static bool Finalized = false;
internal static bool Started = false;
public static IReadOnlyDictionary<int, Rarity> Rarities => (IReadOnlyDictionary<int, Rarity>)(object)rarities;
public static int AddRarity(string name, float relativeRarity, Color color, Color colorOff)
{
//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
<>c__DisplayClass9_0 CS$<>8__locals0 = new <>c__DisplayClass9_0();
CS$<>8__locals0.name = name;
if (!Started)
{
throw new RarityException("The rarity registry hasnt been set up yet. \n Are you depending on raritylib?");
}
if (Finalized)
{
throw new RarityException("Rarities can no longer be registered. \n Is this being called in the mods awake function?");
}
int result = RarityList.Count + 3;
if (Enumerable.Any<Rarity>((IEnumerable<Rarity>)(object)rarities.Values, (Func<Rarity, bool>)((Rarity r) => r.name == CS$<>8__locals0.name)))
{
Debug.LogWarning((object)String.Concat("Rarity with name ", CS$<>8__locals0.name, " already exists"));
return Enumerable.First<int>(Enumerable.Where<int>((IEnumerable<int>)(object)rarities.Keys, (Func<int, bool>)((int j) => rarities[j].name == CS$<>8__locals0.name)));
}
if (relativeRarity <= 0f)
{
throw new RarityException("The relative rarity of a rarity must be greater than 0.");
}
RarityList.Add(new Rarity(CS$<>8__locals0.name, relativeRarity, color, colorOff, (Rarity)(-1)));
return result;
}
internal static void FinalizeRaritys()
{
//IL_001f: Unknown result type (might be due to invalid IL or missing references)
//IL_0033: Unknown result type (might be due to invalid IL or missing references)
//IL_0062: Unknown result type (might be due to invalid IL or missing references)
//IL_0076: Unknown result type (might be due to invalid IL or missing references)
//IL_00a5: 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_0104: Unknown result type (might be due to invalid IL or missing references)
rarities.Add(0, new Rarity("Common", 1f, new Color(0.0978f, 0.1088f, 0.1321f), new Color(0.0978f, 0.1088f, 0.1321f), (Rarity)0));
rarities.Add(1, new Rarity("Uncommon", 0.4f, new Color(0.1745f, 0.6782f, 1f), new Color(0.1934f, 0.3915f, 0.5189f), (Rarity)1));
rarities.Add(2, new Rarity("Rare", 0.1f, new Color(1f, 0.1765f, 0.7567f), new Color(0.5283f, 0.1969f, 0.4321f), (Rarity)2));
RarityList.Sort((Comparison<Rarity>)((Rarity r1, Rarity r2) => ((Single)(ref r2.relativeRarity)).CompareTo(r1.relativeRarity)));
for (int i = 0; i < RarityList.Count; i++)
{
RarityList[i].value = (Rarity)(i + 3);
rarities.Add(3 + i, RarityList[i]);
}
Finalized = true;
}
public static Rarity GetRarity(string rarityName)
{
<>c__DisplayClass11_0 CS$<>8__locals0 = new <>c__DisplayClass11_0();
CS$<>8__locals0.rarityName = rarityName;
if (!Finalized)
{
throw new RarityException("Rarities cant be gotten before they have finished being registered. \n Are you waiting till at least the start function.");
}
CS$<>8__locals0.rarity = Enumerable.ToList<Rarity>((IEnumerable<Rarity>)(object)rarities.Values).Find((Predicate<Rarity>)((Rarity r) => r.name == CS$<>8__locals0.rarityName));
if (CS$<>8__locals0.rarity != null)
{
return (Rarity)Enumerable.ToList<int>((IEnumerable<int>)(object)rarities.Keys).Find((Predicate<int>)((int i) => rarities[i] == CS$<>8__locals0.rarity));
}
return (Rarity)0;
}
public static Rarity GetRarityData(Rarity rarity)
{
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
//IL_000b: Expected I4, but got Unknown
return rarities[(int)rarity];
}
public static float GetCardRarityModifier(CardInfo card)
{
if (!CardRarities.ContainsKey(card))
{
CardRarities[card] = 1f;
}
if (!CardRaritiesAdd.ContainsKey(card))
{
CardRaritiesAdd[card] = 0f;
}
if (!CardRaritiesMul.ContainsKey(card))
{
CardRaritiesMul[card] = 1f;
}
return (CardRarities[card] + CardRaritiesAdd[card]) * CardRaritiesMul[card];
}
public static void SetCardRarityModifier(CardInfo card, float modifier)
{
Debug.Log((object)String.Format("Card {0}'s base rarity modifier set to {1}", (object)((Object)card).name, (object)modifier));
CardRarities[card] = modifier;
}
public static void AjustCardRarityModifier(CardInfo card, float add = 0f, float mul = 0f)
{
Debug.Log((object)String.Format("Card {0}'s rarity modifier ajusted by +{1} and *{2}", (object)((Object)card).name, (object)add, (object)mul));
if (!CardRaritiesAdd.ContainsKey(card))
{
CardRaritiesAdd[card] = 0f;
}
if (!CardRaritiesMul.ContainsKey(card))
{
CardRaritiesMul[card] = 1f;
}
Dictionary<CardInfo, float> cardRaritiesAdd = CardRaritiesAdd;
CardInfo val = card;
cardRaritiesAdd[val] += add;
cardRaritiesAdd = CardRaritiesMul;
val = card;
cardRaritiesAdd[val] += mul;
}
[IteratorStateMachine(/*Could not decode attribute arguments.*/)]
internal static IEnumerator Reset()
{
CardRarities.Clear();
CardRaritiesAdd.Clear();
CardRaritiesMul.Clear();
Enumerable.ToList<Rarity>((IEnumerable<Rarity>)(object)rarities.Values).ForEach((Action<Rarity>)delegate(Rarity r)
{
r.calculatedRarity = r.relativeRarity;
});
yield break;
}
}
public class Rarity : Object
{
public string name;
public float relativeRarity;
public float calculatedRarity;
public Color color;
public Color colorOff;
public Rarity value;
internal Rarity(string name, float relativeRarity, Color color, Color colorOff, Rarity value)
{
//IL_001c: Unknown result type (might be due to invalid IL or missing references)
//IL_001d: Unknown result type (might be due to invalid IL or missing references)
//IL_0023: 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_002b: Unknown result type (might be due to invalid IL or missing references)
//IL_002d: Unknown result type (might be due to invalid IL or missing references)
this.name = name;
this.relativeRarity = relativeRarity;
calculatedRarity = relativeRarity;
this.color = color;
this.colorOff = colorOff;
this.value = value;
}
public override bool Equals(object obj)
{
if (obj.GetType() == typeof(Rarity))
{
return ((Rarity)obj).name == name;
}
return false;
}
}
internal class RarityException : Exception
{
public RarityException(string message)
: base(message)
{
}
}
}
namespace RarityLib.Patches
{
[Serializable]
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
internal class CardChoicePatchGetRanomCard : Object
{
[HarmonyPriority(800)]
private static bool Prefix(CardInfo[] cards, ref GameObject __result)
{
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
//IL_001d: Expected I4, but got Unknown
//IL_0050: Unknown result type (might be due to invalid IL or missing references)
//IL_005a: Expected I4, but got Unknown
float num = 0f;
for (int i = 0; i < cards.Length; i++)
{
num += RarityUtils.rarities[(int)cards[i].rarity].calculatedRarity * RarityUtils.GetCardRarityModifier(cards[i]);
}
float num2 = Random.Range(0f, num);
for (int j = 0; j < cards.Length; j++)
{
num2 -= RarityUtils.rarities[(int)cards[j].rarity].calculatedRarity * RarityUtils.GetCardRarityModifier(cards[j]);
if (num2 <= 0f)
{
__result = ((Component)cards[j]).gameObject;
break;
}
}
return false;
}
}
[Serializable]
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
internal class CardRarityColorPatchToggle : Object
{
private static bool Prefix(bool isOn, CardRarityColor __instance)
{
//IL_002d: Unknown result type (might be due to invalid IL or missing references)
//IL_0037: Expected I4, but got Unknown
//IL_0037: Unknown result type (might be due to invalid IL or missing references)
//IL_0016: Unknown result type (might be due to invalid IL or missing references)
//IL_0020: Expected I4, but got Unknown
//IL_0020: Unknown result type (might be due to invalid IL or missing references)
CardInfo componentInParent = ((Component)__instance).GetComponentInParent<CardInfo>();
((Graphic)((Component)__instance).GetComponent<Image>()).color = (isOn ? RarityUtils.rarities[(int)componentInParent.rarity].color : RarityUtils.rarities[(int)componentInParent.rarity].colorOff);
return false;
}
}
}
