Dice.cs

using System;
using System.Runtime.CompilerServices;
using UnityEngine;
 
// Token: 0x02000060 RID: 96
public class Dice
{
    // Token: 0x0600027F RID: 639 RVA: 0x0001389C File Offset: 0x00011A9C
    public static int Roll(int num, int sides, int bonus = 0, Card card = null)
    {
        Dice.<>c__DisplayClass1_0 CS$<>8__locals1;
        CS$<>8__locals1.sides = sides;
        CS$<>8__locals1.num = num;
        CS$<>8__locals1.bonus = bonus;
        int num2 = 1;
        bool flag = true;
        int num3 = 0;
        if (card != null)
        {
            int num4 = card.Evalue(78);
            flag = (num4 >= 0);
            num2 = 1 + Mathf.Abs(num4 / 100) + ((Mathf.Abs(num4 % 100) > Dice.rnd(100)) ? 1 : 0);
        }
        for (int i = 0; i < num2; i++)
        {
            int num5 = Dice.<Roll>g__Roll|1_0(ref CS$<>8__locals1);
            if (i == 0 || (flag && num5 > num3) || (!flag && num5 < num3))
            {
                num3 = num5;
            }
        }
        return num3;
    }
 
    // Token: 0x06000280 RID: 640 RVA: 0x00013933 File Offset: 0x00011B33
    public static int RollMax(int num, int sides, int bonus = 0)
    {
        return num * sides + bonus;
    }
 
    // Token: 0x06000281 RID: 641 RVA: 0x0001393A File Offset: 0x00011B3A
    public static int rnd(int a)
    {
        return Rand.Range(0, a);
    }
 
    // Token: 0x06000282 RID: 642 RVA: 0x00013943 File Offset: 0x00011B43
    public Dice(int _num = 0, int _sides = 0, int _bonus = 0, Card _card = null)
    {
        this.num = _num;
        this.sides = _sides;
        this.bonus = _bonus;
        this.card = _card;
    }
 
    // Token: 0x06000283 RID: 643 RVA: 0x00013968 File Offset: 0x00011B68
    public static Dice Parse(string raw)
    {
        Dice dice = new Dice(0, 0, 0, null);
        string[] array = raw.Split(',', StringSplitOptions.None);
        if (array.Length != 0)
        {
            string[] array2 = array[0].Split('d', StringSplitOptions.None);
            dice.num = int.Parse(array2[0]);
            dice.sides = int.Parse(array2[1]);
        }
        if (array.Length > 1)
        {
            dice.bonus = int.Parse(array[1]);
        }
        return dice;
    }
 
    // Token: 0x06000284 RID: 644 RVA: 0x000139CA File Offset: 0x00011BCA
    public int Roll()
    {
        return Dice.Roll(this.num, this.sides, this.bonus, this.card);
    }
 
    // Token: 0x06000285 RID: 645 RVA: 0x000139E9 File Offset: 0x00011BE9
    public int RollMax()
    {
        return Dice.RollMax(this.num, this.sides, this.bonus);
    }
 
    // Token: 0x06000286 RID: 646 RVA: 0x00013A04 File Offset: 0x00011C04
    public override string ToString()
    {
        return this.num.ToString() + "d" + this.sides.ToString() + ((this.bonus > 0) ? ("+" + this.bonus.ToString()) : ((this.bonus < 0) ? (this.bonus.ToString() ?? "") : ""));
    }
 
    // Token: 0x06000287 RID: 647 RVA: 0x00013A78 File Offset: 0x00011C78
    public static Dice Create(Element ele, Card c)
    {
        string key = ele.source.alias;
        if (!EClass.sources.calc.map.ContainsKey(key) && !ele.source.aliasRef.IsEmpty())
        {
            key = ele.source.alias.Split('_', StringSplitOptions.None)[0] + "_";
        }
        if (!EClass.sources.calc.map.ContainsKey(key))
        {
            return null;
        }
        SourceCalc.Row row = EClass.sources.calc.map[key];
        int power = ele.GetPower(c);
        int ele2 = ele.source.aliasParent.IsEmpty() ? 0 : c.Evalue(ele.source.aliasParent);
        Dice result;
        try
        {
            result = new Dice(Mathf.Max(1, row.num.Calc(power, ele2, 0)), Mathf.Max(1, row.sides.Calc(power, ele2, 0)), row.bonus.Calc(power, ele2, 0), c);
        }
        catch
        {
            Debug.Log(ele.id);
            result = new Dice(0, 0, 0, null);
        }
        return result;
    }
 
    // Token: 0x06000288 RID: 648 RVA: 0x00013BA8 File Offset: 0x00011DA8
    public static Dice Create(string id, int power, Card c = null, Act act = null)
    {
        if (!EClass.sources.calc.map.ContainsKey(id))
        {
            Debug.Log(id);
            return null;
        }
        SourceCalc.Row row = EClass.sources.calc.map[id];
        int power2 = power;
        int ele = power / 10;
        if (act != null)
        {
            Element orCreateElement = c.elements.GetOrCreateElement(act.source.id);
            power2 = orCreateElement.GetPower(c);
            ele = (orCreateElement.source.aliasParent.IsEmpty() ? 0 : c.Evalue(orCreateElement.source.aliasParent));
        }
        Dice result;
        try
        {
            result = new Dice(Mathf.Max(1, row.num.Calc(power2, ele, 0)), Mathf.Max(1, row.sides.Calc(power2, ele, 0)), row.bonus.Calc(power2, ele, 0), c);
        }
        catch
        {
            result = new Dice(0, 0, 0, null);
        }
        return result;
    }
 
    // Token: 0x0600028A RID: 650 RVA: 0x00013CAC File Offset: 0x00011EAC
    [CompilerGenerated]
    internal static int <Roll>g__Roll|1_0(ref Dice.<>c__DisplayClass1_0 A_0)
    {
        int num = 0;
        for (int i = 0; i < A_0.num; i++)
        {
            num += Dice.rnd(A_0.sides) + 1;
        }
        return num + A_0.bonus;
    }
 
    // Token: 0x04000519 RID: 1305
    public static Dice Null = new Dice(0, 0, 0, null);
 
    // Token: 0x0400051A RID: 1306
    public int num;
 
    // Token: 0x0400051B RID: 1307
    public int sides;
 
    // Token: 0x0400051C RID: 1308
    public int bonus;
 
    // Token: 0x0400051D RID: 1309
    public Card card;
}