Claim() public method

public Claim ( System o ) : void
o System
return void
Exemplo n.º 1
0
        /** Force recalculation of the current path.
         * If there is an ongoing path calculation, it will be canceled (so make sure you leave time for the paths to get calculated before calling this function again).
         */
        public virtual void UpdatePath()
        {
            canSearchPath      = true;
            waitingForPathCalc = false;
            Path p = seeker.GetCurrentPath();

            //Cancel any eventual pending pathfinding request
            if (p != null && !seeker.IsDone())
            {
                p.Error();
                // Make sure it is recycled. We won't receive a callback for this one since we
                // replace the path directly after this
                p.Claim(this);
                p.Release(this);
            }

            waitingForPathCalc = true;
            lastRepath         = Time.time;

            if (target != null)
            {
                seeker.StartPath(tr.position, target.position);
            }

//          seeker.StartPath(tr.position, targetPosition);
        }
Exemplo n.º 2
0
 private void OnPathComplete(Path p)
 {
     this.waitingForPathCalc = false;
     p.Claim(this);
     if (p.error)
     {
         p.Release(this, false);
     }
     else
     {
         if (this.traversingSpecialPath)
         {
             this.delayUpdatePath = true;
         }
         else
         {
             if (this.rp == null)
             {
                 this.rp = new RichPath();
             }
             this.rp.Initialize(this.seeker, p, true, this.funnelSimplification);
         }
         p.Release(this, false);
     }
 }
Exemplo n.º 3
0
 private void OnPathComplete(Path p)
 {
     this.waitingForPathCalc = false;
     p.Claim(this);
     if (p.error)
     {
         p.Release(this, false);
         return;
     }
     if (this.traversingSpecialPath)
     {
         this.delayUpdatePath = true;
     }
     else
     {
         this.richPath.Initialize(this.seeker, p, true, this.funnelSimplification);
         RichFunnel richFunnel = this.richPath.GetCurrentPart() as RichFunnel;
         if (richFunnel != null)
         {
             Vector2 b = this.movementPlane.ToPlane(this.UpdateTarget(richFunnel));
             if (this.lastCorner && this.nextCorners.Count == 1)
             {
                 Vector2 a = this.waypoint = this.movementPlane.ToPlane(this.nextCorners[0]);
                 this.distanceToWaypoint = (a - b).magnitude;
                 if (this.distanceToWaypoint <= this.endReachedDistance)
                 {
                     this.NextPart();
                 }
             }
         }
     }
     p.Release(this, false);
 }
Exemplo n.º 4
0
        void OnPathComplete(Path p)
        {
            waitingForPathCalc = false;
            p.Claim(this);

            if (p.error)
            {
                p.Release(this);
                return;
            }

            if (traversingSpecialPath)
            {
                delayUpdatePath = true;
            }
            else
            {
                if (rp == null)
                {
                    rp = new RichPath();
                }
                rp.Initialize(seeker, p, true, funnelSimplification);
            }
            p.Release(this);
        }
Exemplo n.º 5
0
        /// <summary>
        /// Called when a path has completed.
        /// Will post process it and return it by calling <see cref="tmpPathCallback"/> and <see cref="pathCallback"/>
        /// </summary>
        void OnPathComplete(Path p, bool runModifiers, bool sendCallbacks)
        {
            if (p != null && p != path && sendCallbacks)
            {
                return;
            }

            if (this == null || p == null || p != path)
            {
                return;
            }

            if (!path.error && runModifiers)
            {
                // This will send the path for post processing to modifiers attached to this Seeker
                RunModifiers(ModifierPass.PostProcess, path);
            }

            if (sendCallbacks)
            {
                p.Claim(this);

                lastCompletedNodePath   = p.path;
                lastCompletedVectorPath = p.vectorPath;

                // This will send the path to the callback (if any) specified when calling StartPath
                if (tmpPathCallback != null)
                {
                    tmpPathCallback(p);
                }

                // This will send the path to any script which has registered to the callback
                if (pathCallback != null)
                {
                    pathCallback(p);
                }

                PathComplete?.Invoke();
                PathComplete = null;

                // Note: it is important that #prevPath is kept alive (i.e. not pooled)
                // if we are drawing gizmos.
                // It is also important that #path is kept alive since it can be returned
                // from the GetCurrentPath method.
                // Since #path will be copied to #prevPath it is sufficient that #prevPath
                // is kept alive until it is replaced.

                // Recycle the previous path to reduce the load on the GC
                if (prevPath != null)
                {
                    prevPath.Release(this, true);
                }

                prevPath = p;
            }
        }
Exemplo n.º 6
0
	// Metodo que se llama cuando una ruta ha sido calculada
	public void OnPathComplete (Path p) {
		p.Claim (this);
		if (!p.error) {
			if (path != null) path.Release (this);
			path = p;
			currentWaypoint = 1;
		} else {
			p.Release (this);
			Debug.Log ("No se puede llegar a este punto de destino: "+p.errorLog);
		}
	}
Exemplo n.º 7
0
        /// <summary>
        /// Called when a path has completed.
        /// Will post process it and return it by calling <see cref="tmpPathCallback"/> and <see cref="pathCallback"/>
        /// </summary>
        private void OnPathComplete(Path p, bool runModifiers, bool sendCallbacks)
        {
            if (p != null && p != path && sendCallbacks)
            {
                return;
            }

            if (this == null || p == null || p != path)
            {
                return;
            }

            if (!path.error && runModifiers
                ) // This will send the path for post processing to modifiers attached to this Seeker
            {
                RunModifiers(ModifierPass.PostProcess, path);
            }

            if (sendCallbacks)
            {
                p.Claim(this);

                lastCompletedNodePath   = p.path;
                lastCompletedVectorPath = p.vectorPath;

                // This will send the path to the callback (if any) specified when calling StartPath
                if (tmpPathCallback != null)
                {
                    tmpPathCallback(p);
                }

                // This will send the path to any script which has registered to the callback
                if (pathCallback != null)
                {
                    pathCallback(p);
                }

                // Recycle the previous path to reduce the load on the GC
                if (prevPath != null)
                {
                    prevPath.Release(this, true);
                }

                prevPath = p;

                // If not drawing gizmos, then storing prevPath is quite unecessary
                // So clear it and set prevPath to null
                if (!drawGizmos)
                {
                    ReleaseClaimedPath();
                }
            }
        }
Exemplo n.º 8
0
 /// <summary>
 /// Stop calculating the current path request.
 /// If this Seeker is currently calculating a path it will be canceled.
 /// The callback (usually to a method named OnPathComplete) will soon be called
 /// with a path that has the 'error' field set to true.
 ///
 /// This does not stop the character from moving, it just aborts
 /// the path calculation.
 /// </summary>
 /// <param name="pool">If true then the path will be pooled when the pathfinding system is done with it.</param>
 public void CancelCurrentPathRequest(bool pool = true)
 {
     if (!IsDone()) {
         path.FailWithError("Canceled by script (Seeker.CancelCurrentPathRequest)");
         if (pool) {
             // Make sure the path has had its reference count incremented and decremented once.
             // If this is not done the system will think no pooling is used at all and will not pool the path.
             // The particular object that is used as the parameter (in this case 'path') doesn't matter at all
             // it just has to be *some* object.
             path.Claim(path);
             path.Release(path);
         }
     }
 }
Exemplo n.º 9
0
 public void OnPathComplete(Path p)
 {
     p.Claim (this);
     if (!p.error) {
         if (path != null) path.Release (this);
         path = p;
         //Reset the waypoint counter
         currentWaypoint = 0;
         currentPathCount = path.vectorPath.Count;
     } else {
         p.Release (this);
         Debug.Log ("The target was not reachable: "+p.errorLog);
     }
 }
Exemplo n.º 10
0
 static int Claim(IntPtr L)
 {
     try
     {
         ToLua.CheckArgsCount(L, 2);
         Pathfinding.Path obj  = (Pathfinding.Path)ToLua.CheckObject <Pathfinding.Path>(L, 1);
         object           arg0 = ToLua.ToVarObject(L, 2);
         obj.Claim(arg0);
         return(0);
     }
     catch (Exception e)
     {
         return(LuaDLL.toluaL_exception(L, e));
     }
 }
Exemplo n.º 11
0
    public void OnPathComplete(Path p)
    {
        p.Claim (this);
        if (!p.error) {
            if (path != null) path.Release (this);
            path = p;
            //Reset the waypoint counter
            currentAIWaypoint = 0;
        } else {
            p.Release (this);
            //Debug.Log ("Oh noes, the target was not reachable: "+p.errorLog);
        }

        //seeker.StartPath (transform.position,targetPosition, OnPathComplete);
    }
Exemplo n.º 12
0
		public virtual void UpdatePath()
		{
			this.canSearchPath = true;
			this.waitingForPathCalc = false;
			Path currentPath = this.seeker.GetCurrentPath();
			if (currentPath != null && !this.seeker.IsDone())
			{
				currentPath.Error();
				currentPath.Claim(this);
				currentPath.Release(this, false);
			}
			this.waitingForPathCalc = true;
			this.lastRepath = Time.time;
			this.seeker.StartPath(this.tr.position, this.target.position);
		}
Exemplo n.º 13
0
		public override void UpdatePath()
		{
			this.canSearchPath = true;
			this.waitingForPathCalc = false;
			Path currentPath = this.seeker.GetCurrentPath();
			if (currentPath != null && !this.seeker.IsDone())
			{
				currentPath.Error();
				currentPath.Claim(this);
				currentPath.Release(this, false);
			}
			this.waitingForPathCalc = true;
			this.lastRepath = Time.time;
			Matrix4x4 matrix = this.graph.GetMatrix();
			this.seeker.StartPath(matrix.MultiplyPoint3x4(this.tr.position), matrix.MultiplyPoint3x4(this.target.position));
		}
Exemplo n.º 14
0
        protected override void OnPathComplete(Path p)
        {
            waitingForPathCalculation = false;
            p.Claim(this);

            if (p.error)
            {
                p.Release(this);
                return;
            }

            if (traversingOffMeshLink)
            {
                delayUpdatePath = true;
            }
            else
            {
                richPath.Initialize(seeker, p, true, funnelSimplification);

                // Check if we have already reached the end of the path
                // We need to do this here to make sure that the #reachedEndOfPath
                // property is up to date.
                var part = richPath.GetCurrentPart() as RichFunnel;
                if (part != null)
                {
                    if (updatePosition)
                    {
                        simulatedPosition = tr.position;
                    }

                    // Note: UpdateTarget has some side effects like setting the nextCorners list and the lastCorner field
                    var localPosition = movementPlane.ToPlane(UpdateTarget(part));

                    // Target point
                    steeringTarget = nextCorners[0];
                    Vector2 targetPoint = movementPlane.ToPlane(steeringTarget);
                    distanceToSteeringTarget = (targetPoint - localPosition).magnitude;

                    if (lastCorner && nextCorners.Count == 1 && distanceToSteeringTarget <= endReachedDistance)
                    {
                        NextPart();
                    }
                }
            }
            p.Release(this);
        }
Exemplo n.º 15
0
        public override void UpdatePath()
        {
            base.canSearchPath      = true;
            base.waitingForPathCalc = false;
            Path currentPath = base.seeker.GetCurrentPath();

            if ((currentPath != null) && !base.seeker.IsDone())
            {
                currentPath.Error();
                currentPath.Claim(this);
                currentPath.Release(this, false);
            }
            base.waitingForPathCalc = true;
            base.lastRepath         = Time.time;
            Matrix4x4 matrix = this.graph.GetMatrix();
            Vector3   start  = matrix.MultiplyPoint3x4(base.tr.position);

            base.seeker.StartPath(start, matrix.MultiplyPoint3x4(base.target.position));
        }
Exemplo n.º 16
0
        void OnPathComplete(Path p)
        {
            waitingForPathCalc = false;
            p.Claim(this);

            if (p.error)
            {
                p.Release(this);
                return;
            }

            if (traversingSpecialPath)
            {
                delayUpdatePath = true;
            }
            else
            {
                richPath.Initialize(seeker, p, true, funnelSimplification);

                // Check if we have already reached the end of the path
                // We need to do this here to make sure that the #TargetReached
                // property is up to date.
                var part = richPath.GetCurrentPart() as RichFunnel;
                if (part != null)
                {
                    var position = movementPlane.ToPlane(UpdateTarget(part));
                    if (lastCorner && nextCorners.Count == 1)
                    {
                        // Target point
                        Vector2 targetPoint = waypoint = movementPlane.ToPlane(nextCorners[0]);
                        distanceToWaypoint = (targetPoint - position).magnitude;
                        if (distanceToWaypoint <= endReachedDistance)
                        {
                            NextPart();
                        }
                    }
                }
            }
            p.Release(this);
        }
Exemplo n.º 17
0
 // Token: 0x060021BE RID: 8638 RVA: 0x0019026C File Offset: 0x0018E46C
 private void OnPathComplete(Path p, bool runModifiers, bool sendCallbacks)
 {
     if (p != null && p != this.path && sendCallbacks)
     {
         return;
     }
     if (this == null || p == null || p != this.path)
     {
         return;
     }
     if (!this.path.error && runModifiers)
     {
         this.RunModifiers(Seeker.ModifierPass.PostProcess, this.path);
     }
     if (sendCallbacks)
     {
         p.Claim(this);
         this.lastCompletedNodePath   = p.path;
         this.lastCompletedVectorPath = p.vectorPath;
         if (this.tmpPathCallback != null)
         {
             this.tmpPathCallback(p);
         }
         if (this.pathCallback != null)
         {
             this.pathCallback(p);
         }
         if (this.prevPath != null)
         {
             this.prevPath.Release(this, true);
         }
         this.prevPath = p;
         if (!this.drawGizmos)
         {
             this.ReleaseClaimedPath();
         }
     }
 }
Exemplo n.º 18
0
 // Token: 0x06002177 RID: 8567 RVA: 0x0018E20C File Offset: 0x0018C40C
 protected override void OnPathComplete(Path p)
 {
     this.waitingForPathCalculation = false;
     p.Claim(this);
     if (p.error)
     {
         p.Release(this, false);
         return;
     }
     if (this.traversingOffMeshLink)
     {
         this.delayUpdatePath = true;
     }
     else
     {
         this.richPath.Initialize(this.seeker, p, true, this.funnelSimplification);
         RichFunnel richFunnel = this.richPath.GetCurrentPart() as RichFunnel;
         if (richFunnel != null)
         {
             if (this.updatePosition)
             {
                 this.simulatedPosition = this.tr.position;
             }
             Vector2 b = this.movementPlane.ToPlane(this.UpdateTarget(richFunnel));
             if (this.lastCorner && this.nextCorners.Count == 1)
             {
                 this.steeringTarget = this.nextCorners[0];
                 Vector2 a = this.movementPlane.ToPlane(this.steeringTarget);
                 this.distanceToSteeringTarget = (a - b).magnitude;
                 if (this.distanceToSteeringTarget <= this.endReachedDistance)
                 {
                     this.NextPart();
                 }
             }
         }
     }
     p.Release(this, false);
 }
Exemplo n.º 19
0
    private void OnPathComplete(Path p)
    {
        p.Claim(this);
        if (!p.error) {
            StopMoving();
            isMoving = true;

            path = p;
            currentWaypoint = 0;
        }
        else {
            p.Release(this);
            isMoving = false;
        }
    }
Exemplo n.º 20
0
	/** Called when a path has completed.
	 * Will post process it and return it by calling #tmpPathCallback and #pathCallback */
	public void OnPathComplete (Path p, bool runModifiers, bool sendCallbacks) {
		
		AstarProfiler.StartProfile ("Seeker OnPathComplete");
		
		
		if (p != null && p != path && sendCallbacks) {
			return;
		}
		
		
		if (this == null || p == null || p != path)
			return;
		
		if (!path.error && runModifiers) {
			AstarProfiler.StartProfile ("Seeker Modifiers");
			//This will send the path for post processing to modifiers attached to this Seeker
			RunModifiers (ModifierPass.PostProcessOriginal, path);
			
			//This will send the path for post processing to modifiers attached to this Seeker
			RunModifiers (ModifierPass.PostProcess, path);
			AstarProfiler.EndProfile ();
		}
		
		if (sendCallbacks) {
			
			p.Claim (this);
			
			AstarProfiler.StartProfile ("Seeker Callbacks");
			
			lastCompletedNodePath = p.path;
			lastCompletedVectorPath = p.vectorPath;
			
			//This will send the path to the callback (if any) specified when calling StartPath
			if (tmpPathCallback != null) {
				tmpPathCallback (p);
			}
			
			//This will send the path to any script which has registered to the callback
			if (pathCallback != null) {
				pathCallback (p);
			}
			
			//Recycle the previous path
			if (prevPath != null) {
				prevPath.ReleaseSilent (this);
			}
			
			prevPath = p;

			//If not drawing gizmos, then storing prevPath is quite unecessary
			//So clear it and set prevPath to null
			if (!drawGizmos) ReleaseClaimedPath ();

			AstarProfiler.EndProfile();
		}
		
		AstarProfiler.EndProfile ();
	}
Exemplo n.º 21
0
	/** Puts the Path in queue for calculation.
	  * The callback specified when constructing the path will be called when the path has been calculated.
	  * Usually you should use the Seeker component instead of calling this function directly.
	  * 
	  * \param p The path that should be put in queue for calculation
	  * \param pushToFront If true, the path will be pushed to the front of the queue, bypassing all waiting paths and making it the next path to be calculated.
	  * This can be useful if you have a path which you want to prioritize over all others. Be careful to not overuse it though.
	  * If too many paths are put in the front of the queue often, this can lead to normal paths having to wait a very long time before being calculated.
	  */
	public static void StartPath (Path p, bool pushToFront = false) {
		
		if (active == null) {
			Debug.LogError ("There is no AstarPath object in the scene");
			return;
		}
		
		if (p.GetState() != PathState.Created) {
			throw new System.Exception ("The path has an invalid state. Expected " + PathState.Created + " found " + p.GetState() + "\n" +
				"Make sure you are not requesting the same path twice");
		}
		
		if (active.pathQueue.IsTerminating) {
			p.Error ();
			p.LogError ("No new paths are accepted");
			return;
		}
		
		if (active.graphs == null || active.graphs.Length == 0) {
			Debug.LogError ("There are no graphs in the scene");
			p.Error ();
			p.LogError ("There are no graphs in the scene");
			Debug.LogError (p.errorLog);
			return;
		}
		
		p.Claim (active);
		
		
		//Will increment to PathQueue
		p.AdvanceState (PathState.PathQueue);
		if (pushToFront) {
			active.pathQueue.PushFront (p);
		} else {
			active.pathQueue.Push (p);
		}
	}
Exemplo n.º 22
0
 private void OnPathComplete(Path p, bool runModifiers, bool sendCallbacks)
 {
     if (p != null && p != this.path && sendCallbacks)
     {
         return;
     }
     if (this == null || p == null || p != this.path)
     {
         return;
     }
     if (!this.path.error && runModifiers)
     {
         this.RunModifiers(Seeker.ModifierPass.PostProcess, this.path);
     }
     if (sendCallbacks)
     {
         p.Claim(this);
         this.lastCompletedNodePath = p.path;
         this.lastCompletedVectorPath = p.vectorPath;
         if (this.tmpPathCallback != null)
         {
             this.tmpPathCallback(p);
         }
         if (this.pathCallback != null)
         {
             this.pathCallback(p);
         }
         if (this.prevPath != null)
         {
             this.prevPath.ReleaseSilent(this);
         }
         this.prevPath = p;
         if (!this.drawGizmos)
         {
             this.ReleaseClaimedPath();
         }
     }
 }
Exemplo n.º 23
0
    public void OnPathComplete(Path p)
    {
        if(target == null)
        {
            p.Claim (this);
          //  Debug.Log ("Yey, we got a path back. Did it have an error? "+p.error);
            if (!p.error) {
                if (path != null) path.Release (this);
                path = p;
                //Reset the waypoint counter
                currentWaypoint = 0;
            }
            else {
                p.Release (this);
                bChangeWaypoint = true;
                Debug.Log ("Oh noes, the target was not reachable: "+p.errorLog);
            }
        }
        else
        {
            /*if (Time.time-lastPathSearch >= repathRate) {
            Repath ();
            } else {*/
                StartCoroutine (WaitToRepath ());
            //}
            p.Claim (this);
            //If the path didn't succeed, don't proceed
            if (p.error) {
                p.Release (this);
                return;
            }
            else
            {
                //if(path != null) path.Release (this);
                //Get the calculated path as a Vector3 array
                path2 = p.vectorPath.ToArray();

                //Find the segment in the path which is closest to the AI
                //If a closer segment hasn't been found in '6' iterations, break because it is unlikely to find any closer ones then
                float minDist = Mathf.Infinity;
                int notCloserHits = 0;

                for (int i=0;i<path2.Length-1;i++) {
                    float dist = Mathfx.DistancePointSegmentStrict (path2[i],path2[i+1],tr.position);
                    if (dist < minDist) {
                        notCloserHits = 0;
                        minDist = dist;
                        pathIndex = i+1;
                    } else if (notCloserHits > 6) {
                        break;
                    }
                }
            }
        }
    }
Exemplo n.º 24
0
	/** Puts the Path in queue for calculation.
	  * The callback specified when constructing the path will be called when the path has been calculated.
	  * Usually you should use the Seeker component instead of calling this function directly.
	  */
	public static void StartPath (Path p) {
		
		if (active == null) {
			Debug.LogError ("There is no AstarPath object in the scene");
			return;
		}
		
		if (p.GetState() != PathState.Created) {
			throw new System.Exception ("The path has an invalid state. Expected " + PathState.Created + " found " + p.GetState() + "\n" +
				"Make sure you are not requesting the same path twice");
		}
		
		if (!active.acceptNewPaths) {
			p.Error ();
			p.LogError ("No new paths are accepted");
			//Debug.LogError (p.errorLog);
			//p.ReturnPath ();
			return;
		}
		
		if (active.graphs == null || active.graphs.Length == 0) {
			Debug.LogError ("There are no graphs in the scene");
			p.Error ();
			p.LogError ("There are no graphs in the scene");
			Debug.LogError (p.errorLog);
			//p.ReturnPath ();
			return;
		}
		
		/*MultithreadPath p2 = p as MultithreadPath;
		if (p2 == null) {
			Debug.LogError ("Path Not Set Up For Multithreading");
			return;
		}*/
		
		p.Claim (active);
		
		lock (pathQueue) {
			//Will increment to PathQueue
			p.AdvanceState (PathState.PathQueue);
			pathQueue.Enqueue (p);
			if (doSetQueueState)
				pathQueueFlag.Set ();
		}
	}
Exemplo n.º 25
0
	public void OnPathComplete(Path p)
	{
		//Debug.Log ("Error? -" + p.error);
		if(!p.error) //if no error
		{
			path = p; //set path to correct path
			currentNode = 0; //reset index
			path.Claim(this);
		}
		else{
			ToggleAttack(isPissed);
		}
	}
Exemplo n.º 26
0
		void OnPathComplete (Path p) {
			waitingForPathCalc = false;
			p.Claim(this);
			
			if (p.error) {
				p.Release(this);
				return;
			}
			
			if (traversingSpecialPath) {
				delayUpdatePath = true;
			} else {
				if (rp == null) rp = new RichPath();
				rp.Initialize (seeker, p,true, funnelSimplification);
			}
			p.Release(this);
		}
Exemplo n.º 27
0
    private void OnPathingComplete(Path path)
    {
        if (path.error == false)
        {
            if (_path != null)
            {
                _path.Release(this);
            }

            _path = path;
            _path.Claim(this);

            _pathIndex = 0;
            //Update distanec to objective.
            this.DistanceToObjective = _path.GetTotalLength();
        }
    }