private static List<PathNode> GetNeighbours(PathNode pathNode, 
		Point goal, int[,] field)
	{
		var result = new List<PathNode>();

		// Соседними точками являются соседние по стороне клетки.
		Point[] neighbourPoints = new Point[4];
		neighbourPoints[0] = new Point(pathNode.Position.x + 1, pathNode.Position.y);
		neighbourPoints[1] = new Point(pathNode.Position.x - 1, pathNode.Position.y);
		neighbourPoints[2] = new Point(pathNode.Position.x, pathNode.Position.y + 1);
		neighbourPoints[3] = new Point(pathNode.Position.x, pathNode.Position.y - 1);

		foreach (var point in neighbourPoints)
		{
			// Проверяем, что не вышли за границы карты.
			if (point.x < 0 || point.x >= field.GetLength(0))
				continue;
			if (point.y < 0 || point.y >= field.GetLength(1))
				continue;
			// Проверяем, что по клетке можно ходить.
			if ((field[point.x, point.y] != 1) && (field[point.x, point.y] != 3))
				continue;
			// Заполняем данные для точки маршрута.
			var neighbourNode = new PathNode()
			{
				Position = point,
				CameFrom = pathNode,
				PathLengthFromStart = pathNode.PathLengthFromStart +
					GetDistanceBetweenNeighbours(),
				HeuristicEstimatePathLength = GetHeuristicPathLength(point, goal)
			};
			result.Add(neighbourNode);
		}
		return result;
	}

 /// <summary>Создаёт новый экземпляр класса <see cref="Movement"/>.</summary>
 /// <param name="board">Вся доска.</param>
 /// <param name="state">Прямоугольник отрисовки.</param>
 /// <param name="current">Текущая ячейка.</param>
 /// <param name="speed">Скорость перемещения.</param>
 /// <param name="sprite">Анимация объекта.</param>
 /// <param name="animation">Параметры анимации объекта.</param>
 public Movement(Rectangle state, Cell current, int speed, AnimateSprite sprite, PlayerAnimation animation, bool IsMagic)
 {
     IsEnd = true;
       _CurrentState = state;
       _Current = current;
       _Speed = speed;
       _Tile = sprite;
       _Animation = animation;
       _Field = Helper.Field;
       _Field = new PathNode[Helper.Board.GetLength(0), Helper.Board.GetLength(1)];
       bool pass;
       for (int i = 0; i < Helper.Board.GetLength(0); i++)
     for (int j = 0; j < Helper.Board.GetLength(1); j++)
     {
       if (IsMagic)
     pass = false;
       else
     pass = (Helper.Board[i, j].Type != CellType.Passable);
       _Field[i, j] = new PathNode()
       {
     IsWall = pass ,
     X = Helper.Board[i, j].Rect.X,
     Y = Helper.Board[i, j].Rect.Y,
     i = i,
     j = j,
       };
     }
 }

 /// <summary>
 /// Finds the shortest path, if any, between 2 nodes given the start node and the target node ID.
 /// </summary>
 /// <param name="start"></param>
 /// <param name="targetid"></param>
 /// <returns></returns>
 public static Path Find(PathNode start, uint targetid)
 {
     if (targetid != LastTarget)
         foreach (PathNode node in IDNodeMap.Values)
             node.Visited = false;
     return start.Find(targetid, start);
 }

 public void ClearPathfinding()
 {
     for( int i = 0; i < 4; ++i )
     {
         PathNodes[i] = new PathNode();
     }
 }

 public CharacterMoveReport(Character c, Vector3 s, Vector3 d, PathNode eop)
 {
     character = c;
     src = s;
     dest = d;
     endOfPath = eop;
 }

	//安裝Tag是WP的物件
	void SetupWPNode(){
		GameObject [] point = GameObject.FindGameObjectsWithTag ("WP");
		int pLenth = point.Length;
		m_NodeList = new PathNode[pLenth];
		string tNodeName = "";
		string [] s;
		int iWP;
		
		for (int i = 0; i < pLenth; i++) {
			PathNode pNode = new PathNode ();
			pNode.iNeibors = 0;
			pNode.NeiborsNode = null;
			pNode.fH = 0.0f;
			pNode.fG = 0.0f;
			pNode.fF = 0.0f;
			pNode.tParent = null;
			pNode.tPoint = point [i].transform.position;
			
			tNodeName = point [i].name;
			s = tNodeName.Split ('_');
			
			iWP = int.Parse (s [1]);
			pNode.iID = iWP;
			m_NodeList [iWP] = pNode;
		}
	}

 public void fillHFromNodes(PathNode targetNode)
 {
     foreach (var node in nodes)
     {
         node.FillH(targetNode);
     }
 }

 public PathNode(PathNode newNode)
 {
     this.prev = newNode.prev;
     this.pos = newNode.pos;
     this.totalDist = newNode.totalDist;
     this.distToTarget = newNode.distToTarget;
 }

	private void ResetGame() {
		DestroyAllNodes ();
		
		pathNodeBoundsRect = new Rect ();
		targetPathLength = 0;
		isGameOver = false;
		timeUntilGameEnds = 45f;
		scoreText.enabled = false;
		gameOverText.enabled = false;
		
		// Make the first TWO nodes.
		sourceNode = Instantiate (pathNodePrefab).GetComponent<PathNode> ();
		sourceNode.Initialize (this, Vector2.zero, null, 10, 0, 0, true, true);
		PathNode secondNode = Instantiate (pathNodePrefab).GetComponent<PathNode> ();
		secondNode.Initialize (this, new Vector2(0,-0.5f), null, 4, 50, 0, true, true);
		sourceNode.nextNodes.Add (secondNode);
		secondNode.previousNode = sourceNode;

		// Reset travelers!
		DestroyAllTravelers ();
//		travelers = new List<Traveler> ();
//		int NUM_TRAVELERS = 8;
//		for (int i=0; i<NUM_TRAVELERS; i++) {
//			AddTraveler();
//			Traveler newTraveler = Instantiate (travelerPrefab).GetComponent<Traveler>();
//			float charge = i<NUM_TRAVELERS*0.5f ? -1 : 1;
//			newTraveler.Initialize (this, worldGenerator.sourceNode, charge);
//			travelers.Add (newTraveler);
//		}
	}

        public static PathNode ReversePath(PathNode path)
        {
            // Get the current first element.
            // This will end up being our new last element.
            PathNode root = path;

            // The last element shouldn't have a backpointer
            // so this will start as null.
            PathNode next = null;

            // While we have elements to reverse...
            while (root != null)
            {
                // Get the next element.
                PathNode tmp = root.backPointer;

                // Set the current element's backpointer to our previous element.
                root.backPointer = next;

                // Set the next previous element to the current element.
                next = root;

                // Set the current element to our new element.
                root = tmp;
            }

            // Return the reversed list.
            return next;
        }

 public void SetVals(PathNode prev, Vector3 pos, float dist, float dist2)
 {
     this.prev = prev;
     this.pos = pos;
     this.totalDist = dist;
     this.distToTarget = dist2;
 }

        public virtual BinaryHeapNode Insert(PathNode data)
        {
            Nodes.Add(new BinaryHeapNode(data));
            FilterUp(Count - 1);

            return null;
        }

    public List<PathNode> GetPath(PathNode start, PathNode end)
    {
        WaypointManager wg = GameObject.Find ("WaypointManager").GetComponent<WaypointManager>();
        var sources = wg.pathNodes;

        if(start == null || end == null)
        {
            if (sources != null && sources.Count >= 2)
            {
                start 	= sources[PathNode.startNode]/*.GetComponent<PathNode>()*/;//.GetInnerObject();
                end 	= sources[PathNode.endNode]/*.GetComponent<PathNode>()*/;//.GetInnerObject();
            }

            if (start == null || end == null)
            {
                Debug.LogWarning("Need 'start' and or 'end' defined!");
                enabled = false;
                return null;
            }
        }

        startIndex = Closest(sources, start.position);

        endIndex = Closest(sources, end.position);

        return AStarHelper.Calculate(sources[startIndex]/*.GetComponent<PathNode>()*/, sources[endIndex]/*.GetComponent<PathNode>()*/);
    }

		/** Adds a node to the heap */
		public void Add(PathNode node) {
			
			if (node == null) throw new System.ArgumentNullException ("Sending null node to BinaryHeap");

			if (numberOfItems == binaryHeap.Length) {
				int newSize = System.Math.Max(binaryHeap.Length+4,(int)System.Math.Round(binaryHeap.Length*growthFactor));
				if (newSize > 1<<18) {
					throw new System.Exception ("Binary Heap Size really large (2^18). A heap size this large is probably the cause of pathfinding running in an infinite loop. " +
						"\nRemove this check (in BinaryHeap.cs) if you are sure that it is not caused by a bug");
				}

				PathNode[] tmp = new PathNode[newSize];

				for (int i=0;i<binaryHeap.Length;i++) {
					tmp[i] = binaryHeap[i];
				}
				binaryHeap = tmp;
				
				//Debug.Log ("Forced to discard nodes because of binary heap size limit, please consider increasing the size ("+numberOfItems +" "+binaryHeap.Length+")");
				//numberOfItems--;
			}

			PathNode obj = node;
			binaryHeap[numberOfItems] = obj;

			//node.heapIndex = numberOfItems;//Heap index

			int bubbleIndex = numberOfItems;
			uint nodeF = node.F;
			//Debug.Log ( "Adding node with " + nodeF + " to index " + numberOfItems);
			
			while (bubbleIndex != 0 ) {
				int parentIndex = (bubbleIndex-1) / D;

				//Debug.Log ("Testing " + nodeF + " < " + binaryHeap[parentIndex].F);

				if (nodeF < binaryHeap[parentIndex].F) {

				   	
					//binaryHeap[bubbleIndex].f <= binaryHeap[parentIndex].f) { /* \todo Wouldn't it be more efficient with '<' instead of '<=' ? * /
					//Node tmpValue = binaryHeap[parentIndex];
					
					//tmpValue.heapIndex = bubbleIndex;//HeapIndex
					
					binaryHeap[bubbleIndex] = binaryHeap[parentIndex];
					binaryHeap[parentIndex] = obj;
					
					//binaryHeap[bubbleIndex].heapIndex = bubbleIndex; //Heap index
					//binaryHeap[parentIndex].heapIndex = parentIndex; //Heap index
					
					bubbleIndex = parentIndex;
				} else {
					break;
				}
			}

			numberOfItems++;

			//Validate();
		}

	public static void LoadPathPointDesc (PathNode [] m_NodeList){

		TextAsset ta=(TextAsset)Resources.Load ("WayPoint");
		string [] sText=ta.text.Split("\n"[0]);
		int tLenth=sText.Length;
		string sID;
		string [] sText2;
		int iNeibor=0;

		for (int i=0; i<tLenth; i++) {
			sID = sText [i];
			sID = sID.Trim ();

			sText2 = sID.Split (" " [0]);
			if (sText2.Length < 1) {
				continue;
			}

			iNeibor = sText2.Length - 1;
			sID = sText2 [0];
			int iID = int.Parse (sID);

			m_NodeList [iID].iNeibors = iNeibor;
			m_NodeList [iID].NeiborsNode = new PathNode[iNeibor];

			for (int j=0; j<iNeibor; j++) {
				sID = sText2 [j + 1];
				int iNei = int.Parse (sID);
				m_NodeList [i].NeiborsNode [j] = m_NodeList [iNei];
			}
		}

	}

    private bool Search(PathNode currentNode)
    {
        currentNode.state = NodeState.Closed;
        List<PathNode> nextNodes = GetSiblingNodes(currentNode);

        // Sort by F-value so that the shortest possible routes are considered first
        nextNodes.Sort((node1, node2) => node1.F.CompareTo(node2.F));
        foreach (var nextNode in nextNodes)
        {
            // Check whether the end node has been reached
            if (nextNode.location == targetNode.location)
            {
                return true;
            }
            else
            {
                // If not, check the next set of nodes
                if (Search(nextNode)) // Note: Recurses back into Search(Node)
                    return true;
            }
        }

        // The method returns false if this path leads to be a dead end
        return false;
    }

 static void Main(string[] args)
 {
     string str = FileReader.ReadFile(FILENAME);
     string[] strArray = str.Replace("\n", "|").Split('|');
     int matrixWidth = strArray.Length;
     PathNode[][] matrix = new PathNode[matrixWidth][];
     for (int i = 0; i < strArray.Length; i++)
     {
         matrix[i] = new PathNode[matrixWidth];
         string line = strArray[i];
         string[] numStrs = line.Split(',');
         for (int j = 0; j < numStrs.Length; j++)
         {
             string numStr = numStrs[j];
             matrix[i][j] = new PathNode() { NodeValue = int.Parse(numStr), NodePathSum = 0 };
         }
     }
     matrix[matrixWidth - 1][matrixWidth - 1].NodePathSum = matrix[matrixWidth - 1][matrixWidth - 1].NodeValue;
     int currSub = 1;
     while (currSub < matrixWidth)
     {
         // 从下向上计算左侧
         int colIndex = matrixWidth - currSub - 1;
         int tempRowIndex = 0;
         for (int i = 0; i < currSub; i++)
         {
             tempRowIndex = matrixWidth - i - 1;
             // 下方
             long tempDownSum = long.MaxValue;
             if (i > 0)
             {
                 tempDownSum = matrix[tempRowIndex + 1][colIndex].NodePathSum;
             }
             // 右侧
             long tempRightSum = matrix[tempRowIndex][colIndex + 1].NodePathSum;
             matrix[tempRowIndex][colIndex].NodePathSum = matrix[tempRowIndex][colIndex].NodeValue + Math.Min(tempDownSum, tempRightSum);
         }
         // 从右向左计算顶部
         int rowIndex = matrixWidth - currSub - 1;
         int tempColumnIndex = 0;
         for (int i = 0; i < currSub; i++)
         {
             tempColumnIndex = matrixWidth - i - 1;
             // 下方
             long tempDownSum = matrix[rowIndex + 1][tempColumnIndex].NodePathSum;
             // 右侧
             long tempRightSum = long.MaxValue;
             if (i > 0)
             {
                 tempRightSum = matrix[rowIndex][tempColumnIndex + 1].NodePathSum;
             }
             matrix[rowIndex][tempColumnIndex].NodePathSum = matrix[rowIndex][tempColumnIndex].NodeValue + Math.Min(tempDownSum, tempRightSum);
         }
         // 计算左上角
         matrix[rowIndex][colIndex].NodePathSum = matrix[rowIndex][colIndex].NodeValue + Math.Min(matrix[rowIndex + 1][colIndex].NodePathSum, matrix[rowIndex][colIndex + 1].NodePathSum);
         currSub++;
     }
     Console.WriteLine("Result is {0}", matrix[0][0].NodePathSum);
 }

 public void createPathNode(GameObject square, GameObject goalSquare)
 {
     thisSquare = square;
     this.goalSquare = goalSquare;
     neighbors = findNeighbors();
     parent = null;
     // square.GetComponent<Renderer>().material.color = Color.red;
 }

    public static bool IsClearPath(PathNode node1, PathNode node2)
    {
        float dist = Vector3.Distance(node1.transform.position, node2.transform.position);
        Vector3 direction = node2.transform.position - node1.transform.position;
        direction.Normalize();

        return !Physics.Raycast(node1.transform.position, direction, dist, int.MaxValue);
    }

 public virtual void CharacterMovedIncremental(Character c, Vector3 src, Vector3 dest, PathNode endOfPath)
 {
     map.BroadcastMessage(
         "MovedCharacterIncremental",
         new CharacterMoveReport(c, src, dest, endOfPath),
         SendMessageOptions.DontRequireReceiver
     );
 }