Esempio n. 1
0
 /// <summary>
 ///
 /// </summary>
 /// <param name="entity"></param>
 /// <param name="cellId"></param>
 /// <param name="path"></param>
 /// <returns></returns>
 public MovementPath DecodeMovement(AbstractEntity entity, int cellId, string path)
 {
     return(Pathfinding.IsValidPath(entity, this, cellId, path));
 }
Esempio n. 2
0
 /// <summary>
 ///
 /// </summary>
 /// <param name="character"></param>
 /// <param name="cellId"></param>
 /// <param name="monsters"></param>
 /// <returns></returns>
 public bool CanBeAggro(CharacterEntity character, int cellId, MonsterGroupEntity monsters)
 {
     return(Pathfinding.GoalDistance(this, cellId, monsters.CellId) <= monsters.AggressionRange &&
            ((character.AlignmentId == (int)AlignmentTypeEnum.ALIGNMENT_NEUTRAL && monsters.AlignmentId == -1) ||
             (character.AlignmentId != (int)AlignmentTypeEnum.ALIGNMENT_NEUTRAL && monsters.AlignmentId != character.AlignmentId)));
 }
Esempio n. 3
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="StartCell"></param>
        /// <param name="EndCell"></param>
        /// <param name="Diagonal"></param>
        /// <param name="MovementPoints"></param>
        /// <param name="Obstacles"></param>
        /// <returns></returns>
        private IEnumerable <int> FindPath(int StartCell, int EndCell, bool Diagonal, int MovementPoints = -1, IEnumerable <int> Obstacles = null)
        {
            bool Success = false;

            PathNode[]           CalcGrid   = new PathNode[map.Cells.Count + 1];
            PriorityQueueB <int> OpenList   = new PriorityQueueB <int>(new ComparePFNodeMatrix(CalcGrid));
            List <PathNode>      ClosedList = new List <PathNode>();

            Point StartPoint = Pathfinding.GetPoint(map, StartCell);
            Point EndPoint   = Pathfinding.GetPoint(map, EndCell);

            int   BestLocation     = StartCell;
            int   Location         = StartCell;
            Point LocationPoint    = Pathfinding.GetPoint(map, Location);
            int   NewLocation      = 0;
            Point NewLocationPoint = default(Point);

            double NewG    = 0;
            int    Counter = 0;

            OpenList.Clear();
            ClosedList.Clear();

            if (MovementPoints == 0)
            {
                return(new List <int>());
            }

            CalcGrid[Location].Cell   = Location;
            CalcGrid[Location].G      = 0;
            CalcGrid[Location].F      = estimatedHeuristic;
            CalcGrid[Location].Parent = -1;
            CalcGrid[Location].Status = NodeState.InOpenList;

            OpenList.Push(Location);
            while (OpenList.Count > 0 && !Success)
            {
                Location      = OpenList.Pop();
                LocationPoint = Pathfinding.GetPoint(map, Location);

                if (CalcGrid[Location].Status == NodeState.InCloseList)
                {
                    continue;
                }

                if (Location == EndCell)
                {
                    CalcGrid[Location].Status = NodeState.InCloseList;
                    Success = true;
                    break; // TODO: might not be correct. Was : Exit While
                }

                for (int i = 0; i <= (Diagonal ? 8 - 1 : 4 - 1); i++)
                {
                    NewLocation = Location + directions[i];
                    if (Pathfinding.GetPoint(map, NewLocation).X == -1000)
                    {
                        continue;
                    }
                    NewLocationPoint = Pathfinding.GetPoint(map, NewLocation);

                    if ((NewLocation >= cellCount))
                    {
                        continue;
                    }

                    if ((!map.IsWalkable(NewLocation) || (Obstacles != null && Obstacles.Contains(NewLocation))) && NewLocation != EndCell)
                    {
                        continue;
                    }

                    NewG = CalcGrid[Location].G + 1;
                    // 1 should be the cost of the cell, but it's always 1

                    if (CalcGrid[NewLocation].Status == NodeState.InOpenList || CalcGrid[NewLocation].Status == NodeState.InCloseList)
                    {
                        if (CalcGrid[NewLocation].G <= NewG)
                        {
                            continue;
                        }
                    }

                    CalcGrid[NewLocation].Cell   = NewLocation;
                    CalcGrid[NewLocation].Parent = Location;
                    CalcGrid[NewLocation].G      = NewG;

                    var    xDiff = Math.Abs(NewLocationPoint.X - EndPoint.X);
                    var    yDiff = Math.Abs(NewLocationPoint.Y - EndPoint.Y);
                    double H     = xDiff + yDiff;

                    var Xbegin   = StartPoint.X;
                    var Xend     = EndPoint.X;
                    var Xcurrent = NewLocationPoint.X;
                    var Ycurrent = NewLocationPoint.Y;
                    var Ybegin   = StartPoint.Y;
                    var Yend     = EndPoint.Y;

                    var XdiffCurrentEnd = Xcurrent - Xend;
                    var XdiffStartEnd   = Xbegin - Xend;
                    var YdiffCurrentEnd = Ycurrent - Yend;
                    var YdiffStartEnd   = Ybegin - Yend;

                    var Cross = Math.Abs(XdiffCurrentEnd * YdiffStartEnd - XdiffStartEnd * YdiffCurrentEnd);

                    CalcGrid[NewLocation].F = NewG + H + Cross;
                    OpenList.Push(NewLocation);

                    CalcGrid[NewLocation].Status = NodeState.InOpenList;
                }

                if (BestLocation == -1 || Pathfinding.GoalDistance(map, Location, EndCell) < Pathfinding.GoalDistance(map, BestLocation, EndCell))
                {
                    BestLocation = Location;
                }

                Counter += 1;
                CalcGrid[Location].Status = NodeState.InCloseList;
            }

            if (!Success)
            {
                EndCell = BestLocation;
            }

            var Node = CalcGrid[EndCell];

            while (Node.Parent != -1)
            {
                ClosedList.Add(Node);

                Node = CalcGrid[Node.Parent];
            }

            ClosedList.Add(Node);

            ClosedList.Reverse();

            if (MovementPoints > 0 && ClosedList.Count - 1 >= MovementPoints)
            {
                return(ClosedList.Take(MovementPoints + 1).Select(node => node.Cell));
            }

            return(ClosedList.Select(node => node.Cell));
        }