RecipeCard.cs

using System;
using System.Collections.Generic;
using Newtonsoft.Json;
using UnityEngine;
 
// Token: 0x0200005B RID: 91
public class RecipeCard : Recipe
{
    // Token: 0x1700006E RID: 110
    // (get) Token: 0x0600023E RID: 574 RVA: 0x00011960 File Offset: 0x0000FB60
    public CardRow sourceCard
    {
        get
        {
            CardRow result;
            if ((result = this._sourceCard) == null)
            {
                result = (this._sourceCard = EClass.sources.cards.map.TryGetValue(base.source.row.idString, null));
            }
            return result;
        }
    }
 
    // Token: 0x1700006F RID: 111
    // (get) Token: 0x0600023F RID: 575 RVA: 0x000119A5 File Offset: 0x0000FBA5
    public override RenderRow renderRow
    {
        get
        {
            return this.sourceCard;
        }
    }
 
    // Token: 0x17000070 RID: 112
    // (get) Token: 0x06000240 RID: 576 RVA: 0x000119AD File Offset: 0x0000FBAD
    public override TileType tileType
    {
        get
        {
            return this.Mold.trait.tileType;
        }
    }
 
    // Token: 0x06000241 RID: 577 RVA: 0x000119BF File Offset: 0x0000FBBF
    public override IRenderer GetRenderer()
    {
        return this.Mold.renderer;
    }
 
    // Token: 0x17000071 RID: 113
    // (get) Token: 0x06000242 RID: 578 RVA: 0x000119CC File Offset: 0x0000FBCC
    public string idCard
    {
        get
        {
            return this.sourceCard.id;
        }
    }
 
    // Token: 0x06000243 RID: 579 RVA: 0x000119D9 File Offset: 0x0000FBD9
    public override string GetDetail()
    {
        return this.sourceCard.GetDetail();
    }
 
    // Token: 0x06000244 RID: 580 RVA: 0x000119E6 File Offset: 0x0000FBE6
    public override string GetIdThing()
    {
        return this.id;
    }
 
    // Token: 0x17000072 RID: 114
    // (get) Token: 0x06000245 RID: 581 RVA: 0x000119EE File Offset: 0x0000FBEE
    public override bool CanRotate
    {
        get
        {
            return this.tileType.CanRotate(true);
        }
    }
 
    // Token: 0x17000073 RID: 115
    // (get) Token: 0x06000246 RID: 582 RVA: 0x000119FC File Offset: 0x0000FBFC
    public override bool IsThing
    {
        get
        {
            return true;
        }
    }
 
    // Token: 0x17000074 RID: 116
    // (get) Token: 0x06000247 RID: 583 RVA: 0x00011A00 File Offset: 0x0000FC00
    public override Card Mold
    {
        get
        {
            Card result;
            if ((result = this._mold) == null)
            {
                result = (this._mold = this.CreateMold());
            }
            return result;
        }
    }
 
    // Token: 0x17000075 RID: 117
    // (get) Token: 0x06000248 RID: 584 RVA: 0x00011A26 File Offset: 0x0000FC26
    public bool isDish
    {
        get
        {
            return this.sourceCard._origin == "dish";
        }
    }
 
    // Token: 0x06000249 RID: 585 RVA: 0x00011A40 File Offset: 0x0000FC40
    public override void OnRenderMarker(Point point, bool active, HitResult result, bool main, int dir, int bridgeHeight)
    {
        this.Mold.ignoreStackHeight = Input.GetKey(KeyCode.LeftControl);
        this.Mold.SetFreePos(point);
        this.freePos = this.Mold.freePos;
        this.fx = this.Mold.fx;
        this.fy = this.Mold.fy;
        this.Mold.RenderMarker(point, active, result, main, dir, false);
        if (!point.cell.skipRender)
        {
            this.Mold.trait.OnRenderTile(point, result, dir);
        }
    }
 
    // Token: 0x0600024A RID: 586 RVA: 0x00011AD8 File Offset: 0x0000FCD8
    public override void BuildIngredientList()
    {
        if (this.ingredients.Count != 0)
        {
            return;
        }
        base.BuildIngredientList();
        if (!EClass.core.IsGameStarted || EClass.core.game.isLoading)
        {
            return;
        }
        if (this.isDish && EClass.pc.Evalue(1650) >= 2)
        {
            bool flag = this.ingredients.Count < 3;
            using (List<Recipe.Ingredient>.Enumerator enumerator = this.ingredients.GetEnumerator())
            {
                while (enumerator.MoveNext())
                {
                    if (enumerator.Current.id == "seasoning")
                    {
                        flag = false;
                    }
                }
            }
            if (flag)
            {
                this.ingredients.Add(new Recipe.Ingredient
                {
                    id = "seasoning",
                    optional = true,
                    req = 1
                });
            }
        }
    }
 
    // Token: 0x0600024B RID: 587 RVA: 0x00011BC0 File Offset: 0x0000FDC0
    public override void OnChangeIngredient()
    {
        if (this.UseStock)
        {
            return;
        }
        this.Mold.ChangeMaterial(this.GetMainMaterial());
        if (base.source.colorIng != 0)
        {
            this.Mold.Dye(this.GetColorMaterial());
        }
    }
 
    // Token: 0x0600024C RID: 588 RVA: 0x00011BFB File Offset: 0x0000FDFB
    public override void OnSelected()
    {
        this.CreateMold();
    }
 
    // Token: 0x0600024D RID: 589 RVA: 0x00011C04 File Offset: 0x0000FE04
    public Card CreateMold()
    {
        if (this._mold != null)
        {
            this._mold.Destroy();
        }
        if (this.UseStock)
        {
            this.ingredients[0].RefreshThing();
        }
        if (this.UseStock && this.ingredients[0].thing != null)
        {
            this._mold = this.ingredients[0].thing.Duplicate(1);
        }
        else
        {
            if (this.sourceCard.isChara)
            {
                this._mold = CharaGen.Create(this.idCard, -1);
            }
            else
            {
                this._mold = ThingGen.Create(this.idCard, -1, -1);
            }
            this.OnChangeIngredient();
        }
        this._mold.dir = this._dir;
        this._mold.altitude = ActionMode.Build.altitude;
        this._mold.idSkin = this.idSkin;
        return this._mold;
    }
 
    // Token: 0x0600024E RID: 590 RVA: 0x00011CF0 File Offset: 0x0000FEF0
    public override Thing Craft(BlessedState blessed, bool sound = false, List<Thing> ings = null, bool model = false)
    {
        string text = this.idCard;
        int idMat = this.GetMainMaterial().id;
        Element reqSkill = base.source.GetReqSkill();
        int num = reqSkill.Value - EClass.pc.Evalue(reqSkill.id);
        int qualityBonus = base.GetQualityBonus();
        int num2 = this.renderRow.LV + qualityBonus;
        bool flag = qualityBonus < 0;
        CardRow cardRow = EClass.sources.cards.map.TryGetValue(text, null);
        bool flag2 = false;
        if (ings != null)
        {
            foreach (Thing thing in ings)
            {
                if (thing != null && thing.IsDecayed)
                {
                    flag2 = true;
                }
            }
        }
        if (EClass.debug.godCraft || model)
        {
            flag = false;
        }
        else if (cardRow != null && cardRow.tag.Contains("no_fail"))
        {
            flag = false;
        }
        else if (this.isDish && !EClass.scene.actionMode.IsBuildMode)
        {
            if (num > 0 && EClass.rnd(num * 10) > EClass.rnd(100))
            {
                text = this.GetIdFailDish();
                flag = true;
            }
            else
            {
                flag = false;
            }
        }
        if (!model)
        {
            string id = this.id;
            if (!(id == "weapon_stone") && !(id == "weapon_wood"))
            {
                if (id == "weapon_anvil")
                {
                    Rand.SetSeed(-1);
                    text = new string[]
                    {
                        "dagger",
                        "sword",
                        "axe_hand",
                        "blunt_club",
                        "spear",
                        "staff_long"
                    }.RandomItem<string>();
                    idMat = ings[1].material.id;
                }
            }
            else
            {
                Rand.SetSeed(-1);
                text = new string[]
                {
                    "dagger",
                    "sword",
                    "axe_hand",
                    "blunt_club",
                    "spear",
                    "staff_long"
                }.RandomItem<string>();
            }
        }
        if (!this.isDish && num2 < 1)
        {
            num2 = 1;
        }
        if (EClass.sources.cards.map[text].tag.Contains("noQuality"))
        {
            num2 = -1;
        }
        if (EClass.sources.cards.map[text].tag.Contains("noMaterialChange"))
        {
            idMat = -1;
        }
        CardBlueprint.Set(new CardBlueprint
        {
            qualityBonus = qualityBonus,
            rarity = (flag ? Rarity.Crude : Rarity.Normal)
        });
        Thing thing2 = ThingGen.Create(text, idMat, num2);
        if (thing2.trait.CraftNum > 1)
        {
            thing2.SetNum(thing2.trait.CraftNum);
        }
        thing2.idSkin = this.idSkin;
        thing2.Identify(false, IDTSource.Identify);
        thing2.isCrafted = true;
        if (base.source.colorIng != 0)
        {
            thing2.Dye(this.GetColorMaterial());
        }
        if (thing2.IsContainer)
        {
            thing2.RemoveThings();
            thing2.c_lockLv = 0;
        }
        thing2.SetBlessedState(blessed);
        if (this.isDish)
        {
            if (!flag)
            {
                this.MakeDish(thing2);
            }
        }
        else
        {
            this.MixIngredients(thing2);
        }
        if (this.isDish && flag2)
        {
            thing2.decay = thing2.MaxDecay + 1;
        }
        thing2.trait.OnCrafted(this);
        if (model)
        {
            thing2.SetNum(1);
            return thing2;
        }
        if (EClass.pc.held == null || !thing2.TryStackTo(EClass.pc.held.Thing))
        {
            EClass.pc.HoldCard(thing2, -1);
        }
        if (sound)
        {
            thing2.PlaySoundDrop(false);
        }
        Msg.Say("crafted", thing2, null, null, null);
        if (thing2.Num > EClass.rnd(1000) || EClass.debug.enable)
        {
            EClass.player.recipes.ComeUpWithRandomRecipe(thing2.category.id, 0);
        }
        if (this.isDish && (EClass.debug.enable || (EClass.player.flags.canComupWithFoodRecipe && EClass.rnd(30) == 0)))
        {
            EClass.player.recipes.ComeUpWithRandomRecipe(thing2.category.id, 0);
            EClass.player.flags.canComupWithFoodRecipe = false;
        }
        return thing2;
    }
 
    // Token: 0x0600024F RID: 591 RVA: 0x00012144 File Offset: 0x00010344
    public void MakeDish(Thing t)
    {
        Rand.SetSeed(EClass.pc.turn);
        List<Thing> list = new List<Thing>();
        foreach (Recipe.Ingredient ingredient in this.ingredients)
        {
            list.Add(ingredient.thing);
        }
        CraftUtil.MakeDish(t, list, base.GetQualityBonus());
        Rand.SetSeed(-1);
    }
 
    // Token: 0x06000250 RID: 592 RVA: 0x000121C4 File Offset: 0x000103C4
    public void MixIngredients(Thing t)
    {
        Rand.SetSeed(EClass.pc.turn);
        List<Thing> list = new List<Thing>();
        foreach (Recipe.Ingredient ingredient in this.ingredients)
        {
            list.Add(ingredient.thing);
        }
        CraftUtil.MixIngredients(t, list, CraftUtil.MixType.General, base.GetQualityBonus());
        Rand.SetSeed(-1);
    }
 
    // Token: 0x06000251 RID: 593 RVA: 0x00012248 File Offset: 0x00010448
    public string GetIdFailDish()
    {
        string category = this.sourceCard.category;
        uint num = <PrivateImplementationDetails>.ComputeStringHash(category);
        if (num <= 2191978763U)
        {
            if (num <= 1612508523U)
            {
                if (num != 228605988U)
                {
                    if (num == 1612508523U)
                    {
                        if (category == "meal_bread")
                        {
                            return "fail_dough_bread";
                        }
                    }
                }
                else if (category == "meal_meat")
                {
                    return "fail_meat";
                }
            }
            else if (num != 1937649754U)
            {
                if (num != 2035834996U)
                {
                    if (num == 2191978763U)
                    {
                        if (category == "meal_cake")
                        {
                            return "fail_dough_cake";
                        }
                    }
                }
                else if (category == "meal_noodle")
                {
                    return "fail_noodle";
                }
            }
            else if (category == "meal_vegi")
            {
                return "fail_vegi";
            }
        }
        else if (num <= 2808738325U)
        {
            if (num != 2235373338U)
            {
                if (num == 2808738325U)
                {
                    if (category == "meal_fish")
                    {
                        return "fail_fish";
                    }
                }
            }
            else if (category == "meal_rice")
            {
                return "fail_rice";
            }
        }
        else if (num != 3150879124U)
        {
            if (num != 3348186596U)
            {
                if (num == 4237839943U)
                {
                    if (category == "meal_fruit")
                    {
                        return "fail_fruit";
                    }
                }
            }
            else if (category == "meal_egg")
            {
                return "fail_egg";
            }
        }
        else if (category == "meal_soup")
        {
            return "fail_drink";
        }
        return "fail_dish";
    }
 
    // Token: 0x06000252 RID: 594 RVA: 0x000123E8 File Offset: 0x000105E8
    public override void Build(TaskBuild task)
    {
        Card card;
        if (task.target != null)
        {
            card = task.target;
        }
        else if (this.IngAsProduct)
        {
            if (task.resources.Count == 0)
            {
                Thing thing = this.ingredients[0].RefreshThing();
                if (thing == null)
                {
                    SE.Beep();
                    return;
                }
                Thing item = thing.Split(1);
                task.resources.Add(item);
                if (this.ingredients[0].thing.isDestroyed || this.ingredients[0].thing.ExistsOnMap)
                {
                    this.ingredients[0].thing = null;
                }
            }
            card = task.resources[0];
        }
        else
        {
            if (this.sourceCard.isChara)
            {
                card = CharaGen.Create(this.idCard, Mathf.Max(EClass._zone.DangerLv, EClass.pc.LV));
            }
            else
            {
                card = ThingGen.Create(this.idCard, -1, Mathf.Max(EClass._zone.DangerLv, EClass.pc.LV));
            }
            if (!card.isChara)
            {
                if (!card.IsUnique)
                {
                    card.ChangeMaterial(this.GetMainMaterial());
                }
                if (base.source.colorIng != 0)
                {
                    card.Dye(this.GetColorMaterial());
                }
                if (card.IsContainer)
                {
                    card.RemoveThings();
                }
            }
        }
        this.Build(task.owner, card, task.pos, this.ingredients[0].mat, task.dir, task.altitude, task.bridgeHeight);
        card.renderer.PlayAnime(AnimeID.Place, default(Vector3), false);
    }
 
    // Token: 0x06000253 RID: 595 RVA: 0x00012594 File Offset: 0x00010794
    public override void Build(Chara chara, Card t, Point pos, int mat, int dir, int altitude, int bridgeHeight)
    {
        if (mat == -1)
        {
            mat = 2;
        }
        EClass.pc.PlaySound(EClass.sources.materials.rows[mat].GetSoundImpact(null), 1f, true);
        t.SetDir(dir);
        t.idSkin = this.idSkin;
        EClass._zone.AddCard(t, pos);
        if (t.trait is TraitHouseBoard && ActionMode.Build.houseBoard != null)
        {
            (t.trait as TraitHouseBoard).data = IO.DeepCopy<TraitHouseBoard.Data>(ActionMode.Build.houseBoard.data);
        }
        t.SetPlaceState(PlaceState.installed, true);
        t.altitude = altitude;
        t.isPlayerCreation = true;
        if (EClass._zone.idCurrentSubset != null)
        {
            t.isSubsetCard = true;
        }
        t.ignoreStackHeight = Input.GetKey(KeyCode.LeftControl);
        if (ActionMode.Build.IsActive && t.trait.MaskOnBuild)
        {
            t.isMasked = true;
        }
        if (EClass.scene.actionMode.IsRoofEditMode(t) && t.isThing)
        {
            t.isRoofItem = true;
            t.SetPlaceState(PlaceState.roaming, false);
        }
        t.ForeachPoint(delegate(Point p, bool main)
        {
            base.<Build>g__CheckBlock|0(p);
        });
        t.freePos = this.freePos;
        if (this.freePos)
        {
            t.fx = this.fx;
            t.fy = this.fy;
        }
        t.renderer.RefreshSprite();
    }
 
    // Token: 0x06000254 RID: 596 RVA: 0x0001270D File Offset: 0x0001090D
    public override void OnChangeAltitude(int a)
    {
        this.Mold.altitude = a;
    }
 
    // Token: 0x06000255 RID: 597 RVA: 0x0001271B File Offset: 0x0001091B
    public override void Rotate()
    {
        this.Mold.Rotate(false);
        this._dir = this.Mold.dir;
        if (BuildMenu.Instance)
        {
            BuildMenu.Instance.info1.OnRotate();
        }
    }
 
    // Token: 0x06000256 RID: 598 RVA: 0x00012755 File Offset: 0x00010955
    public override void SetDir(int d)
    {
        this.Mold.dir = d;
        base.SetDir(d);
    }
 
    // Token: 0x06000257 RID: 599 RVA: 0x0001276A File Offset: 0x0001096A
    public override void WriteNote(UINote n)
    {
        n.Clear();
        if (!this.Mold.isChara)
        {
            this.Mold.elements.AddNote(n, null, null, ElementContainer.NoteMode.Default, false, null, null);
        }
        n.Build();
    }
 
    // Token: 0x06000258 RID: 600 RVA: 0x0001279C File Offset: 0x0001099C
    public override Recipe Duplicate()
    {
        RecipeCard recipeCard = IO.DeepCopy<RecipeCard>(this);
        recipeCard._mold = this._mold;
        return recipeCard;
    }
 
    // Token: 0x040004F5 RID: 1269
    public CardRow _sourceCard;
 
    // Token: 0x040004F6 RID: 1270
    [JsonProperty]
    public bool freePos;
 
    // Token: 0x040004F7 RID: 1271
    [JsonProperty]
    public float fx;
 
    // Token: 0x040004F8 RID: 1272
    [JsonProperty]
    public float fy;
 
    // Token: 0x040004F9 RID: 1273
    public Card _mold;
}