Recipe.cs

using System;
using System.Collections.Generic;
using System.Runtime.CompilerServices;
using Newtonsoft.Json;
using UnityEngine;
using UnityEngine.UI;
 
// Token: 0x02000058 RID: 88
public class Recipe : EClass
{
    // Token: 0x060001F8 RID: 504 RVA: 0x000100E8 File Offset: 0x0000E2E8
    public static Recipe GetOrCreate(string id)
    {
        Recipe recipe = Recipe.recipeCache.TryGetValue(id, null);
        if (recipe == null)
        {
            RecipeSource recipeSource = RecipeManager.dict.TryGetValue(id, null);
            if (recipeSource != null)
            {
                recipe = Recipe.Create(recipeSource, -1, null);
                Recipe.recipeCache.Add(id, recipe);
            }
        }
        return recipe;
    }
 
    // Token: 0x060001F9 RID: 505 RVA: 0x0001012C File Offset: 0x0000E32C
    public static Recipe Create(RecipeSource _source, int idMat = -1, Thing ing = null)
    {
        string type = _source.type;
        Recipe recipe = _source.isBridgePillar ? new RecipeBridgePillar() : (type.IsEmpty() ? new RecipeCard() : ((type == "Custom") ? new RecipeCustom() : new Recipe()));
        recipe.id = _source.id;
        recipe._source = _source;
        recipe.idMat = idMat;
        if (ing != null)
        {
            recipe.BuildIngredientList(ing);
            if (ing.trait is TraitTile)
            {
                recipe.VirtualBlock = true;
            }
        }
        return recipe;
    }
 
    // Token: 0x060001FA RID: 506 RVA: 0x000101B4 File Offset: 0x0000E3B4
    public static Recipe Create(Thing t)
    {
        RecipeSource recipeSource = RecipeManager.dict.TryGetValue(t.id, null);
        if (recipeSource == null)
        {
            return null;
        }
        RecipeCard recipeCard = new RecipeCard
        {
            id = recipeSource.id,
            _source = recipeSource,
            IngAsProduct = true,
            idSkin = t.idSkin
        };
        recipeCard.BuildIngredientList(t);
        if (t.uid == 0 || recipeCard.ingredients[0].uid == 0 || recipeCard.ingredients[0].thing == null)
        {
            Debug.LogError("expection: invalid ingredient " + ((t != null) ? t.ToString() : null));
        }
        return recipeCard;
    }
 
    // Token: 0x060001FB RID: 507 RVA: 0x00010258 File Offset: 0x0000E458
    public static void DropIngredients(string id, string idMatMain, int num = 1)
    {
        RecipeManager.BuildList();
        Recipe orCreate = Recipe.GetOrCreate(EClass.sources.cards.map[id].RecipeID);
        orCreate.BuildIngredientList();
        Msg.Say("dropReward");
        foreach (Recipe.Ingredient ingredient in orCreate.ingredients)
        {
            Thing thing = ThingGen.Create(ingredient.id, -1, -1).SetNum(ingredient.req);
            if (ingredient == orCreate.ingredients[0])
            {
                thing.ChangeMaterial(idMatMain);
                thing.SetNum(num);
            }
            EClass.player.DropReward(thing, true);
        }
    }
 
    // Token: 0x17000054 RID: 84
    // (get) Token: 0x060001FC RID: 508 RVA: 0x00010320 File Offset: 0x0000E520
    public RecipeSource source
    {
        get
        {
            RecipeSource result;
            if ((result = this._source) == null)
            {
                result = (this._source = RecipeManager.Get(this.id));
            }
            return result;
        }
    }
 
    // Token: 0x17000055 RID: 85
    // (get) Token: 0x060001FD RID: 509 RVA: 0x0001034B File Offset: 0x0000E54B
    public SourceMaterial.Row DefaultMaterial
    {
        get
        {
            return this.renderRow.DefaultMaterial;
        }
    }
 
    // Token: 0x17000056 RID: 86
    // (get) Token: 0x060001FE RID: 510 RVA: 0x00010358 File Offset: 0x0000E558
    public virtual TileRow tileRow
    {
        get
        {
            return this.source.row as TileRow;
        }
    }
 
    // Token: 0x17000057 RID: 87
    // (get) Token: 0x060001FF RID: 511 RVA: 0x0001036A File Offset: 0x0000E56A
    public virtual RenderRow renderRow
    {
        get
        {
            return this.source.row;
        }
    }
 
    // Token: 0x17000058 RID: 88
    // (get) Token: 0x06000200 RID: 512 RVA: 0x00010377 File Offset: 0x0000E577
    public string Name
    {
        get
        {
            return this.GetName();
        }
    }
 
    // Token: 0x17000059 RID: 89
    // (get) Token: 0x06000201 RID: 513 RVA: 0x00010380 File Offset: 0x0000E580
    public virtual TileType tileType
    {
        get
        {
            if (!(this.source.type == "Bridge") || this.source.row.tileType is TileTypeBridge)
            {
                return this.renderRow.tileType;
            }
            return TileType.Bridge;
        }
    }
 
    // Token: 0x1700005A RID: 90
    // (get) Token: 0x06000202 RID: 514 RVA: 0x000103CC File Offset: 0x0000E5CC
    public virtual bool IsFloorOrBridge
    {
        get
        {
            return this.tileType.IsFloorOrBridge;
        }
    }
 
    // Token: 0x1700005B RID: 91
    // (get) Token: 0x06000203 RID: 515 RVA: 0x000103D9 File Offset: 0x0000E5D9
    public int MaxAltitude
    {
        get
        {
            if (this.IsThing || this.IsBridge || this.tileType.blockRenderMode == BlockRenderMode.Pillar)
            {
                return this.tileType.MaxAltitude;
            }
            return 0;
        }
    }
 
    // Token: 0x1700005C RID: 92
    // (get) Token: 0x06000204 RID: 516 RVA: 0x00010406 File Offset: 0x0000E606
    public int RecipeLv
    {
        get
        {
            return EClass.player.recipes.knownRecipes.TryGetValue(this.id, 0);
        }
    }
 
    // Token: 0x1700005D RID: 93
    // (get) Token: 0x06000205 RID: 517 RVA: 0x00010423 File Offset: 0x0000E623
    public bool IsFloor
    {
        get
        {
            return this.tileType.IsFloor;
        }
    }
 
    // Token: 0x1700005E RID: 94
    // (get) Token: 0x06000206 RID: 518 RVA: 0x00010430 File Offset: 0x0000E630
    public bool IsObj
    {
        get
        {
            return this.tileRow is SourceObj.Row;
        }
    }
 
    // Token: 0x1700005F RID: 95
    // (get) Token: 0x06000207 RID: 519 RVA: 0x00010440 File Offset: 0x0000E640
    public virtual bool IsBlock
    {
        get
        {
            return !this.IsFloorOrBridge;
        }
    }
 
    // Token: 0x17000060 RID: 96
    // (get) Token: 0x06000208 RID: 520 RVA: 0x0001044B File Offset: 0x0000E64B
    public bool IsWallOrFence
    {
        get
        {
            return this.tileType.IsWallOrFence;
        }
    }
 
    // Token: 0x17000061 RID: 97
    // (get) Token: 0x06000209 RID: 521 RVA: 0x00010458 File Offset: 0x0000E658
    public bool IsBridge
    {
        get
        {
            return this.source.type == "Bridge";
        }
    }
 
    // Token: 0x17000062 RID: 98
    // (get) Token: 0x0600020A RID: 522 RVA: 0x0001046F File Offset: 0x0000E66F
    public virtual bool IsThing
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x17000063 RID: 99
    // (get) Token: 0x0600020B RID: 523 RVA: 0x00010472 File Offset: 0x0000E672
    public virtual Card Mold
    {
        get
        {
            return null;
        }
    }
 
    // Token: 0x0600020C RID: 524 RVA: 0x00010478 File Offset: 0x0000E678
    public bool IsStaticLV()
    {
        string idFactory = this.source.idFactory;
        return idFactory == "factory_floor" || idFactory == "factory_block" || idFactory == "factory_wall" || idFactory == "factory_platform" || this.renderRow.Category.IsChildOf("block");
    }
 
    // Token: 0x0600020D RID: 525 RVA: 0x000104DC File Offset: 0x0000E6DC
    public int GetQualityBonus()
    {
        if (this.IsStaticLV())
        {
            return 0;
        }
        Element reqSkill = this.source.GetReqSkill();
        int num = reqSkill.Value - EClass.pc.Evalue(reqSkill.id);
        int num2 = 0;
        if (num <= 0)
        {
            num2 += EClass.curve(-num, 10, 20, 80) / 10 * 10 + 10;
            if (this.RecipeLv > 0)
            {
                num2 += (int)Mathf.Sqrt((float)(this.RecipeLv - 1)) * 10;
            }
            return num2;
        }
        if (num < 5)
        {
            return 0;
        }
        return -(num - 4) * 10;
    }
 
    // Token: 0x17000064 RID: 100
    // (get) Token: 0x0600020E RID: 526 RVA: 0x00010563 File Offset: 0x0000E763
    public virtual int W
    {
        get
        {
            if (this._dir % 2 != 0)
            {
                return this.renderRow.H;
            }
            return this.renderRow.W;
        }
    }
 
    // Token: 0x17000065 RID: 101
    // (get) Token: 0x0600020F RID: 527 RVA: 0x00010586 File Offset: 0x0000E786
    public virtual int H
    {
        get
        {
            if (this._dir % 2 != 0)
            {
                return this.renderRow.W;
            }
            return this.renderRow.H;
        }
    }
 
    // Token: 0x17000066 RID: 102
    // (get) Token: 0x06000210 RID: 528 RVA: 0x000105A9 File Offset: 0x0000E7A9
    public virtual bool RequireIngredients
    {
        get
        {
            return true;
        }
    }
 
    // Token: 0x06000211 RID: 529 RVA: 0x000105AC File Offset: 0x0000E7AC
    public virtual int GetRefVal()
    {
        if (this.source.row is SourceBlock.Row)
        {
            return (this.source.row as SourceBlock.Row).id;
        }
        if (this.source.row is SourceFloor.Row)
        {
            return (this.source.row as SourceFloor.Row).id;
        }
        if (this.source.row is SourceObj.Row)
        {
            return (this.source.row as SourceObj.Row).id;
        }
        return -1;
    }
 
    // Token: 0x06000212 RID: 530 RVA: 0x00010634 File Offset: 0x0000E834
    public virtual string GetIdThing()
    {
        if (this.source.row is SourceBlock.Row)
        {
            return (this.source.row as SourceBlock.Row).idThing;
        }
        if (this.source.row is SourceFloor.Row)
        {
            if (!this.IsBridge)
            {
                return "floor";
            }
            return "platform";
        }
        else
        {
            if (this.source.row is SourceObj.Row)
            {
                return "obj";
            }
            return null;
        }
    }
 
    // Token: 0x17000067 RID: 103
    // (get) Token: 0x06000213 RID: 531 RVA: 0x000106A8 File Offset: 0x0000E8A8
    public bool MultiSize
    {
        get
        {
            return this.W != 1 || this.H != 1;
        }
    }
 
    // Token: 0x06000214 RID: 532 RVA: 0x000106C1 File Offset: 0x0000E8C1
    public virtual bool ShouldShowHighlight(HitResult r)
    {
        return r != HitResult.Valid;
    }
 
    // Token: 0x06000215 RID: 533 RVA: 0x000106CA File Offset: 0x0000E8CA
    public BaseTileSelector.BoxType GetBoxType()
    {
        if (this.tileType.BoxType != BaseTileSelector.BoxType.Fence)
        {
            return BaseTileSelector.BoxType.Box;
        }
        return BaseTileSelector.BoxType.Fence;
    }
 
    // Token: 0x17000068 RID: 104
    // (get) Token: 0x06000216 RID: 534 RVA: 0x000106DD File Offset: 0x0000E8DD
    public BaseTileSelector tileSelector
    {
        get
        {
            return EClass.screen.tileSelector;
        }
    }
 
    // Token: 0x06000217 RID: 535 RVA: 0x000106EC File Offset: 0x0000E8EC
    public int GetDefaultColor()
    {
        if (this.UseStock)
        {
            Thing thing = this.ingredients[0].thing;
            return this.renderRow.GetColorInt(thing.isDyed ? thing.DyeMat : thing.material);
        }
        return this.renderRow.GetColorInt(this.DefaultMaterial);
    }
 
    // Token: 0x06000218 RID: 536 RVA: 0x00010748 File Offset: 0x0000E948
    public virtual SourceMaterial.Row GetMainMaterial()
    {
        int num = -1;
        if (this.ingredients.Count > 0)
        {
            if (this.ingredients[0].thing != null)
            {
                num = this.ingredients[0].thing.material.id;
            }
            else
            {
                num = this.ingredients[0].mat;
            }
        }
        if (num == -1)
        {
            num = 3;
        }
        return EClass.sources.materials.rows[num];
    }
 
    // Token: 0x06000219 RID: 537 RVA: 0x000107C4 File Offset: 0x0000E9C4
    public virtual SourceMaterial.Row GetColorMaterial()
    {
        if (this.idMat != -1)
        {
            return EClass.sources.materials.rows[this.idMat];
        }
        if (!this.UseStock)
        {
            int num = (this.ingredients.Count > 0) ? this.ingredients[this.source.colorIng].mat : 3;
            if (num == -1)
            {
                num = 3;
            }
            return EClass.sources.materials.rows[num];
        }
        this.ingredients[0].RefreshThing();
        Thing thing = this.ingredients[0].thing;
        if (thing == null)
        {
            return EClass.sources.materials.rows[3];
        }
        if (!thing.isDyed)
        {
            return thing.material;
        }
        return thing.DyeMat;
    }
 
    // Token: 0x17000069 RID: 105
    // (get) Token: 0x0600021A RID: 538 RVA: 0x00010898 File Offset: 0x0000EA98
    public virtual int CostMoney
    {
        get
        {
            return 0;
        }
    }
 
    // Token: 0x0600021B RID: 539 RVA: 0x0001089B File Offset: 0x0000EA9B
    public virtual void BuildIngredientList()
    {
        if (this.UseStock || !this.RequireIngredients)
        {
            return;
        }
        this.ingredients = this.source.GetIngredients();
    }
 
    // Token: 0x0600021C RID: 540 RVA: 0x000108C0 File Offset: 0x0000EAC0
    public void BuildIngredientList(Thing t)
    {
        this.UseStock = true;
        Recipe.Ingredient item = new Recipe.Ingredient
        {
            id = t.id,
            tag = null,
            req = 1,
            uid = t.uid,
            thing = t,
            mat = t.material.id
        };
        this.ingredients.Add(item);
    }
 
    // Token: 0x0600021D RID: 541 RVA: 0x00010924 File Offset: 0x0000EB24
    public virtual void OnChangeIngredient()
    {
    }
 
    // Token: 0x1700006A RID: 106
    // (get) Token: 0x0600021E RID: 542 RVA: 0x00010926 File Offset: 0x0000EB26
    public virtual bool CanRotate
    {
        get
        {
            return this.tileType.CanRotate(true) && this.tileRow._tiles.Length > 1;
        }
    }
 
    // Token: 0x0600021F RID: 543 RVA: 0x00010948 File Offset: 0x0000EB48
    public virtual Thing Craft(BlessedState blessed, bool sound = false, List<Thing> ings = null, bool model = false)
    {
        string type = this.source.type;
        Thing thing;
        if (!(type == "Block"))
        {
            if (!(type == "Obj"))
            {
                thing = ThingGen.CreateFloor(this.tileRow.id, this.GetMainMaterial().id, this.source.isBridge);
            }
            else
            {
                thing = ThingGen.CreateObj(this.tileRow.id, this.GetMainMaterial().id);
            }
        }
        else
        {
            thing = ThingGen.CreateBlock(this.tileRow.id, this.GetMainMaterial().id);
        }
        if (thing == null)
        {
            return null;
        }
        thing.trait.OnCrafted(this);
        thing.SetBlessedState(blessed);
        if (model)
        {
            return thing;
        }
        Msg.Say("crafted", thing, null, null, null);
        thing = (EClass.pc.AddCard(thing) as Thing);
        if (thing.GetRootCard() == EClass.pc)
        {
            EClass.pc.HoldCard(thing, -1);
        }
        return thing;
    }
 
    // Token: 0x06000220 RID: 544 RVA: 0x00010A3C File Offset: 0x0000EC3C
    public bool HasSameTile(Point point, int dir, int altitude, int bridgeHeight)
    {
        if (this.IsObj)
        {
            if (point.growth != null && point.sourceObj == this.tileRow && point.cell.matObj == this.GetColorMaterial())
            {
                return true;
            }
            if (dir == point.cell.objDir && point.cell.matObj == this.GetColorMaterial() && point.sourceObj == this.tileRow)
            {
                return true;
            }
        }
        else if (this.IsBridge)
        {
            if (dir == point.cell.floorDir && point.matBridge == this.GetColorMaterial() && point.sourceBridge == this.tileRow && Mathf.Clamp(bridgeHeight + altitude, 0, 255) == (int)point.cell.bridgeHeight)
            {
                return true;
            }
        }
        else if (this.IsFloorOrBridge)
        {
            if (dir == point.cell.floorDir && point.matFloor == this.GetColorMaterial() && point.sourceFloor == this.tileRow)
            {
                return true;
            }
        }
        else if (this.IsWallOrFence)
        {
            if (point.matBlock == this.GetColorMaterial() && point.sourceBlock == this.tileRow && dir == point.cell.blockDir)
            {
                return true;
            }
        }
        else if (this.IsBlock && point.matBlock == this.GetColorMaterial() && point.sourceBlock == this.tileRow)
        {
            return !point.sourceBlock.tileType.AltitudeAsDir || dir == point.cell.objDir;
        }
        return false;
    }
 
    // Token: 0x06000221 RID: 545 RVA: 0x00010BCC File Offset: 0x0000EDCC
    public virtual void Build(TaskBuild task)
    {
        this.Build(task.owner, null, task.pos, (this.ingredients.Count > 0) ? this.ingredients[0].mat : task.recipe.idMat, task.dir, task.altitude, task.bridgeHeight);
    }
 
    // Token: 0x06000222 RID: 546 RVA: 0x00010C2C File Offset: 0x0000EE2C
    public virtual 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);
        pos.cell.isModified = true;
        string type = this.source.type;
        if (!(type == "Block"))
        {
            if (type == "Floor")
            {
                if (pos.sourceObj.tileType.RemoveOnFloorChange && (!BuildMenu.Instance || !EClass.debug.ignoreBuildRule))
                {
                    EClass._map.SetObj(pos.x, pos.z, 0, 1, 0);
                }
                EClass._map.SetFloor(pos.x, pos.z, mat, this.tileRow.id, dir);
                return;
            }
            if (type == "Bridge")
            {
                if (pos.sourceObj.tileType.RemoveOnFloorChange)
                {
                    EClass._map.SetObj(pos.x, pos.z, 0, 1, 0);
                }
                EClass._map.SetBridge(pos.x, pos.z, Mathf.Clamp(bridgeHeight + altitude, 0, 255), mat, this.tileRow.id, dir);
                return;
            }
            if (!(type == "Obj"))
            {
                return;
            }
            EClass._map.SetObj(pos.x, pos.z, mat, this.tileRow.id, 1, dir);
            if (this.tileType.ChangeBlockDir)
            {
                EClass._map.SetBlockDir(pos.x, pos.z, dir);
            }
            if (pos.growth != null)
            {
                pos.growth.SetDefaultStage();
            }
            return;
        }
        else
        {
            int ramp = this.tileRow.id;
            if (ramp == 3)
            {
                ramp = EClass.sources.materials.rows[mat].ramp;
            }
            if (EClass.scene.actionMode.IsRoofEditMode(null))
            {
                EClass._map.SetRoofBlock(pos.x, pos.z, mat, ramp, dir, altitude);
                return;
            }
            if (pos.HasObj && !pos.sourceObj.tileType.CanBuiltOnBlock)
            {
                EClass._map.MineObjSound(pos);
                EClass._map.SetObj(pos.x, pos.z, 0, 1, 0);
            }
            EClass._map.SetBlock(pos.x, pos.z, mat, ramp, dir);
            if (this.tileType.IsBlockPass && pos.HasChara)
            {
                foreach (Chara t2 in pos.ListCharas())
                {
                    chara.Kick(t2, false, true);
                }
            }
            if (this.tileType.AltitudeAsDir)
            {
                pos.cell.objDir = dir;
            }
            foreach (Card card in pos.ListCards(false))
            {
                if (card.isThing && card.placeState == PlaceState.roaming)
                {
                    card._Move(card.pos.GetNearestPoint(false, true, true, false), Card.MoveType.Walk);
                }
            }
            return;
        }
    }
 
    // Token: 0x06000223 RID: 547 RVA: 0x00010F84 File Offset: 0x0000F184
    public unsafe virtual void OnRenderMarker(Point point, bool active, HitResult result, bool main, int dir, int bridgeHeight)
    {
        if (dir != -1)
        {
            this._dir = dir;
        }
        RenderParam renderParam = this.tileRow.GetRenderParam(this.DefaultMaterial, this._dir, point, bridgeHeight);
        renderParam.matColor = (float)(active ? EClass.Colors.blockColors.Active : EClass.Colors.blockColors.Inactive);
        point.ApplyAnime(renderParam);
        if (this.tileType.IsWater)
        {
            if (EClass.screen.guide.isActive)
            {
                EClass.screen.guide.passGuideFloor.Add(point, (float)result, 0.3f);
            }
            return;
        }
        if (this.tileType.IsWallOrFence && point.HasNonWallBlock)
        {
            Vector3 vector = *point.Position();
            if (EClass.screen.guide.isActive)
            {
                EClass.screen.guide.passGuideBlock.Add(ref vector, 5f, 0f);
            }
        }
        if (this.renderRow.renderData.pass == EClass.screen.tileMap.passBlock || this.renderRow.renderData.pass == EClass.screen.tileMap.passBlockEx || this.renderRow.renderData.pass == EClass.screen.tileMap.passLiquid)
        {
            if (bridgeHeight > 0 && !point.cell.skipRender && EClass.screen.guide.isActive)
            {
                EClass.screen.guide.passGuideFloor.Add(point, (float)result, 0.3f);
            }
            if (!this.tileType.IsWallOrFence && (point.HasChara || (point.HasObj && point.cell.blocked)))
            {
                Vector3 vector2 = *point.Position();
                if (EClass.screen.guide.isActive)
                {
                    EClass.screen.guide.passGuideBlock.Add(ref vector2, 5f, 0f);
                }
                return;
            }
            if (EClass.scene.actionMode.IsRoofEditMode(null))
            {
                EClass.screen.tileMap.SetRoofHeight(renderParam, point.cell, point.x, point.z, 0, bridgeHeight, this.tileType.IsWallOrFence ? this._dir : -1, true);
            }
            renderParam.y = renderParam.y - EClass.screen.tileMap.rendererBlockMarker.offset.y + this.renderRow.renderData.offset.y;
            renderParam.z += EClass.setting.render.tileMarkerZ;
            int num = (this.tileType.blockRenderMode == BlockRenderMode.Pillar) ? (this._dir + 1 + ((this._dir >= 7) ? this._dir : 0)) : 1;
            if (num == 1)
            {
                EClass.screen.tileMap.rendererBlockMarker.Draw(renderParam);
                return;
            }
            EClass.screen.tileMap.rendererBlockMarker.DrawRepeat(renderParam, num, this.tileType.RepeatSize, false);
            return;
        }
        else
        {
            if (this.renderRow.renderData.pass == EClass.screen.tileMap.passFloor || this.renderRow.renderData.pass == EClass.screen.tileMap.passFloorEx || this.renderRow.renderData.pass == EClass.screen.tileMap.passFloorWater)
            {
                if (point.HasObj)
                {
                    point.Position();
                }
                renderParam.z += ((point.cell.liquidLv > 0) ? -0.01f : EClass.setting.render.tileMarkerZFloor);
                EClass.screen.tileMap.rendererFloorMarker.Draw(renderParam);
                return;
            }
            renderParam.z += EClass.setting.render.tileMarkerZ;
            this.renderRow.renderData.Draw(renderParam);
            return;
        }
    }
 
    // Token: 0x06000224 RID: 548 RVA: 0x0001139C File Offset: 0x0000F59C
    public string GetName()
    {
        if (this.UseStock && this.ingredients[0].thing == null)
        {
            return "";
        }
        string text = this.UseStock ? this.ingredients[0].thing.Name : this.source.Name;
        if (text == "")
        {
            text = ("card_" + this.source.id).lang();
        }
        if (text == "*r")
        {
            text = this.source.row.GetText("aka", false);
        }
        if (text == "*r")
        {
            text = "(" + this.source.row.GetField("id") + ")";
        }
        return text.ToTitleCase(false);
    }
 
    // Token: 0x06000225 RID: 549 RVA: 0x0001147B File Offset: 0x0000F67B
    public virtual string GetDetail()
    {
        return this.renderRow.GetText("detail", false).IsEmpty(this.source.GetDetail());
    }
 
    // Token: 0x06000226 RID: 550 RVA: 0x0001149E File Offset: 0x0000F69E
    public virtual void WriteNote(UINote n)
    {
        n.Clear();
        n.Build();
    }
 
    // Token: 0x06000227 RID: 551 RVA: 0x000114AC File Offset: 0x0000F6AC
    public void WriteReqFactory(UINote n, bool hasFactory = true)
    {
        if (this.source.NeedFactory)
        {
            n.AddHeaderTopic("reqFactory".lang(this.source.NameFactory.TagColor(hasFactory ? FontColor.Default : FontColor.Bad, null), null, null, null, null), null);
            n.Space(8, 1);
        }
    }
 
    // Token: 0x06000228 RID: 552 RVA: 0x000114FC File Offset: 0x0000F6FC
    public void WriteReqSkill(UINote n)
    {
        n.AddHeaderTopic("reqSkill", null);
        Element reqSkill = this.source.GetReqSkill();
        int value = EClass.pc.elements.GetOrCreateElement(reqSkill).Value;
        Color textColor = EClass.Colors.Skin.GetTextColor((value >= reqSkill.Value) ? FontColor.Good : FontColor.Warning);
        n.AddText(null, string.Concat(new string[]
        {
            reqSkill.Name,
            " ",
            reqSkill.Value.ToString(),
            " (",
            value.ToString(),
            ")"
        }), textColor).text1.SetSize(-1);
        n.Space(8, 1);
    }
 
    // Token: 0x06000229 RID: 553 RVA: 0x000115B9 File Offset: 0x0000F7B9
    public virtual IRenderer GetRenderer()
    {
        return this.tileRow.renderData;
    }
 
    // Token: 0x0600022A RID: 554 RVA: 0x000115C6 File Offset: 0x0000F7C6
    public virtual void OnSelected()
    {
    }
 
    // Token: 0x0600022B RID: 555 RVA: 0x000115C8 File Offset: 0x0000F7C8
    public virtual void OnChangeAltitude(int a)
    {
    }
 
    // Token: 0x0600022C RID: 556 RVA: 0x000115CC File Offset: 0x0000F7CC
    public virtual void Rotate()
    {
        if (EInput.isShiftDown || Input.GetMouseButton(1))
        {
            this._dir--;
        }
        else
        {
            this._dir++;
        }
        if (this.tileType.AltitudeAsDir)
        {
            if (this._dir >= this.tileType.MaxAltitude)
            {
                this._dir = 0;
            }
            if (this._dir < 0)
            {
                this._dir = this.tileType.MaxAltitude - 1;
            }
        }
        else
        {
            int num = this.tileRow._tiles.Length;
            if (this.tileRow.tileType == TileType.Door)
            {
                num = 2;
            }
            if (this._dir < 0)
            {
                this._dir = num - 1;
            }
            if (this._dir >= num)
            {
                this._dir = 0;
            }
        }
        if (BuildMenu.Instance)
        {
            BuildMenu.Instance.info1.OnRotate();
        }
    }
 
    // Token: 0x0600022D RID: 557 RVA: 0x000116AA File Offset: 0x0000F8AA
    public virtual void SetDir(int d)
    {
        this._dir = d;
        if (BuildMenu.Instance)
        {
            BuildMenu.Instance.info1.OnRotate();
        }
    }
 
    // Token: 0x0600022E RID: 558 RVA: 0x000116CE File Offset: 0x0000F8CE
    public virtual Recipe Duplicate()
    {
        return IO.DeepCopy<Recipe>(this);
    }
 
    // Token: 0x0600022F RID: 559 RVA: 0x000116D8 File Offset: 0x0000F8D8
    public virtual void SetImage(Image icon)
    {
        this.renderRow.SetImage(icon, null, this.renderRow.GetColorInt((this.ingredients != null && this.ingredients.Count > 0 && this.ingredients[0].thing != null) ? this.ingredients[0].thing.material : this.DefaultMaterial), true, 0, this.idSkin);
    }
 
    // Token: 0x06000230 RID: 560 RVA: 0x0001174C File Offset: 0x0000F94C
    public bool IsCraftable()
    {
        foreach (Recipe.Ingredient ingredient in this.ingredients)
        {
            if (!ingredient.optional && EClass._map.Stocked.ListThingStack(ingredient, StockSearchMode.AroundPC).max < ingredient.req)
            {
                return false;
            }
        }
        return true;
    }
 
    // Token: 0x06000231 RID: 561 RVA: 0x000117C8 File Offset: 0x0000F9C8
    public int GetMaxCount()
    {
        int num = 999;
        for (int i = 0; i < this.ingredients.Count; i++)
        {
            Recipe.Ingredient ingredient = this.ingredients[i];
            Thing thing = ingredient.thing;
            int num2 = 0;
            if (!ingredient.optional || thing != null)
            {
                if (thing != null && !thing.isDestroyed)
                {
                    num2 = thing.Num / ingredient.req;
                }
                if (num2 < num)
                {
                    num = num2;
                }
            }
        }
        return num;
    }
 
    // Token: 0x06000232 RID: 562 RVA: 0x00011838 File Offset: 0x0000FA38
    public void SetTextDifficulty(UIText text)
    {
        Element reqSkill = this.source.GetReqSkill();
        int value = EClass.pc.elements.GetOrCreateElement(reqSkill).Value;
        string text2 = reqSkill.Name + " " + reqSkill.Value.ToString();
        text.SetText(text2);
    }
 
    // Token: 0x06000233 RID: 563 RVA: 0x00011890 File Offset: 0x0000FA90
    public int GetSortVal()
    {
        Element reqSkill = this.source.GetReqSkill();
        return reqSkill.source.id * 10000 - reqSkill.Value;
    }
 
    // Token: 0x040004E9 RID: 1257
    public static Dictionary<string, Recipe> recipeCache = new Dictionary<string, Recipe>();
 
    // Token: 0x040004EA RID: 1258
    [JsonProperty]
    public string id;
 
    // Token: 0x040004EB RID: 1259
    [JsonProperty]
    public List<Recipe.Ingredient> ingredients = new List<Recipe.Ingredient>();
 
    // Token: 0x040004EC RID: 1260
    [JsonProperty]
    public bool UseStock;
 
    // Token: 0x040004ED RID: 1261
    [JsonProperty]
    public bool IngAsProduct;
 
    // Token: 0x040004EE RID: 1262
    [JsonProperty]
    public bool VirtualBlock;
 
    // Token: 0x040004EF RID: 1263
    public int _dir;
 
    // Token: 0x040004F0 RID: 1264
    public int sync;
 
    // Token: 0x040004F1 RID: 1265
    public int idMat = -1;
 
    // Token: 0x040004F2 RID: 1266
    public int idSkin;
 
    // Token: 0x040004F3 RID: 1267
    public Recipe.State state;
 
    // Token: 0x040004F4 RID: 1268
    public RecipeSource _source;
 
    // Token: 0x020007CD RID: 1997
    public enum State
    {
        // Token: 0x040021DB RID: 8667
        Valid,
        // Token: 0x040021DC RID: 8668
        Invalid
    }
 
    // Token: 0x020007CE RID: 1998
    public class Ingredient : EClass
    {
        // Token: 0x17001119 RID: 4377
        // (get) Token: 0x060037CF RID: 14287 RVA: 0x0012B73D File Offset: 0x0012993D
        public bool IsThingSpecified
        {
            get
            {
                return this.uid != 0;
            }
        }
 
        // Token: 0x1700111A RID: 4378
        // (get) Token: 0x060037D0 RID: 14288 RVA: 0x0012B748 File Offset: 0x00129948
        public string IdThing
        {
            get
            {
                if (!this.useCat)
                {
                    return this.id;
                }
                return EClass.sources.categories.map[this.id].GetIdThing();
            }
        }
 
        // Token: 0x060037D1 RID: 14289 RVA: 0x0012B778 File Offset: 0x00129978
        public Thing RefreshThing()
        {
            if (this.thing == null)
            {
                this.thing = EClass.pc.things.Find(this.uid);
                if (this.thing == null)
                {
                    this.thing = EClass._map.Stocked.Find(this.uid);
                    if (this.thing == null)
                    {
                        this.thing = EClass.pc.things.Find(this.id, this.mat, this.refVal);
                        if (this.thing == null)
                        {
                            this.thing = EClass._map.Stocked.Find(this.id, this.mat, this.refVal, false);
                        }
                    }
                }
            }
            return this.thing;
        }
 
        // Token: 0x060037D2 RID: 14290 RVA: 0x0012B833 File Offset: 0x00129A33
        public bool CanSetThing(Thing t)
        {
            return !(t.id != this.id) && t.Num >= this.req;
        }
 
        // Token: 0x060037D3 RID: 14291 RVA: 0x0012B859 File Offset: 0x00129A59
        public void SetThing(Thing t = null)
        {
            this.uid = ((t != null) ? t.uid : 0);
            this.thing = t;
            this.mat = ((t != null) ? t.material.id : -1);
        }
 
        // Token: 0x060037D4 RID: 14292 RVA: 0x0012B88C File Offset: 0x00129A8C
        public string GetName()
        {
            if (this.useCat)
            {
                string text = Recipe.Ingredient.<GetName>g__CatName|18_0(this.id);
                if (this.idOther.Count > 0)
                {
                    foreach (string text2 in this.idOther)
                    {
                        text = text + ", " + Recipe.Ingredient.<GetName>g__CatName|18_0(text2);
                    }
                }
                return "ingCat".lang(text, null, null, null, null);
            }
            string str = EClass.sources.cards.map[this.id].GetName().IsEmpty(("card_" + this.id).lang());
            string text3 = this.tag.IsEmpty() ? "" : ("(" + ("tag_" + this.tag).lang() + ")");
            if (this.idOther.Count > 0)
            {
                foreach (string key in this.idOther)
                {
                    text3 = text3 + ", " + EClass.sources.cards.map[key].GetName();
                }
            }
            return str + text3;
        }
 
        // Token: 0x060037D6 RID: 14294 RVA: 0x0012BA2D File Offset: 0x00129C2D
        [CompilerGenerated]
        internal static string <GetName>g__CatName|18_0(string id)
        {
            return EClass.sources.categories.map[id].GetName();
        }
 
        // Token: 0x040021DD RID: 8669
        [JsonProperty]
        public int uid;
 
        // Token: 0x040021DE RID: 8670
        [JsonProperty]
        public int req;
 
        // Token: 0x040021DF RID: 8671
        [JsonProperty]
        public int mat = -1;
 
        // Token: 0x040021E0 RID: 8672
        [JsonProperty]
        public int refVal = -1;
 
        // Token: 0x040021E1 RID: 8673
        [JsonProperty]
        public string id;
 
        // Token: 0x040021E2 RID: 8674
        [JsonProperty]
        public string tag;
 
        // Token: 0x040021E3 RID: 8675
        [JsonProperty]
        public List<string> idOther = new List<string>();
 
        // Token: 0x040021E4 RID: 8676
        public Thing thing;
 
        // Token: 0x040021E5 RID: 8677
        public bool optional;
 
        // Token: 0x040021E6 RID: 8678
        public bool dye;
 
        // Token: 0x040021E7 RID: 8679
        public bool useCat;
    }
}