TileType.cs

using System;
using System.Collections.Generic;
using System.Reflection;
using UnityEngine;
 
// Token: 0x020006B1 RID: 1713
public class TileType : EClass
{
    // Token: 0x06003195 RID: 12693 RVA: 0x00116414 File Offset: 0x00114614
    public static void Init()
    {
        TileType.dict.Clear();
        foreach (FieldInfo fieldInfo in typeof(TileType).GetFields(BindingFlags.Static | BindingFlags.Public))
        {
            if (typeof(TileType).IsAssignableFrom(fieldInfo.FieldType))
            {
                TileType.dict[fieldInfo.Name] = (TileType)fieldInfo.GetValue(null);
            }
        }
    }
 
    // Token: 0x17000E37 RID: 3639
    // (get) Token: 0x06003196 RID: 12694 RVA: 0x00116482 File Offset: 0x00114682
    public virtual string LangPlaceType
    {
        get
        {
            return "place_Obj";
        }
    }
 
    // Token: 0x17000E38 RID: 3640
    // (get) Token: 0x06003197 RID: 12695 RVA: 0x00116489 File Offset: 0x00114689
    public virtual bool CanStack
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x06003198 RID: 12696 RVA: 0x0011648C File Offset: 0x0011468C
    public virtual bool CanRotate(bool buildMode)
    {
        return true;
    }
 
    // Token: 0x17000E39 RID: 3641
    // (get) Token: 0x06003199 RID: 12697 RVA: 0x0011648F File Offset: 0x0011468F
    public virtual bool ChangeBlockDir
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x17000E3A RID: 3642
    // (get) Token: 0x0600319A RID: 12698 RVA: 0x00116492 File Offset: 0x00114692
    public virtual bool IsSkipLowBlock
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x17000E3B RID: 3643
    // (get) Token: 0x0600319B RID: 12699 RVA: 0x00116495 File Offset: 0x00114695
    public virtual bool IsSkipFloor
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x17000E3C RID: 3644
    // (get) Token: 0x0600319C RID: 12700 RVA: 0x00116498 File Offset: 0x00114698
    public virtual bool IsUseBlockDir
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x17000E3D RID: 3645
    // (get) Token: 0x0600319D RID: 12701 RVA: 0x0011649B File Offset: 0x0011469B
    public virtual bool IsFloorOrBridge
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x17000E3E RID: 3646
    // (get) Token: 0x0600319E RID: 12702 RVA: 0x0011649E File Offset: 0x0011469E
    public virtual bool IsWall
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x17000E3F RID: 3647
    // (get) Token: 0x0600319F RID: 12703 RVA: 0x001164A1 File Offset: 0x001146A1
    public virtual bool IsFloor
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x17000E40 RID: 3648
    // (get) Token: 0x060031A0 RID: 12704 RVA: 0x001164A4 File Offset: 0x001146A4
    public virtual bool IsBridge
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x17000E41 RID: 3649
    // (get) Token: 0x060031A1 RID: 12705 RVA: 0x001164A7 File Offset: 0x001146A7
    public virtual bool IsWallOrFence
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x17000E42 RID: 3650
    // (get) Token: 0x060031A2 RID: 12706 RVA: 0x001164AA File Offset: 0x001146AA
    public virtual bool IsWallOrFullBlock
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x17000E43 RID: 3651
    // (get) Token: 0x060031A3 RID: 12707 RVA: 0x001164AD File Offset: 0x001146AD
    public bool IsRamp
    {
        get
        {
            return this.Ramp > TileType.RampType.None;
        }
    }
 
    // Token: 0x17000E44 RID: 3652
    // (get) Token: 0x060031A4 RID: 12708 RVA: 0x001164B8 File Offset: 0x001146B8
    public virtual TileType.RampType Ramp
    {
        get
        {
            return TileType.RampType.None;
        }
    }
 
    // Token: 0x17000E45 RID: 3653
    // (get) Token: 0x060031A5 RID: 12709 RVA: 0x001164BB File Offset: 0x001146BB
    public virtual bool IsLadder
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x17000E46 RID: 3654
    // (get) Token: 0x060031A6 RID: 12710 RVA: 0x001164BE File Offset: 0x001146BE
    public virtual bool IsBlockPass
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x17000E47 RID: 3655
    // (get) Token: 0x060031A7 RID: 12711 RVA: 0x001164C1 File Offset: 0x001146C1
    public virtual bool IsOccupyCell
    {
        get
        {
            return true;
        }
    }
 
    // Token: 0x17000E48 RID: 3656
    // (get) Token: 0x060031A8 RID: 12712 RVA: 0x001164C4 File Offset: 0x001146C4
    public virtual bool IsBlockSight
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x17000E49 RID: 3657
    // (get) Token: 0x060031A9 RID: 12713 RVA: 0x001164C7 File Offset: 0x001146C7
    public virtual bool IsOpenSight
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x17000E4A RID: 3658
    // (get) Token: 0x060031AA RID: 12714 RVA: 0x001164CA File Offset: 0x001146CA
    public virtual bool IsBlockLiquid
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x17000E4B RID: 3659
    // (get) Token: 0x060031AB RID: 12715 RVA: 0x001164CD File Offset: 0x001146CD
    public virtual bool IsWater
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x17000E4C RID: 3660
    // (get) Token: 0x060031AC RID: 12716 RVA: 0x001164D0 File Offset: 0x001146D0
    public virtual bool IsDeepWater
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x17000E4D RID: 3661
    // (get) Token: 0x060031AD RID: 12717 RVA: 0x001164D3 File Offset: 0x001146D3
    public virtual bool IsBlockMount
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x17000E4E RID: 3662
    // (get) Token: 0x060031AE RID: 12718 RVA: 0x001164D6 File Offset: 0x001146D6
    public virtual bool IsFullBlock
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x17000E4F RID: 3663
    // (get) Token: 0x060031AF RID: 12719 RVA: 0x001164D9 File Offset: 0x001146D9
    public virtual bool IsFence
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x17000E50 RID: 3664
    // (get) Token: 0x060031B0 RID: 12720 RVA: 0x001164DC File Offset: 0x001146DC
    public virtual bool IsFloodBlock
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x17000E51 RID: 3665
    // (get) Token: 0x060031B1 RID: 12721 RVA: 0x001164DF File Offset: 0x001146DF
    public virtual bool IsPlayFootSound
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x17000E52 RID: 3666
    // (get) Token: 0x060031B2 RID: 12722 RVA: 0x001164E2 File Offset: 0x001146E2
    public virtual bool CanSpawnOnWater
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x17000E53 RID: 3667
    // (get) Token: 0x060031B3 RID: 12723 RVA: 0x001164E5 File Offset: 0x001146E5
    public virtual bool IsWaterTop
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x17000E54 RID: 3668
    // (get) Token: 0x060031B4 RID: 12724 RVA: 0x001164E8 File Offset: 0x001146E8
    public virtual bool CastShadowSelf
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x17000E55 RID: 3669
    // (get) Token: 0x060031B5 RID: 12725 RVA: 0x001164EB File Offset: 0x001146EB
    public virtual bool CastShadowBack
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x17000E56 RID: 3670
    // (get) Token: 0x060031B6 RID: 12726 RVA: 0x001164EE File Offset: 0x001146EE
    public virtual bool CastAmbientShadow
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x17000E57 RID: 3671
    // (get) Token: 0x060031B7 RID: 12727 RVA: 0x001164F1 File Offset: 0x001146F1
    public virtual bool CastAmbientShadowBack
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x17000E58 RID: 3672
    // (get) Token: 0x060031B8 RID: 12728 RVA: 0x001164F4 File Offset: 0x001146F4
    public virtual bool CanBuiltOnArea
    {
        get
        {
            return true;
        }
    }
 
    // Token: 0x17000E59 RID: 3673
    // (get) Token: 0x060031B9 RID: 12729 RVA: 0x001164F7 File Offset: 0x001146F7
    public virtual bool CanBuiltOnWater
    {
        get
        {
            return true;
        }
    }
 
    // Token: 0x17000E5A RID: 3674
    // (get) Token: 0x060031BA RID: 12730 RVA: 0x001164FA File Offset: 0x001146FA
    public virtual bool CanBuiltOnThing
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x17000E5B RID: 3675
    // (get) Token: 0x060031BB RID: 12731 RVA: 0x001164FD File Offset: 0x001146FD
    public virtual bool CanBuiltOnBlock
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x17000E5C RID: 3676
    // (get) Token: 0x060031BC RID: 12732 RVA: 0x00116500 File Offset: 0x00114700
    public virtual bool IsDoor
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x17000E5D RID: 3677
    // (get) Token: 0x060031BD RID: 12733 RVA: 0x00116503 File Offset: 0x00114703
    public virtual bool CanBuiltOnFloor
    {
        get
        {
            return true;
        }
    }
 
    // Token: 0x17000E5E RID: 3678
    // (get) Token: 0x060031BE RID: 12734 RVA: 0x00116506 File Offset: 0x00114706
    public virtual bool CanBuiltOnBridge
    {
        get
        {
            return true;
        }
    }
 
    // Token: 0x17000E5F RID: 3679
    // (get) Token: 0x060031BF RID: 12735 RVA: 0x00116509 File Offset: 0x00114709
    public virtual bool CanInstaComplete
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x17000E60 RID: 3680
    // (get) Token: 0x060031C0 RID: 12736 RVA: 0x0011650C File Offset: 0x0011470C
    public virtual int MinAltitude
    {
        get
        {
            return 1;
        }
    }
 
    // Token: 0x17000E61 RID: 3681
    // (get) Token: 0x060031C1 RID: 12737 RVA: 0x0011650F File Offset: 0x0011470F
    public virtual int MaxAltitude
    {
        get
        {
            return 10;
        }
    }
 
    // Token: 0x17000E62 RID: 3682
    // (get) Token: 0x060031C2 RID: 12738 RVA: 0x00116513 File Offset: 0x00114713
    public virtual bool AltitudeAsDir
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x17000E63 RID: 3683
    // (get) Token: 0x060031C3 RID: 12739 RVA: 0x00116516 File Offset: 0x00114716
    public virtual bool UseLowWallTiles
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x17000E64 RID: 3684
    // (get) Token: 0x060031C4 RID: 12740 RVA: 0x00116519 File Offset: 0x00114719
    public virtual bool UseMountHeight
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x17000E65 RID: 3685
    // (get) Token: 0x060031C5 RID: 12741 RVA: 0x0011651C File Offset: 0x0011471C
    public virtual bool UseHangZFix
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x17000E66 RID: 3686
    // (get) Token: 0x060031C6 RID: 12742 RVA: 0x0011651F File Offset: 0x0011471F
    public virtual bool UseLowBlock
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x17000E67 RID: 3687
    // (get) Token: 0x060031C7 RID: 12743 RVA: 0x00116522 File Offset: 0x00114722
    public virtual bool RemoveOnFloorChange
    {
        get
        {
            return true;
        }
    }
 
    // Token: 0x17000E68 RID: 3688
    // (get) Token: 0x060031C8 RID: 12744 RVA: 0x00116525 File Offset: 0x00114725
    public virtual bool AllowObj
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x17000E69 RID: 3689
    // (get) Token: 0x060031C9 RID: 12745 RVA: 0x00116528 File Offset: 0x00114728
    public virtual bool AllowMultiInstall
    {
        get
        {
            return true;
        }
    }
 
    // Token: 0x17000E6A RID: 3690
    // (get) Token: 0x060031CA RID: 12746 RVA: 0x0011652B File Offset: 0x0011472B
    public virtual bool FreeStyle
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x17000E6B RID: 3691
    // (get) Token: 0x060031CB RID: 12747 RVA: 0x0011652E File Offset: 0x0011472E
    public virtual byte slopeHeight
    {
        get
        {
            return 0;
        }
    }
 
    // Token: 0x17000E6C RID: 3692
    // (get) Token: 0x060031CC RID: 12748 RVA: 0x00116531 File Offset: 0x00114731
    public virtual float MountHeight
    {
        get
        {
            return 0f;
        }
    }
 
    // Token: 0x17000E6D RID: 3693
    // (get) Token: 0x060031CD RID: 12749 RVA: 0x00116538 File Offset: 0x00114738
    public virtual float FloorHeight
    {
        get
        {
            return 0f;
        }
    }
 
    // Token: 0x17000E6E RID: 3694
    // (get) Token: 0x060031CE RID: 12750 RVA: 0x0011653F File Offset: 0x0011473F
    public virtual float RepeatSize
    {
        get
        {
            return 1f;
        }
    }
 
    // Token: 0x17000E6F RID: 3695
    // (get) Token: 0x060031CF RID: 12751 RVA: 0x00116546 File Offset: 0x00114746
    public virtual int FloorAltitude
    {
        get
        {
            return 0;
        }
    }
 
    // Token: 0x17000E70 RID: 3696
    // (get) Token: 0x060031D0 RID: 12752 RVA: 0x00116549 File Offset: 0x00114749
    public virtual int LiquidLV
    {
        get
        {
            return 0;
        }
    }
 
    // Token: 0x17000E71 RID: 3697
    // (get) Token: 0x060031D1 RID: 12753 RVA: 0x0011654C File Offset: 0x0011474C
    public virtual bool AllowLitter
    {
        get
        {
            return true;
        }
    }
 
    // Token: 0x17000E72 RID: 3698
    // (get) Token: 0x060031D2 RID: 12754 RVA: 0x0011654F File Offset: 0x0011474F
    public virtual bool AllowBlood
    {
        get
        {
            return true;
        }
    }
 
    // Token: 0x17000E73 RID: 3699
    // (get) Token: 0x060031D3 RID: 12755 RVA: 0x00116552 File Offset: 0x00114752
    public virtual bool ShowPillar
    {
        get
        {
            return true;
        }
    }
 
    // Token: 0x17000E74 RID: 3700
    // (get) Token: 0x060031D4 RID: 12756 RVA: 0x00116555 File Offset: 0x00114755
    public virtual bool AlwaysShowShadow
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x17000E75 RID: 3701
    // (get) Token: 0x060031D5 RID: 12757 RVA: 0x00116558 File Offset: 0x00114758
    public virtual bool RepeatBlock
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x17000E76 RID: 3702
    // (get) Token: 0x060031D6 RID: 12758 RVA: 0x0011655B File Offset: 0x0011475B
    public virtual bool ForceRpeatBlock
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x17000E77 RID: 3703
    // (get) Token: 0x060031D7 RID: 12759 RVA: 0x0011655E File Offset: 0x0011475E
    public virtual bool CanBeHeld
    {
        get
        {
            return true;
        }
    }
 
    // Token: 0x17000E78 RID: 3704
    // (get) Token: 0x060031D8 RID: 12760 RVA: 0x00116561 File Offset: 0x00114761
    public virtual bool EditorTile
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x17000E79 RID: 3705
    // (get) Token: 0x060031D9 RID: 12761 RVA: 0x00116564 File Offset: 0x00114764
    public virtual bool IsFloodDoor
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x17000E7A RID: 3706
    // (get) Token: 0x060031DA RID: 12762 RVA: 0x00116567 File Offset: 0x00114767
    public virtual bool Invisible
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x17000E7B RID: 3707
    // (get) Token: 0x060031DB RID: 12763 RVA: 0x0011656A File Offset: 0x0011476A
    public virtual bool IgnoreBuildRule
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x17000E7C RID: 3708
    // (get) Token: 0x060031DC RID: 12764 RVA: 0x0011656D File Offset: 0x0011476D
    public virtual bool RenderWaterBlock
    {
        get
        {
            return true;
        }
    }
 
    // Token: 0x17000E7D RID: 3709
    // (get) Token: 0x060031DD RID: 12765 RVA: 0x00116570 File Offset: 0x00114770
    public virtual BaseTileSelector.SelectType SelectType
    {
        get
        {
            return BaseTileSelector.SelectType.Single;
        }
    }
 
    // Token: 0x17000E7E RID: 3710
    // (get) Token: 0x060031DE RID: 12766 RVA: 0x00116573 File Offset: 0x00114773
    public virtual BaseTileSelector.BoxType BoxType
    {
        get
        {
            return BaseTileSelector.BoxType.Box;
        }
    }
 
    // Token: 0x17000E7F RID: 3711
    // (get) Token: 0x060031DF RID: 12767 RVA: 0x00116576 File Offset: 0x00114776
    public virtual BaseTileSelector.HitType HitType
    {
        get
        {
            return BaseTileSelector.HitType.Block;
        }
    }
 
    // Token: 0x17000E80 RID: 3712
    // (get) Token: 0x060031E0 RID: 12768 RVA: 0x00116579 File Offset: 0x00114779
    public virtual BlockRenderMode blockRenderMode
    {
        get
        {
            return BlockRenderMode.Default;
        }
    }
 
    // Token: 0x17000E81 RID: 3713
    // (get) Token: 0x060031E1 RID: 12769 RVA: 0x0011657C File Offset: 0x0011477C
    public bool IsMountBlock
    {
        get
        {
            return this.MountHeight > 0f;
        }
    }
 
    // Token: 0x060031E2 RID: 12770 RVA: 0x0011658C File Offset: 0x0011478C
    public HitResult _HitTest(Point pos, Card target, bool canIgnore = true)
    {
        if ((EClass.debug.ignoreBuildRule || this.IgnoreBuildRule) && canIgnore)
        {
            return HitResult.Valid;
        }
        if (!this.CanBuiltOnArea && pos.HasArea)
        {
            return HitResult.Invalid;
        }
        if (pos.cell.IsTopWater)
        {
            if (!this.CanBuiltOnWater)
            {
                return HitResult.Invalid;
            }
        }
        else if (!this.CanBuiltOnFloor)
        {
            return HitResult.Invalid;
        }
        if (!this.CanBuiltOnBridge && pos.cell._bridge != 0)
        {
            return HitResult.Invalid;
        }
        if (target != null)
        {
            if (target.sourceCard.multisize && (pos.Installed != null || pos.cell.blocked || (pos.HasChara && pos.FirstChara.IsHostile(EClass.pc))))
            {
                return HitResult.Invalid;
            }
            if (pos.Installed != null && pos.Installed != target)
            {
                TileType tileType = pos.Installed.TileType;
                TileType tileType2 = target.TileType;
                if (!tileType.AllowMultiInstall || !tileType2.AllowMultiInstall)
                {
                    return HitResult.Invalid;
                }
            }
            if (!target.trait.CanBuiltAt(pos))
            {
                return HitResult.Invalid;
            }
        }
        else if (pos.Installed != null && !this.CanBuiltOnThing && !pos.cell.hasDoor)
        {
            return HitResult.Invalid;
        }
        if (pos.HasBlock)
        {
            if (!this.CanBuiltOnBlock && pos.sourceBlock.tileType.IsOccupyCell)
            {
                return HitResult.Invalid;
            }
            if (this.IsDoor && pos.HasWallOrFence && pos.cell.blockDir == 2)
            {
                return HitResult.Invalid;
            }
        }
        else if (this.IsDoor)
        {
            return HitResult.Invalid;
        }
        return this.HitTest(pos);
    }
 
    // Token: 0x060031E3 RID: 12771 RVA: 0x001166FA File Offset: 0x001148FA
    protected virtual HitResult HitTest(Point pos)
    {
        if (pos.HasObj)
        {
            return HitResult.Warning;
        }
        return HitResult.Valid;
    }
 
    // Token: 0x060031E4 RID: 12772 RVA: 0x00116707 File Offset: 0x00114907
    public virtual int GetDesiredDir(Point p, int d)
    {
        return -1;
    }
 
    // Token: 0x060031E5 RID: 12773 RVA: 0x0011670A File Offset: 0x0011490A
    public virtual void GetMountHeight(ref Vector3 v, Point p, int d, Card target = null)
    {
        v += EClass.screen.tileMap.altitudeFix * (float)target.altitude;
    }
 
    // Token: 0x060031E6 RID: 12774 RVA: 0x0011673C File Offset: 0x0011493C
    public Vector3 GetRampFix(int dir)
    {
        int num = this.Ramp * TileType.RampType.Half - TileType.RampType.Half + ((dir <= 1) ? 0 : 1);
        Vector3 vector = EClass.setting.render.rampFix[num];
        return new Vector3(vector.x * (float)((dir % 2 == 0) ? 1 : -1), vector.y, vector.z);
    }
 
    // Token: 0x04001BC3 RID: 7107
    public static TileTypeNone None = new TileTypeNone();
 
    // Token: 0x04001BC4 RID: 7108
    public static TileTypeInvisibleBlock InvisiBlock = new TileTypeInvisibleBlock();
 
    // Token: 0x04001BC5 RID: 7109
    public static TileTypeBlock Block = new TileTypeBlock();
 
    // Token: 0x04001BC6 RID: 7110
    public static TileTypeBlockShip BlockShip = new TileTypeBlockShip();
 
    // Token: 0x04001BC7 RID: 7111
    public static TileTypeSlope Slope = new TileTypeSlope();
 
    // Token: 0x04001BC8 RID: 7112
    public static TileTypeHalfBlock HalfBlock = new TileTypeHalfBlock();
 
    // Token: 0x04001BC9 RID: 7113
    public static TileTypeStairs Stairs = new TileTypeStairs();
 
    // Token: 0x04001BCA RID: 7114
    public static TileTypeStairs StairsHalf = new TileTypeStairsHalf();
 
    // Token: 0x04001BCB RID: 7115
    public static TileTypeRooftop Rooftop = new TileTypeRooftop();
 
    // Token: 0x04001BCC RID: 7116
    public static TileTypeScaffold Scaffold = new TileTypeScaffold();
 
    // Token: 0x04001BCD RID: 7117
    public static TileTypeLadder Ladder = new TileTypeLadder();
 
    // Token: 0x04001BCE RID: 7118
    public static TileTypePillar Pillar = new TileTypePillar();
 
    // Token: 0x04001BCF RID: 7119
    public static TileTypeWaterfall Waterfall = new TileTypeWaterfall();
 
    // Token: 0x04001BD0 RID: 7120
    public static TileTypeWall Wall = new TileTypeWall();
 
    // Token: 0x04001BD1 RID: 7121
    public static TileTypeWallOpen WallOpen = new TileTypeWallOpen();
 
    // Token: 0x04001BD2 RID: 7122
    public static TileTypeFence Fence = new TileTypeFence();
 
    // Token: 0x04001BD3 RID: 7123
    public static TileTypeFenceClosed FenceClosed = new TileTypeFenceClosed();
 
    // Token: 0x04001BD4 RID: 7124
    public static TileTypeFloor Floor = new TileTypeFloor();
 
    // Token: 0x04001BD5 RID: 7125
    public static TileTypeFloorScaffold FloorScaffold = new TileTypeFloorScaffold();
 
    // Token: 0x04001BD6 RID: 7126
    public static TileTypeWater FloorWater = new TileTypeWater();
 
    // Token: 0x04001BD7 RID: 7127
    public static TileTypeWaterShallow FloorWaterShallow = new TileTypeWaterShallow();
 
    // Token: 0x04001BD8 RID: 7128
    public static TileTypeWaterDeep FloorWaterDeep = new TileTypeWaterDeep();
 
    // Token: 0x04001BD9 RID: 7129
    public static TileTypeBridge Bridge = new TileTypeBridge();
 
    // Token: 0x04001BDA RID: 7130
    public static TileTypeBridgeDeco BridgeDeco = new TileTypeBridgeDeco();
 
    // Token: 0x04001BDB RID: 7131
    public static TileTypeBridgePillar BridgePillar = new TileTypeBridgePillar();
 
    // Token: 0x04001BDC RID: 7132
    public static TileTypeSky Sky = new TileTypeSky();
 
    // Token: 0x04001BDD RID: 7133
    public static TileTypeObj Obj = new TileTypeObj();
 
    // Token: 0x04001BDE RID: 7134
    public static TileTypeObjBig ObjBig = new TileTypeObjBig();
 
    // Token: 0x04001BDF RID: 7135
    public static TileTypeObjHuge ObjHuge = new TileTypeObjHuge();
 
    // Token: 0x04001BE0 RID: 7136
    public static TileTypeObjCeil ObjCeil = new TileTypeObjCeil();
 
    // Token: 0x04001BE1 RID: 7137
    public static TileTypeObjFloat ObjFloat = new TileTypeObjFloat();
 
    // Token: 0x04001BE2 RID: 7138
    public static TileTypeObjWater ObjWater = new TileTypeObjWater();
 
    // Token: 0x04001BE3 RID: 7139
    public static TileTypeObjWaterTop ObjWaterTop = new TileTypeObjWaterTop();
 
    // Token: 0x04001BE4 RID: 7140
    public static TileTypeIllumination Illumination = new TileTypeIllumination();
 
    // Token: 0x04001BE5 RID: 7141
    public static TileTypeTree Tree = new TileTypeTree();
 
    // Token: 0x04001BE6 RID: 7142
    public static TileTypeDoor Door = new TileTypeDoor();
 
    // Token: 0x04001BE7 RID: 7143
    public static TileTypeWallHang WallHang = new TileTypeWallHang();
 
    // Token: 0x04001BE8 RID: 7144
    public static TileTypeWallHangSign WallHangSign = new TileTypeWallHangSign();
 
    // Token: 0x04001BE9 RID: 7145
    public static TileTypeVine Vine = new TileTypeVine();
 
    // Token: 0x04001BEA RID: 7146
    public static TileTypeWallMount WallMount = new TileTypeWallMount();
 
    // Token: 0x04001BEB RID: 7147
    public static TileTypePaint Paint = new TileTypePaint();
 
    // Token: 0x04001BEC RID: 7148
    public static TileTypeWindow Window = new TileTypeWindow();
 
    // Token: 0x04001BED RID: 7149
    public static TileTypeRoof Roof = new TileTypeRoof();
 
    // Token: 0x04001BEE RID: 7150
    public static TileTypeRoad Road = new TileTypeRoad();
 
    // Token: 0x04001BEF RID: 7151
    public static TileTypeChasm Chasm = new TileTypeChasm();
 
    // Token: 0x04001BF0 RID: 7152
    public static TileTypeBoat Boat = new TileTypeBoat();
 
    // Token: 0x04001BF1 RID: 7153
    public static TileTypeLiquid Liquid = new TileTypeLiquid();
 
    // Token: 0x04001BF2 RID: 7154
    public static TileTypeMarker Marker = new TileTypeMarker();
 
    // Token: 0x04001BF3 RID: 7155
    public static Dictionary<string, TileType> dict = new Dictionary<string, TileType>();
 
    // Token: 0x02000C0A RID: 3082
    public enum RampType
    {
        // Token: 0x04002FE8 RID: 12264
        None,
        // Token: 0x04002FE9 RID: 12265
        Full,
        // Token: 0x04002FEA RID: 12266
        Half
    }
}