Zone_Dungeon.cs

using System;
using System.Linq;
using System.Runtime.CompilerServices;
using Algorithms;
using UnityEngine;
 
// Token: 0x0200072B RID: 1835
public class Zone_Dungeon : Zone
{
    // Token: 0x17000FF2 RID: 4082
    // (get) Token: 0x06003498 RID: 13464 RVA: 0x0011C837 File Offset: 0x0011AA37
    public override string IDGenerator
    {
        get
        {
            return "Dungeon";
        }
    }
 
    // Token: 0x17000FF3 RID: 4083
    // (get) Token: 0x06003499 RID: 13465 RVA: 0x0011C83E File Offset: 0x0011AA3E
    public override bool DisableRooms
    {
        get
        {
            return !base.IsPCFaction;
        }
    }
 
    // Token: 0x17000FF4 RID: 4084
    // (get) Token: 0x0600349A RID: 13466 RVA: 0x0011C849 File Offset: 0x0011AA49
    public override bool UseFog
    {
        get
        {
            return true;
        }
    }
 
    // Token: 0x17000FF5 RID: 4085
    // (get) Token: 0x0600349B RID: 13467 RVA: 0x0011C84C File Offset: 0x0011AA4C
    public override bool ShowDangerLv
    {
        get
        {
            return true;
        }
    }
 
    // Token: 0x17000FF6 RID: 4086
    // (get) Token: 0x0600349C RID: 13468 RVA: 0x0011C84F File Offset: 0x0011AA4F
    public override float PrespawnRate
    {
        get
        {
            if (!this.idExport.IsEmpty())
            {
                return 0f;
            }
            return 1f;
        }
    }
 
    // Token: 0x17000FF7 RID: 4087
    // (get) Token: 0x0600349D RID: 13469 RVA: 0x0011C869 File Offset: 0x0011AA69
    public override bool IsReturnLocation
    {
        get
        {
            return base.GetDeepestLv() == base.lv;
        }
    }
 
    // Token: 0x17000FF8 RID: 4088
    // (get) Token: 0x0600349E RID: 13470 RVA: 0x0011C879 File Offset: 0x0011AA79
    public override int StartLV
    {
        get
        {
            return -1;
        }
    }
 
    // Token: 0x17000FF9 RID: 4089
    // (get) Token: 0x0600349F RID: 13471 RVA: 0x0011C87C File Offset: 0x0011AA7C
    public override bool BlockBorderExit
    {
        get
        {
            return true;
        }
    }
 
    // Token: 0x17000FFA RID: 4090
    // (get) Token: 0x060034A0 RID: 13472 RVA: 0x0011C87F File Offset: 0x0011AA7F
    public override float EvolvedChance
    {
        get
        {
            if (!EClass.debug.test)
            {
                return 0.08f;
            }
            return 1f;
        }
    }
 
    // Token: 0x17000FFB RID: 4091
    // (get) Token: 0x060034A1 RID: 13473 RVA: 0x0011C898 File Offset: 0x0011AA98
    public override float BigDaddyChance
    {
        get
        {
            if (!EClass.debug.test)
            {
                return 0.08f;
            }
            return 1f;
        }
    }
 
    // Token: 0x17000FFC RID: 4092
    // (get) Token: 0x060034A2 RID: 13474 RVA: 0x0011C8B1 File Offset: 0x0011AAB1
    public override float ShrineChance
    {
        get
        {
            if (!EClass.debug.test)
            {
                return 0.35f;
            }
            return 1f;
        }
    }
 
    // Token: 0x17000FFD RID: 4093
    // (get) Token: 0x060034A3 RID: 13475 RVA: 0x0011C8CA File Offset: 0x0011AACA
    public override bool IsSnowCovered
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x17000FFE RID: 4094
    // (get) Token: 0x060034A4 RID: 13476 RVA: 0x0011C8CD File Offset: 0x0011AACD
    public override bool GrowPlant
    {
        get
        {
            return true;
        }
    }
 
    // Token: 0x17000FFF RID: 4095
    // (get) Token: 0x060034A5 RID: 13477 RVA: 0x0011C8D0 File Offset: 0x0011AAD0
    public override bool GrowWeed
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x17001000 RID: 4096
    // (get) Token: 0x060034A6 RID: 13478 RVA: 0x0011C8D3 File Offset: 0x0011AAD3
    public override bool CountDeepestLevel
    {
        get
        {
            return true;
        }
    }
 
    // Token: 0x17001001 RID: 4097
    // (get) Token: 0x060034A7 RID: 13479 RVA: 0x0011C8D6 File Offset: 0x0011AAD6
    public override ZoneTransition.EnterState RegionEnterState
    {
        get
        {
            return ZoneTransition.EnterState.Down;
        }
    }
 
    // Token: 0x060034A8 RID: 13480 RVA: 0x0011C8DA File Offset: 0x0011AADA
    public override string GetDungenID()
    {
        if (EClass.rnd(2) == 0)
        {
            return "DungeonRuins";
        }
        if (EClass.rnd(4) == 0)
        {
            return "Cavern";
        }
        if (EClass.rnd(8) == 0)
        {
            return "RoundRooms";
        }
        return "Dungeon";
    }
 
    // Token: 0x060034A9 RID: 13481 RVA: 0x0011C90B File Offset: 0x0011AB0B
    public override void OnGenerateMap()
    {
        if (!this.idExport.IsEmpty())
        {
            return;
        }
        base.TryGenerateOre();
        base.TryGenerateBigDaddy();
        base.TryGenerateEvolved(false);
        base.TryGenerateShrine();
    }
 
    // Token: 0x060034AA RID: 13482 RVA: 0x0011C934 File Offset: 0x0011AB34
    public void PlaceRail(Zone_Dungeon.RailType railType = Zone_Dungeon.RailType.Mine)
    {
        Zone_Dungeon.<>c__DisplayClass35_0 CS$<>8__locals1;
        CS$<>8__locals1.idRail = 31;
        CS$<>8__locals1.idTrolley = "390";
        CS$<>8__locals1.placeStopper = true;
        int num = 8;
        if (railType == Zone_Dungeon.RailType.Factoy)
        {
            CS$<>8__locals1.idRail = 110;
            CS$<>8__locals1.placeStopper = false;
            num = EClass.rnd(4) + 1;
        }
        PathManager.Instance._pathfinder.PunishChangeDirection = true;
        PathManager.Instance._pathfinder.Diagonals = false;
        TraitStairsDown traitStairsDown = EClass._map.FindThing<TraitStairsDown>();
        TraitStairsUp traitStairsUp = EClass._map.FindThing<TraitStairsUp>();
        if (traitStairsDown != null && traitStairsUp != null)
        {
            Zone_Dungeon.<PlaceRail>g__TryPlaceRail|35_0(traitStairsDown.owner.pos, traitStairsUp.owner.pos, ref CS$<>8__locals1);
        }
        int num2 = 0;
        for (int i = 0; i < 200; i++)
        {
            if (Zone_Dungeon.<PlaceRail>g__TryPlaceRail|35_0(EClass._map.bounds.GetRandomSurface(false, true, false), EClass._map.bounds.GetRandomSurface(false, true, false), ref CS$<>8__locals1))
            {
                num2++;
                if (num2 > num)
                {
                    break;
                }
            }
        }
        PathManager.Instance._pathfinder.Diagonals = true;
    }
 
    // Token: 0x060034AC RID: 13484 RVA: 0x0011CA40 File Offset: 0x0011AC40
    [CompilerGenerated]
    internal static bool <PlaceRail>g__TryPlaceRail|35_0(Point p1, Point p2, ref Zone_Dungeon.<>c__DisplayClass35_0 A_2)
    {
        if (p1.Distance(p2) < 20)
        {
            return false;
        }
        PathProgress pathProgress = PathManager.Instance.RequestPathImmediate(p1, p2, EClass.pc, PathManager.MoveType.Default, -1, 0);
        if (!pathProgress.HasPath)
        {
            return false;
        }
        Point point = new Point();
        Point point2 = new Point();
        bool flag = false;
        int num = 0;
        foreach (PathFinderNode pathFinderNode in pathProgress.nodes)
        {
            Point shared = Point.GetShared(pathFinderNode.X, pathFinderNode.Z);
            for (int i = -1; i < 2; i++)
            {
                int j = -1;
                while (j < 2)
                {
                    point2.Set(shared.x + j, shared.z + i);
                    if ((Mathf.Abs(j) != 1 || Mathf.Abs(i) != 1) && point2.IsValid && point2.sourceObj.id == 31 && !point2.Equals(point))
                    {
                        flag = true;
                        if (num == 0)
                        {
                            return false;
                        }
                        break;
                    }
                    else
                    {
                        j++;
                    }
                }
            }
            if (shared.sourceObj.id == A_2.idRail)
            {
                break;
            }
            shared.SetBlock(0, 0);
            shared.SetObj(A_2.idRail, 1, 0);
            shared.Things.ForeachReverse(delegate(Thing t)
            {
                if (!t.trait.CanBeDestroyed)
                {
                    return;
                }
                t.Destroy();
            });
            if (flag)
            {
                break;
            }
            num++;
            point.Set(shared);
        }
        if (!flag & A_2.placeStopper)
        {
            Point shared2 = Point.GetShared(pathProgress.nodes.LastItem<PathFinderNode>().X, pathProgress.nodes.LastItem<PathFinderNode>().Z);
            Cell cell = shared2.cell;
            int dir = (cell.Front.obj == 31) ? 0 : ((cell.Right.obj == 31) ? 1 : ((cell.Back.obj == 31) ? 2 : 3));
            if (!shared2.HasThing)
            {
                EClass._zone.AddCard(ThingGen.Create("1208", -1, -1), shared2).Install().dir = dir;
            }
        }
        if (num > 2)
        {
            Point shared3 = Point.GetShared(pathProgress.nodes.First<PathFinderNode>().X, pathProgress.nodes.First<PathFinderNode>().Z);
            if (!shared3.HasThing)
            {
                EClass._zone.AddCard(ThingGen.Create(A_2.idTrolley, -1, -1), shared3).Install();
            }
        }
        return true;
    }
 
    // Token: 0x02000C1A RID: 3098
    public enum RailType
    {
        // Token: 0x04003026 RID: 12326
        Mine,
        // Token: 0x04003027 RID: 12327
        Factoy
    }
}