Esempio n. 1
0
        private void RasterLine(int x0, int y0, int x1, int y1, ref BoardCellDynamicArray cells, out int flatDist, out int diagDist)
        {
            int num  = (x1 <= x0) ? -1 : 1;
            int num2 = (x1 - x0) * num;
            int num3 = (y1 <= y0) ? -1 : 1;
            int num4 = (y1 - y0) * num3;

            flatDist = 0;
            diagDist = 0;
            if (num2 > num4)
            {
                int num5 = num4 * 2 - num2;
                int num6 = num4 * 2;
                int num7 = (num4 - num2) * 2;
                int num8 = x0;
                int num9 = y0;
                while (num8 != x1)
                {
                    if (num5 <= 0)
                    {
                        num5 += num6;
                        num8 += num;
                        flatDist++;
                    }
                    else
                    {
                        num5 += num7;
                        num8 += num;
                        num9 += num3;
                        diagDist++;
                    }
                    this.AddCell(num8, num9, ref cells);
                }
            }
            else
            {
                int num10 = num2 * 2 - num4;
                int num11 = num2 * 2;
                int num12 = (num2 - num4) * 2;
                int num13 = x0;
                int num14 = y0;
                while (num14 != y1)
                {
                    if (num10 <= 0)
                    {
                        num10 += num11;
                        num14 += num3;
                        flatDist++;
                    }
                    else
                    {
                        num10 += num12;
                        num13 += num;
                        num14 += num3;
                        diagDist++;
                    }
                    this.AddCell(num13, num14, ref cells);
                }
            }
        }
Esempio n. 2
0
        public static List <SmartEntity> TraverseSpiralToFindTargets(int radius, int centerX, int centerZ, TargetingController.TargetValidator validator, object caller, bool returnFirstFound)
        {
            BoardCellDynamicArray boardCellDynamicArray = GameUtils.TraverseSpiral(radius, centerX, centerZ);
            List <SmartEntity>    list = new List <SmartEntity>();

            for (int i = 0; i < boardCellDynamicArray.Length; i++)
            {
                BoardCell boardCell = boardCellDynamicArray.Array[i];
                if (boardCell.Children != null)
                {
                    foreach (BoardItem current in boardCell.Children)
                    {
                        if (validator((SmartEntity)current.Data, caller))
                        {
                            list.Add((SmartEntity)current.Data);
                            if (returnFirstFound)
                            {
                                return(list);
                            }
                        }
                    }
                }
            }
            return(list);
        }
Esempio n. 3
0
        private void SmoothThePath(ref BoardCellDynamicArray rawTurns, ref BoardCellDynamicArray pathCells, ref BoardCellDynamicArray turns, List <int> turnDistances)
        {
            if (rawTurns.Length == 0)
            {
                Service.Logger.Error("SmoothThePath: Not expecting empty path!");
                return;
            }
            pathCells.Add(rawTurns.Array[0]);
            turns.Add(rawTurns.Array[0]);
            turnDistances.Add(0);
            if (rawTurns.Length == 1)
            {
                return;
            }
            if (rawTurns.Length == 2)
            {
                this.AddTurn(rawTurns.Array[0], rawTurns.Array[1], ref pathCells, ref turns, turnDistances);
                return;
            }
            BoardCell boardCell  = rawTurns.Array[0];
            BoardCell boardCell2 = rawTurns.Array[1];

            for (int i = 2; i < rawTurns.Length; i++)
            {
                BoardCell boardCell3 = rawTurns.Array[i];
                if (!BoardUtils.HasLineOfClearance(this.board, boardCell.X, boardCell.Z, boardCell3.X, boardCell3.Z, this.TroopWidth))
                {
                    this.AddTurn(boardCell, boardCell2, ref pathCells, ref turns, turnDistances);
                    boardCell = boardCell2;
                }
                boardCell2 = boardCell3;
            }
            this.AddTurn(boardCell, boardCell2, ref pathCells, ref turns, turnDistances);
        }
Esempio n. 4
0
        private void AddTurn(BoardCell legStart, BoardCell legEnd, ref BoardCellDynamicArray pathCells, ref BoardCellDynamicArray turns, List <int> turnDistances)
        {
            turns.Add(legEnd);
            int num  = 0;
            int num2 = 0;

            this.RasterLine(legStart.X, legStart.Z, legEnd.X, legEnd.Z, ref pathCells, out num, out num2);
            turnDistances.Add(num * 1000 + num2 * 1414);
        }
Esempio n. 5
0
 private void AddCell(int x, int y, ref BoardCellDynamicArray cells)
 {
     x += 23;
     if (x >= 0 && x < 46)
     {
         y += 23;
         if (y >= 0 && y < 46)
         {
             BoardCell element = this.board.Cells[x, y];
             cells.Add(element);
         }
     }
 }
Esempio n. 6
0
        public bool FindValidDropShipTroopPlacementCell(IntPosition boardPosition, TeamType teamType, int troopWidth, out IntPosition newBoardPosition)
        {
            BoardCellDynamicArray boardCellDynamicArray = GameUtils.TraverseSpiral(2, boardPosition.x, boardPosition.z);

            newBoardPosition = IntPosition.Zero;
            this.boardController.Board.RefreshClearanceMap();
            for (int i = 0; i < boardCellDynamicArray.Length; i++)
            {
                BoardCell boardCell = boardCellDynamicArray.Array[i];
                if (boardCell != null && boardCell.Clearance >= troopWidth && !boardCell.CollidesWith(CollisionFilters.TROOP))
                {
                    newBoardPosition = new IntPosition(boardCell.X, boardCell.Z);
                    return(true);
                }
            }
            return(false);
        }
Esempio n. 7
0
        public Path(BoardCell fromCell, BoardCell toCell, BoardCell targetAt, int maxLength, PathTroopParams troopParams, PathBoardParams boardParams)
        {
            this.pathCells     = new BoardCellDynamicArray(64);
            this.scratchCells  = new BoardCellDynamicArray(64);
            this.turns         = new BoardCellDynamicArray(64);
            this.turnDistances = new List <int>(64);
            BoardController boardController = Service.BoardController;

            this.board                 = boardController.Board;
            this.pathingManager        = Service.PathingManager;
            this.startCell             = fromCell;
            this.destCell              = toCell;
            this.targetCell            = targetAt;
            this.NoWall                = (boardParams.IgnoreWall || troopParams.CrushesWalls);
            this.crushesWalls          = troopParams.CrushesWalls;
            this.destructible          = boardParams.Destructible;
            this.isHealer              = troopParams.IsHealer;
            this.TroopWidth            = troopParams.TroopWidth;
            this.damagePerSecond       = troopParams.DPS;
            this.maxShooterRange       = troopParams.MaxRange;
            this.targetInRangeModifier = troopParams.TargetInRangeModifier;
            if (this.isHealer && this.maxShooterRange > troopParams.SupportRange)
            {
                this.maxShooterRange = troopParams.SupportRange;
            }
            this.minShooterRange    = troopParams.MinRange;
            this.maxSpeed           = troopParams.MaxSpeed;
            this.heristicMultiplier = (int)troopParams.PathSearchWidth;
            this.maxPathLength      = ((!this.isHealer) ? maxLength : -1);
            this.melee                        = troopParams.IsMelee;
            this.overWalls                    = troopParams.IsOverWall;
            this.projectileType               = troopParams.ProjectileType;
            this.isTargetShield               = troopParams.IsTargetShield;
            this.openCells                    = new HeapPriorityQueue(boardController.GetPriorityQueueSize());
            this.curPathingCell               = this.pathingManager.GetPathingCell();
            this.curPathingCell.Cell          = this.startCell;
            this.startCell.PathInfo           = this.curPathingCell;
            this.curPathingCell.InRange       = this.InRangeOfTarget(this.startCell);
            this.curPathingCell.RemainingCost = this.HeuristicDiagonal(this.startCell, this.destCell);
            this.curPathingCell.PathLength    = 0;
            this.curPathingCell.PastCost      = 0;
            this.curPathingCell.InClosedSet   = true;
        }
Esempio n. 8
0
        public BoardCellDynamicArray GetCellsInSquare(int distFromCenter, int centerX, int centerZ)
        {
            BoardCellDynamicArray result = new BoardCellDynamicArray(distFromCenter * distFromCenter);
            int num  = centerX - distFromCenter;
            int num2 = centerX + distFromCenter;
            int num3 = centerZ - distFromCenter;
            int num4 = centerZ + distFromCenter;

            for (int i = num; i <= num2; i++)
            {
                for (int j = num3; j <= num4; j++)
                {
                    BoardCell cellAt = this.GetCellAt(i, j);
                    if (cellAt != null)
                    {
                        result.Add(cellAt);
                    }
                }
            }
            return(result);
        }
Esempio n. 9
0
        private void ImpactAreaWithSplash(Bullet bullet)
        {
            int targetBoardX = bullet.TargetBoardX;
            int targetBoardZ = bullet.TargetBoardZ;
            int splashRadius = bullet.SplashVO.SplashRadius;
            BoardCellDynamicArray     cellsInSquare = Service.BoardController.Board.GetCellsInSquare(splashRadius, targetBoardX, targetBoardZ);
            Dictionary <Entity, bool> dictionary    = new Dictionary <Entity, bool>();
            Vector3 targetWorldLocation             = bullet.TargetWorldLocation;

            for (int i = 0; i < cellsInSquare.Length; i++)
            {
                BoardCell boardCell           = cellsInSquare.Array[i];
                int       chessboardDistance  = BoardUtils.GetChessboardDistance(boardCell.X, boardCell.Z, targetBoardX, targetBoardZ);
                int       splashDamagePercent = bullet.SplashVO.GetSplashDamagePercent(chessboardDistance);
                if (splashDamagePercent != 0)
                {
                    ShieldGeneratorComponent activeShieldAffectingBoardPos = Service.ShieldController.GetActiveShieldAffectingBoardPos(boardCell.X, boardCell.Z);
                    if (activeShieldAffectingBoardPos != null && !bullet.ProjectileType.PassThroughShield && activeShieldAffectingBoardPos.Entity.Get <TeamComponent>().TeamType != bullet.OwnerTeam)
                    {
                        TransformComponent transformComponent = activeShieldAffectingBoardPos.Entity.Get <TransformComponent>();
                        Vector3            targetPos          = new Vector3(Units.BoardToWorldX(transformComponent.CenterX()), transformComponent.CenterX(), Units.BoardToWorldZ(transformComponent.CenterZ()));
                        Vector3            zero = Vector3.zero;
                        if (Service.ShieldController.GetRayShieldIntersection(targetWorldLocation, targetPos, activeShieldAffectingBoardPos, out zero))
                        {
                            bullet.SetTargetWorldLocation(zero);
                        }
                        this.ImpactTargetFromSplashDamage((SmartEntity)activeShieldAffectingBoardPos.ShieldBorderEntity, bullet, splashDamagePercent, ref dictionary);
                    }
                    else if (boardCell.Children != null)
                    {
                        LinkedListNode <BoardItem> next;
                        for (LinkedListNode <BoardItem> linkedListNode = boardCell.Children.First; linkedListNode != null; linkedListNode = next)
                        {
                            next = linkedListNode.Next;
                            this.ImpactTargetFromSplashDamage((SmartEntity)linkedListNode.Value.Data, bullet, splashDamagePercent, ref dictionary);
                        }
                    }
                }
            }
        }
Esempio n. 10
0
        private BoardCellDynamicArray FindTheTurns(ref BoardCellDynamicArray path)
        {
            BoardCellDynamicArray result = new BoardCellDynamicArray(64);
            int length = path.Length;

            result.Add(path.Array[length - 1]);
            for (int i = length - 2; i > 0; i--)
            {
                BoardCell boardCell  = path.Array[i];
                BoardCell boardCell2 = path.Array[i + 1];
                BoardCell boardCell3 = path.Array[i - 1];
                if (boardCell.X - boardCell2.X != boardCell3.X - boardCell.X || boardCell.Z - boardCell2.Z != boardCell3.Z - boardCell.Z)
                {
                    result.Add(boardCell);
                }
            }
            if (length >= 2)
            {
                result.Add(path.Array[0]);
            }
            return(result);
        }
Esempio n. 11
0
        private bool ImpactBeamTargets(Bullet bullet)
        {
            BoardCellDynamicArray beamNearbyCells = bullet.GetBeamNearbyCells();

            if (beamNearbyCells.Array == null)
            {
                return(false);
            }
            for (int i = 0; i < beamNearbyCells.Length; i++)
            {
                BoardCell boardCell = beamNearbyCells.Array[i];
                if (boardCell.Children != null)
                {
                    int beamDamagePercent = bullet.GetBeamDamagePercent(boardCell.X, boardCell.Z);
                    if (beamDamagePercent != 0)
                    {
                        for (LinkedListNode <BoardItem> linkedListNode = boardCell.Children.First; linkedListNode != null; linkedListNode = linkedListNode.Next)
                        {
                            SmartEntity target = (SmartEntity)linkedListNode.Value.Data;
                            bullet.ApplyBeamDamagePercent(target, beamDamagePercent);
                        }
                    }
                }
            }
            foreach (BeamTarget current in bullet.BeamTargets.Values)
            {
                if (current.HitThisSegment)
                {
                    bullet.SetTarget(current.Target);
                    this.ImpactSingleTarget(bullet, current.CurDamagePercent, false, true);
                    bullet.SetTarget(null);
                }
                current.OnBeamAdvance();
            }
            bullet.AdvanceBeam();
            return(true);
        }
Esempio n. 12
0
        private void CreateSpawnMesh()
        {
            Board board = Service.BoardController.Board;

            if (this.meshCells.Array == null)
            {
                this.meshCells = new BoardCellDynamicArray(16);
            }
            IState currentState = Service.GameStateMachine.CurrentState;
            bool   flag         = currentState is HomeState || currentState is EditBaseState || currentState is ApplicationLoadState;
            int    i            = 0;
            int    boardSize    = board.BoardSize;

            while (i < boardSize)
            {
                for (int j = 0; j < boardSize; j++)
                {
                    BoardCell cellAt = board.GetCellAt(i, j, true);
                    if ((cellAt.Flags & 4u) != 0u || (!flag && (cellAt.Flags & 16u) != 0u))
                    {
                        this.meshCells.Add(cellAt);
                    }
                }
                i++;
            }
            int num       = 23;
            int num2      = 47;
            int quadCount = this.meshCells.Length + num2 * 4;

            Vector3[] vertices;
            Vector2[] uv;
            int[]     triangles;
            UnityUtils.SetupVerticesForQuads(quadCount, out vertices, out uv, out triangles);
            int num3   = 0;
            int k      = 0;
            int length = this.meshCells.Length;

            while (k < length)
            {
                BoardCell boardCell = this.meshCells.Array[k];
                this.SetGridQuadVertices(boardCell.X, boardCell.Z, num3++, vertices);
                k++;
            }
            this.meshCells.Clear();
            int num4 = -num - 1;
            int num5 = num;
            int l    = 0;
            int num6 = num4;
            int num7 = num5;

            while (l < num2)
            {
                this.SetGridQuadVertices(num4, num6, num3++, vertices);
                this.SetGridQuadVertices(num6, num5, num3++, vertices);
                this.SetGridQuadVertices(num5, num7, num3++, vertices);
                this.SetGridQuadVertices(num7, num4, num3++, vertices);
                l++;
                num6++;
                num7--;
            }
            this.mesh = UnityUtils.CreateMeshWithVertices(vertices, uv, triangles);
        }
Esempio n. 13
0
        public LinkedList <Entity> GetBlockingEntities(uint targetId, out LinkedList <Entity> wallListForCrushing)
        {
            HashSet <uint>        entityIds             = new HashSet <uint>();
            LinkedList <Entity>   linkedList            = new LinkedList <Entity>();
            LinkedList <Entity>   linkedList2           = new LinkedList <Entity>();
            BoardCellDynamicArray boardCellDynamicArray = new BoardCellDynamicArray(64);

            for (int i = 0; i < this.pathCells.Length; i++)
            {
                BoardCell boardCell = this.pathCells.Array[i];
                int       num       = (!this.NoWall || this.crushesWalls) ? boardCell.Clearance : boardCell.ClearanceNoWall;
                if (num < this.TroopWidth)
                {
                    int x;
                    int y;
                    if (i == 0)
                    {
                        if (this.pathCells.Length <= 1)
                        {
                            break;
                        }
                        x = boardCell.X * 2 - this.pathCells.Array[1].X;
                        y = boardCell.Z * 2 - this.pathCells.Array[1].Z;
                    }
                    else
                    {
                        x = this.pathCells.Array[i - 1].X;
                        y = this.pathCells.Array[i - 1].Z;
                    }
                    this.RasterCrossSection(x, y, boardCell.X, boardCell.Z, this.TroopWidth, ref boardCellDynamicArray);
                }
            }
            for (int j = 0; j < boardCellDynamicArray.Length; j++)
            {
                this.AddEntitiesOnCellToBlockingList(boardCellDynamicArray.Array[j], targetId, entityIds, linkedList, linkedList2, true);
            }
            if (!this.melee)
            {
                boardCellDynamicArray.Clear();
                int         num2 = 0;
                int         num3 = 0;
                int         halfWidthForOffset = BoardUtils.GetHalfWidthForOffset(this.TroopWidth);
                BoardCell   boardCell2         = this.pathCells.Array[this.pathCells.Length - 1];
                int         num4        = boardCell2.X + halfWidthForOffset;
                int         num5        = boardCell2.Z + halfWidthForOffset;
                SmartEntity smartEntity = null;
                bool        flag        = true;
                if (this.isTargetShield)
                {
                    foreach (BoardItem current in this.targetCell.Children)
                    {
                        if (GameUtils.IsEntityShieldGenerator((SmartEntity)current.Data))
                        {
                            smartEntity = (SmartEntity)current.Data;
                            break;
                        }
                    }
                    if (smartEntity == null)
                    {
                        Service.Logger.Error("Pathing believes target is shield generator, however targetCell does not have shield generator entity.");
                    }
                    else
                    {
                        flag = Service.ShieldController.IsPositionUnderShield(num4, num5, smartEntity);
                    }
                }
                this.RasterLine(num4, num5, this.targetCell.X, this.targetCell.Z, ref boardCellDynamicArray, out num2, out num3);
                for (int k = 0; k < boardCellDynamicArray.Length - 1; k++)
                {
                    if (this.isTargetShield && !flag && Service.ShieldController.IsPositionUnderShield(boardCellDynamicArray.Array[k].X, boardCellDynamicArray.Array[k].Z, smartEntity))
                    {
                        break;
                    }
                    this.AddEntitiesOnCellToBlockingList(boardCellDynamicArray.Array[k], targetId, entityIds, linkedList, linkedList2, false);
                }
            }
            wallListForCrushing = linkedList2;
            return(linkedList);
        }
Esempio n. 14
0
        private int RasterCrossSection(int x0, int y0, int x1, int y1, int size, ref BoardCellDynamicArray cells)
        {
            if (size == 1)
            {
                this.AddCell(x1, y1, ref cells);
                return(1);
            }
            int num  = x1 - x0;
            int num2 = y1 - y0;

            if (num > 0 && num2 == 0)
            {
                int i    = y1;
                int num3 = y1 + size;
                while (i < num3)
                {
                    this.AddCell(x1 + 1, i, ref cells);
                    i++;
                }
                return(size);
            }
            if (num < 0 && num2 == 0)
            {
                int j    = y1;
                int num4 = y1 + size;
                while (j < num4)
                {
                    this.AddCell(x1, j, ref cells);
                    j++;
                }
                return(size);
            }
            if (num == 0 && num2 > 0)
            {
                int k    = x1;
                int num5 = x1 + size;
                while (k < num5)
                {
                    this.AddCell(k, y1 + 1, ref cells);
                    k++;
                }
                return(size);
            }
            if (num == 0 && num2 < 0)
            {
                int l    = x1;
                int num6 = x1 + size;
                while (l < num6)
                {
                    this.AddCell(l, y1, ref cells);
                    l++;
                }
                return(size);
            }
            if (num > 0 && num2 < 0)
            {
                int num7  = 1;
                int num8  = x1;
                int num9  = y1 + size - 1;
                int num10 = x1 + size - 1;
                while (num8 < num10 && num9 > y1)
                {
                    this.AddCell(num8, y1, ref cells);
                    this.AddCell(x1 + 1, num9, ref cells);
                    num7 += 2;
                    num8++;
                    num9--;
                }
                this.AddCell(x1 + 1, y1, ref cells);
                return(num7);
            }
            if (num < 0 && num2 < 0)
            {
                int num7  = 1;
                int num11 = x1 + size - 1;
                int num12 = y1 + size - 1;
                while (num11 > x1 && num12 > y1)
                {
                    this.AddCell(num11, y1, ref cells);
                    this.AddCell(x1, num12, ref cells);
                    num7 += 2;
                    num11--;
                    num12--;
                }
                this.AddCell(x1, y1, ref cells);
                return(num7);
            }
            if (num < 0 && num2 > 0)
            {
                int num7  = 1;
                int num13 = x1 + size - 1;
                int num14 = y1;
                int num15 = y1 + size - 1;
                while (num13 > x1 && num14 < num15)
                {
                    this.AddCell(num13, y1 + 1, ref cells);
                    this.AddCell(x1, num14, ref cells);
                    num7 += 2;
                    num13--;
                    num14++;
                }
                this.AddCell(x1, y1 + 1, ref cells);
                return(num7);
            }
            if (num > 0 && num2 > 0)
            {
                int num7  = 1;
                int num16 = x1;
                int num17 = y1;
                int num18 = y1 + size - 1;
                while (num16 < x1 + size - 1 && num17 < num18)
                {
                    this.AddCell(num16, y1 + 1, ref cells);
                    this.AddCell(x1 + 1, num17, ref cells);
                    num7 += 2;
                    num16++;
                    num17++;
                }
                this.AddCell(x1 + 1, y1 + 1, ref cells);
                return(num7);
            }
            return(0);
        }
Esempio n. 15
0
        private int CostToNeighbor(BoardCell fromCell, BoardCell toCell, ref BoardCellDynamicArray cells)
        {
            int num;

            if (fromCell.X != toCell.X && fromCell.Z != toCell.Z)
            {
                num = 1414;
            }
            else
            {
                num = 1000;
            }
            int num2 = num * 10 / this.maxSpeed;
            int num3 = this.TroopWidth - ((!this.NoWall) ? toCell.Clearance : toCell.ClearanceNoWall);

            if (num3 > 0)
            {
                int num4 = this.RasterCrossSection(fromCell.X, fromCell.Z, toCell.X, toCell.Z, this.TroopWidth, ref cells);
                for (int i = 0; i < num4; i++)
                {
                    BoardCell boardCell = cells.Array[i];
                    uint      flags     = boardCell.Flags;
                    if ((flags & 3u) != 0u)
                    {
                        if (!this.NoWall || (flags & 1u) != 0u)
                        {
                            if ((flags & 64u) != 0u || this.isHealer)
                            {
                                num2 = 2147483647;
                                break;
                            }
                            HealthComponent buildingHealth = boardCell.BuildingHealth;
                            if (buildingHealth != null && this.damagePerSecond != 0)
                            {
                                ArmorType armorType = buildingHealth.ArmorType;
                                int       num5      = 100;
                                if (this.projectileType != null)
                                {
                                    int num6 = this.projectileType.DamageMultipliers[(int)armorType];
                                    if (num6 >= 0)
                                    {
                                        num5 = num6;
                                    }
                                    else
                                    {
                                        Service.Logger.ErrorFormat("ArmorType {0} not found in ProjectileType {1}", new object[]
                                        {
                                            armorType,
                                            this.projectileType.Uid
                                        });
                                    }
                                }
                                int num7 = this.damagePerSecond * num5 / 100;
                                if (num7 <= 0)
                                {
                                    num2 = 2147483647;
                                    break;
                                }
                                num2 += buildingHealth.Health * 1000 / num7;
                            }
                        }
                    }
                }
                cells.Clear();
            }
            return(num2);
        }
Esempio n. 16
0
        private void CalculatePath(out bool found, ref BoardCellDynamicArray scratchCells)
        {
            int num = 46 - this.TroopWidth;

            while (!this.curPathingCell.InRange)
            {
                if (this.maxPathLength < 0 || this.curPathingCell.PathLength < this.maxPathLength)
                {
                    BoardCell cell = this.curPathingCell.Cell;
                    int       x    = cell.X;
                    int       z    = cell.Z;
                    for (int i = 0; i < 8; i++)
                    {
                        int num2 = x + Path.dirX[i];
                        if (num2 >= 0 && num2 <= num)
                        {
                            int num3 = z + Path.dirY[i];
                            if (num3 >= 0 && num3 <= num)
                            {
                                BoardCell boardCell = this.board.Cells[num2, num3];
                                if ((boardCell.Flags & 64u) == 0u)
                                {
                                    if (!this.destructible)
                                    {
                                        int num4 = (!this.NoWall) ? boardCell.Clearance : boardCell.ClearanceNoWall;
                                        if (this.TroopWidth > num4)
                                        {
                                            goto IL_29A;
                                        }
                                    }
                                    int num5 = this.CostToNeighbor(cell, boardCell, ref scratchCells);
                                    if (num5 != 2147483647)
                                    {
                                        int num6       = this.curPathingCell.PastCost + num5;
                                        int pathLength = this.curPathingCell.PathLength + 1;
                                        PathfindingCellInfo pathfindingCellInfo = boardCell.PathInfo;
                                        if (pathfindingCellInfo != null && pathfindingCellInfo.PoolIndex < this.pathingManager.FreeCellIndex)
                                        {
                                            if (!pathfindingCellInfo.InClosedSet)
                                            {
                                                if (!this.openCells.Contains(pathfindingCellInfo))
                                                {
                                                    Service.Logger.ErrorFormat("Allocated cell not in close/open sets,PoolIndex:{0}, FreeIndex:{1}", new object[]
                                                    {
                                                        pathfindingCellInfo.PoolIndex,
                                                        this.pathingManager.FreeCellIndex
                                                    });
                                                }
                                                else if (num6 < pathfindingCellInfo.PastCost)
                                                {
                                                    pathfindingCellInfo.PastCost   = num6;
                                                    pathfindingCellInfo.PathLength = pathLength;
                                                    this.openCells.UpdatePriority(pathfindingCellInfo, pathfindingCellInfo.PastCost + pathfindingCellInfo.RemainingCost);
                                                }
                                            }
                                        }
                                        else
                                        {
                                            pathfindingCellInfo          = this.pathingManager.GetPathingCell();
                                            pathfindingCellInfo.PrevCell = this.curPathingCell;
                                            if (boardCell.PathInfo != null)
                                            {
                                                PathfindingCellInfo pathInfo = boardCell.PathInfo;
                                                pathInfo.Cell = null;
                                            }
                                            pathfindingCellInfo.Cell          = boardCell;
                                            boardCell.PathInfo                = pathfindingCellInfo;
                                            pathfindingCellInfo.InRange       = this.InRangeOfTarget(boardCell);
                                            pathfindingCellInfo.RemainingCost = this.HeuristicDiagonal(boardCell, this.destCell);
                                            pathfindingCellInfo.PastCost      = num6;
                                            pathfindingCellInfo.PathLength    = pathLength;
                                            this.openCells.Enqueue(pathfindingCellInfo, pathfindingCellInfo.PastCost + pathfindingCellInfo.RemainingCost);
                                        }
                                    }
                                }
                            }
                        }
                        IL_29A :;
                    }
                }
                if (this.openCells.Count == 0)
                {
                    this.pathingManager.RecycleAllPathingCells();
                    this.openCells = null;
                    found          = false;
                    scratchCells.Clear();
                    return;
                }
                this.curPathingCell             = this.openCells.Dequeue();
                this.curPathingCell.InClosedSet = true;
            }
            if (!this.curPathingCell.InRange)
            {
                this.pathingManager.RecycleAllPathingCells();
                this.openCells = null;
                found          = false;
                scratchCells.Clear();
                return;
            }
            do
            {
                scratchCells.Add(this.curPathingCell.Cell);
                this.curPathingCell = this.curPathingCell.PrevCell;
            }while (this.curPathingCell != null);
            int length = scratchCells.Length;

            if (length == 0)
            {
                Service.Logger.ErrorFormat("Empth Path from {0} to {1} within range {2}", new object[]
                {
                    this.startCell,
                    this.destCell,
                    this.maxShooterRange
                });
            }
            if (scratchCells.Array[length - 1] != this.startCell)
            {
                Service.Logger.ErrorFormat("First cell doesn't match: {0} and {1}", new object[]
                {
                    this.startCell,
                    scratchCells.Array[length - 1]
                });
            }
            BoardCellDynamicArray boardCellDynamicArray = this.FindTheTurns(ref scratchCells);

            this.SmoothThePath(ref boardCellDynamicArray, ref this.pathCells, ref this.turns, this.turnDistances);
            this.pathingManager.RecycleAllPathingCells();
            this.openCells = null;
            found          = true;
            scratchCells.Clear();
        }