Point.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.CompilerServices;
using Newtonsoft.Json;
using UnityEngine;
 
// Token: 0x02000694 RID: 1684
[Serializable]
public class Point : EClass
{
    // Token: 0x06003067 RID: 12391 RVA: 0x0010F24D File Offset: 0x0010D44D
    public static Point GetShared(int x, int z)
    {
        Point.shared.x = x;
        Point.shared.z = z;
        return Point.shared;
    }
 
    // Token: 0x17000DE9 RID: 3561
    // (get) Token: 0x06003068 RID: 12392 RVA: 0x0010F26A File Offset: 0x0010D46A
    public int index
    {
        get
        {
            return this.x + this.z * Point.map.Size;
        }
    }
 
    // Token: 0x17000DEA RID: 3562
    // (get) Token: 0x06003069 RID: 12393 RVA: 0x0010F284 File Offset: 0x0010D484
    public Cell cell
    {
        get
        {
            return Point.map.cells[this.x, this.z];
        }
    }
 
    // Token: 0x17000DEB RID: 3563
    // (get) Token: 0x0600306A RID: 12394 RVA: 0x0010F2A1 File Offset: 0x0010D4A1
    public SourceMaterial.Row matRoofBlock
    {
        get
        {
            return this.cell.matRoofBlock;
        }
    }
 
    // Token: 0x17000DEC RID: 3564
    // (get) Token: 0x0600306B RID: 12395 RVA: 0x0010F2AE File Offset: 0x0010D4AE
    public SourceMaterial.Row matBlock
    {
        get
        {
            return this.cell.matBlock;
        }
    }
 
    // Token: 0x17000DED RID: 3565
    // (get) Token: 0x0600306C RID: 12396 RVA: 0x0010F2BB File Offset: 0x0010D4BB
    public SourceMaterial.Row matFloor
    {
        get
        {
            return this.cell.matFloor;
        }
    }
 
    // Token: 0x17000DEE RID: 3566
    // (get) Token: 0x0600306D RID: 12397 RVA: 0x0010F2C8 File Offset: 0x0010D4C8
    public SourceMaterial.Row matBridge
    {
        get
        {
            return this.cell.matBridge;
        }
    }
 
    // Token: 0x17000DEF RID: 3567
    // (get) Token: 0x0600306E RID: 12398 RVA: 0x0010F2D5 File Offset: 0x0010D4D5
    public SourceBlock.Row sourceRoofBlock
    {
        get
        {
            return this.cell.sourceRoofBlock;
        }
    }
 
    // Token: 0x17000DF0 RID: 3568
    // (get) Token: 0x0600306F RID: 12399 RVA: 0x0010F2E2 File Offset: 0x0010D4E2
    public SourceBlock.Row sourceBlock
    {
        get
        {
            return this.cell.sourceBlock;
        }
    }
 
    // Token: 0x17000DF1 RID: 3569
    // (get) Token: 0x06003070 RID: 12400 RVA: 0x0010F2EF File Offset: 0x0010D4EF
    public SourceFloor.Row sourceFloor
    {
        get
        {
            return this.cell.sourceFloor;
        }
    }
 
    // Token: 0x17000DF2 RID: 3570
    // (get) Token: 0x06003071 RID: 12401 RVA: 0x0010F2FC File Offset: 0x0010D4FC
    public SourceFloor.Row sourceBridge
    {
        get
        {
            return this.cell.sourceBridge;
        }
    }
 
    // Token: 0x17000DF3 RID: 3571
    // (get) Token: 0x06003072 RID: 12402 RVA: 0x0010F309 File Offset: 0x0010D509
    public SourceObj.Row sourceObj
    {
        get
        {
            return this.cell.sourceObj;
        }
    }
 
    // Token: 0x17000DF4 RID: 3572
    // (get) Token: 0x06003073 RID: 12403 RVA: 0x0010F316 File Offset: 0x0010D516
    public CellDetail detail
    {
        get
        {
            return this.cell.detail;
        }
    }
 
    // Token: 0x17000DF5 RID: 3573
    // (get) Token: 0x06003074 RID: 12404 RVA: 0x0010F323 File Offset: 0x0010D523
    public Area area
    {
        get
        {
            CellDetail detail = this.detail;
            if (detail == null)
            {
                return null;
            }
            return detail.area;
        }
    }
 
    // Token: 0x17000DF6 RID: 3574
    // (get) Token: 0x06003075 RID: 12405 RVA: 0x0010F336 File Offset: 0x0010D536
    public Point Front
    {
        get
        {
            return new Point(this.x + 1, this.z - 1);
        }
    }
 
    // Token: 0x17000DF7 RID: 3575
    // (get) Token: 0x06003076 RID: 12406 RVA: 0x0010F34D File Offset: 0x0010D54D
    public GrowSystem growth
    {
        get
        {
            return this.cell.growth;
        }
    }
 
    // Token: 0x17000DF8 RID: 3576
    // (get) Token: 0x06003077 RID: 12407 RVA: 0x0010F35A File Offset: 0x0010D55A
    public int eloX
    {
        get
        {
            return EClass.scene.elomap.minX + this.x;
        }
    }
 
    // Token: 0x17000DF9 RID: 3577
    // (get) Token: 0x06003078 RID: 12408 RVA: 0x0010F372 File Offset: 0x0010D572
    public int eloY
    {
        get
        {
            return EClass.scene.elomap.minY + this.z;
        }
    }
 
    // Token: 0x17000DFA RID: 3578
    // (get) Token: 0x06003079 RID: 12409 RVA: 0x0010F38A File Offset: 0x0010D58A
    public bool HasDesignation
    {
        get
        {
            CellDetail detail = this.cell.detail;
            return ((detail != null) ? detail.designation : null) != null;
        }
    }
 
    // Token: 0x17000DFB RID: 3579
    // (get) Token: 0x0600307A RID: 12410 RVA: 0x0010F3A6 File Offset: 0x0010D5A6
    public bool HasDirt
    {
        get
        {
            return this.cell.decal > 0;
        }
    }
 
    // Token: 0x17000DFC RID: 3580
    // (get) Token: 0x0600307B RID: 12411 RVA: 0x0010F3B6 File Offset: 0x0010D5B6
    // (set) Token: 0x0600307C RID: 12412 RVA: 0x0010F3F0 File Offset: 0x0010D5F0
    public bool IsValid
    {
        get
        {
            return this.x >= 0 && this.z >= 0 && this.x < Point.map.Size && this.z < Point.map.Size;
        }
        set
        {
            this.x = (value ? 0 : -999);
        }
    }
 
    // Token: 0x17000DFD RID: 3581
    // (get) Token: 0x0600307D RID: 12413 RVA: 0x0010F404 File Offset: 0x0010D604
    public bool IsInBounds
    {
        get
        {
            return this.x >= Point.map.bounds.x && this.z >= Point.map.bounds.z && this.x <= Point.map.bounds.maxX && this.z <= Point.map.bounds.maxZ;
        }
    }
 
    // Token: 0x17000DFE RID: 3582
    // (get) Token: 0x0600307E RID: 12414 RVA: 0x0010F474 File Offset: 0x0010D674
    public bool IsInBoundsPlus
    {
        get
        {
            return this.x >= 0 && this.z >= 0 && this.x <= Point.map.Size - 1 && this.z <= Point.map.Size - 1;
        }
    }
 
    // Token: 0x0600307F RID: 12415 RVA: 0x0010F4C0 File Offset: 0x0010D6C0
    public bool Within(int _x, int _z, int _w, int _h)
    {
        return this.x >= _x && this.z >= _z && this.x < _x + _w && this.z < _z + _h;
    }
 
    // Token: 0x17000DFF RID: 3583
    // (get) Token: 0x06003080 RID: 12416 RVA: 0x0010F4ED File Offset: 0x0010D6ED
    public bool IsFarmField
    {
        get
        {
            return (this.HasBridge ? this.sourceBridge : this.sourceFloor).alias == "field";
        }
    }
 
    // Token: 0x17000E00 RID: 3584
    // (get) Token: 0x06003081 RID: 12417 RVA: 0x0010F514 File Offset: 0x0010D714
    public bool IsWater
    {
        get
        {
            return this.cell.IsTopWater;
        }
    }
 
    // Token: 0x17000E01 RID: 3585
    // (get) Token: 0x06003082 RID: 12418 RVA: 0x0010F521 File Offset: 0x0010D721
    public bool HasRamp
    {
        get
        {
            return this.cell.HasRamp;
        }
    }
 
    // Token: 0x17000E02 RID: 3586
    // (get) Token: 0x06003083 RID: 12419 RVA: 0x0010F52E File Offset: 0x0010D72E
    public bool HasRail
    {
        get
        {
            return this.sourceObj.tag.Contains("rail");
        }
    }
 
    // Token: 0x17000E03 RID: 3587
    // (get) Token: 0x06003084 RID: 12420 RVA: 0x0010F545 File Offset: 0x0010D745
    public bool HasRampOrLadder
    {
        get
        {
            return this.cell.HasRampOrLadder;
        }
    }
 
    // Token: 0x17000E04 RID: 3588
    // (get) Token: 0x06003085 RID: 12421 RVA: 0x0010F552 File Offset: 0x0010D752
    public bool HasObj
    {
        get
        {
            return this.cell.obj > 0;
        }
    }
 
    // Token: 0x17000E05 RID: 3589
    // (get) Token: 0x06003086 RID: 12422 RVA: 0x0010F562 File Offset: 0x0010D762
    public bool HasDecal
    {
        get
        {
            return this.cell.decal > 0;
        }
    }
 
    // Token: 0x17000E06 RID: 3590
    // (get) Token: 0x06003087 RID: 12423 RVA: 0x0010F572 File Offset: 0x0010D772
    public bool HasBlock
    {
        get
        {
            return this.cell._block > 0;
        }
    }
 
    // Token: 0x17000E07 RID: 3591
    // (get) Token: 0x06003088 RID: 12424 RVA: 0x0010F582 File Offset: 0x0010D782
    public bool HasMinableBlock
    {
        get
        {
            return this.HasObj && this.sourceBlock.tileType.IsFullBlock;
        }
    }
 
    // Token: 0x17000E08 RID: 3592
    // (get) Token: 0x06003089 RID: 12425 RVA: 0x0010F59E File Offset: 0x0010D79E
    public bool HasWallOrFence
    {
        get
        {
            return this.cell.HasWallOrFence;
        }
    }
 
    // Token: 0x17000E09 RID: 3593
    // (get) Token: 0x0600308A RID: 12426 RVA: 0x0010F5AB File Offset: 0x0010D7AB
    public bool HasWall
    {
        get
        {
            return this.cell._block != 0 && this.cell.sourceBlock.tileType.IsWall;
        }
    }
 
    // Token: 0x17000E0A RID: 3594
    // (get) Token: 0x0600308B RID: 12427 RVA: 0x0010F5D1 File Offset: 0x0010D7D1
    public bool HasFence
    {
        get
        {
            return this.cell._block != 0 && this.cell.sourceBlock.tileType.IsFence;
        }
    }
 
    // Token: 0x17000E0B RID: 3595
    // (get) Token: 0x0600308C RID: 12428 RVA: 0x0010F5F7 File Offset: 0x0010D7F7
    public bool HasNonWallBlock
    {
        get
        {
            return this.HasBlock && !this.cell.sourceBlock.tileType.IsWallOrFence;
        }
    }
 
    // Token: 0x17000E0C RID: 3596
    // (get) Token: 0x0600308D RID: 12429 RVA: 0x0010F61B File Offset: 0x0010D81B
    public bool HasTaskBuild
    {
        get
        {
            return this.cell.detail != null && this.cell.detail.designation is TaskBuild;
        }
    }
 
    // Token: 0x17000E0D RID: 3597
    // (get) Token: 0x0600308E RID: 12430 RVA: 0x0010F644 File Offset: 0x0010D844
    public bool HasBlockRecipe
    {
        get
        {
            CellDetail detail = this.cell.detail;
            TaskBuild taskBuild = ((detail != null) ? detail.designation : null) as TaskBuild;
            return taskBuild != null && taskBuild.isBlock;
        }
    }
 
    // Token: 0x17000E0E RID: 3598
    // (get) Token: 0x0600308F RID: 12431 RVA: 0x0010F66D File Offset: 0x0010D86D
    public bool HasFloor
    {
        get
        {
            return this.cell._floor > 0;
        }
    }
 
    // Token: 0x17000E0F RID: 3599
    // (get) Token: 0x06003090 RID: 12432 RVA: 0x0010F67D File Offset: 0x0010D87D
    public bool HasBridge
    {
        get
        {
            return this.cell._bridge > 0;
        }
    }
 
    // Token: 0x17000E10 RID: 3600
    // (get) Token: 0x06003091 RID: 12433 RVA: 0x0010F68D File Offset: 0x0010D88D
    public bool IsSky
    {
        get
        {
            return this.sourceFloor.tileType == TileType.Sky && !this.HasBridge;
        }
    }
 
    // Token: 0x17000E11 RID: 3601
    // (get) Token: 0x06003092 RID: 12434 RVA: 0x0010F6AC File Offset: 0x0010D8AC
    public bool HasArea
    {
        get
        {
            CellDetail detail = this.detail;
            return ((detail != null) ? detail.area : null) != null;
        }
    }
 
    // Token: 0x17000E12 RID: 3602
    // (get) Token: 0x06003093 RID: 12435 RVA: 0x0010F6C3 File Offset: 0x0010D8C3
    public bool HasChara
    {
        get
        {
            CellDetail detail = this.detail;
            return detail != null && detail.charas.Count > 0;
        }
    }
 
    // Token: 0x17000E13 RID: 3603
    // (get) Token: 0x06003094 RID: 12436 RVA: 0x0010F6DE File Offset: 0x0010D8DE
    public bool HasThing
    {
        get
        {
            CellDetail detail = this.detail;
            return detail != null && detail.things.Count > 0;
        }
    }
 
    // Token: 0x17000E14 RID: 3604
    // (get) Token: 0x06003095 RID: 12437 RVA: 0x0010F6F9 File Offset: 0x0010D8F9
    public bool HasMultipleChara
    {
        get
        {
            return this.detail != null && this.detail.charas.Count > 1;
        }
    }
 
    // Token: 0x17000E15 RID: 3605
    // (get) Token: 0x06003096 RID: 12438 RVA: 0x0010F718 File Offset: 0x0010D918
    public Chara FirstChara
    {
        get
        {
            CellDetail detail = this.detail;
            if (detail == null || detail.charas.Count <= 0)
            {
                return null;
            }
            return this.detail.charas[0];
        }
    }
 
    // Token: 0x06003097 RID: 12439 RVA: 0x0010F74C File Offset: 0x0010D94C
    public Chara FirstVisibleChara()
    {
        if (this.detail != null)
        {
            foreach (Chara chara in this.detail.charas)
            {
                if (EClass.pc.CanSee(chara))
                {
                    return chara;
                }
            }
        }
        return null;
    }
 
    // Token: 0x17000E16 RID: 3606
    // (get) Token: 0x06003098 RID: 12440 RVA: 0x0010F7BC File Offset: 0x0010D9BC
    public Thing FirstThing
    {
        get
        {
            CellDetail detail = this.detail;
            if (detail == null || detail.things.Count <= 0)
            {
                return null;
            }
            return this.detail.things[0];
        }
    }
 
    // Token: 0x17000E17 RID: 3607
    // (get) Token: 0x06003099 RID: 12441 RVA: 0x0010F7ED File Offset: 0x0010D9ED
    public Thing LastThing
    {
        get
        {
            CellDetail detail = this.detail;
            if (detail == null || detail.things.Count <= 0)
            {
                return null;
            }
            return this.detail.things.LastItem<Thing>();
        }
    }
 
    // Token: 0x17000E18 RID: 3608
    // (get) Token: 0x0600309A RID: 12442 RVA: 0x0010F820 File Offset: 0x0010DA20
    public Thing Installed
    {
        get
        {
            if (this.detail == null || this.detail.things.Count <= 0 || !this.detail.things[0].IsInstalled)
            {
                return null;
            }
            return this.detail.things[0];
        }
    }
 
    // Token: 0x17000E19 RID: 3609
    // (get) Token: 0x0600309B RID: 12443 RVA: 0x0010F873 File Offset: 0x0010DA73
    public List<Thing> Things
    {
        get
        {
            return this.cell.Things;
        }
    }
 
    // Token: 0x17000E1A RID: 3610
    // (get) Token: 0x0600309C RID: 12444 RVA: 0x0010F880 File Offset: 0x0010DA80
    public List<Chara> Charas
    {
        get
        {
            return this.cell.Charas;
        }
    }
 
    // Token: 0x17000E1B RID: 3611
    // (get) Token: 0x0600309D RID: 12445 RVA: 0x0010F88D File Offset: 0x0010DA8D
    public bool IsSeen
    {
        get
        {
            return this.cell.isSeen;
        }
    }
 
    // Token: 0x17000E1C RID: 3612
    // (get) Token: 0x0600309E RID: 12446 RVA: 0x0010F89A File Offset: 0x0010DA9A
    public bool IsSync
    {
        get
        {
            return this.cell.pcSync;
        }
    }
 
    // Token: 0x17000E1D RID: 3613
    // (get) Token: 0x0600309F RID: 12447 RVA: 0x0010F8A8 File Offset: 0x0010DAA8
    public bool IsHidden
    {
        get
        {
            return !this.cell.isSeen || (this.cell.room != null && !EClass.screen.tileMap.hideRoomFog && !this.cell.hasDoor && this.cell.HasRoof);
        }
    }
 
    // Token: 0x17000E1E RID: 3614
    // (get) Token: 0x060030A0 RID: 12448 RVA: 0x0010F8FC File Offset: 0x0010DAFC
    public bool IsBlocked
    {
        get
        {
            return !this.IsValid || this.cell.blocked;
        }
    }
 
    // Token: 0x060030A1 RID: 12449 RVA: 0x0010F913 File Offset: 0x0010DB13
    public bool HasRoomOrArea(BaseArea a)
    {
        return this.area == a || this.cell.room == a;
    }
 
    // Token: 0x060030A2 RID: 12450 RVA: 0x0010F930 File Offset: 0x0010DB30
    public bool IsPublicSpace()
    {
        if (this.area != null)
        {
            return this.area.type.IsPublicArea;
        }
        return this.cell.room == null || this.cell.room.type.IsPublicArea;
    }
 
    // Token: 0x060030A3 RID: 12451 RVA: 0x0010F984 File Offset: 0x0010DB84
    public Point()
    {
    }
 
    // Token: 0x060030A4 RID: 12452 RVA: 0x0010F98C File Offset: 0x0010DB8C
    public Point(Point p)
    {
        this.x = p.x;
        this.z = p.z;
    }
 
    // Token: 0x060030A5 RID: 12453 RVA: 0x0010F9AC File Offset: 0x0010DBAC
    public Point(int _x, int _z)
    {
        this.x = _x;
        this.z = _z;
    }
 
    // Token: 0x060030A6 RID: 12454 RVA: 0x0010F9C2 File Offset: 0x0010DBC2
    public Point(int _index)
    {
        this.Set(_index);
    }
 
    // Token: 0x060030A7 RID: 12455 RVA: 0x0010F9D2 File Offset: 0x0010DBD2
    public Point Copy()
    {
        return new Point(this.x, this.z);
    }
 
    // Token: 0x060030A8 RID: 12456 RVA: 0x0010F9E5 File Offset: 0x0010DBE5
    public T Copy<T>() where T : Point
    {
        T t = Activator.CreateInstance<T>();
        t.Set(this);
        return t;
    }
 
    // Token: 0x060030A9 RID: 12457 RVA: 0x0010F9F9 File Offset: 0x0010DBF9
    public Point Set(int _x, int _z)
    {
        this.x = _x;
        this.z = _z;
        return this;
    }
 
    // Token: 0x060030AA RID: 12458 RVA: 0x0010FA0A File Offset: 0x0010DC0A
    public Point Set(int index)
    {
        this.x = index % Point.map.Size;
        this.z = index % Point.map.SizeXZ / Point.map.Size;
        return this;
    }
 
    // Token: 0x060030AB RID: 12459 RVA: 0x0010FA3C File Offset: 0x0010DC3C
    public Point Set(Point point)
    {
        this.x = point.x;
        this.z = point.z;
        return this;
    }
 
    // Token: 0x060030AC RID: 12460 RVA: 0x0010FA58 File Offset: 0x0010DC58
    public override string ToString()
    {
        return string.Concat(new string[]
        {
            "(",
            this.x.ToString(),
            " / ",
            this.z.ToString(),
            ")"
        });
    }
 
    // Token: 0x060030AD RID: 12461 RVA: 0x0010FAA4 File Offset: 0x0010DCA4
    public void Set(Vector3 v)
    {
        v.x -= 0.64f;
        v.y -= 0.64f;
        int num = Mathf.RoundToInt(v.x / Point._screen.tileAlign.x);
        int num2 = Mathf.RoundToInt(v.y / Point._screen.tileAlign.y);
        this.x = (num2 - num) / 2 * -1;
        this.z = num - this.x;
    }
 
    // Token: 0x060030AE RID: 12462 RVA: 0x0010FB24 File Offset: 0x0010DD24
    public ref Vector3 PositionAuto()
    {
        if (EClass._zone.IsRegion)
        {
            return this.PositionTopdown();
        }
        return this.Position();
    }
 
    // Token: 0x060030AF RID: 12463 RVA: 0x0010FB40 File Offset: 0x0010DD40
    public ref Vector3 Position(int height)
    {
        if (height == -1)
        {
            return this.Position();
        }
        this.vCache.x = (float)(this.x + this.z) * Point._screen.tileAlign.x;
        this.vCache.y = (float)(this.z - this.x) * Point._screen.tileAlign.y + (float)height * Point._screen.tileMap._heightMod.y;
        this.vCache.z = 1000f + this.vCache.x * Point._screen.tileWeight.x + this.vCache.y * Point._screen.tileWeight.z + (float)height * Point._screen.tileMap._heightMod.z;
        return ref this.vCache;
    }
 
    // Token: 0x060030B0 RID: 12464 RVA: 0x0010FC2C File Offset: 0x0010DE2C
    public ref Vector3 Position()
    {
        byte b = (this.cell.bridgeHeight == 0) ? this.cell.height : this.cell.bridgeHeight;
        this.vCache.x = (float)(this.x + this.z) * Point._screen.tileAlign.x;
        this.vCache.y = (float)(this.z - this.x) * Point._screen.tileAlign.y + (float)b * Point._screen.tileMap._heightMod.y;
        this.vCache.z = 1000f + this.vCache.x * Point._screen.tileWeight.x + this.vCache.y * Point._screen.tileWeight.z + (float)b * Point._screen.tileMap._heightMod.z;
        return ref this.vCache;
    }
 
    // Token: 0x060030B1 RID: 12465 RVA: 0x0010FD30 File Offset: 0x0010DF30
    public ref Vector3 PositionTopdown()
    {
        byte b = (this.cell.bridgeHeight == 0) ? this.cell.height : this.cell.bridgeHeight;
        this.vCache.x = (float)this.x * Point._screen.tileAlign.x;
        this.vCache.y = (float)this.z * Point._screen.tileAlign.y + (float)b * Point._screen.tileMap._heightMod.y;
        this.vCache.z = 1000f + this.vCache.x * Point._screen.tileWeight.x + this.vCache.y * Point._screen.tileWeight.z + (float)b * Point._screen.tileMap._heightMod.z;
        return ref this.vCache;
    }
 
    // Token: 0x060030B2 RID: 12466 RVA: 0x0010FE28 File Offset: 0x0010E028
    public ref Vector3 PositionTopdownTreasure()
    {
        GameScreenElona screenElona = EClass.scene.screenElona;
        this.vCache.x = (float)(this.x - EClass.scene.elomap.minX) * screenElona.tileAlign.x;
        this.vCache.y = (float)(this.z - EClass.scene.elomap.minY) * screenElona.tileAlign.y;
        this.vCache.z = 1400f;
        return ref this.vCache;
    }
 
    // Token: 0x060030B3 RID: 12467 RVA: 0x0010FEB4 File Offset: 0x0010E0B4
    public ref Vector3 PositionCenter()
    {
        if (EClass._zone.IsRegion)
        {
            this.PositionTopdown();
        }
        else
        {
            this.Position();
        }
        this.vCache.x = this.vCache.x + EClass.screen.tileWorldSize.x * 0.5f;
        this.vCache.y = this.vCache.y + EClass.screen.tileWorldSize.y * 0.75f;
        return ref this.vCache;
    }
 
    // Token: 0x060030B4 RID: 12468 RVA: 0x0010FF2B File Offset: 0x0010E12B
    public Quaternion GetRotation(Point to)
    {
        return Quaternion.Euler(0f, 0f, this.GetAngle(to));
    }
 
    // Token: 0x060030B5 RID: 12469 RVA: 0x0010FF44 File Offset: 0x0010E144
    public unsafe float GetAngle(Point to)
    {
        Vector3 vector = *to.Position() - *this.Position();
        return Mathf.Atan2(vector.y, vector.x) * 57.29578f;
    }
 
    // Token: 0x060030B6 RID: 12470 RVA: 0x0010FF84 File Offset: 0x0010E184
    public float GetAngle2(Point to)
    {
        int num = to.x - this.x;
        return Mathf.Atan2((float)(to.z - this.z), (float)num) * 57.29578f;
    }
 
    // Token: 0x060030B7 RID: 12471 RVA: 0x0010FFBC File Offset: 0x0010E1BC
    public Point GetNearestPoint(bool allowBlock = false, bool allowChara = true, bool allowInstalled = true, bool ignoreCenter = false)
    {
        Point.<>c__DisplayClass146_0 CS$<>8__locals1;
        CS$<>8__locals1.ignoreCenter = ignoreCenter;
        CS$<>8__locals1.<>4__this = this;
        CS$<>8__locals1.allowBlock = allowBlock;
        CS$<>8__locals1.allowChara = allowChara;
        CS$<>8__locals1.allowInstalled = allowInstalled;
        CS$<>8__locals1.p = new Point();
        int num = 1;
        int num2 = this.x;
        int num3 = this.z;
        if (this.<GetNearestPoint>g__IsValid|146_0(num2, num3, ref CS$<>8__locals1))
        {
            return CS$<>8__locals1.p;
        }
        if (this.<GetNearestPoint>g__IsValid|146_0(num2, num3 + 1, ref CS$<>8__locals1))
        {
            return CS$<>8__locals1.p;
        }
        for (int i = 0; i < 30; i++)
        {
            for (int j = 0; j < num; j++)
            {
                num2++;
                if (this.<GetNearestPoint>g__IsValid|146_0(num2, num3, ref CS$<>8__locals1))
                {
                    return CS$<>8__locals1.p;
                }
            }
            num++;
            for (int k = 0; k < num; k++)
            {
                num3++;
                if (this.<GetNearestPoint>g__IsValid|146_0(num2, num3, ref CS$<>8__locals1))
                {
                    return CS$<>8__locals1.p;
                }
            }
            for (int l = 0; l < num; l++)
            {
                num2--;
                if (this.<GetNearestPoint>g__IsValid|146_0(num2, num3, ref CS$<>8__locals1))
                {
                    return CS$<>8__locals1.p;
                }
            }
            num++;
            for (int m = 0; m < num; m++)
            {
                num3--;
                if (this.<GetNearestPoint>g__IsValid|146_0(num2, num3, ref CS$<>8__locals1))
                {
                    return CS$<>8__locals1.p;
                }
            }
        }
        CS$<>8__locals1.p.Set(this);
        return CS$<>8__locals1.p;
    }
 
    // Token: 0x060030B8 RID: 12472 RVA: 0x00110104 File Offset: 0x0010E304
    public bool ForeachNearestPoint(Func<Point, bool> endFunc, bool allowBlock = false, bool allowChara = true, bool allowInstalled = true, bool ignoreCenter = false)
    {
        Point.<>c__DisplayClass147_0 CS$<>8__locals1;
        CS$<>8__locals1.ignoreCenter = ignoreCenter;
        CS$<>8__locals1.<>4__this = this;
        CS$<>8__locals1.allowBlock = allowBlock;
        CS$<>8__locals1.allowChara = allowChara;
        CS$<>8__locals1.allowInstalled = allowInstalled;
        CS$<>8__locals1.p = new Point();
        int num = 1;
        int num2 = this.x;
        int num3 = this.z;
        if (this.<ForeachNearestPoint>g__IsValid|147_0(num2, num3, ref CS$<>8__locals1) && endFunc(CS$<>8__locals1.p))
        {
            return true;
        }
        if (this.<ForeachNearestPoint>g__IsValid|147_0(num2, num3 + 1, ref CS$<>8__locals1) && endFunc(CS$<>8__locals1.p))
        {
            return true;
        }
        for (int i = 0; i < 30; i++)
        {
            for (int j = 0; j < num; j++)
            {
                num2++;
                if (this.<ForeachNearestPoint>g__IsValid|147_0(num2, num3, ref CS$<>8__locals1) && endFunc(CS$<>8__locals1.p))
                {
                    return true;
                }
            }
            num++;
            for (int k = 0; k < num; k++)
            {
                num3++;
                if (this.<ForeachNearestPoint>g__IsValid|147_0(num2, num3, ref CS$<>8__locals1) && endFunc(CS$<>8__locals1.p))
                {
                    return true;
                }
            }
            for (int l = 0; l < num; l++)
            {
                num2--;
                if (this.<ForeachNearestPoint>g__IsValid|147_0(num2, num3, ref CS$<>8__locals1) && endFunc(CS$<>8__locals1.p))
                {
                    return true;
                }
            }
            num++;
            for (int m = 0; m < num; m++)
            {
                num3--;
                if (this.<ForeachNearestPoint>g__IsValid|147_0(num2, num3, ref CS$<>8__locals1) && endFunc(CS$<>8__locals1.p))
                {
                    return true;
                }
            }
        }
        Debug.Log("ForeachNearestPoint Fail:" + ((this != null) ? this.ToString() : null));
        return false;
    }
 
    // Token: 0x060030B9 RID: 12473 RVA: 0x00110290 File Offset: 0x0010E490
    public Point GetRandomNeighbor()
    {
        int num = (EClass.rnd(2) == 0) ? 1 : -1;
        if (EClass.rnd(2) == 0)
        {
            return new Point(Mathf.Clamp(this.x + num, 0, Point.map.Size - 1), this.z);
        }
        return new Point(this.x, Mathf.Clamp(this.z + num, 0, Point.map.Size - 1));
    }
 
    // Token: 0x060030BA RID: 12474 RVA: 0x00110300 File Offset: 0x0010E500
    public Point GetRandomPoint(int radius, bool requireLos = true, bool allowChara = true, bool allowBlocked = false, int tries = 100)
    {
        Point point = new Point();
        for (int i = 0; i < tries; i++)
        {
            point.Set(this.x - radius + EClass.rnd(radius * 2 + 1), this.z - radius + EClass.rnd(radius * 2 + 1));
            if (point.IsValid && (allowBlocked || !point.IsBlocked) && (!requireLos || Los.IsVisible(this, point, null)) && (allowChara || !point.HasChara))
            {
                return point;
            }
        }
        return null;
    }
 
    // Token: 0x060030BB RID: 12475 RVA: 0x0011037C File Offset: 0x0010E57C
    public Point GetPointTowards(Point dest)
    {
        Point point = new Point(this);
        int num = dest.x - point.x;
        int num2 = dest.z - point.z;
        if (Mathf.Abs(num) > 1 || Mathf.Abs(num2) > 1)
        {
            int num3 = Mathf.Max(Mathf.Abs(num), Mathf.Abs(num2));
            point.x += num / num3;
            point.z += num2 / num3;
        }
        return point;
    }
 
    // Token: 0x060030BC RID: 12476 RVA: 0x001103F4 File Offset: 0x0010E5F4
    public void TalkWitnesses(Chara criminal, string idTalk, int radius = 4, WitnessType type = WitnessType.everyone, Func<Chara, bool> talkIf = null, int chance = 3)
    {
        if (talkIf == null)
        {
            talkIf = ((Chara c) => EClass.rnd(chance) == 0);
        }
        foreach (Chara chara in this.ListWitnesses(criminal, radius, type, null))
        {
            if (talkIf(chara) && !chara.renderer.IsTalking())
            {
                chara.Talk(idTalk, null, null, false);
            }
        }
    }
 
    // Token: 0x060030BD RID: 12477 RVA: 0x00110488 File Offset: 0x0010E688
    public List<Chara> ListWitnesses(Chara criminal, int radius = 4, WitnessType type = WitnessType.crime, Chara target = null)
    {
        List<Chara> list = new List<Chara>();
        foreach (Point point in Point.map.ListPointsInCircle(this, (float)radius, false, true))
        {
            CellDetail detail = point.detail;
            List<Chara> list2 = (detail != null) ? detail.charas : null;
            if (list2 != null && list2.Count != 0)
            {
                foreach (Chara chara in list2)
                {
                    if (chara != criminal && !chara.IsPC && (chara == target || chara.CanWitness) && (!chara.HasCondition<ConDim>() || EClass.rnd(2) != 0) && chara.conSuspend == null && !chara.isParalyzed && !chara.IsDisabled)
                    {
                        switch (type)
                        {
                        case WitnessType.crime:
                            if (criminal == null || chara.isBlind || chara.isConfused || (criminal.IsPCParty && (chara.IsPCFaction || chara.IsPCFactionMinion)))
                            {
                                continue;
                            }
                            if (target == null)
                            {
                                if (chara.OriginalHostility < Hostility.Neutral)
                                {
                                    continue;
                                }
                            }
                            else if (!target.IsFriendOrAbove(chara))
                            {
                                continue;
                            }
                            break;
                        case WitnessType.music:
                            if (chara.hostility <= Hostility.Enemy)
                            {
                                continue;
                            }
                            break;
                        case WitnessType.ally:
                            if (!criminal.IsPCFaction)
                            {
                                continue;
                            }
                            if (chara.hostility <= Hostility.Neutral)
                            {
                                continue;
                            }
                            break;
                        }
                        list.Add(chara);
                    }
                }
            }
        }
        return list;
    }
 
    // Token: 0x060030BE RID: 12478 RVA: 0x00110648 File Offset: 0x0010E848
    public bool TryWitnessCrime(Chara criminal, Chara target = null, int radius = 4, Func<Chara, bool> funcWitness = null)
    {
        List<Chara> list = this.ListWitnesses(criminal, radius, WitnessType.crime, target);
        bool result = false;
        if (funcWitness == null)
        {
            funcWitness = ((Chara c) => EClass.rnd(10) == 0);
        }
        foreach (Chara chara in list)
        {
            if (funcWitness(chara))
            {
                this.CallGuard(criminal, chara);
                result = true;
                if (target != null)
                {
                    target.DoHostileAction(criminal, false);
                }
                if (chara != target)
                {
                    chara.DoHostileAction(criminal, false);
                    break;
                }
                break;
            }
        }
        return result;
    }
 
    // Token: 0x060030BF RID: 12479 RVA: 0x001106F0 File Offset: 0x0010E8F0
    public void CallGuard(Chara criminal, Chara caller)
    {
        caller.Talk("callGuards", null, null, false);
        List<Chara> list = (from c in EClass._map.charas
        where c.trait is TraitGuard && !c.IsInCombat
        select c).ToList<Chara>();
        if (list.Count > 0)
        {
            Chara chara = list.RandomItem<Chara>();
            caller.Say("calledGuard", caller, null, null);
            chara.DoHostileAction(criminal, false);
        }
    }
 
    // Token: 0x060030C0 RID: 12480 RVA: 0x00110763 File Offset: 0x0010E963
    public void SetBlock(int idMat = 0, int idBlock = 0)
    {
        Point.map.SetBlock(this.x, this.z, idMat, idBlock);
    }
 
    // Token: 0x060030C1 RID: 12481 RVA: 0x0011077D File Offset: 0x0010E97D
    public void SetFloor(int idMat = 0, int idFloor = 0)
    {
        Point.map.SetFloor(this.x, this.z, idMat, idFloor);
    }
 
    // Token: 0x060030C2 RID: 12482 RVA: 0x00110797 File Offset: 0x0010E997
    public void SetObj(int id = 0, int value = 1, int dir = 0)
    {
        Point.map.SetObj(this.x, this.z, id, value, dir);
    }
 
    // Token: 0x060030C3 RID: 12483 RVA: 0x001107B2 File Offset: 0x0010E9B2
    public void ModFire(int value)
    {
        Point.map.ModFire(this.x, this.z, value);
    }
 
    // Token: 0x060030C4 RID: 12484 RVA: 0x001107CC File Offset: 0x0010E9CC
    public void Plow()
    {
        if (this.IsFarmField)
        {
            if (this.cell.Right.HasWallOrFence)
            {
                this.Set(this.cell.Right.GetPoint());
            }
            else if (this.cell.Front.HasWallOrFence)
            {
                this.Set(this.cell.Front.GetPoint());
            }
        }
        this.SetFloor(4, 4);
    }
 
    // Token: 0x060030C5 RID: 12485 RVA: 0x0011083D File Offset: 0x0010EA3D
    public bool Equals(int _x, int _z)
    {
        return this.x == _x && this.z == _z;
    }
 
    // Token: 0x060030C6 RID: 12486 RVA: 0x00110854 File Offset: 0x0010EA54
    public override bool Equals(object obj)
    {
        Point point = obj as Point;
        if (point == null)
        {
            Point point2 = point;
            string str = (point2 != null) ? point2.ToString() : null;
            string str2 = ":";
            Type type = point.GetType();
            Debug.Log(str + str2 + ((type != null) ? type.ToString() : null) + "is not Point");
            return false;
        }
        return this.x == point.x && this.z == point.z;
    }
 
    // Token: 0x060030C7 RID: 12487 RVA: 0x001108BE File Offset: 0x0010EABE
    public override int GetHashCode()
    {
        return this.x + this.z * Point.map.Size;
    }
 
    // Token: 0x060030C8 RID: 12488 RVA: 0x001108D8 File Offset: 0x0010EAD8
    public int Distance(Point p)
    {
        return Fov.Distance(p.x, p.z, this.x, this.z);
    }
 
    // Token: 0x060030C9 RID: 12489 RVA: 0x001108F7 File Offset: 0x0010EAF7
    public int Distance(int tx, int tz)
    {
        return Fov.Distance(tx, tz, this.x, this.z);
    }
 
    // Token: 0x060030CA RID: 12490 RVA: 0x0011090C File Offset: 0x0010EB0C
    public bool IsBlockByHeight(Point p)
    {
        return Mathf.Abs((int)(p.cell.minHeight - this.cell.topHeight)) > 8 && Mathf.Abs((int)(p.cell.topHeight - this.cell.minHeight)) > 8;
    }
 
    // Token: 0x060030CB RID: 12491 RVA: 0x0011095C File Offset: 0x0010EB5C
    public Point Clamp(bool useBounds = false)
    {
        if (useBounds)
        {
            if (this.x < Point.map.bounds.x)
            {
                this.x = Point.map.bounds.x;
            }
            else if (this.x >= Point.map.bounds.maxX)
            {
                this.x = Point.map.bounds.maxX;
            }
            if (this.z < Point.map.bounds.z)
            {
                this.z = Point.map.bounds.z;
            }
            else if (this.z >= Point.map.bounds.maxZ)
            {
                this.z = Point.map.bounds.maxZ;
            }
        }
        else
        {
            if (this.x < 0)
            {
                this.x = 0;
            }
            else if (this.x >= Point.map.Size)
            {
                this.x = Point.map.Size - 1;
            }
            if (this.z < 0)
            {
                this.z = 0;
            }
            else if (this.z >= Point.map.Size)
            {
                this.z = Point.map.Size - 1;
            }
        }
        return this;
    }
 
    // Token: 0x060030CC RID: 12492 RVA: 0x00110A98 File Offset: 0x0010EC98
    public List<Card> ListCards(bool includeMasked = false)
    {
        Point.listCard.Clear();
        bool flag = EClass.scene.actionMode != null && EClass.scene.actionMode.IsRoofEditMode(null);
        if (this.detail != null)
        {
            foreach (Thing thing in this.detail.things)
            {
                if (!thing.isHidden && (includeMasked || !thing.isMasked) && thing.isRoofItem == flag)
                {
                    Point.listCard.Add(thing);
                }
            }
            if (!flag)
            {
                foreach (Chara item in this.detail.charas)
                {
                    Point.listCard.Add(item);
                }
            }
        }
        return Point.listCard;
    }
 
    // Token: 0x060030CD RID: 12493 RVA: 0x00110B9C File Offset: 0x0010ED9C
    public List<Card> ListVisibleCards()
    {
        Point.listCard.Clear();
        if (this.detail != null)
        {
            foreach (Thing thing in this.detail.things)
            {
                if (!thing.isHidden && !thing.isMasked && !thing.isRoofItem)
                {
                    Point.listCard.Add(thing);
                }
            }
            foreach (Chara chara in this.detail.charas)
            {
                if (EClass.pc.CanSee(chara))
                {
                    Point.listCard.Add(chara);
                }
            }
        }
        return Point.listCard;
    }
 
    // Token: 0x060030CE RID: 12494 RVA: 0x00110C84 File Offset: 0x0010EE84
    public Card FindAttackTarget()
    {
        foreach (Card card in this.ListCards(false))
        {
            if (card.isChara || card.trait.CanBeAttacked)
            {
                return card;
            }
        }
        return null;
    }
 
    // Token: 0x060030CF RID: 12495 RVA: 0x00110CF0 File Offset: 0x0010EEF0
    public T FindThing<T>() where T : Trait
    {
        if (this.detail != null)
        {
            foreach (Thing thing in this.detail.things)
            {
                if (thing.trait is T)
                {
                    return thing.trait as T;
                }
            }
        }
        return default(T);
    }
 
    // Token: 0x060030D0 RID: 12496 RVA: 0x00110D74 File Offset: 0x0010EF74
    public List<Card> ListThings<T>(bool onlyInstalled = true) where T : Trait
    {
        Point.listCard.Clear();
        if (this.detail != null)
        {
            foreach (Thing thing in this.detail.things)
            {
                if (!thing.isHidden && !thing.isRoofItem && !thing.isMasked && (!onlyInstalled || thing.IsInstalled) && thing.trait is T)
                {
                    Point.listCard.Add(thing);
                }
            }
        }
        return Point.listCard;
    }
 
    // Token: 0x060030D1 RID: 12497 RVA: 0x00110E18 File Offset: 0x0010F018
    public List<Chara> ListCharas()
    {
        Point.listChara.Clear();
        if (this.detail != null)
        {
            foreach (Chara item in this.detail.charas)
            {
                Point.listChara.Add(item);
            }
        }
        return Point.listChara;
    }
 
    // Token: 0x060030D2 RID: 12498 RVA: 0x00110E8C File Offset: 0x0010F08C
    public List<Chara> ListVisibleCharas()
    {
        Point.listChara.Clear();
        if (this.detail != null)
        {
            foreach (Chara chara in this.detail.charas)
            {
                if (EClass.pc.CanSee(chara))
                {
                    Point.listChara.Add(chara);
                }
            }
        }
        return Point.listChara;
    }
 
    // Token: 0x060030D3 RID: 12499 RVA: 0x00110F0C File Offset: 0x0010F10C
    public List<Chara> ListCharasInNeighbor(Func<Chara, bool> func)
    {
        Point.listChara.Clear();
        this.ForeachNeighbor(delegate(Point p)
        {
            if (p.detail == null)
            {
                return;
            }
            foreach (Chara chara in p.detail.charas)
            {
                if (func(chara))
                {
                    Point.listChara.Add(chara);
                }
            }
        }, true);
        return Point.listChara;
    }
 
    // Token: 0x060030D4 RID: 12500 RVA: 0x00110F48 File Offset: 0x0010F148
    public List<Chara> ListCharasInRadius(Chara cc, int dist, Func<Chara, bool> func)
    {
        Point.listChara.Clear();
        foreach (Chara chara in EClass._map.charas)
        {
            if (func(chara) && chara.Dist(cc) < dist && Los.IsVisible(chara, cc))
            {
                Point.listChara.Add(chara);
            }
        }
        return Point.listChara;
    }
 
    // Token: 0x060030D5 RID: 12501 RVA: 0x00110FD0 File Offset: 0x0010F1D0
    public T GetInstalled<T>() where T : Trait
    {
        if (this.detail != null)
        {
            foreach (Thing thing in this.detail.things)
            {
                if (thing.IsInstalled && thing.trait is T)
                {
                    return thing.trait as T;
                }
            }
        }
        return default(T);
    }
 
    // Token: 0x060030D6 RID: 12502 RVA: 0x0011105C File Offset: 0x0010F25C
    public Effect PlayEffect(string id)
    {
        return Effect.Get(id).Play(this, 0f, null, null);
    }
 
    // Token: 0x060030D7 RID: 12503 RVA: 0x00111074 File Offset: 0x0010F274
    public unsafe SoundSource PlaySound(string id, bool synced = true, float v = 1f, bool spatial = true)
    {
        Vector3 vector = default(Vector3);
        if (spatial)
        {
            if (!this.IsValid)
            {
                return null;
            }
            vector = (EClass._zone.IsRegion ? (*this.PositionTopdown()) : (*this.Position()));
            vector.z = 0f;
            if (Vector3.Distance(vector, EClass.scene.transAudio.position) > EClass.core.gameSetting.audio.maxRange)
            {
                return null;
            }
            if (!synced)
            {
                v -= 0.4f;
            }
        }
        return EClass.Sound.Play(id, vector, (!spatial) ? 1f : (v * ((EClass.screen.Zoom >= 1f) ? 1f : EClass.screen.Zoom)));
    }
 
    // Token: 0x060030D8 RID: 12504 RVA: 0x0011113E File Offset: 0x0010F33E
    public void RefreshNeighborTiles()
    {
        Point.map.RefreshNeighborTiles(this.x, this.z);
    }
 
    // Token: 0x060030D9 RID: 12505 RVA: 0x00111156 File Offset: 0x0010F356
    public void RefreshTile()
    {
        Point.map.RefreshSingleTile(this.x, this.z);
    }
 
    // Token: 0x060030DA RID: 12506 RVA: 0x00111170 File Offset: 0x0010F370
    public bool HasNonHomeProperty(Thing exclude = null)
    {
        if (this.FirstThing == null)
        {
            return false;
        }
        foreach (Thing thing in this.detail.things)
        {
            if (thing != exclude && thing.isNPCProperty)
            {
                return true;
            }
        }
        return false;
    }
 
    // Token: 0x060030DB RID: 12507 RVA: 0x001111E0 File Offset: 0x0010F3E0
    public void Animate(AnimeID id, bool animeBlock = false)
    {
        if (!this.IsValid)
        {
            return;
        }
        CellDetail orCreateDetail = this.cell.GetOrCreateDetail();
        if (orCreateDetail.anime != null)
        {
            return;
        }
        TransAnime transAnime = new TransAnime
        {
            data = ResourceCache.Load<TransAnimeData>("Scene/Render/Anime/" + id.ToString()),
            point = this,
            animeBlock = animeBlock
        }.Init();
        orCreateDetail.anime = transAnime;
        EClass._map.pointAnimes.Add(transAnime);
        if (id == AnimeID.Quake)
        {
            transAnime.drawBlock = true;
        }
    }
 
    // Token: 0x060030DC RID: 12508 RVA: 0x0011126C File Offset: 0x0010F46C
    public RenderParam ApplyAnime(RenderParam p)
    {
        if (this.detail == null || this.detail.anime == null)
        {
            return p;
        }
        p.x += this.detail.anime.v.x;
        p.y += this.detail.anime.v.y;
        p.z += this.detail.anime.v.z;
        p.v.x = p.v.x + this.detail.anime.v.x;
        p.v.y = p.v.y + this.detail.anime.v.y;
        p.v.z = p.v.z + this.detail.anime.v.z;
        return p;
    }
 
    // Token: 0x060030DD RID: 12509 RVA: 0x00111364 File Offset: 0x0010F564
    public Vector3 ApplyAnime(ref Vector3 p)
    {
        if (this.detail == null || this.detail.anime == null)
        {
            return p;
        }
        p.x += this.detail.anime.v.x;
        p.y += this.detail.anime.v.y;
        p.z += this.detail.anime.v.z;
        return p;
    }
 
    // Token: 0x060030DE RID: 12510 RVA: 0x001113F0 File Offset: 0x0010F5F0
    public List<IInspect> ListInspectorTargets()
    {
        List<IInspect> list = new List<IInspect>();
        CellDetail detail = this.detail;
        if (detail != null)
        {
            foreach (Chara chara in detail.charas)
            {
                if (chara.isSynced)
                {
                    list.Add(chara);
                }
            }
            foreach (Thing item in detail.things)
            {
                list.Add(item);
            }
            if (detail.designation != null && !(detail.designation is TaskCut) && !(detail.designation is TaskMine))
            {
                list.Add(detail.designation);
            }
        }
        if (ObjInfo._CanInspect(this))
        {
            list.Add(ObjInfo.GetTempList(this));
        }
        if (BlockInfo._CanInspect(this))
        {
            list.Add(BlockInfo.GetTempList(this));
        }
        return list;
    }
 
    // Token: 0x060030DF RID: 12511 RVA: 0x001114FC File Offset: 0x0010F6FC
    public void ForeachMultiSize(int w, int h, Action<Point, bool> action)
    {
        for (int i = 0; i < h; i++)
        {
            for (int j = 0; j < w; j++)
            {
                Point.shared3.Set(this.x - j, this.z + i);
                action(Point.shared3, j == 0 && i == 0);
            }
        }
    }
 
    // Token: 0x060030E0 RID: 12512 RVA: 0x00111554 File Offset: 0x0010F754
    public void ForeachNeighbor(Action<Point> action, bool diagonal = true)
    {
        Point point = new Point();
        for (int i = this.x - 1; i <= this.x + 1; i++)
        {
            for (int j = this.z - 1; j <= this.z + 1; j++)
            {
                if (diagonal || i == this.x || j == this.z)
                {
                    point.Set(i, j);
                    if (point.IsValid)
                    {
                        action(point);
                    }
                }
            }
        }
    }
 
    // Token: 0x060030E1 RID: 12513 RVA: 0x001115C8 File Offset: 0x0010F7C8
    public Point ToRegionPos()
    {
        Point point = new Point(this.x, this.z);
        point.x += EClass.scene.elomap.minX;
        point.z += EClass.scene.elomap.minY;
        return point;
    }
 
    // Token: 0x060030E3 RID: 12515 RVA: 0x001116C0 File Offset: 0x0010F8C0
    [CompilerGenerated]
    private bool <GetNearestPoint>g__IsValid|146_0(int dx, int dz, ref Point.<>c__DisplayClass146_0 A_3)
    {
        A_3.p.Set(dx, dz);
        return A_3.p.IsInBounds && Point.map.Contains(dx, dz) && (!A_3.ignoreCenter || dx != this.x || dz != this.z) && (A_3.allowBlock || (!A_3.p.cell.blocked && !A_3.p.cell.hasDoor && (A_3.p.cell.growth == null || !A_3.p.cell.growth.IsTree))) && (A_3.allowChara || !A_3.p.HasChara) && (A_3.allowInstalled || A_3.p.Installed == null);
    }
 
    // Token: 0x060030E4 RID: 12516 RVA: 0x00111794 File Offset: 0x0010F994
    [CompilerGenerated]
    private bool <ForeachNearestPoint>g__IsValid|147_0(int dx, int dz, ref Point.<>c__DisplayClass147_0 A_3)
    {
        A_3.p.Set(dx, dz);
        return A_3.p.IsInBounds && Point.map.Contains(dx, dz) && (!A_3.ignoreCenter || dx != this.x || dz != this.z) && (A_3.allowBlock || (!A_3.p.cell.blocked && !A_3.p.cell.hasDoor && (A_3.p.cell.growth == null || !A_3.p.cell.growth.IsTree))) && (A_3.allowChara || !A_3.p.HasChara) && (A_3.allowInstalled || A_3.p.Installed == null);
    }
 
    // Token: 0x04001B00 RID: 6912
    public static readonly XY[] Surrounds = new XY[]
    {
        new XY(0, -1),
        new XY(1, 0),
        new XY(0, 1),
        new XY(-1, 0)
    };
 
    // Token: 0x04001B01 RID: 6913
    public static Vector3 fixedPos;
 
    // Token: 0x04001B02 RID: 6914
    public static Point shared = new Point();
 
    // Token: 0x04001B03 RID: 6915
    public static Point shared2 = new Point();
 
    // Token: 0x04001B04 RID: 6916
    public static Point shared3 = new Point();
 
    // Token: 0x04001B05 RID: 6917
    public static Map map;
 
    // Token: 0x04001B06 RID: 6918
    public static Point Invalid = new Point
    {
        IsValid = false
    };
 
    // Token: 0x04001B07 RID: 6919
    public static Point Zero = new Point();
 
    // Token: 0x04001B08 RID: 6920
    [JsonProperty]
    public int x;
 
    // Token: 0x04001B09 RID: 6921
    [JsonProperty]
    public int z;
 
    // Token: 0x04001B0A RID: 6922
    private Vector3 vCache;
 
    // Token: 0x04001B0B RID: 6923
    public static BaseGameScreen _screen;
 
    // Token: 0x04001B0C RID: 6924
    private static List<Card> listCard = new List<Card>();
 
    // Token: 0x04001B0D RID: 6925
    private static List<Chara> listChara = new List<Chara>();
}