public override MoveLookTarget GetNextPathWaypoint(MoveLookTarget aPathTarget, bool aAllow3DMovement, bool aAllowOffGraphMovement, MoveLookTarget aCachedMoveLookTarget = null) { mlt = base.GetNextPathWaypoint(aPathTarget, aAllow3DMovement, aAllowOffGraphMovement, aCachedMoveLookTarget); //Debug.Log("Called GetNextPathWaypoint"); return(mlt); }
public override bool IsAt(MoveLookTarget aPosition) { var fMaxCloseEnoughDistance = Mathf.Max(aPosition.CloseEnoughDistance, AI.Motor.CloseEnoughDistance); bool flag = false; if (AI.Motor.Allow3DMovement) { var vector2 = AI.Kinematic.Position - aPosition.Position; if (vector2.magnitude <= fMaxCloseEnoughDistance) { flag = true; } } else { var position = aPosition.Position; position.y = AI.Kinematic.Position.y; var vector3 = AI.Kinematic.Position - position; if (vector3.magnitude <= fMaxCloseEnoughDistance) { flag = true; } } return(flag); }
public override MoveLookTarget GetNextPathWaypoint(MoveLookTarget aPathTarget, bool aAllow3DMovement, bool aAllowOffGraphMovement, MoveLookTarget aCachedMoveLookTarget = null) { mlt = base.GetNextPathWaypoint(aPathTarget, aAllow3DMovement, aAllowOffGraphMovement, aCachedMoveLookTarget); //Debug.Log("Called GetNextPathWaypoint"); return mlt; }
public override bool IsAt(MoveLookTarget aTarget) { Vector3 tDistance = AI.Body.transform.position - aTarget.Position; tDistance.y = 0; return(tDistance.magnitude <= UnityAgent.stoppingDistance); }
public override ActionResult Execute(RAIN.Core.AI ai) { GameObject loc = ai.WorkingMemory.GetItem<GameObject>("varHero"); MoveLookTarget newTarget = new MoveLookTarget(); newTarget.VectorTarget = new Vector3(loc.transform.position.x, 0, loc.transform.position.z); newTarget.CloseEnoughDistance = ai.Motor.CloseEnoughDistance; ai.WorkingMemory.SetItem(MoveTarget.VariableName, newTarget); return ActionResult.SUCCESS; }
public override ActionResult Execute(RAIN.Core.AI ai) { if (!WanderTargetVariable.IsVariable) { throw new Exception("The Choose Wander Position node requires a valid Wander Target Variable"); } float tWanderDistance = 0f; if (WanderDistance.IsValid) { tWanderDistance = WanderDistance.Evaluate <float>(ai.DeltaTime, ai.WorkingMemory); } if (tWanderDistance <= 0f) { tWanderDistance = _defaultWanderDistance; } MoveLookTarget.GetTargetFromVariable(ai.WorkingMemory, AspectVariable.VariableName, ai.Motor.DefaultCloseEnoughDistance, followTarget); //move in the direction of target Vector3 tAway = ai.Kinematic.Position + followTarget.Position; Vector3 tFollowDirection = tAway.normalized * UnityEngine.Random.Range(1f, tWanderDistance); Vector3 tFollowPosition = ai.Kinematic.Position + tFollowDirection; // if (ai.Navigator.OnGraph(tFollowPosition, ai.Motor.MaxHeightOffset)) // { ai.WorkingMemory.SetItem <Vector3>(WanderTargetVariable.VariableName, tFollowPosition); return(ActionResult.SUCCESS); // } // Vector3 tDirection = followTarget.Position;//new Vector3(UnityEngine.Random.Range(-1f, 1f), 0f, UnityEngine.Random.Range(-1f, 1f)); // // tDirection *= tWanderDistance; // // Vector3 tDestination = ai.Kinematic.Position + tDirection; //// if (StayOnGraph.IsValid && (StayOnGraph.Evaluate<bool>(ai.DeltaTime, ai.WorkingMemory))) //// { //// if (NavigationManager.Instance.GraphForPoint(tDestination, ai.Motor.MaxHeightOffset, NavigationManager.GraphType.Navmesh, ((BasicNavigator)ai.Navigator).GraphTags).Count == 0) //// return ActionResult.FAILURE; //// } // // ai.WorkingMemory.SetItem<Vector3>(WanderTargetVariable.VariableName, tDestination); // // return ActionResult.SUCCESS; }
public override bool IsFacing(MoveLookTarget aTarget) { if (aTarget == null || !aTarget.IsValid) { return(false); } Vector3 tFaceTargetPosition = aTarget.Position; tFaceTargetPosition.y = AI.Body.transform.position.y; Vector3 tDirection = aTarget.Position - AI.Body.transform.position; tDirection.y = 0; return(Mathf.Abs(MathUtils.WrapAngle(Vector3.Angle(AI.Body.transform.forward, tDirection.normalized))) <= CloseEnoughAngle); }
public override ActionResult Execute(AI ai) { //get player GameObject player = ai.WorkingMemory.GetItem<GameObject>("posPlayer"); var playerPosition = player.transform.position; //Debug.Log("p: " + playerPosition); //get enemy position var enemyPosition = new Vector3(ai.Kinematic.Position.x, ai.Kinematic.Position.y, ai.Kinematic.Position.z); //Debug.Log("e: " + enemyPosition); //computes the different between both positions var difference = (enemyPosition - playerPosition); //normalizes the vector //difference.Normalize(); //Debug.Log("dif: " + difference); //checks how close enemy and player are var dist = Vector3.Distance(playerPosition, enemyPosition); var mag = remap(dist, 0, 11, 11, 0); difference *= (mag/3); //Debug.Log("old mag: " + dist + " new mag: " + mag); //computes the new escape point var result = (enemyPosition+difference); //Debug.Log("new scape point: " + result); result.y = playerPosition.y; //update the scapePoint var newPosition = new MoveLookTarget(); //result.VectorTarget = new Vector3(200,1,215); newPosition.VectorTarget = result; ai.WorkingMemory.SetItem<MoveLookTarget>("escapePoint", newPosition); //ai.Motor.MoveTo(result); return ActionResult.SUCCESS; }
public override ActionResult Execute(RAIN.Core.AI ai) { if (!FleeTargetVariable.IsVariable) { throw new Exception("The Choose Flee Position node requires a valid Flee Target Variable"); } float tFleeDistance = 0f; if (FleeDistance.IsValid) { tFleeDistance = FleeDistance.Evaluate <float>(ai.DeltaTime, ai.WorkingMemory); } if (tFleeDistance <= 0f) { tFleeDistance = _defaultFleeDistance; } //Start by trying to flee away from the FleeFrom if (FleeFrom.IsVariable) { MoveLookTarget.GetTargetFromVariable(ai.WorkingMemory, FleeFrom.VariableName, ai.Motor.DefaultCloseEnoughDistance, _fleeTarget); } else { _fleeTarget.TargetType = MoveLookTarget.MoveLookTargetType.None; } if (_fleeTarget.IsValid) { //Start by just running the opposite direction Vector3 tAway = ai.Kinematic.Position - _fleeTarget.Position; Vector3 tFleeDirection = tAway.normalized * UnityEngine.Random.Range(1f, tFleeDistance); Vector3 tFleePosition = ai.Kinematic.Position + tFleeDirection; if (ai.Navigator.OnGraph(tFleePosition, ai.Motor.MaxHeightOffset)) { ai.WorkingMemory.SetItem <Vector3>(FleeTargetVariable.VariableName, tFleePosition); return(ActionResult.SUCCESS); } //Check forty five away Vector3 tFortyFive = Quaternion.Euler(new Vector3(0, 45, 0)) * tFleeDirection; tFleePosition = ai.Kinematic.Position + tFortyFive; if (ai.Navigator.OnGraph(tFleePosition, ai.Motor.MaxHeightOffset)) { ai.WorkingMemory.SetItem <Vector3>(FleeTargetVariable.VariableName, tFleePosition); return(ActionResult.SUCCESS); } //Check minus forty five away tFortyFive = Quaternion.Euler(new Vector3(0, -45, 0)) * tFleeDirection; tFleePosition = ai.Kinematic.Position + tFortyFive; if (ai.Navigator.OnGraph(tFleePosition, ai.Motor.MaxHeightOffset)) { ai.WorkingMemory.SetItem <Vector3>(FleeTargetVariable.VariableName, tFleePosition); return(ActionResult.SUCCESS); } } //We could not find a reasonable flee target, so just choose a random point Vector3 tDirection = new Vector3(UnityEngine.Random.Range(-1f, 1f), 0f, UnityEngine.Random.Range(-1f, 1f)); tDirection *= tFleeDistance; Vector3 tDestination = ai.Kinematic.Position + tDirection; if (StayOnGraph.IsValid && (StayOnGraph.Evaluate <bool>(ai.DeltaTime, ai.WorkingMemory))) { if (!ai.Navigator.OnGraph(tDestination, ai.Motor.MaxHeightOffset)) { return(ActionResult.FAILURE); } } ai.WorkingMemory.SetItem <Vector3>(FleeTargetVariable.VariableName, tDestination); return(ActionResult.SUCCESS); }
public override bool IsFacing(MoveLookTarget aTarget) { // Too tired to do this return(true); }
public override bool IsFacing(MoveLookTarget aTarget) { //TODO return(true); }
public override bool GetPathToMoveTarget(MoveLookTarget aPathTarget, bool allowOffGraphMovement, out RAINPath path) { //Debug.Log("Called GetPathToMoveTarget"); var result = base.GetPathToMoveTarget(aPathTarget, allowOffGraphMovement, out path); for (int i = 0; i < path.PathPoints.Count; i++) { var p = path.PathPoints[i]; path.PathPoints[i] = new Vector3(Mathf.Round(p.x), 0, Mathf.Round(p.z)); } if (path.PathNodes.Count == 2) { return(result); } for (int i = 0; i < path.PathNodes.Count - 1; i++) { if (path.PathPoints[i] == path.PathPoints[i + 1]) { path.RemovePathNode(i); i--; } } bool sameX = false; bool sameZ = false; for (int i = 0; i < path.PathNodes.Count - 1; i++) { //if (Mathf.Approximately(path.PathPoints[i].x, AI.Body.transform.position.x) && // Mathf.Approximately(path.PathPoints[i].z, AI.Body.transform.position.z)) //{ //path.RemovePathNode(i); //i--; //} if (sameX) { if (path.PathPoints[i].x == path.PathPoints[i + 1].x) { path.RemovePathNode(i); i--; } else { sameX = false; } } else if (sameZ) { if (path.PathPoints[i].z == path.PathPoints[i + 1].z) { path.RemovePathNode(i); i--; } else { sameZ = false; } } if (!sameX && !sameZ) { if (path.PathPoints[i].x == path.PathPoints[i + 1].x) { sameX = true; } else if (path.PathPoints[i].z == path.PathPoints[i + 1].z) { sameZ = true; } } } if (Mathf.Approximately(path.PathPoints[0].x, path.PathPoints[path.PathPoints.Count - 1].x) || Mathf.Approximately(path.PathPoints[0].z, path.PathPoints[path.PathPoints.Count - 1].z)) { for (int i = 1; i < path.PathPoints.Count - 1; i++) { path.RemovePathNode(i); --i; } } return(result); }
public override ActionResult Execute(RAIN.Core.AI ai) { if (!FleeTargetVariable.IsVariable) { throw new Exception("The Choose Flee Position node requires a valid Flee Target Variable"); } float _tFleeDistance = 0f; if (FleeDistance.IsValid) { _tFleeDistance = FleeDistance.Evaluate <float>(ai.DeltaTime, ai.WorkingMemory); } if (_tFleeDistance <= 0f) { _tFleeDistance = defaultFleeDistance; } if (FleeFrom.IsVariable) { MoveLookTarget.GetTargetFromVariable(ai.WorkingMemory, FleeFrom.VariableName, ai.Motor.DefaultCloseEnoughDistance, fleeTarget); } else { fleeTarget.TargetType = MoveLookTarget.MoveLookTargetType.None; } if (fleeTarget.IsValid) { Vector3 _tAway = ai.Kinematic.Position - fleeTarget.Position; Vector3 _tFleeDirection = _tAway.normalized * UnityEngine.Random.Range(1f, _tFleeDistance); Vector3 _tFleePosition = ai.Kinematic.Position + _tFleeDirection; if (ai.Navigator.OnGraph(_tFleePosition, ai.Motor.MaxHeightOffset)) { ai.WorkingMemory.SetItem <Vector3>(FleeTargetVariable.VariableName, _tFleePosition); return(ActionResult.SUCCESS); } Vector3 tFortyFive = Quaternion.Euler(new Vector3(0, 45, 0)) * _tFleeDirection; _tFleePosition = ai.Kinematic.Position + tFortyFive; if (ai.Navigator.OnGraph(_tFleePosition, ai.Motor.MaxHeightOffset)) { ai.WorkingMemory.SetItem <Vector3>(FleeTargetVariable.VariableName, _tFleePosition); return(ActionResult.SUCCESS); } tFortyFive = Quaternion.Euler(new Vector3(0, -45, 0)) * _tFleeDirection; _tFleePosition = ai.Kinematic.Position + tFortyFive; if (ai.Navigator.OnGraph(_tFleePosition, ai.Motor.MaxHeightOffset)) { ai.WorkingMemory.SetItem <Vector3>(FleeTargetVariable.VariableName, _tFleePosition); return(ActionResult.SUCCESS); } } Vector3 _tDirection = new Vector3(UnityEngine.Random.Range(-1f, 1f), 0f, UnityEngine.Random.Range(-1f, 1f)); Vector3 _tDestination = ai.Kinematic.Position + _tDirection.normalized * _tFleeDistance; if (StayOnGraph.IsValid && (StayOnGraph.Evaluate <bool>(ai.DeltaTime, ai.WorkingMemory))) { if (!ai.Navigator.OnGraph(_tDestination, ai.Motor.MaxHeightOffset)) { return(ActionResult.FAILURE); } } ai.WorkingMemory.SetItem <Vector3>(FleeTargetVariable.VariableName, _tDestination); return(ActionResult.SUCCESS); }
public override bool IsAt(MoveLookTarget aTarget) { //Debug.Log("Called IsAt"); return(base.IsAt(aTarget)); }
public override bool GetPathToMoveTarget(MoveLookTarget aPathTarget, bool aAllowOffGraphMovement, out RAINPath aPath) { throw new NotImplementedException(); }
public override bool GetPathToMoveTarget(MoveLookTarget aPathTarget, bool allowOffGraphMovement, out RAINPath path) { //Debug.Log("Called GetPathToMoveTarget"); var result = base.GetPathToMoveTarget(aPathTarget, allowOffGraphMovement, out path); for (int i = 0; i < path.PathPoints.Count; i++) { var p = path.PathPoints[i]; path.PathPoints[i] = new Vector3(Mathf.Round(p.x), 0, Mathf.Round(p.z)); } if (path.PathNodes.Count == 2) { return result; } for (int i = 0; i < path.PathNodes.Count - 1; i++) { if (path.PathPoints[i] == path.PathPoints[i + 1]) { path.RemovePathNode(i); i--; } } bool sameX = false; bool sameZ = false; for (int i = 0; i < path.PathNodes.Count - 1; i++) { //if (Mathf.Approximately(path.PathPoints[i].x, AI.Body.transform.position.x) && // Mathf.Approximately(path.PathPoints[i].z, AI.Body.transform.position.z)) //{ //path.RemovePathNode(i); //i--; //} if (sameX) { if (path.PathPoints[i].x == path.PathPoints[i + 1].x) { path.RemovePathNode(i); i--; } else { sameX = false; } } else if (sameZ) { if (path.PathPoints[i].z == path.PathPoints[i + 1].z) { path.RemovePathNode(i); i--; } else { sameZ = false; } } if (!sameX && !sameZ) { if (path.PathPoints[i].x == path.PathPoints[i + 1].x) { sameX = true; } else if (path.PathPoints[i].z == path.PathPoints[i + 1].z) { sameZ = true; } } } if (Mathf.Approximately(path.PathPoints[0].x, path.PathPoints[path.PathPoints.Count - 1].x) || Mathf.Approximately(path.PathPoints[0].z, path.PathPoints[path.PathPoints.Count - 1].z)) { for (int i = 1; i < path.PathPoints.Count - 1; i++) { path.RemovePathNode(i); --i; } } return result; }
public override bool IsAt(MoveLookTarget aTarget) { return IsAt(aTarget.Position); }
public override MoveLookTarget GetNextPathWaypoint(MoveLookTarget aPathTarget, bool aAllow3DMovement, bool aAllowOffGraphMovement, MoveLookTarget aCachedMoveLookTarget = null) { throw new NotImplementedException(); }
public override MoveLookTarget GetNextPathWaypoint(MoveLookTarget aPathTarget, bool aAllow3DMovement, bool aAllowOffGraphMovement, MoveLookTarget aCachedMoveLookTarget = null) { throw new NotImplementedException(); }
private void FindBestCoverPoint(AI ai) { if (!StoreCoverVarInName.IsValid || !StoreCoverVarInName.IsVariable) { return; } //We don't actually have to have an enemy. We can choose cover points that are simply near ourselves. Vector3 tEnemyPosition = ai.Kinematic.Position; //Assign a current enemy target if (EnemyVariable.IsValid && EnemyVariable.IsVariable) { //using a MoveLookTarget lets us automatically convert between gameObject, Vector3, etc., when getting //a position from AI memory tTarget = MoveLookTarget.GetTargetFromVariable(ai.WorkingMemory, EnemyVariable.VariableName, ai.Motor.CloseEnoughDistance); if (tTarget.IsValid) { tEnemyPosition = tTarget.Position; } } //Cover points should be marked with the "cover" entity for (int i = 0; i <= ai.Senses.Sensors.Count; i++) { if (ai.Senses.Sensors [i].SensorName == CoverDetector.VariableName) { CoverSensor = ai.Senses.Sensors [i] as VisualSensor; break; } } CoverSensor.Sense(CoverEntityName.VariableName, RAINSensor.MatchType.ALL); Vector3 previousCoverAspect = ai.Kinematic.Position;; //Default cover point is our own position float bestCost = float.MaxValue; Vector3 tCoverPosition = ai.Kinematic.Position; //return the closest position out of all found positions //that the player cannot see. for (int i = 0; i < CoverSensor.Matches.Count; i++) { //if your current enemy can see the cover position skip it. //This makes the AI choose a more defensable position. Vector3 ray = (tTarget.Position + adjustment); Vector3 direction = (CoverSensor.Matches[i].Position - (tTarget.Position + adjustment)); RaycastHit hit; if (Physics.Raycast(ray, direction, out hit, 100.0f)) { if (hit.collider.transform.gameObject.GetComponent <CoverSpot> ()) { if (hit.collider.transform.gameObject == CoverSensor.Matches [i].MountPoint.gameObject) { continue; } } } //find all cover matches RAINAspect tCandidateAspect = CoverSensor.Matches[i]; if (tCandidateAspect == null) { continue; } //Cover points are AIObjectives, which are objects that allow AI to "occupy" them CoverSpot tObjective = tCandidateAspect.Entity.Form.GetComponent <CoverSpot>(); //Skip occupied cover points if ((tObjective != null) && (tObjective.isTaken) && (tObjective.occupant == ai.Body)) { previousCoverSpot = tObjective; previousCoverAspect = tCandidateAspect.Position; continue; } if ((tObjective == null) || (tObjective.isTaken && tObjective.occupant != ai.Body)) { continue; } //Our cost function gives 50% more weight to points near the enemy //But then also adds in the AI distance to the point float tCost = 1.5f * Vector3.Distance(tEnemyPosition, tCandidateAspect.Position) + Vector3.Distance(ai.Kinematic.Position, tCandidateAspect.Position); if (tCost < bestCost) { currentCoverPoint = tObjective; tCoverPosition = tCandidateAspect.Position; bestCost = tCost; } } //If we found a cover point, then occupy it if (currentCoverPoint != null) { if (previousCoverSpot != null) { previousCoverSpot.LeaveSpot(ai.Body); } currentCoverPoint.TakeSpot(ai.Body); } else if (previousCoverSpot != null) { tCoverPosition = previousCoverAspect; previousCoverSpot.TakeSpot(ai.Body); } //Set the cover position in AI memory ai.WorkingMemory.SetItem <Vector3>(StoreCoverVarInName.VariableName, tCoverPosition); }
//TODO do I need Reset() implemented also? public override bool IsAt(MoveLookTarget aTarget) { return(IsAt(aTarget.Position)); }
public override MoveLookTarget GetNextPathWaypoint(bool allow3DMovement, bool allowOffGraphMovement, MoveLookTarget moveLookTarget) { if (moveLookTarget == null) { moveLookTarget = new RAIN.Motion.MoveLookTarget(); } if ((base.pathTarget == null) || !base.pathTarget.IsValid) { moveLookTarget.TargetType = MoveLookTarget.MoveLookTargetType.None; return(moveLookTarget); } if (_aStarAIPath.canMove) { _aStarAIPath.TargetPosition = wp.position; moveLookTarget.VectorTarget = _aStarAIPath.TargetPoint; } return(moveLookTarget); }
public override bool IsAt(MoveLookTarget aPosition) { var fMaxCloseEnoughDistance = Mathf.Max(aPosition.CloseEnoughDistance, AI.Motor.CloseEnoughDistance); bool flag = false; if (AI.Motor.Allow3DMovement) { var vector2 = AI.Kinematic.Position - aPosition.Position; if (vector2.magnitude <= fMaxCloseEnoughDistance) { flag = true; } } else { var position = aPosition.Position; position.y = AI.Kinematic.Position.y; var vector3 = AI.Kinematic.Position - position; if (vector3.magnitude <= fMaxCloseEnoughDistance) { flag = true; } } return flag; }
public override bool GetPathToMoveTarget(MoveLookTarget aPathTarget, bool aAllowOffGraphMovement, out RAINPath aPath) { throw new NotImplementedException(); }
public override bool IsAt(MoveLookTarget aTarget) { //Debug.Log("Called IsAt"); return base.IsAt(aTarget); }
public override MoveLookTarget GetNextPathWaypoint(bool allow3DMovement, bool allowOffGraphMovement, MoveLookTarget moveLookTarget) { if (moveLookTarget == null) { moveLookTarget = new RAIN.Motion.MoveLookTarget(); } if ((base.pathTarget == null) || !base.pathTarget.IsValid) { moveLookTarget.TargetType = MoveLookTarget.MoveLookTargetType.None; return moveLookTarget; } if (_aStarAIPath.canMove) { _aStarAIPath.TargetPosition = wp.position; moveLookTarget.VectorTarget = _aStarAIPath.TargetPoint; } return moveLookTarget; }
public override bool IsFacing(MoveLookTarget aTarget) { // Too tired to do this return true; }