Los.cs

using System;
using System.Collections.Generic;
 
// Token: 0x020000A4 RID: 164
public class Los : EClass
{
    // Token: 0x06000458 RID: 1112 RVA: 0x0001D2D0 File Offset: 0x0001B4D0
    public static int MAX(int a, int b)
    {
        if (a <= b)
        {
            return b;
        }
        return a;
    }
 
    // Token: 0x06000459 RID: 1113 RVA: 0x0001D2D9 File Offset: 0x0001B4D9
    public static int ABS(int a)
    {
        if (a >= 0)
        {
            return a;
        }
        return -a;
    }
 
    // Token: 0x0600045A RID: 1114 RVA: 0x0001D2E3 File Offset: 0x0001B4E3
    public static int ZSGN(int a)
    {
        if (a < 0)
        {
            return -1;
        }
        if (a <= 0)
        {
            return 0;
        }
        return 1;
    }
 
    // Token: 0x0600045B RID: 1115 RVA: 0x0001D2F4 File Offset: 0x0001B4F4
    private static bool IsBlocked(int x, int z, int sx, int sz)
    {
        bool flag = false;
        if (x < 0 || z < 0 || x >= EClass._map.Size || z >= EClass._map.Size)
        {
            flag = true;
        }
        else
        {
            Cell cell = EClass._map.cells[x, z];
            byte[] weights = EClass._map.cells[x, z].weights;
            if ((sz == -1 && weights[0] == 0) || (sz == 1 && weights[2] == 0) || (sx == 1 && weights[1] == 0) || (sx == -1 && weights[3] == 0))
            {
                flag = true;
            }
            if (!flag && sx != 0 && sz != 0)
            {
                if (x + sx < 0 || z + sz < 0 || x + sx >= EClass._map.Size || z + sz >= EClass._map.Size)
                {
                    flag = true;
                }
                else
                {
                    byte[] weights2 = EClass._map.cells[x + sx, z + sz].weights;
                    if ((sz < 0 && weights2[2] == 0) || (sx > 0 && weights2[3] == 0))
                    {
                        flag = true;
                    }
                    if ((sz > 0 && weights2[0] == 0) || (sx < 0 && weights2[1] == 0))
                    {
                        flag = true;
                    }
                }
            }
            if (cell.blockSight)
            {
                flag = true;
            }
        }
        Los.p.Set(x, z);
        if (Los.onVisit != null)
        {
            Los.onVisit(Los.p, flag);
        }
        return flag;
    }
 
    // Token: 0x0600045C RID: 1116 RVA: 0x0001D424 File Offset: 0x0001B624
    public static List<Point> ListVisible(Point p1, Point p2, int radius, Action<Point, bool> _onVisit = null)
    {
        List<Point> list = new List<Point>();
        List<Point> vecs = new List<Point>();
        Point lastPoint = p1.Copy();
        Los.IsVisible(p1.x, p2.x, p1.z, p2.z, delegate(Point p, bool blocked)
        {
            Point point3 = new Point(p.x - lastPoint.x, p.z - lastPoint.z);
            if (point3.x != 0 || point3.z != 0)
            {
                vecs.Add(point3);
            }
            lastPoint.Set(p);
        }, false);
        if (vecs.Count == 0)
        {
            return list;
        }
        Point point = p1.Copy();
        for (int i = 0; i < radius; i++)
        {
            Point point2 = vecs[i % vecs.Count];
            point.x += point2.x;
            point.z += point2.z;
        }
        Los.IsVisible(p1.x, point.x, p1.z, point.z, delegate(Point p, bool blocked)
        {
            if (!blocked)
            {
                list.Add(p.Copy());
            }
            if (_onVisit != null)
            {
                _onVisit(p, blocked);
            }
        }, true);
        return list;
    }
 
    // Token: 0x0600045D RID: 1117 RVA: 0x0001D524 File Offset: 0x0001B724
    public static Point GetNearestNeighbor(Point p1, Point p2)
    {
        Point dest = null;
        Los.IsVisible(p1, p2, delegate(Point p, bool blocked)
        {
            if (!blocked && dest == null && p2.Distance(p) == 1 && !p.HasChara)
            {
                dest = new Point(p);
            }
        });
        return dest;
    }
 
    // Token: 0x0600045E RID: 1118 RVA: 0x0001D564 File Offset: 0x0001B764
    public static Point GetRushPoint(Point p1, Point dest)
    {
        Point rushPos = null;
        bool valid = true;
        Los.IsVisible(p1, dest, delegate(Point p, bool blocked)
        {
            if (p.Equals(dest) || p.Equals(p1))
            {
                return;
            }
            if (blocked || p.HasChara || p.IsBlocked)
            {
                valid = false;
            }
            if (p.Distance(dest) == 1)
            {
                rushPos = p.Copy();
            }
        });
        if (!valid)
        {
            return null;
        }
        return rushPos;
    }
 
    // Token: 0x0600045F RID: 1119 RVA: 0x0001D5C1 File Offset: 0x0001B7C1
    public static bool IsVisible(Point p1, Point p2, Action<Point, bool> _onVisit = null)
    {
        return Los.IsVisible(p1.x, p2.x, p1.z, p2.z, _onVisit, true);
    }
 
    // Token: 0x06000460 RID: 1120 RVA: 0x0001D5E2 File Offset: 0x0001B7E2
    public static bool IsVisible(Card c1, Card c2)
    {
        return Los.IsVisible(c1.pos.x, c2.pos.x, c1.pos.z, c2.pos.z, null, true);
    }
 
    // Token: 0x06000461 RID: 1121 RVA: 0x0001D618 File Offset: 0x0001B818
    public static bool IsVisible(int x1, int x2, int z1, int z2, Action<Point, bool> _onVisit = null, bool returnOnBlock = true)
    {
        Los.onVisit = _onVisit;
        Los.p.Set(x1, z1);
        Los.originalP.Set(x1, z1);
        int a = x2 - x1;
        int a2 = z2 - z1;
        int num = Los.ABS(a) << 1;
        int num2 = Los.ABS(a2) << 1;
        int num3 = Los.ZSGN(a);
        int num4 = Los.ZSGN(a2);
        int num5 = x1;
        int num6 = z1;
        if (num >= num2)
        {
            int num7 = num2 - (num >> 1);
            while (num5 != x2)
            {
                if (Los.IsBlocked(num5, num6, num3, (num7 >= 0) ? num4 : 0) && returnOnBlock)
                {
                    return false;
                }
                if (num7 >= 0)
                {
                    num6 += num4;
                    num7 -= num;
                }
                num5 += num3;
                num7 += num2;
            }
            Los.p.Set(num5, num6);
            if (Los.onVisit != null)
            {
                Los.onVisit(Los.p, false);
            }
            return true;
        }
        if (num2 >= num)
        {
            int num8 = num - (num2 >> 1);
            while (num6 != z2)
            {
                if (Los.IsBlocked(num5, num6, (num8 >= 0) ? num3 : 0, num4) && returnOnBlock)
                {
                    return false;
                }
                if (num8 >= 0)
                {
                    num5 += num3;
                    num8 -= num2;
                }
                num6 += num4;
                num8 += num;
            }
            Los.p.Set(num5, num6);
            if (Los.onVisit != null)
            {
                Los.onVisit(Los.p, false);
            }
            return true;
        }
        return false;
    }
 
    // Token: 0x040005DF RID: 1503
    public static Point p = new Point();
 
    // Token: 0x040005E0 RID: 1504
    public static Point originalP = new Point();
 
    // Token: 0x040005E1 RID: 1505
    public static Action<Point, bool> onVisit;
}
public class Los : EClass {…};